Gorm作为Go语言中很常用的一个ORM库，功能非常强大。应用程序的大量时间都花在通过gorm与数据库连接上面，所以我们想在链路跟踪中获得更好的视图。

幸运的是，Gorm有完美的钩子，我们可以通过Callbacks API将跟踪功能注入到数据库处理当中。Callbacks API允许我们为Gorm提供在查询生命周期的特定部分中执行相应的函数，或者允许您在传统的中间件方法中更改查询行为，或者在我们的例子中，为可观察性提取数据。

func beforeQuery(scope *gorm.DB) {
    // do stuff!
}

db.Callback().
    Create().
    Before("gorm:query").
    Register("instrumentation:before_query", beforeQuery)

这篇文章的目标是在我们的Gorm查询中引入链路跟踪，为了做到这一点，我们需要同时捕获开始和结束事件，并相应地处理链路信息span。在这些例子中，我将使用go.opencensus.io/trace提供的跟踪工具，它对接谷歌云跟踪，但其他跟踪库的行为应该类似。

现在我们有一个函数在查询开始时调用，我们需要引入链路追逐:

func beforeQuery(scope *gorm.DB) {
    db.Statement.Context = startTrace(
    db.Statement.Context,
    db,
    operation,
  )
}

func startTrace(
  ctx context.Context,
  db *gorm.DB,
) context.Context {
    // 判断是否需要启动链路追逐，查看追踪的span是否存在
    if span := trace.FromContext(ctx); span == nil {
        return ctx
    }

    ctx, span := trace.StartSpan(ctx, "gorm.query")
    return ctx
}

然后我们需要对这个追踪span收尾处理:

func afterQuery(scope *gorm.DB) { endTrace(scope) }

func endTrace(db *gorm.DB) {
    span := trace.FromContext(db.Statement.Context)
    if span == nil || !span.IsRecordingEvents() {
        return
    }

    var status trace.Status

    if db.Error != nil {
        err := db.Error
        if err == gorm.ErrRecordNotFound {
            status.Code = trace.StatusCodeNotFound
        } else {
            status.Code = trace.StatusCodeUnknown
        }

        status.Message = err.Error()
    }
    span.SetStatus(status)
    span.End()
}

db.Callback().
    Query().
    After("gorm:query").
    Register("instrumentation:after_query", afterQuery)

现在我们可以在链路追踪中看到所有gorm查询!

然而，上图中不太清楚查询实际上在做什么，让我们看看是否可以让这些span包含更多有用信息，通过添加:

• 数据库表名信息和查询指纹
• 函数调用代码行数
• 查询的WHERE参数
• 影响表行数

查询指纹是查询的唯一标识符，与格式和变量无关，因此您可以唯一地标识在数据库中具有相同行为的查询。
让我们扩展前面的代码:

func startTrace(ctx context.Context, db *gorm.DB) context.Context {
    // Don't trace queries if they don't have a parent span.
    if span := trace.FromContext(ctx); span == nil {
        return ctx
    }

    // start the span
    ctx, span := trace.StartSpan(ctx, fmt.Sprintf("gorm.query.%s", db.Statement.Table))

    // set the caller of the gorm query, so we know where in the codebase the
    // query originated.
    //
    // walk up the call stack looking for the line of code that called us. but
    // give up if it's more than 20 steps, and skip the first 5 as they're all
    // gorm anyway
    var (
        file string
        line int
    )
    for n := 5; n < 20; n++ {
        _, file, line, _ = runtime.Caller(n)
        if strings.Contains(file, "/gorm.io/") {
            // skip any helper code and go further up the call stack
            continue
        }
        break
    }
    span.AddAttributes(trace.StringAttribute("caller", fmt.Sprintf("%s:%v", file, line)))

    // add the primary table to the span metadata
    span.AddAttributes(trace.StringAttribute("gorm.table", db.Statement.Table))
    return ctx
}

func endTrace(db *gorm.DB) {
    // get the span from the context
    span := trace.FromContext(db.Statement.Context)
    if span == nil || !span.IsRecordingEvents() {
        return
    }

    // set the span status, so we know if the query was successful
    var status trace.Status
    if db.Error != nil {
        err := db.Error
        if err == gorm.ErrRecordNotFound {
            status.Code = trace.StatusCodeNotFound
        } else {
            status.Code = trace.StatusCodeUnknown
        }

        status.Message = err.Error()
    }
    span.SetStatus(status)

    // add the number of affected rows & query string to the span metadata
    span.AddAttributes(
        trace.Int64Attribute("gorm.rows_affected", db.Statement.RowsAffected),
        trace.StringAttribute("gorm.query", db.Statement.SQL.String()),
    )
    // Query fingerprint provided by github.com/pganalyze/pg_query_go
    fingerprint, err := pg_query.Fingerprint(db.Statement.SQL.String())
    if err != nil {
        fingerprint = "unknown"
    }

    // Rename the span with the fingerprint, as the DB handle
    // doesn't have SQL to fingerprint before being executed
    span.SetName(fmt.Sprintf("gorm.query.%s.%s", db.Statement.Table, fingerprint))

    // finally end the span
    span.End()
}

func afterQuery(scope *gorm.DB) {
    // now in afterQuery we can add query vars to the span metadata
    // we do this in afterQuery rather than the trace functions so we
    // can re-use the traces for non-select cases where we wouldn't want
    // to record the vars as they may contain sensitive data

    // first we extract the vars from the query & map them into a
  // human readable format
    fieldStrings := []string{}
    if scope.Statement != nil {
        fieldStrings = lo.Map(scope.Statement.Vars, func(v any i int) string {
            return fmt.Sprintf("($%v = %v)", i+1, v)
        })
    }
    // then add the vars to the span metadata
    span := trace.FromContext(scope.Statement.Context)
    if span != nil && span.IsRecordingEvents() {
        span.AddAttributes(
            trace.StringAttribute("gorm.query.vars", strings.Join(fieldStrings, ", ")),
        )
    }
    endTrace(scope)
}

现在，我们获得了非常简单详细的数据库查询跟踪信息，使我们更容易理解我们的应用程序在做什么!

Gorm为查询生命周期的不同部分提供回调，你可以为它们添加特定的行为，我们目前分别跟踪创建、删除、更新和查询，但如果你想更进一步，你可以查看Gorm文档!． 你可以在这里[https://gist.github.com/arussellsaw/bbedfdefee119b4600ce085b773da4b9]找到这篇文章中的所有代码。

请记住，如果不小心，您可能会追踪到一些敏感数据。因此，请确保清理您的查询变量。一个好的实践是只跟踪SELECT查询，因为它们通常是通过ID完成的，而不是任何敏感信息。