From bec0a0e7d7b557047f252bcfd3e814967ea10080 Mon Sep 17 00:00:00 2001 From: abritkov Date: Tue, 28 Jan 2025 21:09:56 +0300 Subject: [PATCH] feat: added the ability to generate a path based on the second FunctionId argument --- internal/cmd/gstack/astparser.go | 209 +++++++++++++++++++++++++++++ internal/cmd/gstack/main.go | 161 ---------------------- internal/cmd/gstack/utils/utils.go | 61 +++++---- internal/stack/function_id_test.go | 10 ++ internal/xsql/conn.go | 16 +-- internal/xsql/connector.go | 2 +- internal/xsql/stmt.go | 6 +- internal/xsql/tx.go | 10 +- 8 files changed, 274 insertions(+), 201 deletions(-) create mode 100644 internal/cmd/gstack/astparser.go diff --git a/internal/cmd/gstack/astparser.go b/internal/cmd/gstack/astparser.go new file mode 100644 index 000000000..730214db8 --- /dev/null +++ b/internal/cmd/gstack/astparser.go @@ -0,0 +1,209 @@ +package main + +import ( + "bytes" + "go/ast" + "go/token" + "os" + "strings" + + "github.com/ydb-platform/ydb-go-sdk/v3/internal/cmd/gstack/utils" +) + +const ( + stackPackageName = "stack" +) + +func processFile(src []byte, path string, fset *token.FileSet, file *ast.File, info os.FileInfo) error { + formatted, err := format(src, path, fset, file) + if err != nil { + return err + } + if !bytes.Equal(src, formatted) { + err = utils.WriteFile(path, formatted, info.Mode().Perm()) + if err != nil { + return err + } + } + + return nil +} + +func format(src []byte, path string, fset *token.FileSet, file *ast.File) ([]byte, error) { + var listOfArgs []utils.FunctionIDArg + for _, f := range file.Decls { + var listOfCalls []*ast.CallExpr + fn, ok := f.(*ast.FuncDecl) + if !ok { + continue + } + listOfCalls = getListOfCallExpressionsFromBlockStmt(fn.Body) + listOfArgs = append(listOfArgs, getListOfArgsFromListOfCalls(listOfCalls, fn)...) + } + if len(listOfArgs) != 0 { + fixed, err := utils.FixSource(fset, path, src, listOfArgs) + if err != nil { + return nil, err + } + + return fixed, nil + } + + return src, nil +} + +func getListOfArgsFromListOfCalls(listOfCalls []*ast.CallExpr, fn *ast.FuncDecl) []utils.FunctionIDArg { + listOfArgs := make([]utils.FunctionIDArg, 0) + + for _, call := range listOfCalls { + if function, ok := call.Fun.(*ast.SelectorExpr); ok && function.Sel.Name == "FunctionID" { + pack, ok := function.X.(*ast.Ident) + if !ok { + continue + } + if pack.Name == stackPackageName && len(call.Args) > 0 { + packagePath := parseFunctionIDArgs(call.Args[1:]) + listOfArgs = append(listOfArgs, utils.FunctionIDArg{ + FuncDecl: fn, + ArgPos: call.Args[0].Pos(), + ArgEnd: call.Args[0].End(), + StackCallPath: packagePath, + }) + } + } + } + + return listOfArgs +} + +func parseFunctionIDArgs(args []ast.Expr) string { + for _, argExpr := range args { + if arg, ok := argExpr.(*ast.CallExpr); ok { + packagePath := getPackagePathFromCallExpr(arg) + if packagePath != "" { + return packagePath + } + } + } + + return "" +} + +func getPackagePathFromCallExpr(call *ast.CallExpr) string { + if function, ok := call.Fun.(*ast.SelectorExpr); ok { + if pack, ok := function.X.(*ast.Ident); ok && pack.Name == stackPackageName && function.Sel.Name == "Package" { + if len(call.Args) == 1 { + if packagePath, ok := call.Args[0].(*ast.BasicLit); ok && packagePath.Kind == token.STRING { + return strings.Trim(packagePath.Value, "\"") + } + } + } + } + + return "" +} + +func getCallExpressionsFromExpr(expr ast.Expr) (listOfCalls []*ast.CallExpr) { + switch expr := expr.(type) { + case *ast.SelectorExpr: + listOfCalls = getCallExpressionsFromExpr(expr.X) + case *ast.IndexExpr: + listOfCalls = getCallExpressionsFromExpr(expr.X) + case *ast.StarExpr: + listOfCalls = getCallExpressionsFromExpr(expr.X) + case *ast.BinaryExpr: + listOfCalls = getCallExpressionsFromExpr(expr.X) + listOfCalls = append(listOfCalls, getCallExpressionsFromExpr(expr.Y)...) + case *ast.CallExpr: + listOfCalls = append(listOfCalls, expr) + listOfCalls = append(listOfCalls, getCallExpressionsFromExpr(expr.Fun)...) + for _, arg := range expr.Args { + listOfCalls = append(listOfCalls, getCallExpressionsFromExpr(arg)...) + } + case *ast.CompositeLit: + for _, elt := range expr.Elts { + listOfCalls = append(listOfCalls, getCallExpressionsFromExpr(elt)...) + } + case *ast.UnaryExpr: + listOfCalls = append(listOfCalls, getCallExpressionsFromExpr(expr.X)...) + case *ast.KeyValueExpr: + listOfCalls = append(listOfCalls, getCallExpressionsFromExpr(expr.Value)...) + case *ast.FuncLit: + listOfCalls = append(listOfCalls, getListOfCallExpressionsFromBlockStmt(expr.Body)...) + } + + return listOfCalls +} + +func getExprFromDeclStmt(statement *ast.DeclStmt) (listOfExpressions []ast.Expr) { + decl, ok := statement.Decl.(*ast.GenDecl) + if !ok { + return listOfExpressions + } + for _, spec := range decl.Specs { + if spec, ok := spec.(*ast.ValueSpec); ok { + listOfExpressions = append(listOfExpressions, spec.Values...) + } + } + + return listOfExpressions +} + +func getCallExpressionsFromStmt(statement ast.Stmt) (listOfCallExpressions []*ast.CallExpr) { + var body *ast.BlockStmt + switch stmt := statement.(type) { + case *ast.IfStmt: + body = stmt.Body + case *ast.SwitchStmt: + body = stmt.Body + case *ast.TypeSwitchStmt: + body = stmt.Body + case *ast.SelectStmt: + body = stmt.Body + case *ast.ForStmt: + body = stmt.Body + case *ast.GoStmt: + if fun, ok := stmt.Call.Fun.(*ast.FuncLit); ok { + listOfCallExpressions = append(listOfCallExpressions, getListOfCallExpressionsFromBlockStmt(fun.Body)...) + } else { + listOfCallExpressions = append(listOfCallExpressions, stmt.Call) + } + case *ast.RangeStmt: + body = stmt.Body + case *ast.DeclStmt: + for _, expr := range getExprFromDeclStmt(stmt) { + listOfCallExpressions = append(listOfCallExpressions, getCallExpressionsFromExpr(expr)...) + } + case *ast.CommClause: + stmts := stmt.Body + for _, stmt := range stmts { + listOfCallExpressions = append(listOfCallExpressions, getCallExpressionsFromStmt(stmt)...) + } + case *ast.ExprStmt: + listOfCallExpressions = append(listOfCallExpressions, getCallExpressionsFromExpr(stmt.X)...) + case *ast.AssignStmt: + for _, rh := range stmt.Rhs { + listOfCallExpressions = append(listOfCallExpressions, getCallExpressionsFromExpr(rh)...) + } + case *ast.ReturnStmt: + for _, result := range stmt.Results { + listOfCallExpressions = append(listOfCallExpressions, getCallExpressionsFromExpr(result)...) + } + } + if body != nil { + listOfCallExpressions = append( + listOfCallExpressions, + getListOfCallExpressionsFromBlockStmt(body)..., + ) + } + + return listOfCallExpressions +} + +func getListOfCallExpressionsFromBlockStmt(block *ast.BlockStmt) (listOfCallExpressions []*ast.CallExpr) { + for _, statement := range block.List { + listOfCallExpressions = append(listOfCallExpressions, getCallExpressionsFromStmt(statement)...) + } + + return listOfCallExpressions +} diff --git a/internal/cmd/gstack/main.go b/internal/cmd/gstack/main.go index 10f3ed061..78edc2b81 100644 --- a/internal/cmd/gstack/main.go +++ b/internal/cmd/gstack/main.go @@ -1,10 +1,8 @@ package main import ( - "bytes" "flag" "fmt" - "go/ast" "go/parser" "go/token" "io/fs" @@ -19,165 +17,6 @@ func usage() { flag.PrintDefaults() } -func getCallExpressionsFromExpr(expr ast.Expr) (listOfCalls []*ast.CallExpr) { - switch expr := expr.(type) { - case *ast.SelectorExpr: - listOfCalls = getCallExpressionsFromExpr(expr.X) - case *ast.IndexExpr: - listOfCalls = getCallExpressionsFromExpr(expr.X) - case *ast.StarExpr: - listOfCalls = getCallExpressionsFromExpr(expr.X) - case *ast.BinaryExpr: - listOfCalls = getCallExpressionsFromExpr(expr.X) - listOfCalls = append(listOfCalls, getCallExpressionsFromExpr(expr.Y)...) - case *ast.CallExpr: - listOfCalls = append(listOfCalls, expr) - listOfCalls = append(listOfCalls, getCallExpressionsFromExpr(expr.Fun)...) - for _, arg := range expr.Args { - listOfCalls = append(listOfCalls, getCallExpressionsFromExpr(arg)...) - } - case *ast.CompositeLit: - for _, elt := range expr.Elts { - listOfCalls = append(listOfCalls, getCallExpressionsFromExpr(elt)...) - } - case *ast.UnaryExpr: - listOfCalls = append(listOfCalls, getCallExpressionsFromExpr(expr.X)...) - case *ast.KeyValueExpr: - listOfCalls = append(listOfCalls, getCallExpressionsFromExpr(expr.Value)...) - case *ast.FuncLit: - listOfCalls = append(listOfCalls, getListOfCallExpressionsFromBlockStmt(expr.Body)...) - } - - return listOfCalls -} - -func getExprFromDeclStmt(statement *ast.DeclStmt) (listOfExpressions []ast.Expr) { - decl, ok := statement.Decl.(*ast.GenDecl) - if !ok { - return listOfExpressions - } - for _, spec := range decl.Specs { - if spec, ok := spec.(*ast.ValueSpec); ok { - listOfExpressions = append(listOfExpressions, spec.Values...) - } - } - - return listOfExpressions -} - -func getCallExpressionsFromStmt(statement ast.Stmt) (listOfCallExpressions []*ast.CallExpr) { - var body *ast.BlockStmt - var listOfExpressions []ast.Expr - switch stmt := statement.(type) { - case *ast.IfStmt: - body = stmt.Body - case *ast.SwitchStmt: - body = stmt.Body - case *ast.TypeSwitchStmt: - body = stmt.Body - case *ast.SelectStmt: - body = stmt.Body - case *ast.ForStmt: - body = stmt.Body - case *ast.GoStmt: - if fun, ok := stmt.Call.Fun.(*ast.FuncLit); ok { - listOfCallExpressions = append(listOfCallExpressions, getListOfCallExpressionsFromBlockStmt(fun.Body)...) - } else { - listOfCallExpressions = append(listOfCallExpressions, stmt.Call) - } - case *ast.RangeStmt: - body = stmt.Body - case *ast.DeclStmt: - listOfExpressions = append(listOfExpressions, getExprFromDeclStmt(stmt)...) - for _, expr := range listOfExpressions { - listOfCallExpressions = append(listOfCallExpressions, getCallExpressionsFromExpr(expr)...) - } - case *ast.CommClause: - stmts := stmt.Body - for _, stmt := range stmts { - listOfCallExpressions = append(listOfCallExpressions, getCallExpressionsFromStmt(stmt)...) - } - case *ast.ExprStmt: - listOfCallExpressions = append(listOfCallExpressions, getCallExpressionsFromExpr(stmt.X)...) - case *ast.AssignStmt: - for _, rh := range stmt.Rhs { - listOfCallExpressions = append(listOfCallExpressions, getCallExpressionsFromExpr(rh)...) - } - case *ast.ReturnStmt: - for _, result := range stmt.Results { - listOfCallExpressions = append(listOfCallExpressions, getCallExpressionsFromExpr(result)...) - } - } - if body != nil { - listOfCallExpressions = append( - listOfCallExpressions, - getListOfCallExpressionsFromBlockStmt(body)..., - ) - } - - return listOfCallExpressions -} - -func getListOfCallExpressionsFromBlockStmt(block *ast.BlockStmt) (listOfCallExpressions []*ast.CallExpr) { - for _, statement := range block.List { - listOfCallExpressions = append(listOfCallExpressions, getCallExpressionsFromStmt(statement)...) - } - - return listOfCallExpressions -} - -func format(src []byte, path string, fset *token.FileSet, file *ast.File) ([]byte, error) { - var listOfArgs []utils.FunctionIDArg - for _, f := range file.Decls { - var listOfCalls []*ast.CallExpr - fn, ok := f.(*ast.FuncDecl) - if !ok { - continue - } - listOfCalls = getListOfCallExpressionsFromBlockStmt(fn.Body) - for _, call := range listOfCalls { - if function, ok := call.Fun.(*ast.SelectorExpr); ok && function.Sel.Name == "FunctionID" { - pack, ok := function.X.(*ast.Ident) - if !ok { - continue - } - if pack.Name == "stack" && len(call.Args) == 1 { - listOfArgs = append(listOfArgs, utils.FunctionIDArg{ - FuncDecl: fn, - ArgPos: call.Args[0].Pos(), - ArgEnd: call.Args[0].End(), - }) - } - } - } - } - if len(listOfArgs) != 0 { - fixed, err := utils.FixSource(fset, path, src, listOfArgs) - if err != nil { - return nil, err - } - - return fixed, nil - } - - return src, nil -} - -func processFile(src []byte, path string, fset *token.FileSet, file *ast.File, info os.FileInfo) error { - formatted, err := format(src, path, fset, file) - if err != nil { - return err - } - if !bytes.Equal(src, formatted) { - err = utils.WriteFile(path, formatted, info.Mode().Perm()) - if err != nil { - return err - } - } - - return nil -} - func main() { flag.Usage = usage flag.Parse() diff --git a/internal/cmd/gstack/utils/utils.go b/internal/cmd/gstack/utils/utils.go index 791c858ea..7cf319ddf 100644 --- a/internal/cmd/gstack/utils/utils.go +++ b/internal/cmd/gstack/utils/utils.go @@ -14,9 +14,10 @@ import ( ) type FunctionIDArg struct { - FuncDecl *ast.FuncDecl - ArgPos token.Pos - ArgEnd token.Pos + FuncDecl *ast.FuncDecl + ArgPos token.Pos + ArgEnd token.Pos + StackCallPath string } func ReadFile(filename string, info fs.FileInfo) ([]byte, error) { @@ -24,39 +25,47 @@ func ReadFile(filename string, info fs.FileInfo) ([]byte, error) { if err != nil { return nil, err } + defer f.Close() - size := int(info.Size()) - src := make([]byte, size) + + fileSize := int(info.Size()) + src := make([]byte, fileSize) n, err := io.ReadFull(f, src) if err != nil { return nil, err } - if n < size { - return nil, fmt.Errorf("error: size of %q changed during reading (from %d to %d bytes)", filename, size, n) - } else if n > size { - return nil, fmt.Errorf("error: size of %q changed during reading (from %d to >=%d bytes)", filename, size, len(src)) + + if n < fileSize { + return nil, fmt.Errorf("error: fileSize of %s changed during reading (from %d to %d bytes)", filename, + fileSize, n) + } else if n > fileSize { + return nil, fmt.Errorf("error: fileSize of %s changed during reading (from %d to >=%d bytes)", filename, + fileSize, len(src)) } return src, nil } func FixSource(fset *token.FileSet, path string, src []byte, listOfArgs []FunctionIDArg) ([]byte, error) { - var fixed []byte var previousArgEnd int + var fixedSource []byte + for _, arg := range listOfArgs { argPosOffset := fset.Position(arg.ArgPos).Offset argEndOffset := fset.Position(arg.ArgEnd).Offset + argument, err := makeCall(fset, path, arg) if err != nil { - return nil, err + return nil, fmt.Errorf("error during making call path: %w", err) } - fixed = append(fixed, src[previousArgEnd:argPosOffset]...) - fixed = append(fixed, fmt.Sprintf("%q", argument)...) + + fixedSource = append(fixedSource, src[previousArgEnd:argPosOffset]...) + fixedSource = append(fixedSource, fmt.Sprintf("%q", argument)...) previousArgEnd = argEndOffset } - fixed = append(fixed, src[previousArgEnd:]...) + fixedSource = append(fixedSource, src[previousArgEnd:]...) - return fixed, nil + return fixedSource, nil } func WriteFile(filename string, formatted []byte, perm fs.FileMode) error { @@ -76,18 +85,24 @@ func WriteFile(filename string, formatted []byte, perm fs.FileMode) error { } func makeCall(fset *token.FileSet, path string, arg FunctionIDArg) (string, error) { - basePath := filepath.Join("github.com", "ydb-platform", version.Package, "v"+version.Major, "") - packageName, err := getPackageName(fset, arg) + funcName, err := getFuncName(arg.FuncDecl) if err != nil { - return "", err + return "", fmt.Errorf("error during getting function name: %w", err) } - filePath := filepath.Dir(filepath.Dir(path)) - funcName, err := getFuncName(arg.FuncDecl) + + if arg.StackCallPath != "" { + return arg.StackCallPath + "." + funcName, nil + } + + modulePath := filepath.Join("github.com", "ydb-platform", version.Package, "v"+version.Major, "") + packageName, err := getPackageName(fset, arg) if err != nil { - return "", err + return "", fmt.Errorf("error during getting package name for %s: %w", funcName, err) } - return filepath.Join(basePath, filePath, packageName) + "." + funcName, nil + filePath := filepath.Dir(filepath.Dir(path)) + + return filepath.Join(modulePath, filePath, packageName) + "." + funcName, nil } func getFuncName(funcDecl *ast.FuncDecl) (string, error) { @@ -128,7 +143,7 @@ func getPackageName(fset *token.FileSet, arg FunctionIDArg) (string, error) { file := fset.File(arg.ArgPos) parsedFile, err := parser.ParseFile(fset, file.Name(), nil, parser.PackageClauseOnly) if err != nil { - return "", fmt.Errorf("error during get package name function") + return "", fmt.Errorf("error during getting package name function") } return parsedFile.Name.Name, nil diff --git a/internal/stack/function_id_test.go b/internal/stack/function_id_test.go index 1ba408655..0ccb7c45e 100644 --- a/internal/stack/function_id_test.go +++ b/internal/stack/function_id_test.go @@ -40,6 +40,10 @@ func anonymousFunctionCall() string { return result } +func callWithPackageDefinition() string { + return FunctionID("", Package("database/sql")).String() +} + func TestFunctionIDForGenericType(t *testing.T) { t.Run("StaticFunc", func(t *testing.T) { require.Equal(t, @@ -66,4 +70,10 @@ func TestFunctionIDForGenericType(t *testing.T) { anonymousFunctionCall(), ) }) + t.Run("CallWithPackageDefinition", func(t *testing.T) { + require.Equal(t, + "database/sql.callWithPackageDefinition", + callWithPackageDefinition(), + ) + }) } diff --git a/internal/xsql/conn.go b/internal/xsql/conn.go index a59e2b1cc..78f6a6c61 100644 --- a/internal/xsql/conn.go +++ b/internal/xsql/conn.go @@ -25,7 +25,7 @@ type Conn struct { func (c *Conn) Ping(ctx context.Context) (finalErr error) { onDone := trace.DatabaseSQLOnConnPing(c.connector.trace, &c.ctx, - stack.FunctionID("", stack.Package("database/sql")), + stack.FunctionID("database/sql.(*Conn).Ping", stack.Package("database/sql")), ) defer func() { onDone(finalErr) @@ -36,7 +36,7 @@ func (c *Conn) Ping(ctx context.Context) (finalErr error) { func (c *Conn) CheckNamedValue(value *driver.NamedValue) (finalErr error) { onDone := trace.DatabaseSQLOnConnCheckNamedValue(c.connector.trace, &c.ctx, - stack.FunctionID("", stack.Package("database/sql")), + stack.FunctionID("database/sql.(*Conn).CheckNamedValue", stack.Package("database/sql")), value, ) defer func() { @@ -49,7 +49,7 @@ func (c *Conn) CheckNamedValue(value *driver.NamedValue) (finalErr error) { func (c *Conn) BeginTx(ctx context.Context, opts driver.TxOptions) (_ driver.Tx, finalErr error) { onDone := trace.DatabaseSQLOnConnBeginTx(c.connector.trace, &ctx, - stack.FunctionID("", stack.Package("database/sql")), + stack.FunctionID("database/sql.(*Conn).BeginTx", stack.Package("database/sql")), ) defer func() { onDone(c.currentTx, finalErr) @@ -75,7 +75,7 @@ func (c *Conn) BeginTx(ctx context.Context, opts driver.TxOptions) (_ driver.Tx, func (c *Conn) Close() (finalErr error) { onDone := trace.DatabaseSQLOnConnClose(c.connector.Trace(), &c.ctx, - stack.FunctionID("", stack.Package("database/sql")), + stack.FunctionID("database/sql.(*Conn).Close", stack.Package("database/sql")), ) defer func() { onDone(finalErr) @@ -91,7 +91,7 @@ func (c *Conn) Close() (finalErr error) { func (c *Conn) Begin() (_ driver.Tx, finalErr error) { onDone := trace.DatabaseSQLOnConnBegin(c.connector.trace, &c.ctx, - stack.FunctionID("", stack.Package("database/sql")), + stack.FunctionID("database/sql.(*Conn).Begin", stack.Package("database/sql")), ) defer func() { onDone(c.currentTx, finalErr) @@ -110,7 +110,7 @@ func (c *Conn) Prepare(string) (driver.Stmt, error) { func (c *Conn) PrepareContext(ctx context.Context, sql string) (_ driver.Stmt, finalErr error) { onDone := trace.DatabaseSQLOnConnPrepare(c.connector.Trace(), &ctx, - stack.FunctionID("", stack.Package("database/sql")), + stack.FunctionID("database/sql.(*Conn).PrepareContext", stack.Package("database/sql")), sql, ) defer func() { @@ -133,7 +133,7 @@ func (c *Conn) QueryContext(ctx context.Context, sql string, args []driver.Named _ driver.Rows, finalErr error, ) { onDone := trace.DatabaseSQLOnConnQuery(c.connector.Trace(), &ctx, - stack.FunctionID("", stack.Package("database/sql")), + stack.FunctionID("database/sql.(*Conn).QueryContext", stack.Package("database/sql")), sql, c.connector.processor.String(), xcontext.IsIdempotent(ctx), c.connector.clock.Since(c.lastUsage.Get()), ) defer func() { @@ -168,7 +168,7 @@ func (c *Conn) ExecContext(ctx context.Context, sql string, args []driver.NamedV _ driver.Result, finalErr error, ) { onDone := trace.DatabaseSQLOnConnExec(c.connector.Trace(), &ctx, - stack.FunctionID("", stack.Package("database/sql")), + stack.FunctionID("database/sql.(*Conn).ExecContext", stack.Package("database/sql")), sql, c.connector.processor.String(), xcontext.IsIdempotent(ctx), c.connector.clock.Since(c.lastUsage.Get()), ) defer func() { diff --git a/internal/xsql/connector.go b/internal/xsql/connector.go index 4a2b42f3d..95c9cc9c9 100644 --- a/internal/xsql/connector.go +++ b/internal/xsql/connector.go @@ -126,7 +126,7 @@ func (c *Connector) Open(name string) (driver.Conn, error) { func (c *Connector) Connect(ctx context.Context) (_ driver.Conn, finalErr error) { //nolint:funlen onDone := trace.DatabaseSQLOnConnectorConnect(c.Trace(), &ctx, - stack.FunctionID("", stack.Package("database/sql")), + stack.FunctionID("database/sql.(*Connector).Connect", stack.Package("database/sql")), ) switch c.processor { diff --git a/internal/xsql/stmt.go b/internal/xsql/stmt.go index 4afe2d4d5..fab351f28 100644 --- a/internal/xsql/stmt.go +++ b/internal/xsql/stmt.go @@ -28,7 +28,7 @@ var ( func (stmt *Stmt) QueryContext(ctx context.Context, args []driver.NamedValue) (_ driver.Rows, finalErr error) { onDone := trace.DatabaseSQLOnStmtQuery(stmt.conn.connector.Trace(), &ctx, - stack.FunctionID("", stack.Package("database/sql")), + stack.FunctionID("database/sql.(*Stmt).QueryContext", stack.Package("database/sql")), stmt.ctx, stmt.sql, ) defer func() { @@ -49,7 +49,7 @@ func (stmt *Stmt) QueryContext(ctx context.Context, args []driver.NamedValue) (_ func (stmt *Stmt) ExecContext(ctx context.Context, args []driver.NamedValue) (_ driver.Result, finalErr error) { onDone := trace.DatabaseSQLOnStmtExec(stmt.conn.connector.Trace(), &ctx, - stack.FunctionID("", stack.Package("database/sql")), + stack.FunctionID("database/sql.(*Stmt).ExecContext", stack.Package("database/sql")), stmt.ctx, stmt.sql, ) defer func() { @@ -76,7 +76,7 @@ func (stmt *Stmt) Close() (finalErr error) { var ( ctx = stmt.ctx onDone = trace.DatabaseSQLOnStmtClose(stmt.conn.connector.Trace(), &ctx, - stack.FunctionID("", stack.Package("database/sql")), + stack.FunctionID("database/sql.(*Stmt).Close", stack.Package("database/sql")), ) ) defer func() { diff --git a/internal/xsql/tx.go b/internal/xsql/tx.go index 1f9f386b9..35b6f2a4b 100644 --- a/internal/xsql/tx.go +++ b/internal/xsql/tx.go @@ -39,7 +39,7 @@ func (tx *Tx) Commit() (finalErr error) { var ( ctx = tx.ctx onDone = trace.DatabaseSQLOnTxCommit(tx.conn.connector.Trace(), &ctx, - stack.FunctionID("", stack.Package("database/sql")), + stack.FunctionID("database/sql.(*Tx).Commit", stack.Package("database/sql")), tx, ) ) @@ -62,7 +62,7 @@ func (tx *Tx) Rollback() (finalErr error) { var ( ctx = tx.ctx onDone = trace.DatabaseSQLOnTxRollback(tx.conn.connector.Trace(), &ctx, - stack.FunctionID("", stack.Package("database/sql")), + stack.FunctionID("database/sql.(*Tx).Rollback", stack.Package("database/sql")), tx, ) ) @@ -82,7 +82,7 @@ func (tx *Tx) QueryContext(ctx context.Context, sql string, args []driver.NamedV _ driver.Rows, finalErr error, ) { onDone := trace.DatabaseSQLOnTxQuery(tx.conn.connector.Trace(), &ctx, - stack.FunctionID("", stack.Package("database/sql")), + stack.FunctionID("database/sql.(*Tx).QueryContext", stack.Package("database/sql")), tx.ctx, tx, sql, ) defer func() { @@ -115,7 +115,7 @@ func (tx *Tx) ExecContext(ctx context.Context, sql string, args []driver.NamedVa _ driver.Result, finalErr error, ) { onDone := trace.DatabaseSQLOnTxExec(tx.conn.connector.Trace(), &ctx, - stack.FunctionID("", stack.Package("database/sql")), + stack.FunctionID("database/sql.(*Tx).ExecContext", stack.Package("database/sql")), tx.ctx, tx, sql, ) defer func() { @@ -137,7 +137,7 @@ func (tx *Tx) ExecContext(ctx context.Context, sql string, args []driver.NamedVa func (tx *Tx) PrepareContext(ctx context.Context, sql string) (_ driver.Stmt, finalErr error) { onDone := trace.DatabaseSQLOnTxPrepare(tx.conn.connector.Trace(), &ctx, - stack.FunctionID("", stack.Package("database/sql")), + stack.FunctionID("database/sql.(*Tx).PrepareContext", stack.Package("database/sql")), tx.ctx, tx, sql, ) defer func() {