Instana tracer implementation

vendor/github.com/opentracing/basictracer-go/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 The OpenTracing Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/opentracing/basictracer-go/context.go

@@ -0,0 +1,42 @@
+package basictracer
+
+// SpanContext holds the basic Span metadata.
+type SpanContext struct {
+	// A probabilistically unique identifier for a [multi-span] trace.
+	TraceID uint64
+
+	// A probabilistically unique identifier for a span.
+	SpanID uint64
+
+	// Whether the trace is sampled.
+	Sampled bool
+
+	// The span's associated baggage.
+	Baggage map[string]string // initialized on first use
+}
+
+// ForeachBaggageItem belongs to the opentracing.SpanContext interface
+func (c SpanContext) ForeachBaggageItem(handler func(k, v string) bool) {
+	for k, v := range c.Baggage {
+		if !handler(k, v) {
+			break
+		}
+	}
+}
+
+// WithBaggageItem returns an entirely new basictracer SpanContext with the
+// given key:value baggage pair set.
+func (c SpanContext) WithBaggageItem(key, val string) SpanContext {
+	var newBaggage map[string]string
+	if c.Baggage == nil {
+		newBaggage = map[string]string{key: val}
+	} else {
+		newBaggage = make(map[string]string, len(c.Baggage)+1)
+		for k, v := range c.Baggage {
+			newBaggage[k] = v
+		}
+		newBaggage[key] = val
+	}
+	// Use positional parameters so the compiler will help catch new fields.
+	return SpanContext{c.TraceID, c.SpanID, c.Sampled, newBaggage}
+}

vendor/github.com/opentracing/basictracer-go/debug.go

@@ -0,0 +1,78 @@
+package basictracer
+
+import (
+	"bytes"
+	"fmt"
+	"runtime"
+	"strconv"
+	"sync"
+)
+
+const debugGoroutineIDTag = "_initial_goroutine"
+
+type errAssertionFailed struct {
+	span *spanImpl
+	msg  string
+}
+
+// Error implements the error interface.
+func (err *errAssertionFailed) Error() string {
+	return fmt.Sprintf("%s:\n%+v", err.msg, err.span)
+}
+
+func (s *spanImpl) Lock() {
+	s.Mutex.Lock()
+	s.maybeAssertSanityLocked()
+}
+
+func (s *spanImpl) maybeAssertSanityLocked() {
+	if s.tracer == nil {
+		s.Mutex.Unlock()
+		panic(&errAssertionFailed{span: s, msg: "span used after call to Finish()"})
+	}
+	if s.tracer.options.DebugAssertSingleGoroutine {
+		startID := curGoroutineID()
+		curID, ok := s.raw.Tags[debugGoroutineIDTag].(uint64)
+		if !ok {
+			// This is likely invoked in the context of the SetTag which sets
+			// debugGoroutineTag.
+			return
+		}
+		if startID != curID {
+			s.Mutex.Unlock()
+			panic(&errAssertionFailed{
+				span: s,
+				msg:  fmt.Sprintf("span started on goroutine %d, but now running on %d", startID, curID),
+			})
+		}
+	}
+}
+
+var goroutineSpace = []byte("goroutine ")
+var littleBuf = sync.Pool{
+	New: func() interface{} {
+		buf := make([]byte, 64)
+		return &buf
+	},
+}
+
+// Credit to @bradfitz:
+// https://github.com/golang/net/blob/master/http2/gotrack.go#L51
+func curGoroutineID() uint64 {
+	bp := littleBuf.Get().(*[]byte)
+	defer littleBuf.Put(bp)
+	b := *bp
+	b = b[:runtime.Stack(b, false)]
+	// Parse the 4707 out of "goroutine 4707 ["
+	b = bytes.TrimPrefix(b, goroutineSpace)
+	i := bytes.IndexByte(b, ' ')
+	if i < 0 {
+		panic(fmt.Sprintf("No space found in %q", b))
+	}
+	b = b[:i]
+	n, err := strconv.ParseUint(string(b), 10, 64)
+	if err != nil {
+		panic(fmt.Sprintf("Failed to parse goroutine ID out of %q: %v", b, err))
+	}
+	return n
+}

vendor/github.com/opentracing/basictracer-go/event.go

@@ -0,0 +1,62 @@
+package basictracer
+
+import "github.com/opentracing/opentracing-go"
+
+// A SpanEvent is emitted when a mutating command is called on a Span.
+type SpanEvent interface{}
+
+// EventCreate is emitted when a Span is created.
+type EventCreate struct{ OperationName string }
+
+// EventTag is received when SetTag is called.
+type EventTag struct {
+	Key   string
+	Value interface{}
+}
+
+// EventBaggage is received when SetBaggageItem is called.
+type EventBaggage struct {
+	Key, Value string
+}
+
+// EventLogFields is received when LogFields or LogKV is called.
+type EventLogFields opentracing.LogRecord
+
+// EventLog is received when Log (or one of its derivatives) is called.
+//
+// DEPRECATED
+type EventLog opentracing.LogData
+
+// EventFinish is received when Finish is called.
+type EventFinish RawSpan
+
+func (s *spanImpl) onCreate(opName string) {
+	if s.event != nil {
+		s.event(EventCreate{OperationName: opName})
+	}
+}
+func (s *spanImpl) onTag(key string, value interface{}) {
+	if s.event != nil {
+		s.event(EventTag{Key: key, Value: value})
+	}
+}
+func (s *spanImpl) onLog(ld opentracing.LogData) {
+	if s.event != nil {
+		s.event(EventLog(ld))
+	}
+}
+func (s *spanImpl) onLogFields(lr opentracing.LogRecord) {
+	if s.event != nil {
+		s.event(EventLogFields(lr))
+	}
+}
+func (s *spanImpl) onBaggage(key, value string) {
+	if s.event != nil {
+		s.event(EventBaggage{Key: key, Value: value})
+	}
+}
+func (s *spanImpl) onFinish(sp RawSpan) {
+	if s.event != nil {
+		s.event(EventFinish(sp))
+	}
+}

vendor/github.com/opentracing/basictracer-go/propagation.go

