82 lines
2.6 KiB
Go
82 lines
2.6 KiB
Go
// Copyright 2019 The Go Cloud Development Kit Authors
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package oc
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"reflect"
|
|
"time"
|
|
|
|
"go.opencensus.io/stats"
|
|
"go.opencensus.io/tag"
|
|
"go.opencensus.io/trace"
|
|
"gocloud.dev/gcerrors"
|
|
)
|
|
|
|
// A Tracer supports OpenCensus tracing and latency metrics.
|
|
type Tracer struct {
|
|
Package string
|
|
Provider string
|
|
LatencyMeasure *stats.Float64Measure
|
|
}
|
|
|
|
// ProviderName returns the name of the provider associated with the driver value.
|
|
// It is intended to be used to set Tracer.Provider.
|
|
// It actually returns the package path of the driver's type.
|
|
func ProviderName(driver interface{}) string {
|
|
// Return the last component of the package path.
|
|
if driver == nil {
|
|
return ""
|
|
}
|
|
t := reflect.TypeOf(driver)
|
|
if t.Kind() == reflect.Ptr {
|
|
t = t.Elem()
|
|
}
|
|
return t.PkgPath()
|
|
}
|
|
|
|
// Context key for starting time of a method call.
|
|
type startTimeKey struct{}
|
|
|
|
// Start adds a span to the trace, and prepares for recording a latency measurement.
|
|
func (t *Tracer) Start(ctx context.Context, methodName string) context.Context {
|
|
fullName := t.Package + "." + methodName
|
|
ctx, _ = trace.StartSpan(ctx, fullName)
|
|
ctx, err := tag.New(ctx,
|
|
tag.Upsert(MethodKey, fullName),
|
|
tag.Upsert(ProviderKey, t.Provider))
|
|
if err != nil {
|
|
// The only possible errors are from invalid key or value names, and those are programming
|
|
// errors that will be found during testing.
|
|
panic(fmt.Sprintf("fullName=%q, provider=%q: %v", fullName, t.Provider, err))
|
|
}
|
|
return context.WithValue(ctx, startTimeKey{}, time.Now())
|
|
}
|
|
|
|
// End ends a span with the given error, and records a latency measurement.
|
|
func (t *Tracer) End(ctx context.Context, err error) {
|
|
startTime := ctx.Value(startTimeKey{}).(time.Time)
|
|
elapsed := time.Since(startTime)
|
|
code := gcerrors.Code(err)
|
|
span := trace.FromContext(ctx)
|
|
if err != nil {
|
|
span.SetStatus(trace.Status{Code: int32(code), Message: err.Error()})
|
|
}
|
|
span.End()
|
|
stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(StatusKey, fmt.Sprint(code))},
|
|
t.LatencyMeasure.M(float64(elapsed.Nanoseconds())/1e6)) // milliseconds
|
|
}
|