feat: new CallContext.{GetFuncName, GetPackageName} APIs

Author: y1yang0

Diff for: pkg/api/api.go

@@ -46,4 +46,8 @@ type CallContext interface {
 	GetReturnVal(idx int) interface{}
 	// Change the original function return value at index idx
 	SetReturnVal(idx int, val interface{})
+	// Get the original function name
+	GetFuncName() string
+	// Get the package name of the original function
+	GetPackageName() string
 }

Diff for: pkg/api/impl.go

@@ -63,6 +63,14 @@ func (c *CallContextImpl) SetReturnVal(idx int, val interface{}) {
 	c.ReturnVals[idx] = val
 }
 
+func (c *CallContextImpl) GetFuncName() string {
+	return ""
+}
+
+func (c *CallContextImpl) GetPackageName() string {
+	return ""
+}
+
 func NewCallContext() CallContext {
 	return &CallContextImpl{
 		Params:     make([]interface{}, 1024),

Diff for: pkg/data/test_error.json

@@ -138,5 +138,12 @@
         "Function": ".*",
         "OnEnter": "onEnterGeneric4",
         "Path": "github.com/alibaba/opentelemetry-go-auto-instrumentation/pkg/rules/test/error19"
+    },
+    {
+        "ImportPath": "errorstest/all",
+        "ReceiverType": ".*",
+        "Function": ".*",
+        "OnEnter": "onEnterGeneric5",
+        "Path": "github.com/alibaba/opentelemetry-go-auto-instrumentation/pkg/rules/test/error19"
     }
 ]

Diff for: pkg/rules/test/error19/hook.go

@@ -36,3 +36,8 @@ func onEnterGeneric3(call api.CallContext) {
 func onEnterGeneric4(call api.CallContext) {
 	println("beijing")
 }
+
+func onEnterGeneric5(call api.CallContext) {
+	println("entering" + call.GetFuncName())
+	println("within" + call.GetPackageName())
+}

Diff for: test/errors_test.go

@@ -58,6 +58,7 @@ func TestRunErrors(t *testing.T) {
 	}
 
 	// Test for generic hook
+	maxFunc := 7
 	re = regexp.MustCompile(".*xian.*")
 	matches = re.FindAllString(stderr, -1)
 	if len(matches) != 4 { // f1 + f2 + f4 + init
@@ -70,12 +71,22 @@ func TestRunErrors(t *testing.T) {
 	}
 	re = regexp.MustCompile(".*zhejiang.*") // match all funcs(including init)
 	matches = re.FindAllString(stderr, -1)
-	if len(matches) != 7 {
-		t.Fatalf("expecting 7 matches")
+	if len(matches) != maxFunc {
+		t.Fatalf("expecting full matches")
 	}
 	re = regexp.MustCompile(".*beijing.*") // f3 + f5
 	matches = re.FindAllString(stderr, -1)
 	if len(matches) != 2 {
 		t.Fatalf("expecting 2 matches")
 	}
+	re = regexp.MustCompile(".*entering.*") // match all funcs(including init)
+	matches = re.FindAllString(stderr, -1)
+	if len(matches) != maxFunc {
+		t.Fatalf("expecting full matches")
+	}
+	re = regexp.MustCompile(".*within.*") // match all funcs(including init)
+	matches = re.FindAllString(stderr, -1)
+	if len(matches) != maxFunc {
+		t.Fatalf("expecting full matches")
+	}
 }

Diff for: tool/instrument/template.go

@@ -21,10 +21,12 @@ package instrument
 
 // Struct Template
 type CallContextImpl struct {
-	Params     []interface{}
-	ReturnVals []interface{}
-	SkipCall   bool
-	Data       interface{}
+	Params      []interface{}
+	ReturnVals  []interface{}
+	SkipCall    bool
+	Data        interface{}
+	FuncName    string
+	PackageName string
 }
 
 func (c *CallContextImpl) SetSkipCall(skip bool)    { c.SkipCall = skip }
@@ -79,6 +81,9 @@ func (c *CallContextImpl) SetReturnVal(idx int, val interface{}) {
 	}
 }
 
+func (c *CallContextImpl) GetFuncName() string    { return c.FuncName }
+func (c *CallContextImpl) GetPackageName() string { return c.PackageName }
+
 // Variable Template
 var OtelGetStackImpl func() []byte = nil
 var OtelPrintStackImpl func([]byte) = nil
@@ -99,6 +104,8 @@ func OtelOnEnterTrampoline() (CallContext, bool) {
 	}()
 	callContext := &CallContextImpl{}
 	callContext.Params = []interface{}{}
+	callContext.FuncName = ""
+	callContext.PackageName = ""
 	return callContext, callContext.SkipCall
 }
 

