Implement generic function instrumentation

[y1yang0]

The current instrumentation logic does not support generic functions

func F[T any](value T) {}

However, this is a real-world and frequently requested feature, especially for instrumenting libraries like those used in Kubernetes. We need to implement this functionality, but we anticipate it will be a very challenging task.

[txabman42]

//go:linknames and generic functions don't match well.

From Linkname Directive

//go:linkname directive determines the object-file symbol used for a Go var or func declaration, allowing two Go symbols to alias the same object-file symbol.

As they are the alias of the object-file symbol, we assume that both functions (hook and target) must share the same signature.

Thats a problem with generic functions, as the generic function instantiation doesn't exist, but a function instantiation per shape (generics-implementation-dictionaries-go1.18.md). So, //go:linknames directive won't know how to link hook and target generic functions.

They also comment here that:

//go:linkname is not supported for generic code. There's no reasonable way to make this work given how generics is implemented.

However, from checklinkname Analyzer we can read:

Since //go:linkname only affects linker behavior, there is no built-in type safety and it is the programmer's responsibility to ensure the types on either side are compatible.

Not same signature, but compatible signatures!

So, my question is: could have sense from the hook design POV to test the following idea?

Example:

func GenericExample[K comparable, V any](value T) map[K]V { ... }

func GenericHookBefore(ictx inst.HookContext, k interface{}, v interface{}) {
  // Can perform type assertion if needed
  ...
}

func GenericHookAfter(ictx inst.HookContext, r interface{}) {
  // Can perform type assertion if needed
  ...
}

[y1yang0]

The core challenge, in my opinion, is that we can't provide SetParam/SetReturnVal. It relies on the developer knowing that hookContext always holds pointers to the actual parameters and return values.

package main

func Target[K comparable, V any](key K, value V) (retval map[K]V) {
	if ctx, skip := OtelBeforeTrampoline(&key, &value); skip {
	} else {
		defer OtelAfterTrampoline(ctx, &retval)
	}
	println(key, value)
	return nil
}

type HookContextImpl struct {
	skipCall   bool
	params     []interface{}
	returnVals []interface{}
}

func (c *HookContextImpl) GetParam(idx int) interface{} {
	return c.params[idx]
}

func (c *HookContextImpl) SetParam(idx int, val interface{}) {
	panic("cannot generate SetParam automatically")
}

func (c *HookContextImpl) GetReturnVal(idx int) interface{} {
	return c.returnVals[idx]
}

func (c *HookContextImpl) SetReturnVal(idx int, val interface{}) {
	panic("cannot generate SetReturnVal automatically")
}

func OtelBeforeTrampoline[K comparable, V any](key *K, value *V) (hookContext *HookContextImpl, skipCall bool) {
	defer func() { /*panic handlers....*/ }()
	hookContext = &HookContextImpl{}
	hookContext.params = []interface{}{key, value}
	if HookBefore != nil {
		HookBefore(hookContext)
	}
	return hookContext, hookContext.skipCall
}

func OtelAfterTrampoline[K comparable, V any](hookContext *HookContextImpl, retval *map[K]V) {
	defer func() { /*panic handlers....*/ }()
	hookContext.returnVals = []interface{}{retval}
	if HookAfter != nil {
		HookAfter(hookContext)
	}
}

func HookBefore(ctx *HookContextImpl) {
	// It's easy to access parameters
	println("args0", *ctx.GetParam(0).(*string))
	println("args1", *ctx.GetParam(1).(*int))
	// But it's hard to modify them
	// It requires users to dereference pointers manually
	// because we are unlikely to generate SetParam/SetReturnVal automatically
	arg0 := ctx.GetParam(0).(*string)
	*arg0 = "modifiedKey"
	arg1 := ctx.GetParam(1).(*int)
	*arg1 = 100

}

func HookAfter(ctx *HookContextImpl) {
	println("returnVal0", *ctx.GetReturnVal(0).(*map[string]int))
	// Similarly, it's hard to modify return values
	// It requires users to dereference pointers manually
	ret0 := ctx.GetReturnVal(0).(*map[string]int)
	newMap := map[string]int{"newKey": 999}
	*ret0 = newMap
}

func main() {
	key := "aaa"
	value := 42
	Target(key, value)
}

[txabman42]

Could that not be an acceptable limitation for now?

If its documented, although not being user friendly, devs interested in instrumenting a generic function wouldn't be blocked.

[y1yang0]

Could that not be an acceptable limitation for now?

If its documented, although not being user friendly, devs interested in instrumenting a generic function wouldn't be blocked.

Yes, I agree this is an acceptable approach for now. It's not perfect, but it's a workable solution, and the need for generic injection, while it exists, isn't very common.