@@ -0,0 +1,61 @@
+package basictracer
+
+import opentracing "github.com/opentracing/opentracing-go"
+
+type accessorPropagator struct {
+	tracer *tracerImpl
+}
+
+// DelegatingCarrier is a flexible carrier interface which can be implemented
+// by types which have a means of storing the trace metadata and already know
+// how to serialize themselves (for example, protocol buffers).
+type DelegatingCarrier interface {
+	SetState(traceID, spanID uint64, sampled bool)
+	State() (traceID, spanID uint64, sampled bool)
+	SetBaggageItem(key, value string)
+	GetBaggage(func(key, value string))
+}
+
+func (p *accessorPropagator) Inject(
+	spanContext opentracing.SpanContext,
+	carrier interface{},
+) error {
+	dc, ok := carrier.(DelegatingCarrier)
+	if !ok || dc == nil {
+		return opentracing.ErrInvalidCarrier
+	}
+	sc, ok := spanContext.(SpanContext)
+	if !ok {
+		return opentracing.ErrInvalidSpanContext
+	}
+	dc.SetState(sc.TraceID, sc.SpanID, sc.Sampled)
+	for k, v := range sc.Baggage {
+		dc.SetBaggageItem(k, v)
+	}
+	return nil
+}
+
+func (p *accessorPropagator) Extract(
+	carrier interface{},
+) (opentracing.SpanContext, error) {
+	dc, ok := carrier.(DelegatingCarrier)
+	if !ok || dc == nil {
+		return nil, opentracing.ErrInvalidCarrier
+	}
+
+	traceID, spanID, sampled := dc.State()
+	sc := SpanContext{
+		TraceID: traceID,
+		SpanID:  spanID,
+		Sampled: sampled,
+		Baggage: nil,
+	}
+	dc.GetBaggage(func(k, v string) {
+		if sc.Baggage == nil {
+			sc.Baggage = map[string]string{}
+		}
+		sc.Baggage[k] = v
+	})
+
+	return sc, nil
+}

vendor/github.com/opentracing/basictracer-go/propagation_ot.go