Diff for: tool/instrument/trampoline.go

@@ -44,6 +44,8 @@ const (
 	TrampolineValIdentifier          = "val"
 	TrampolineCtxIdentifier          = "c"
 	TrampolineParamsIdentifier       = "Params"
+	TrampolineFuncNameIdentifier     = "FuncName"
+	TrampolinePackageNameIdentifier  = "PackageName"
 	TrampolineReturnValsIdentifier   = "ReturnVals"
 	TrampolineSkipName               = "skip"
 	TrampolineCallContextName        = "callContext"
@@ -400,34 +402,85 @@ func (rp *RuleProcessor) rectifyTypes() {
 	addCallContext(onExitHookFunc.Type.Params)
 }
 
+// replenishCallContext replenishes the call context before hook invocation
 func (rp *RuleProcessor) replenishCallContext(onEnter bool) bool {
 	funcDecl := rp.onEnterHookFunc
 	if !onEnter {
 		funcDecl = rp.onExitHookFunc
 	}
 	for _, stmt := range funcDecl.Body.List {
 		if assignStmt, ok := stmt.(*dst.AssignStmt); ok {
-			rhs := assignStmt.Rhs
-			if len(rhs) == 1 {
-				rhsExpr := rhs[0]
-				if compositeLit, ok := rhsExpr.(*dst.CompositeLit); ok {
-					elems := compositeLit.Elts
-					names := getNames(funcDecl.Type.Params)
-					for i, name := range names {
-						if i == 0 && !onEnter {
-							// SKip first callContext parameter for onExit
-							continue
+			lhs := assignStmt.Lhs
+			if sel, ok := lhs[0].(*dst.SelectorExpr); ok {
+				switch sel.Sel.Name {
+				case TrampolineFuncNameIdentifier:
+					util.Assert(onEnter, "sanity check")
+					// callContext.FuncName = "..."
+					rhs := assignStmt.Rhs
+					if len(rhs) == 1 {
+						rhsExpr := rhs[0]
+						if basicLit, ok := rhsExpr.(*dst.BasicLit); ok {
+							if basicLit.Kind == token.STRING {
+								rawFuncName := rp.rawFunc.Name.Name
+								basicLit.Value = strconv.Quote(rawFuncName)
+							} else {
+								return false // ill-formed AST
+							}
+						} else {
+							return false // ill-formed AST
+						}
+					} else {
+						return false // ill-formed AST
+					}
+					dst.Print(rhs)
+				case TrampolinePackageNameIdentifier:
+					util.Assert(onEnter, "sanity check")
+					// callContext.PackageName = "..."
+					rhs := assignStmt.Rhs
+					if len(rhs) == 1 {
+						rhsExpr := rhs[0]
+						if basicLit, ok := rhsExpr.(*dst.BasicLit); ok {
+							if basicLit.Kind == token.STRING {
+								pkgName := rp.target.Name.Name
+								basicLit.Value = strconv.Quote(pkgName)
+							} else {
+								return false // ill-formed AST
+							}
+						} else {
+							return false // ill-formed AST
 						}
-						elems = append(elems, util.Ident(name))
+					} else {
+						return false // ill-formed AST
+					}
+				default:
+					// callContext.Params = []interface{}{...} or
+					// callContext.(*CallContextImpl).Params[0] = &int
+					rhs := assignStmt.Rhs
+					if len(rhs) == 1 {
+						rhsExpr := rhs[0]
+						if compositeLit, ok := rhsExpr.(*dst.CompositeLit); ok {
+							elems := compositeLit.Elts
+							names := getNames(funcDecl.Type.Params)
+							for i, name := range names {
+								if i == 0 && !onEnter {
+									// SKip first callContext parameter for onExit
+									continue
+								}
+								elems = append(elems, util.Ident(name))
+							}
+							compositeLit.Elts = elems
+						} else {
+							return false // ill-formed AST
+						}
+					} else {
+						return false // ill-formed AST
 					}
-					compositeLit.Elts = elems
-					return true
 				}
 			}
+
 		}
 	}
-	util.ShouldNotReachHereT("failed to replenish call context")
-	return false
+	return true
 }
 
 // -----------------------------------------------------------------------------