Go 运行时注入与覆盖率实现方案调研

package main

import (
    "fmt"
    "strings"
    "bou.ke/monkey"
)

func main() {
    monkey.Patch(fmt.Println, func(a ...interface{}) (n int, err error) {
        s := make([]interface{}, len(a))
        for i, v := range a {
            s[i] = strings.Replace(fmt.Sprint(v), "hell", "*bleep*", -1)
        }
        return fmt.Fprintln(os.Stdout, s...)
    })
    fmt.Println("what the hell?") // 输出: what the *bleep*?
}

// 原始代码
func add(a, b int) int {
    return a + b
}

// 编译后（简化示例）
func add(a, b int) int {
    coverCount[0]++  // 入口计数
    defer func() { coverCount[1]++ }()  // 出口计数
    return a + b
}

# 1. 启动 goc 服务端
goc server

# 2. 使用 goc 构建目标服务（会自动插桩）
goc build .

# 3. 运行生成的二进制文件
./your-app

# 4. 获取覆盖率数据
goc profile

go install go.uber.org/mock/mockgen@latest

func TestFoo(t *testing.T) {
    ctrl := gomock.NewController(t)
    m := NewMockFoo(ctrl)
    m.EXPECT().Bar(gomock.Eq(99)).Return(101)
    SUT(m)
}

func TestSomething(t *testing.T) {
    testObj := new(MyMockedObject)
    testObj.On("DoSomething", 123).Return(true, nil)
    targetFuncThatDoesSomethingWithObj(testObj)
    testObj.AssertExpectations(t)
}

func main() {
    app := fx.New(
        fx.Provide(NewDB, NewService),
        fx.Invoke(RunServer),
    )
    app.Run()
}

c := dig.New()
c.Provide(NewDB)
c.Provide(NewService)
c.Invoke(func(s *Service) {
    // 使用 service
})

func callMethod(obj interface{}, name string, args ...interface{}) ([]interface{}, error) {
    v := reflect.ValueOf(obj)
    method := v.MethodByName(name)
    if !method.IsValid() {
        return nil, fmt.Errorf("method not found")
    }
    inArgs := make([]reflect.Value, len(args))
    for i, arg := range args {
        inArgs[i] = reflect.ValueOf(arg)
    }
    results := method.Call(inArgs...)
    out := make([]interface{}, len(results))
    for i, result := range results {
        out[i] = result.Interface()
    }
    return out, nil
}

package main

import (
    "fmt"
    "github.com/expr-lang/expr"
)

func main() {
    env := map[string]interface{}{
        "greet": "Hello, %v!",
        "names": []string{"world", "you"},
        "sprintf": fmt.Sprintf,
    }
    code := `sprintf(greet, names[0])`
    program, _ := expr.Compile(code, expr.Env(env))
    output, _ := expr.Run(program, env)
    fmt.Println(output)
}

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Printf("Request: %s %s", r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
    })
}

func loggingInterceptor(
    ctx context.Context,
    req interface{},
    info *grpc.UnaryServerInfo,
    handler grpc.UnaryHandler,
) (interface{}, error) {
    log.Printf("gRPC call: %s", info.FullMethod)
    return handler(ctx, req)
}

// 原始函数
func add(a, b int) int {
    return a + b
}

// 插桩后的函数
func add(a, b int) int {
    GoCover_0_1234567890.Count[0] = 1  // 入口计数
    defer func() { GoCover_0_1234567890.Count[1] = 1 }()  // 出口计数
    return a + b
}

// 覆盖率计数器
var GoCover_0_1234567890 = struct {
    Count     [2]uint32  // 计数器数组
    Pos       [2]token.Pos  // 位置信息
    NumStmt   [2]uint16   // 语句数量
}

package main

import (
    "bytes"
    "fmt"
    "go/ast"
    "go/parser"
    "go/printer"
    "go/token"
)

// 插桩器
type Instrumenter struct {
    fset    *token.FileSet
    file    *ast.File
    counter int
}

