Instana tracer implementation

vendor/github.com/instana/go-sensor/tracer.go

@@ -0,0 +1,119 @@
+package instana
+
+import (
+	"time"
+
+	ot "github.com/opentracing/opentracing-go"
+)
+
+const (
+	// MaxLogsPerSpan The maximum number of logs allowed on a span.
+	MaxLogsPerSpan = 2
+)
+
+type tracerS struct {
+	options        TracerOptions
+	textPropagator *textMapPropagator
+}
+
+func (r *tracerS) Inject(sc ot.SpanContext, format interface{}, carrier interface{}) error {
+	switch format {
+	case ot.TextMap, ot.HTTPHeaders:
+		return r.textPropagator.inject(sc, carrier)
+	}
+
+	return ot.ErrUnsupportedFormat
+}
+
+func (r *tracerS) Extract(format interface{}, carrier interface{}) (ot.SpanContext, error) {
+	switch format {
+	case ot.TextMap, ot.HTTPHeaders:
+		return r.textPropagator.extract(carrier)
+	}
+
+	return nil, ot.ErrUnsupportedFormat
+}
+
+func (r *tracerS) StartSpan(operationName string, opts ...ot.StartSpanOption) ot.Span {
+	sso := ot.StartSpanOptions{}
+	for _, o := range opts {
+		o.Apply(&sso)
+	}
+
+	return r.StartSpanWithOptions(operationName, sso)
+}
+
+func (r *tracerS) StartSpanWithOptions(operationName string, opts ot.StartSpanOptions) ot.Span {
+	startTime := opts.StartTime
+	if startTime.IsZero() {
+		startTime = time.Now()
+	}
+
+	tags := opts.Tags
+	span := &spanS{}
+Loop:
+	for _, ref := range opts.References {
+		switch ref.Type {
+		case ot.ChildOfRef, ot.FollowsFromRef:
+			refCtx := ref.ReferencedContext.(SpanContext)
+			span.context.TraceID = refCtx.TraceID
+			span.context.SpanID = randomID()
+			span.context.Sampled = refCtx.Sampled
+			span.ParentSpanID = refCtx.SpanID
+			if l := len(refCtx.Baggage); l > 0 {
+				span.context.Baggage = make(map[string]string, l)
+				for k, v := range refCtx.Baggage {
+					span.context.Baggage[k] = v
+				}
+			}
+
+			break Loop
+		}
+	}
+
+	if span.context.TraceID == 0 {
+		span.context.SpanID = randomID()
+		span.context.TraceID = span.context.SpanID
+		span.context.Sampled = r.options.ShouldSample(span.context.TraceID)
+	}
+
+	return r.startSpanInternal(span, operationName, startTime, tags)
+}
+
+func (r *tracerS) startSpanInternal(span *spanS, operationName string, startTime time.Time, tags ot.Tags) ot.Span {
+	span.tracer = r
+	span.Operation = operationName
+	span.Start = startTime
+	span.Duration = -1
+	span.Tags = tags
+
+	return span
+}
+
+func shouldSample(traceID int64) bool {
+	return false
+}
+
+// NewTracer Get a new Tracer with the default options applied.
+func NewTracer() ot.Tracer {
+	return NewTracerWithOptions(&Options{})
+}
+
+// NewTracerWithOptions Get a new Tracer with the specified options.
+func NewTracerWithOptions(options *Options) ot.Tracer {
+	InitSensor(options)
+
+	return NewTracerWithEverything(options, NewRecorder())
+}
+
+// NewTracerWithEverything Get a new Tracer with the works.
+func NewTracerWithEverything(options *Options, recorder SpanRecorder) ot.Tracer {
+	InitSensor(options)
+	ret := &tracerS{options: TracerOptions{
+		Recorder:       recorder,
+		ShouldSample:   shouldSample,
+		MaxLogsPerSpan: MaxLogsPerSpan}}
+	ret.textPropagator = &textMapPropagator{ret}
+
+	return ret
+}