@@ -0,0 +1,180 @@
+package basictracer
+
+import (
+	"encoding/binary"
+	"io"
+	"strconv"
+	"strings"
+
+	"github.com/gogo/protobuf/proto"
+	"github.com/opentracing/basictracer-go/wire"
+	opentracing "github.com/opentracing/opentracing-go"
+)
+
+type textMapPropagator struct {
+	tracer *tracerImpl
+}
+type binaryPropagator struct {
+	tracer *tracerImpl
+}
+
+const (
+	prefixTracerState = "ot-tracer-"
+	prefixBaggage     = "ot-baggage-"
+
+	tracerStateFieldCount = 3
+	fieldNameTraceID      = prefixTracerState + "traceid"
+	fieldNameSpanID       = prefixTracerState + "spanid"
+	fieldNameSampled      = prefixTracerState + "sampled"
+)
+
+func (p *textMapPropagator) Inject(
+	spanContext opentracing.SpanContext,
+	opaqueCarrier interface{},
+) error {
+	sc, ok := spanContext.(SpanContext)
+	if !ok {
+		return opentracing.ErrInvalidSpanContext
+	}
+	carrier, ok := opaqueCarrier.(opentracing.TextMapWriter)
+	if !ok {
+		return opentracing.ErrInvalidCarrier
+	}
+	carrier.Set(fieldNameTraceID, strconv.FormatUint(sc.TraceID, 16))
+	carrier.Set(fieldNameSpanID, strconv.FormatUint(sc.SpanID, 16))
+	carrier.Set(fieldNameSampled, strconv.FormatBool(sc.Sampled))
+
+	for k, v := range sc.Baggage {
+		carrier.Set(prefixBaggage+k, v)
+	}
+	return nil
+}
+
+func (p *textMapPropagator) Extract(
+	opaqueCarrier interface{},
+) (opentracing.SpanContext, error) {
+	carrier, ok := opaqueCarrier.(opentracing.TextMapReader)
+	if !ok {
+		return nil, opentracing.ErrInvalidCarrier
+	}
+	requiredFieldCount := 0
+	var traceID, spanID uint64
+	var sampled bool
+	var err error
+	decodedBaggage := make(map[string]string)
+	err = carrier.ForeachKey(func(k, v string) error {
+		switch strings.ToLower(k) {
+		case fieldNameTraceID:
+			traceID, err = strconv.ParseUint(v, 16, 64)
+			if err != nil {
+				return opentracing.ErrSpanContextCorrupted
+			}
+		case fieldNameSpanID:
+			spanID, err = strconv.ParseUint(v, 16, 64)
+			if err != nil {
+				return opentracing.ErrSpanContextCorrupted
+			}
+		case fieldNameSampled:
+			sampled, err = strconv.ParseBool(v)
+			if err != nil {
+				return opentracing.ErrSpanContextCorrupted
+			}
+		default:
+			lowercaseK := strings.ToLower(k)
+			if strings.HasPrefix(lowercaseK, prefixBaggage) {
+				decodedBaggage[strings.TrimPrefix(lowercaseK, prefixBaggage)] = v
+			}
+			// Balance off the requiredFieldCount++ just below...
+			requiredFieldCount--
+		}
+		requiredFieldCount++
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	if requiredFieldCount < tracerStateFieldCount {
+		if requiredFieldCount == 0 {
+			return nil, opentracing.ErrSpanContextNotFound
+		}
+		return nil, opentracing.ErrSpanContextCorrupted
+	}
+
+	return SpanContext{
+		TraceID: traceID,
+		SpanID:  spanID,
+		Sampled: sampled,
+		Baggage: decodedBaggage,
+	}, nil
+}
+
+func (p *binaryPropagator) Inject(
+	spanContext opentracing.SpanContext,
+	opaqueCarrier interface{},
+) error {
+	sc, ok := spanContext.(SpanContext)
+	if !ok {
+		return opentracing.ErrInvalidSpanContext
+	}
+	carrier, ok := opaqueCarrier.(io.Writer)
+	if !ok {
+		return opentracing.ErrInvalidCarrier
+	}
+
+	state := wire.TracerState{}
+	state.TraceId = sc.TraceID
+	state.SpanId = sc.SpanID
+	state.Sampled = sc.Sampled
+	state.BaggageItems = sc.Baggage
+
+	b, err := proto.Marshal(&state)
+	if err != nil {
+		return err
+	}
+
+	// Write the length of the marshalled binary to the writer.
+	length := uint32(len(b))
+	if err := binary.Write(carrier, binary.BigEndian, &length); err != nil {
+		return err
+	}
+
+	_, err = carrier.Write(b)
+	return err
+}
+
+func (p *binaryPropagator) Extract(
+	opaqueCarrier interface{},
+) (opentracing.SpanContext, error) {
+	carrier, ok := opaqueCarrier.(io.Reader)
+	if !ok {
+		return nil, opentracing.ErrInvalidCarrier
+	}
+
+	// Read the length of marshalled binary. io.ReadAll isn't that performant
+	// since it keeps resizing the underlying buffer as it encounters more bytes
+	// to read. By reading the length, we can allocate a fixed sized buf and read
+	// the exact amount of bytes into it.
+	var length uint32
+	if err := binary.Read(carrier, binary.BigEndian, &length); err != nil {
+		return nil, opentracing.ErrSpanContextCorrupted
+	}
+	buf := make([]byte, length)
+	if n, err := carrier.Read(buf); err != nil {
+		if n > 0 {
+			return nil, opentracing.ErrSpanContextCorrupted
+		}
+		return nil, opentracing.ErrSpanContextNotFound
+	}
+
+	ctx := wire.TracerState{}
+	if err := proto.Unmarshal(buf, &ctx); err != nil {
+		return nil, opentracing.ErrSpanContextCorrupted
+	}
+
+	return SpanContext{
+		TraceID: ctx.TraceId,
+		SpanID:  ctx.SpanId,
+		Sampled: ctx.Sampled,
+		Baggage: ctx.BaggageItems,
+	}, nil
+}

vendor/github.com/opentracing/basictracer-go/raw.go

@@ -0,0 +1,34 @@
+package basictracer
+
+import (
+	"time"
+
+	opentracing "github.com/opentracing/opentracing-go"
+)
+
+// RawSpan encapsulates all state associated with a (finished) Span.
+type RawSpan struct {
+	// Those recording the RawSpan should also record the contents of its
+	// SpanContext.
+	Context SpanContext
+
+	// The SpanID of this SpanContext's first intra-trace reference (i.e.,
+	// "parent"), or 0 if there is no parent.
+	ParentSpanID uint64
+
+	// The name of the "operation" this span is an instance of. (Called a "span
+	// name" in some implementations)
+	Operation string
+
+	// We store <start, duration> rather than <start, end> so that only
+	// one of the timestamps has global clock uncertainty issues.
+	Start    time.Time
+	Duration time.Duration
+
+	// Essentially an extension mechanism. Can be used for many purposes,
+	// not to be enumerated here.
+	Tags opentracing.Tags
+
+	// The span's "microlog".
+	Logs []opentracing.LogRecord
+}

vendor/github.com/opentracing/basictracer-go/recorder.go

@@ -0,0 +1,60 @@
+package basictracer
+
+import "sync"
+
+// A SpanRecorder handles all of the `RawSpan` data generated via an
+// associated `Tracer` (see `NewStandardTracer`) instance. It also names
+// the containing process and provides access to a straightforward tag map.
+type SpanRecorder interface {
+	// Implementations must determine whether and where to store `span`.
+	RecordSpan(span RawSpan)
+}
+
+// InMemorySpanRecorder is a simple thread-safe implementation of
+// SpanRecorder that stores all reported spans in memory, accessible
+// via reporter.GetSpans(). It is primarily intended for testing purposes.
+type InMemorySpanRecorder struct {
+	sync.RWMutex
+	spans []RawSpan
+}
+
+// NewInMemoryRecorder creates new InMemorySpanRecorder
+func NewInMemoryRecorder() *InMemorySpanRecorder {
+	return new(InMemorySpanRecorder)
+}
+
+// RecordSpan implements the respective method of SpanRecorder.
+func (r *InMemorySpanRecorder) RecordSpan(span RawSpan) {
+	r.Lock()
+	defer r.Unlock()
+	r.spans = append(r.spans, span)
+}
+
+// GetSpans returns a copy of the array of spans accumulated so far.
+func (r *InMemorySpanRecorder) GetSpans() []RawSpan {
+	r.RLock()
+	defer r.RUnlock()
+	spans := make([]RawSpan, len(r.spans))
+	copy(spans, r.spans)
+	return spans
+}
+
+// GetSampledSpans returns a slice of spans accumulated so far which were sampled.
+func (r *InMemorySpanRecorder) GetSampledSpans() []RawSpan {
+	r.RLock()
+	defer r.RUnlock()
+	spans := make([]RawSpan, 0, len(r.spans))
+	for _, span := range r.spans {
+		if span.Context.Sampled {
+			spans = append(spans, span)
+		}
+	}
+	return spans
+}
+
+// Reset clears the internal array of spans.
+func (r *InMemorySpanRecorder) Reset() {
+	r.Lock()
+	defer r.Unlock()
+	r.spans = nil
+}

vendor/github.com/opentracing/basictracer-go/span.go

@@ -0,0 +1,274 @@
+package basictracer
+
+import (
+	"sync"
+	"time"
+
+	opentracing "github.com/opentracing/opentracing-go"
+	"github.com/opentracing/opentracing-go/ext"
+	"github.com/opentracing/opentracing-go/log"
+)
+
+// Span provides access to the essential details of the span, for use
+// by basictracer consumers.  These methods may only be called prior
+// to (*opentracing.Span).Finish().
+type Span interface {
+	opentracing.Span
+
+	// Operation names the work done by this span instance
+	Operation() string
+
+	// Start indicates when the span began
+	Start() time.Time
+}
+
+// Implements the `Span` interface. Created via tracerImpl (see
+// `basictracer.New()`).
+type spanImpl struct {
+	tracer     *tracerImpl
+	event      func(SpanEvent)
+	sync.Mutex // protects the fields below
+	raw        RawSpan
+	// The number of logs dropped because of MaxLogsPerSpan.
+	numDroppedLogs int
+}
+
+var spanPool = &sync.Pool{New: func() interface{} {
+	return &spanImpl{}
+}}
+
+func (s *spanImpl) reset() {
+	s.tracer, s.event = nil, nil
+	// Note: Would like to do the following, but then the consumer of RawSpan
+	// (the recorder) needs to make sure that they're not holding on to the
+	// baggage or logs when they return (i.e. they need to copy if they care):
+	//
+	//     logs, baggage := s.raw.Logs[:0], s.raw.Baggage
+	//     for k := range baggage {
+	//         delete(baggage, k)
+	//     }
+	//     s.raw.Logs, s.raw.Baggage = logs, baggage
+	//
+	// That's likely too much to ask for. But there is some magic we should
+	// be able to do with `runtime.SetFinalizer` to reclaim that memory into
+	// a buffer pool when GC considers them unreachable, which should ease
+	// some of the load. Hard to say how quickly that would be in practice
+	// though.
+	s.raw = RawSpan{
+		Context: SpanContext{},
+	}
+}
+
+func (s *spanImpl) SetOperationName(operationName string) opentracing.Span {
+	s.Lock()
+	defer s.Unlock()
+	s.raw.Operation = operationName
+	return s
+}
+
+func (s *spanImpl) trim() bool {
+	return !s.raw.Context.Sampled && s.tracer.options.TrimUnsampledSpans
+}
+
+func (s *spanImpl) SetTag(key string, value interface{}) opentracing.Span {
+	defer s.onTag(key, value)
+	s.Lock()
+	defer s.Unlock()
+	if key == string(ext.SamplingPriority) {
+		if v, ok := value.(uint16); ok {
+			s.raw.Context.Sampled = v != 0
+			return s
+		}
+	}
+	if s.trim() {
+		return s
+	}
+
+	if s.raw.Tags == nil {
+		s.raw.Tags = opentracing.Tags{}
+	}
+	s.raw.Tags[key] = value
+	return s
+}
+
+func (s *spanImpl) LogKV(keyValues ...interface{}) {
+	fields, err := log.InterleavedKVToFields(keyValues...)
+	if err != nil {
+		s.LogFields(log.Error(err), log.String("function", "LogKV"))
+		return
+	}
+	s.LogFields(fields...)
+}
+
+func (s *spanImpl) appendLog(lr opentracing.LogRecord) {
+	maxLogs := s.tracer.options.MaxLogsPerSpan
+	if maxLogs == 0 || len(s.raw.Logs) < maxLogs {
+		s.raw.Logs = append(s.raw.Logs, lr)
+		return
+	}
+
+	// We have too many logs. We don't touch the first numOld logs; we treat the
+	// rest as a circular buffer and overwrite the oldest log among those.
+	numOld := (maxLogs - 1) / 2
+	numNew := maxLogs - numOld
+	s.raw.Logs[numOld+s.numDroppedLogs%numNew] = lr
+	s.numDroppedLogs++
+}
+
+func (s *spanImpl) LogFields(fields ...log.Field) {
+	lr := opentracing.LogRecord{
+		Fields: fields,
+	}
+	defer s.onLogFields(lr)
+	s.Lock()
+	defer s.Unlock()
+	if s.trim() || s.tracer.options.DropAllLogs {
+		return
+	}
+	if lr.Timestamp.IsZero() {
+		lr.Timestamp = time.Now()
+	}
+	s.appendLog(lr)
+}
+
+func (s *spanImpl) LogEvent(event string) {
+	s.Log(opentracing.LogData{
+		Event: event,
+	})
+}
+
+func (s *spanImpl) LogEventWithPayload(event string, payload interface{}) {
+	s.Log(opentracing.LogData{
+		Event:   event,
+		Payload: payload,
+	})
+}
+
+func (s *spanImpl) Log(ld opentracing.LogData) {
+	defer s.onLog(ld)
+	s.Lock()
+	defer s.Unlock()
+	if s.trim() || s.tracer.options.DropAllLogs {
+		return
+	}
+
+	if ld.Timestamp.IsZero() {
+		ld.Timestamp = time.Now()
+	}
+
+	s.appendLog(ld.ToLogRecord())
+}
+
+func (s *spanImpl) Finish() {
+	s.FinishWithOptions(opentracing.FinishOptions{})
+}
+
+// rotateLogBuffer rotates the records in the buffer: records 0 to pos-1 move at
+// the end (i.e. pos circular left shifts).
+func rotateLogBuffer(buf []opentracing.LogRecord, pos int) {
+	// This algorithm is described in:
+	//    http://www.cplusplus.com/reference/algorithm/rotate
+	for first, middle, next := 0, pos, pos; first != middle; {
+		buf[first], buf[next] = buf[next], buf[first]
+		first++
+		next++
+		if next == len(buf) {
+			next = middle
+		} else if first == middle {
+			middle = next
+		}
+	}
+}
+
+func (s *spanImpl) FinishWithOptions(opts opentracing.FinishOptions) {
+	finishTime := opts.FinishTime
+	if finishTime.IsZero() {
+		finishTime = time.Now()
+	}
+	duration := finishTime.Sub(s.raw.Start)
+
+	s.Lock()
+	defer s.Unlock()
+
+	for _, lr := range opts.LogRecords {
+		s.appendLog(lr)
+	}
+	for _, ld := range opts.BulkLogData {
+		s.appendLog(ld.ToLogRecord())
+	}
+
+	if s.numDroppedLogs > 0 {
+		// We dropped some log events, which means that we used part of Logs as a
+		// circular buffer (see appendLog). De-circularize it.
+		numOld := (len(s.raw.Logs) - 1) / 2
+		numNew := len(s.raw.Logs) - numOld
+		rotateLogBuffer(s.raw.Logs[numOld:], s.numDroppedLogs%numNew)
+
+		// Replace the log in the middle (the oldest "new" log) with information
+		// about the dropped logs. This means that we are effectively dropping one
+		// more "new" log.
+		numDropped := s.numDroppedLogs + 1
+		s.raw.Logs[numOld] = opentracing.LogRecord{
+			// Keep the timestamp of the last dropped event.
+			Timestamp: s.raw.Logs[numOld].Timestamp,
+			Fields: []log.Field{
+				log.String("event", "dropped Span logs"),
+				log.Int("dropped_log_count", numDropped),
+				log.String("component", "basictracer"),
+			},
+		}
+	}
+
+	s.raw.Duration = duration
+
+	s.onFinish(s.raw)
+	s.tracer.options.Recorder.RecordSpan(s.raw)
+
+	// Last chance to get options before the span is possibly reset.
+	poolEnabled := s.tracer.options.EnableSpanPool
+	if s.tracer.options.DebugAssertUseAfterFinish {
+		// This makes it much more likely to catch a panic on any subsequent
+		// operation since s.tracer is accessed on every call to `Lock`.
+		// We don't call `reset()` here to preserve the logs in the Span
+		// which are printed when the assertion triggers.
+		s.tracer = nil
+	}
+
+	if poolEnabled {
+		spanPool.Put(s)
+	}
+}
+
+func (s *spanImpl) Tracer() opentracing.Tracer {
+	return s.tracer
+}
+
+func (s *spanImpl) Context() opentracing.SpanContext {
+	return s.raw.Context
+}
+
+func (s *spanImpl) SetBaggageItem(key, val string) opentracing.Span {
+	s.onBaggage(key, val)
+	if s.trim() {
+		return s
+	}
+
+	s.Lock()
+	defer s.Unlock()
+	s.raw.Context = s.raw.Context.WithBaggageItem(key, val)
+	return s
+}
+
+func (s *spanImpl) BaggageItem(key string) string {
+	s.Lock()
+	defer s.Unlock()
+	return s.raw.Context.Baggage[key]
+}
+
+func (s *spanImpl) Operation() string {
+	return s.raw.Operation
+}
+
+func (s *spanImpl) Start() time.Time {
+	return s.raw.Start
+}

vendor/github.com/opentracing/basictracer-go/tracer.go

@@ -0,0 +1,262 @@
+package basictracer
+
+import (
+	"time"
+
+	opentracing "github.com/opentracing/opentracing-go"
+)
+
+// Tracer extends the opentracing.Tracer interface with methods to
+// probe implementation state, for use by basictracer consumers.
+type Tracer interface {
+	opentracing.Tracer
+
+	// Options gets the Options used in New() or NewWithOptions().
+	Options() Options
+}
+
+// Options allows creating a customized Tracer via NewWithOptions. The object
+// must not be updated when there is an active tracer using it.
+type Options struct {
+	// ShouldSample is a function which is called when creating a new Span and
+	// determines whether that Span is sampled. The randomized TraceID is supplied
+	// to allow deterministic sampling decisions to be made across different nodes.
+	// For example,
+	//
+	//   func(traceID uint64) { return traceID % 64 == 0 }
+	//
+	// samples every 64th trace on average.
+	ShouldSample func(traceID uint64) bool
+	// TrimUnsampledSpans turns potentially expensive operations on unsampled
+	// Spans into no-ops. More precisely, tags and log events are silently
+	// discarded. If NewSpanEventListener is set, the callbacks will still fire.
+	TrimUnsampledSpans bool
+	// Recorder receives Spans which have been finished.
+	Recorder SpanRecorder
+	// NewSpanEventListener can be used to enhance the tracer by effectively
+	// attaching external code to trace events. See NetTraceIntegrator for a
+	// practical example, and event.go for the list of possible events.
+	NewSpanEventListener func() func(SpanEvent)
+	// DropAllLogs turns log events on all Spans into no-ops.
+	// If NewSpanEventListener is set, the callbacks will still fire.
+	DropAllLogs bool
+	// MaxLogsPerSpan limits the number of Logs in a span (if set to a nonzero
+	// value). If a span has more logs than this value, logs are dropped as
+	// necessary (and replaced with a log describing how many were dropped).
+	//
+	// About half of the MaxLogPerSpan logs kept are the oldest logs, and about
+	// half are the newest logs.
+	//
+	// If NewSpanEventListener is set, the callbacks will still fire for all log
+	// events. This value is ignored if DropAllLogs is true.
+	MaxLogsPerSpan int
+	// DebugAssertSingleGoroutine internally records the ID of the goroutine
+	// creating each Span and verifies that no operation is carried out on
+	// it on a different goroutine.
+	// Provided strictly for development purposes.
+	// Passing Spans between goroutine without proper synchronization often
+	// results in use-after-Finish() errors. For a simple example, consider the
+	// following pseudocode:
+	//
+	//  func (s *Server) Handle(req http.Request) error {
+	//    sp := s.StartSpan("server")
+	//    defer sp.Finish()
+	//    wait := s.queueProcessing(opentracing.ContextWithSpan(context.Background(), sp), req)
+	//    select {
+	//    case resp := <-wait:
+	//      return resp.Error
+	//    case <-time.After(10*time.Second):
+	//      sp.LogEvent("timed out waiting for processing")
+	//      return ErrTimedOut
+	//    }
+	//  }
+	//
+	// This looks reasonable at first, but a request which spends more than ten
+	// seconds in the queue is abandoned by the main goroutine and its trace
+	// finished, leading to use-after-finish when the request is finally
+	// processed. Note also that even joining on to a finished Span via
+	// StartSpanWithOptions constitutes an illegal operation.
+	//
+	// Code bases which do not require (or decide they do not want) Spans to
+	// be passed across goroutine boundaries can run with this flag enabled in
+	// tests to increase their chances of spotting wrong-doers.
+	DebugAssertSingleGoroutine bool
+	// DebugAssertUseAfterFinish is provided strictly for development purposes.
+	// When set, it attempts to exacerbate issues emanating from use of Spans
+	// after calling Finish by running additional assertions.
+	DebugAssertUseAfterFinish bool
+	// EnableSpanPool enables the use of a pool, so that the tracer reuses spans
+	// after Finish has been called on it. Adds a slight performance gain as it
+	// reduces allocations. However, if you have any use-after-finish race
+	// conditions the code may panic.
+	EnableSpanPool bool
+}
+
+// DefaultOptions returns an Options object with a 1 in 64 sampling rate and
+// all options disabled. A Recorder needs to be set manually before using the
+// returned object with a Tracer.
+func DefaultOptions() Options {
+	return Options{
+		ShouldSample:   func(traceID uint64) bool { return traceID%64 == 0 },
+		MaxLogsPerSpan: 100,
+	}
+}
+
+// NewWithOptions creates a customized Tracer.
+func NewWithOptions(opts Options) opentracing.Tracer {
+	rval := &tracerImpl{options: opts}
+	rval.textPropagator = &textMapPropagator{rval}
+	rval.binaryPropagator = &binaryPropagator{rval}
+	rval.accessorPropagator = &accessorPropagator{rval}
+	return rval
+}
+
+// New creates and returns a standard Tracer which defers completed Spans to
+// `recorder`.
+// Spans created by this Tracer support the ext.SamplingPriority tag: Setting
+// ext.SamplingPriority causes the Span to be Sampled from that point on.
+func New(recorder SpanRecorder) opentracing.Tracer {
+	opts := DefaultOptions()
+	opts.Recorder = recorder
+	return NewWithOptions(opts)
+}
+
+// Implements the `Tracer` interface.
+type tracerImpl struct {
+	options            Options
+	textPropagator     *textMapPropagator
+	binaryPropagator   *binaryPropagator
+	accessorPropagator *accessorPropagator
+}
+
+func (t *tracerImpl) StartSpan(
+	operationName string,
+	opts ...opentracing.StartSpanOption,
+) opentracing.Span {
+	sso := opentracing.StartSpanOptions{}
+	for _, o := range opts {
+		o.Apply(&sso)
+	}
+	return t.StartSpanWithOptions(operationName, sso)
+}
+
+func (t *tracerImpl) getSpan() *spanImpl {
+	if t.options.EnableSpanPool {
+		sp := spanPool.Get().(*spanImpl)
+		sp.reset()
+		return sp
+	}
+	return &spanImpl{}
+}
+
+func (t *tracerImpl) StartSpanWithOptions(
+	operationName string,
+	opts opentracing.StartSpanOptions,
+) opentracing.Span {
+	// Start time.
+	startTime := opts.StartTime
+	if startTime.IsZero() {
+		startTime = time.Now()
+	}
+
+	// Tags.
+	tags := opts.Tags
+
+	// Build the new span. This is the only allocation: We'll return this as
+	// an opentracing.Span.
+	sp := t.getSpan()
+	// Look for a parent in the list of References.
+	//
+	// TODO: would be nice if basictracer did something with all
+	// References, not just the first one.
+ReferencesLoop:
+	for _, ref := range opts.References {
+		switch ref.Type {
+		case opentracing.ChildOfRef,
+			opentracing.FollowsFromRef:
+
+			refCtx := ref.ReferencedContext.(SpanContext)
+			sp.raw.Context.TraceID = refCtx.TraceID
+			sp.raw.Context.SpanID = randomID()
+			sp.raw.Context.Sampled = refCtx.Sampled
+			sp.raw.ParentSpanID = refCtx.SpanID
+
+			if l := len(refCtx.Baggage); l > 0 {
+				sp.raw.Context.Baggage = make(map[string]string, l)
+				for k, v := range refCtx.Baggage {
+					sp.raw.Context.Baggage[k] = v
+				}
+			}
+			break ReferencesLoop
+		}
+	}
+	if sp.raw.Context.TraceID == 0 {
+		// No parent Span found; allocate new trace and span ids and determine
+		// the Sampled status.
+		sp.raw.Context.TraceID, sp.raw.Context.SpanID = randomID2()
+		sp.raw.Context.Sampled = t.options.ShouldSample(sp.raw.Context.TraceID)
+	}
+
+	return t.startSpanInternal(
+		sp,
+		operationName,
+		startTime,
+		tags,
+	)
+}
+
+func (t *tracerImpl) startSpanInternal(
+	sp *spanImpl,
+	operationName string,
+	startTime time.Time,
+	tags opentracing.Tags,
+) opentracing.Span {
+	sp.tracer = t
+	if t.options.NewSpanEventListener != nil {
+		sp.event = t.options.NewSpanEventListener()
+	}
+	sp.raw.Operation = operationName
+	sp.raw.Start = startTime
+	sp.raw.Duration = -1
+	sp.raw.Tags = tags
+	if t.options.DebugAssertSingleGoroutine {
+		sp.SetTag(debugGoroutineIDTag, curGoroutineID())
+	}
+	defer sp.onCreate(operationName)
+	return sp
+}
+
+type delegatorType struct{}
+
+// Delegator is the format to use for DelegatingCarrier.
+var Delegator delegatorType
+
+func (t *tracerImpl) Inject(sc opentracing.SpanContext, format interface{}, carrier interface{}) error {
+	switch format {
+	case opentracing.TextMap, opentracing.HTTPHeaders:
+		return t.textPropagator.Inject(sc, carrier)
+	case opentracing.Binary:
+		return t.binaryPropagator.Inject(sc, carrier)
+	}
+	if _, ok := format.(delegatorType); ok {
+		return t.accessorPropagator.Inject(sc, carrier)
+	}
+	return opentracing.ErrUnsupportedFormat
+}
+
+func (t *tracerImpl) Extract(format interface{}, carrier interface{}) (opentracing.SpanContext, error) {
+	switch format {
+	case opentracing.TextMap, opentracing.HTTPHeaders:
+		return t.textPropagator.Extract(carrier)
+	case opentracing.Binary:
+		return t.binaryPropagator.Extract(carrier)
+	}
+	if _, ok := format.(delegatorType); ok {
+		return t.accessorPropagator.Extract(carrier)
+	}
+	return nil, opentracing.ErrUnsupportedFormat
+}
+
+func (t *tracerImpl) Options() Options {
+	return t.options
+}

vendor/github.com/opentracing/basictracer-go/util.go

@@ -0,0 +1,25 @@
+package basictracer
+
+import (
+	"math/rand"
+	"sync"
+	"time"
+)
+
+var (
+	seededIDGen = rand.New(rand.NewSource(time.Now().UnixNano()))
+	// The golang rand generators are *not* intrinsically thread-safe.
+	seededIDLock sync.Mutex
+)
+
+func randomID() uint64 {
+	seededIDLock.Lock()
+	defer seededIDLock.Unlock()
+	return uint64(seededIDGen.Int63())
+}
+
+func randomID2() (uint64, uint64) {
+	seededIDLock.Lock()
+	defer seededIDLock.Unlock()
+	return uint64(seededIDGen.Int63()), uint64(seededIDGen.Int63())
+}

vendor/github.com/opentracing/basictracer-go/wire/carrier.go

@@ -0,0 +1,40 @@
+package wire
+
+// ProtobufCarrier is a DelegatingCarrier that uses protocol buffers as the
+// the underlying datastructure. The reason for implementing DelagatingCarrier
+// is to allow for end users to serialize the underlying protocol buffers using
+// jsonpb or any other serialization forms they want.
+type ProtobufCarrier TracerState
+
+// SetState set's the tracer state.
+func (p *ProtobufCarrier) SetState(traceID, spanID uint64, sampled bool) {
+	p.TraceId = traceID
+	p.SpanId = spanID
+	p.Sampled = sampled
+}
+
+// State returns the tracer state.
+func (p *ProtobufCarrier) State() (traceID, spanID uint64, sampled bool) {
+	traceID = p.TraceId
+	spanID = p.SpanId
+	sampled = p.Sampled
+	return traceID, spanID, sampled
+}
+
+// SetBaggageItem sets a baggage item.
+func (p *ProtobufCarrier) SetBaggageItem(key, value string) {
+	if p.BaggageItems == nil {
+		p.BaggageItems = map[string]string{key: value}
+		return
+	}
+
+	p.BaggageItems[key] = value
+}
+
+// GetBaggage iterates over each baggage item and executes the callback with
+// the key:value pair.
+func (p *ProtobufCarrier) GetBaggage(f func(k, v string)) {
+	for k, v := range p.BaggageItems {
+		f(k, v)
+	}
+}

vendor/github.com/opentracing/basictracer-go/wire/gen.go

@@ -0,0 +1,6 @@
+package wire
+
+//go:generate protoc --gogofaster_out=$GOPATH/src/github.com/opentracing/basictracer-go/wire wire.proto
+
+// Run `go get github.com/gogo/protobuf/protoc-gen-gogofaster` to install the
+// gogofaster generator binary.

vendor/github.com/opentracing/basictracer-go/wire/wire.pb.go

@@ -0,0 +1,508 @@
+// Code generated by protoc-gen-gogo.
+// source: wire.proto
+// DO NOT EDIT!
+
+/*
+	Package wire is a generated protocol buffer package.
+
+	It is generated from these files:
+		wire.proto
+
+	It has these top-level messages:
+		TracerState
+*/
+package wire
+
+import proto "github.com/gogo/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import io "io"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+const _ = proto.GoGoProtoPackageIsVersion1
+
+type TracerState struct {
+	TraceId      uint64            `protobuf:"fixed64,1,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"`
+	SpanId       uint64            `protobuf:"fixed64,2,opt,name=span_id,json=spanId,proto3" json:"span_id,omitempty"`
+	Sampled      bool              `protobuf:"varint,3,opt,name=sampled,proto3" json:"sampled,omitempty"`
+	BaggageItems map[string]string `protobuf:"bytes,4,rep,name=baggage_items,json=baggageItems" json:"baggage_items,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+}
+
+func (m *TracerState) Reset()                    { *m = TracerState{} }
+func (m *TracerState) String() string            { return proto.CompactTextString(m) }
+func (*TracerState) ProtoMessage()               {}
+func (*TracerState) Descriptor() ([]byte, []int) { return fileDescriptorWire, []int{0} }
+
+func (m *TracerState) GetBaggageItems() map[string]string {
+	if m != nil {
+		return m.BaggageItems
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*TracerState)(nil), "basictracer_go.wire.TracerState")
+}
+func (m *TracerState) Marshal() (data []byte, err error) {
+	size := m.Size()
+	data = make([]byte, size)
+	n, err := m.MarshalTo(data)
+	if err != nil {
+		return nil, err
+	}
+	return data[:n], nil
+}
+
+func (m *TracerState) MarshalTo(data []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.TraceId != 0 {
+		data[i] = 0x9
+		i++
+		i = encodeFixed64Wire(data, i, uint64(m.TraceId))
+	}
+	if m.SpanId != 0 {
+		data[i] = 0x11
+		i++
+		i = encodeFixed64Wire(data, i, uint64(m.SpanId))
+	}
+	if m.Sampled {
+		data[i] = 0x18
+		i++
+		if m.Sampled {
+			data[i] = 1
+		} else {
+			data[i] = 0
+		}
+		i++
+	}
+	if len(m.BaggageItems) > 0 {
+		for k, _ := range m.BaggageItems {
+			data[i] = 0x22
+			i++
+			v := m.BaggageItems[k]
+			mapSize := 1 + len(k) + sovWire(uint64(len(k))) + 1 + len(v) + sovWire(uint64(len(v)))
+			i = encodeVarintWire(data, i, uint64(mapSize))
+			data[i] = 0xa
+			i++
+			i = encodeVarintWire(data, i, uint64(len(k)))
+			i += copy(data[i:], k)
+			data[i] = 0x12
+			i++
+			i = encodeVarintWire(data, i, uint64(len(v)))
+			i += copy(data[i:], v)
+		}
+	}
+	return i, nil
+}
+
+func encodeFixed64Wire(data []byte, offset int, v uint64) int {
+	data[offset] = uint8(v)
+	data[offset+1] = uint8(v >> 8)
+	data[offset+2] = uint8(v >> 16)
+	data[offset+3] = uint8(v >> 24)
+	data[offset+4] = uint8(v >> 32)
+	data[offset+5] = uint8(v >> 40)
+	data[offset+6] = uint8(v >> 48)
+	data[offset+7] = uint8(v >> 56)
+	return offset + 8
+}
+func encodeFixed32Wire(data []byte, offset int, v uint32) int {
+	data[offset] = uint8(v)
+	data[offset+1] = uint8(v >> 8)
+	data[offset+2] = uint8(v >> 16)
+	data[offset+3] = uint8(v >> 24)
+	return offset + 4
+}
+func encodeVarintWire(data []byte, offset int, v uint64) int {
+	for v >= 1<<7 {
+		data[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	data[offset] = uint8(v)
+	return offset + 1
+}
+func (m *TracerState) Size() (n int) {
+	var l int
+	_ = l
+	if m.TraceId != 0 {
+		n += 9
+	}
+	if m.SpanId != 0 {
+		n += 9
+	}
+	if m.Sampled {
+		n += 2
+	}
+	if len(m.BaggageItems) > 0 {
+		for k, v := range m.BaggageItems {
+			_ = k
+			_ = v
+			mapEntrySize := 1 + len(k) + sovWire(uint64(len(k))) + 1 + len(v) + sovWire(uint64(len(v)))
+			n += mapEntrySize + 1 + sovWire(uint64(mapEntrySize))
+		}
+	}
+	return n
+}
+
+func sovWire(x uint64) (n int) {
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
+}
+func sozWire(x uint64) (n int) {
+	return sovWire(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *TracerState) Unmarshal(data []byte) error {
+	l := len(data)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowWire
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := data[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: TracerState: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: TracerState: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TraceId", wireType)
+			}
+			m.TraceId = 0
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += 8
+			m.TraceId = uint64(data[iNdEx-8])
+			m.TraceId |= uint64(data[iNdEx-7]) << 8
+			m.TraceId |= uint64(data[iNdEx-6]) << 16
+			m.TraceId |= uint64(data[iNdEx-5]) << 24
+			m.TraceId |= uint64(data[iNdEx-4]) << 32
+			m.TraceId |= uint64(data[iNdEx-3]) << 40
+			m.TraceId |= uint64(data[iNdEx-2]) << 48
+			m.TraceId |= uint64(data[iNdEx-1]) << 56
+		case 2:
+			if wireType != 1 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SpanId", wireType)
+			}
+			m.SpanId = 0
+			if (iNdEx + 8) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += 8
+			m.SpanId = uint64(data[iNdEx-8])
+			m.SpanId |= uint64(data[iNdEx-7]) << 8
+			m.SpanId |= uint64(data[iNdEx-6]) << 16
+			m.SpanId |= uint64(data[iNdEx-5]) << 24
+			m.SpanId |= uint64(data[iNdEx-4]) << 32
+			m.SpanId |= uint64(data[iNdEx-3]) << 40
+			m.SpanId |= uint64(data[iNdEx-2]) << 48
+			m.SpanId |= uint64(data[iNdEx-1]) << 56
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Sampled", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowWire
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Sampled = bool(v != 0)
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BaggageItems", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowWire
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthWire
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			var keykey uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowWire
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				keykey |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			var stringLenmapkey uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowWire
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				stringLenmapkey |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLenmapkey := int(stringLenmapkey)
+			if intStringLenmapkey < 0 {
+				return ErrInvalidLengthWire
+			}
+			postStringIndexmapkey := iNdEx + intStringLenmapkey
+			if postStringIndexmapkey > l {
+				return io.ErrUnexpectedEOF
+			}
+			mapkey := string(data[iNdEx:postStringIndexmapkey])
+			iNdEx = postStringIndexmapkey
+			var valuekey uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowWire
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				valuekey |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			var stringLenmapvalue uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowWire
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				stringLenmapvalue |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLenmapvalue := int(stringLenmapvalue)
+			if intStringLenmapvalue < 0 {
+				return ErrInvalidLengthWire
+			}
+			postStringIndexmapvalue := iNdEx + intStringLenmapvalue
+			if postStringIndexmapvalue > l {
+				return io.ErrUnexpectedEOF
+			}
+			mapvalue := string(data[iNdEx:postStringIndexmapvalue])
+			iNdEx = postStringIndexmapvalue
+			if m.BaggageItems == nil {
+				m.BaggageItems = make(map[string]string)
+			}
+			m.BaggageItems[mapkey] = mapvalue
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipWire(data[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthWire
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipWire(data []byte) (n int, err error) {
+	l := len(data)
+	iNdEx := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowWire
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := data[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowWire
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if data[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+			return iNdEx, nil
+		case 1:
+			iNdEx += 8
+			return iNdEx, nil
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowWire
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := data[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			iNdEx += length
+			if length < 0 {
+				return 0, ErrInvalidLengthWire
+			}
+			return iNdEx, nil
+		case 3:
+			for {
+				var innerWire uint64
+				var start int = iNdEx
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return 0, ErrIntOverflowWire
+					}
+					if iNdEx >= l {
+						return 0, io.ErrUnexpectedEOF
+					}
+					b := data[iNdEx]
+					iNdEx++
+					innerWire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				innerWireType := int(innerWire & 0x7)
+				if innerWireType == 4 {
+					break
+				}
+				next, err := skipWire(data[start:])
+				if err != nil {
+					return 0, err
+				}
+				iNdEx = start + next
+			}
+			return iNdEx, nil
+		case 4:
+			return iNdEx, nil
+		case 5:
+			iNdEx += 4
+			return iNdEx, nil
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+	}
+	panic("unreachable")
+}
+
+var (
+	ErrInvalidLengthWire = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowWire   = fmt.Errorf("proto: integer overflow")
+)
+
+var fileDescriptorWire = []byte{
+	// 234 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0x2a, 0xcf, 0x2c, 0x4a,
+	0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x4e, 0x4a, 0x2c, 0xce, 0x4c, 0x2e, 0x29, 0x4a,
+	0x4c, 0x4e, 0x2d, 0x8a, 0x4f, 0xcf, 0xd7, 0x03, 0x49, 0x29, 0x7d, 0x65, 0xe4, 0xe2, 0x0e, 0x01,
+	0x0b, 0x05, 0x97, 0x24, 0x96, 0xa4, 0x0a, 0x49, 0x72, 0x71, 0x80, 0x55, 0xc4, 0x67, 0xa6, 0x48,
+	0x30, 0x2a, 0x30, 0x6a, 0xb0, 0x05, 0xb1, 0x83, 0xf9, 0x9e, 0x29, 0x42, 0xe2, 0x5c, 0xec, 0xc5,
+	0x05, 0x89, 0x79, 0x20, 0x19, 0x26, 0xb0, 0x0c, 0x1b, 0x88, 0x0b, 0x94, 0x90, 0x00, 0x4a, 0x24,
+	0xe6, 0x16, 0xe4, 0xa4, 0xa6, 0x48, 0x30, 0x03, 0x25, 0x38, 0x82, 0x60, 0x5c, 0xa1, 0x70, 0x2e,
+	0xde, 0xa4, 0xc4, 0xf4, 0xf4, 0xc4, 0x74, 0xa0, 0x79, 0x25, 0xa9, 0xb9, 0xc5, 0x12, 0x2c, 0x0a,
+	0xcc, 0x1a, 0xdc, 0x46, 0x46, 0x7a, 0x58, 0x9c, 0xa2, 0x87, 0xe4, 0x0c, 0x3d, 0x27, 0x88, 0x2e,
+	0x4f, 0x90, 0x26, 0xd7, 0xbc, 0x92, 0xa2, 0xca, 0x20, 0x9e, 0x24, 0x24, 0x21, 0x29, 0x7b, 0x2e,
+	0x41, 0x0c, 0x25, 0x42, 0x02, 0x5c, 0xcc, 0xd9, 0xa9, 0x95, 0x60, 0x67, 0x73, 0x06, 0x81, 0x98,
+	0x42, 0x22, 0x5c, 0xac, 0x65, 0x89, 0x39, 0xa5, 0xa9, 0x60, 0x07, 0x73, 0x06, 0x41, 0x38, 0x56,
+	0x4c, 0x16, 0x8c, 0x4e, 0x62, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x00, 0xe2, 0x07, 0x40, 0x3c, 0xe1,
+	0xb1, 0x1c, 0x43, 0x14, 0x0b, 0xc8, 0x11, 0x49, 0x6c, 0xe0, 0xb0, 0x32, 0x06, 0x04, 0x00, 0x00,
+	0xff, 0xff, 0x0a, 0x20, 0x89, 0x38, 0x39, 0x01, 0x00, 0x00,
+}