func NewInstrumenter(src string) (*Instrumenter, error) {
    fset := token.NewFileSet()
    file, err := parser.ParseFile(fset, "source.go", []byte(src), parser.ParseComments)
    if err != nil {
        return nil, err
    }
    return &Instrumenter{fset: fset, file: file}, nil
}

// 在函数入口插入计数器
func (i *Instrumenter) InstrumentFunctions() {
    ast.Inspect(i.file, func(n ast.Node) bool {
        if fn, ok := n.(*ast.FuncDecl); ok && fn.Body != nil {
            // 在函数体开头插入计数器
            counterCall := &ast.ExprStmt{
                X: &ast.CallExpr{
                    Fun: &ast.Ident{Name: "incrementCounter"},
                    Args: []ast.Expr{&ast.BasicLit{Kind: token.INT, Value: fmt.Sprintf("%d", i.counter)}},
                },
            }
            // 插入到函数体开头
            fn.Body.List = append([]ast.Stmt{counterCall}, fn.Body.List...)
            i.counter++
        }
        return true
    })
}

// 输出修改后的代码
func (i *Instrumenter) Print() string {
    var buf bytes.Buffer
    printer.Fprint(&buf, i.fset, i.file)
    return buf.String()
}

func main() {
    src := `
package main

func add(a, b int) int {
    return a + b
}

func main() {
    result := add(1, 2)
    println(result)
}
`
    
    inst, err := NewInstrumenter(src)
    if err != nil {
        panic(err)
    }
    
    inst.InstrumentFunctions()
    fmt.Println(inst.Print())
}

package main

func add(a, b int) int {
    incrementCounter(0)
    return a + b
}

func main() {
    incrementCounter(1)
    result := add(1, 2)
    println(result)
}

package main

import (
    "fmt"
    "go/ast"
    "go/types"
    "golang.org/x/tools/go/packages"
)

func main() {
    cfg := &packages.Config{Mode: packages.NeedName s | packages.NeedFiles | packages.NeedTypes}
    pkgs, err := packages.Load(cfg, "fmt", "os")
    if err != nil {
        panic(err)
    }
    
    for _, pkg := range pkgs {
        fmt.Printf("Package: %s\n", pkg.Name)
        for _, file := range pkg.Syntax {
            ast.Inspect(file, func(n ast.Node) bool {
                if fn, ok := n.(*ast.FuncDecl); ok {
                    fmt.Printf("  Function: %s\n", fn.Name.Name)
                }
                return true
            })
        }
    }
}

type Linter struct {
    cfg *packages.Config
}

func (l *Linter) Run(pkgPath string) error {
    pkgs, err := packages.Load(l.cfg, pkgPath)
    if err != nil {
        return err
    }
    
    for _, pkg := range pkgs {
        for _, file := range pkg.Syntax {
            // 检查未使用的变量
            ast.Inspect(file, func(n ast.Node) bool {
                if decl, ok := n.(*ast.GenDecl); ok && decl.Tok == token.VAR {
                    // 检查变量是否被使用
                    checkUnusedVariable(pkg.TypesInfo, decl)
                }
                return true
            })
        }
    }
    return nil
}

# 使用自定义工具包装编译器
go build -toolexec='/path/to/my-tool'

#!/bin/bash
# my-go-build.sh

# 1. 提取源文件
SOURCES=$(go list -f '{{range .GoFiles}}{{.}}{{"\n"}}{{end}}' ./...)

# 2. 插桩
for src in $SOURCES; do
    my-instrumenter $src > instrumented/$src
done

# 3. 编译
go build ./instrumented

// 插桩后的代码
var coverage = struct {
    sync.RWMutex
    counters map[string]uint64
}{
    counters: make(map[string]uint64),
}

func incrementCounter(funcName string) {
    coverage.Lock()
    coverage.counters[funcName]++
    coverage.Unlock()
}

// HTTP 接口
func getCoverage(w http.ResponseWriter, r *http.Request) {
    coverage.RLock()
    defer coverage.RUnlock()
    json.NewEncoder(w).Encode(coverage.counters)
}

// 插桩后的函数
func add(a, b int) int {
    incrementCounter("add")
    return a + b
}