From 5541d9f42edd409b71781786a974ab40097a8986 Mon Sep 17 00:00:00 2001 From: Brandon Gonzalez Date: Mon, 22 Feb 2016 18:47:19 -0500 Subject: [PATCH] Change trace attributes to Baggage --- propagation.go | 76 +++++++++++++++++++++++++------------------------- raw.go | 4 +-- span.go | 18 ++++++------ tracer.go | 10 +++---- 4 files changed, 54 insertions(+), 54 deletions(-) diff --git a/propagation.go b/propagation.go index dd3f2633391f..1e168b37d18f 100644 --- a/propagation.go +++ b/propagation.go @@ -46,11 +46,11 @@ func (p *splitTextPropagator) InjectSpan( splitTextCarrier.TracerState[fieldNameSampled] = strconv.FormatBool(sc.raw.Sampled) sc.Lock() - if l := len(sc.raw.Attributes); l > 0 && splitTextCarrier.TraceAttributes == nil { - splitTextCarrier.TraceAttributes = make(map[string]string, l) + if l := len(sc.raw.Baggage); l > 0 && splitTextCarrier.Baggage == nil { + splitTextCarrier.Baggage = make(map[string]string, l) } - for k, v := range sc.raw.Attributes { - splitTextCarrier.TraceAttributes[k] = v + for k, v := range sc.raw.Baggage { + splitTextCarrier.Baggage[k] = v } sc.Unlock() return nil @@ -107,7 +107,7 @@ func (p *splitTextPropagator) JoinTrace( Sampled: sampled, }, } - sp.raw.Attributes = splitTextCarrier.TraceAttributes + sp.raw.Baggage = splitTextCarrier.Baggage return p.tracer.startSpanInternal( sp, @@ -149,25 +149,25 @@ func (p *splitBinaryPropagator) InjectSpan( return err } - // Handle the attributes. - attrsBuf := bytes.NewBuffer(splitBinaryCarrier.TraceAttributes[:0]) - err = binary.Write(attrsBuf, binary.BigEndian, int32(len(sc.raw.Attributes))) + // Handle the baggageibutes. + baggageBuf := bytes.NewBuffer(splitBinaryCarrier.Baggage[:0]) + err = binary.Write(baggageBuf, binary.BigEndian, int32(len(sc.raw.Baggage))) if err != nil { return err } - for k, v := range sc.raw.Attributes { - if err = binary.Write(attrsBuf, binary.BigEndian, int32(len(k))); err != nil { + for k, v := range sc.raw.Baggage { + if err = binary.Write(baggageBuf, binary.BigEndian, int32(len(k))); err != nil { return err } - attrsBuf.WriteString(k) - if err = binary.Write(attrsBuf, binary.BigEndian, int32(len(v))); err != nil { + baggageBuf.WriteString(k) + if err = binary.Write(baggageBuf, binary.BigEndian, int32(len(v))); err != nil { return err } - attrsBuf.WriteString(v) + baggageBuf.WriteString(v) } splitBinaryCarrier.TracerState = contextBuf.Bytes() - splitBinaryCarrier.TraceAttributes = attrsBuf.Bytes() + splitBinaryCarrier.Baggage = baggageBuf.Bytes() return nil } @@ -197,36 +197,36 @@ func (p *splitBinaryPropagator) JoinTrace( return nil, opentracing.ErrTraceCorrupted } - // Handle the attributes. - attrsReader := bytes.NewReader(splitBinaryCarrier.TraceAttributes) - var numAttrs int32 - if err := binary.Read(attrsReader, binary.BigEndian, &numAttrs); err != nil { + // Handle the baggageibutes. + baggageReader := bytes.NewReader(splitBinaryCarrier.Baggage) + var numBaggage int32 + if err := binary.Read(baggageReader, binary.BigEndian, &numBaggage); err != nil { return nil, opentracing.ErrTraceCorrupted } - iNumAttrs := int(numAttrs) - var attrMap map[string]string - if iNumAttrs > 0 { + iNumBaggage := int(numBaggage) + var baggageMap map[string]string + if iNumBaggage > 0 { var buf bytes.Buffer // TODO(tschottdorf): candidate for sync.Pool - attrMap = make(map[string]string, iNumAttrs) + baggageMap = make(map[string]string, iNumBaggage) var keyLen, valLen int32 - for i := 0; i < iNumAttrs; i++ { - if err := binary.Read(attrsReader, binary.BigEndian, &keyLen); err != nil { + for i := 0; i < iNumBaggage; i++ { + if err := binary.Read(baggageReader, binary.BigEndian, &keyLen); err != nil { return nil, opentracing.ErrTraceCorrupted } buf.Grow(int(keyLen)) - if n, err := io.CopyN(&buf, attrsReader, int64(keyLen)); err != nil || int32(n) != keyLen { + if n, err := io.CopyN(&buf, baggageReader, int64(keyLen)); err != nil || int32(n) != keyLen { return nil, opentracing.ErrTraceCorrupted } key := buf.String() buf.Reset() - if err := binary.Read(attrsReader, binary.BigEndian, &valLen); err != nil { + if err := binary.Read(baggageReader, binary.BigEndian, &valLen); err != nil { return nil, opentracing.ErrTraceCorrupted } - if n, err := io.CopyN(&buf, attrsReader, int64(valLen)); err != nil || int32(n) != valLen { + if n, err := io.CopyN(&buf, baggageReader, int64(valLen)); err != nil || int32(n) != valLen { return nil, opentracing.ErrTraceCorrupted } - attrMap[key] = buf.String() + baggageMap[key] = buf.String() buf.Reset() } } @@ -240,7 +240,7 @@ func (p *splitBinaryPropagator) JoinTrace( Sampled: sampledByte != 0, }, } - sp.raw.Attributes = attrMap + sp.raw.Baggage = baggageMap return p.tracer.startSpanInternal( sp, @@ -251,8 +251,8 @@ func (p *splitBinaryPropagator) JoinTrace( } const ( - tracerStateHeaderName = "Tracer-State" - traceAttrsHeaderName = "Trace-Attributes" + tracerStateHeaderName = "Tracer-State" + traceBaggageHeaderName = "Trace-Baggage" ) func (p *goHTTPPropagator) InjectSpan( @@ -269,8 +269,8 @@ func (p *goHTTPPropagator) InjectSpan( header := carrier.(http.Header) header.Add(tracerStateHeaderName, base64.StdEncoding.EncodeToString( splitBinaryCarrier.TracerState)) - header.Add(traceAttrsHeaderName, base64.StdEncoding.EncodeToString( - splitBinaryCarrier.TraceAttributes)) + header.Add(traceBaggageHeaderName, base64.StdEncoding.EncodeToString( + splitBinaryCarrier.Baggage)) return nil } @@ -285,23 +285,23 @@ func (p *goHTTPPropagator) JoinTrace( if !found || len(tracerStateBase64) == 0 { return nil, opentracing.ErrTraceNotFound } - traceAttrsBase64, found := header[http.CanonicalHeaderKey(traceAttrsHeaderName)] - if !found || len(traceAttrsBase64) == 0 { + traceBaggageBase64, found := header[http.CanonicalHeaderKey(traceBaggageHeaderName)] + if !found || len(traceBaggageBase64) == 0 { return nil, opentracing.ErrTraceNotFound } tracerStateBinary, err := base64.StdEncoding.DecodeString(tracerStateBase64[0]) if err != nil { return nil, opentracing.ErrTraceCorrupted } - traceAttrsBinary, err := base64.StdEncoding.DecodeString(traceAttrsBase64[0]) + traceBaggageBinary, err := base64.StdEncoding.DecodeString(traceBaggageBase64[0]) if err != nil { return nil, opentracing.ErrTraceCorrupted } // Defer to SplitBinary for the real work. splitBinaryCarrier := &opentracing.SplitBinaryCarrier{ - TracerState: tracerStateBinary, - TraceAttributes: traceAttrsBinary, + TracerState: tracerStateBinary, + Baggage: traceBaggageBinary, } return p.splitBinaryPropagator.JoinTrace(operationName, splitBinaryCarrier) } diff --git a/raw.go b/raw.go index f11977f41aaa..eaac6a6dc203 100644 --- a/raw.go +++ b/raw.go @@ -28,6 +28,6 @@ type RawSpan struct { // The span's "microlog". Logs []opentracing.LogData - // The span's associated attributes. - Attributes map[string]string // initialized on first use + // The span's associated baggage. + Baggage map[string]string // initialized on first use } diff --git a/span.go b/span.go index c0279cf23ac9..5065c1f05f2b 100644 --- a/span.go +++ b/span.go @@ -20,7 +20,7 @@ type spanImpl struct { func (s *spanImpl) reset() { s.tracer = nil s.raw = RawSpan{} - s.raw.Attributes = nil // TODO(tschottdorf): is clearing out the map better? + s.raw.Baggage = nil // TODO(tschottdorf): is clearing out the map better? } func (s *spanImpl) SetOperationName(operationName string) opentracing.Span { @@ -101,8 +101,8 @@ func (s *spanImpl) FinishWithOptions(opts opentracing.FinishOptions) { s.tracer.spanPool.Put(s) } -func (s *spanImpl) SetTraceAttribute(restrictedKey, val string) opentracing.Span { - canonicalKey, valid := opentracing.CanonicalizeTraceAttributeKey(restrictedKey) +func (s *spanImpl) SetBaggageItem(restrictedKey, val string) opentracing.Span { + canonicalKey, valid := opentracing.CanonicalizeBaggageKey(restrictedKey) if !valid { panic(fmt.Errorf("Invalid key: %q", restrictedKey)) } @@ -113,15 +113,15 @@ func (s *spanImpl) SetTraceAttribute(restrictedKey, val string) opentracing.Span return s } - if s.raw.Attributes == nil { - s.raw.Attributes = make(map[string]string) + if s.raw.Baggage == nil { + s.raw.Baggage = make(map[string]string) } - s.raw.Attributes[canonicalKey] = val + s.raw.Baggage[canonicalKey] = val return s } -func (s *spanImpl) TraceAttribute(restrictedKey string) string { - canonicalKey, valid := opentracing.CanonicalizeTraceAttributeKey(restrictedKey) +func (s *spanImpl) BaggageItem(restrictedKey string) string { + canonicalKey, valid := opentracing.CanonicalizeBaggageKey(restrictedKey) if !valid { panic(fmt.Errorf("Invalid key: %q", restrictedKey)) } @@ -129,7 +129,7 @@ func (s *spanImpl) TraceAttribute(restrictedKey string) string { s.Lock() defer s.Unlock() - return s.raw.Attributes[canonicalKey] + return s.raw.Baggage[canonicalKey] } func (s *spanImpl) Tracer() opentracing.Tracer { diff --git a/tracer.go b/tracer.go index 5f03e16138e9..ff6796373512 100644 --- a/tracer.go +++ b/tracer.go @@ -20,7 +20,7 @@ type Options struct { // samples every 64th trace on average. ShouldSample func(int64) bool // TrimUnsampledSpans turns potentially expensive operations on unsampled - // Spans into no-ops. More precisely, tags, attributes and log events + // Spans into no-ops. More precisely, tags, baggage items, and log events // are silently discarded. TrimUnsampledSpans bool // Recorder receives Spans which have been finished. @@ -110,10 +110,10 @@ func (t *tracerImpl) StartSpanWithOptions( sp.raw.Sampled = pr.raw.Sampled pr.Lock() - if l := len(pr.raw.Attributes); l > 0 { - sp.raw.Attributes = make(map[string]string, len(pr.raw.Attributes)) - for k, v := range pr.raw.Attributes { - sp.raw.Attributes[k] = v + if l := len(pr.raw.Baggage); l > 0 { + sp.raw.Baggage = make(map[string]string, len(pr.raw.Baggage)) + for k, v := range pr.raw.Baggage { + sp.raw.Baggage[k] = v } } pr.Unlock()