123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325 |
- // Copyright (c) 2017 Uber Technologies, Inc.
- //
- // 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
- //
- // http://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 jaeger
- import (
- "bytes"
- "encoding/binary"
- "fmt"
- "io"
- "log"
- "net/url"
- "strings"
- "sync"
- opentracing "github.com/opentracing/opentracing-go"
- )
- // Injector is responsible for injecting SpanContext instances in a manner suitable
- // for propagation via a format-specific "carrier" object. Typically the
- // injection will take place across an RPC boundary, but message queues and
- // other IPC mechanisms are also reasonable places to use an Injector.
- type Injector interface {
- // Inject takes `SpanContext` and injects it into `carrier`. The actual type
- // of `carrier` depends on the `format` passed to `Tracer.Inject()`.
- //
- // Implementations may return opentracing.ErrInvalidCarrier or any other
- // implementation-specific error if injection fails.
- Inject(ctx SpanContext, carrier interface{}) error
- }
- // Extractor is responsible for extracting SpanContext instances from a
- // format-specific "carrier" object. Typically the extraction will take place
- // on the server side of an RPC boundary, but message queues and other IPC
- // mechanisms are also reasonable places to use an Extractor.
- type Extractor interface {
- // Extract decodes a SpanContext instance from the given `carrier`,
- // or (nil, opentracing.ErrSpanContextNotFound) if no context could
- // be found in the `carrier`.
- Extract(carrier interface{}) (SpanContext, error)
- }
- // TextMapPropagator is a combined Injector and Extractor for TextMap format
- type TextMapPropagator struct {
- headerKeys *HeadersConfig
- metrics Metrics
- encodeValue func(string) string
- decodeValue func(string) string
- }
- // NewTextMapPropagator creates a combined Injector and Extractor for TextMap format
- func NewTextMapPropagator(headerKeys *HeadersConfig, metrics Metrics) *TextMapPropagator {
- return &TextMapPropagator{
- headerKeys: headerKeys,
- metrics: metrics,
- encodeValue: func(val string) string {
- return val
- },
- decodeValue: func(val string) string {
- return val
- },
- }
- }
- // NewHTTPHeaderPropagator creates a combined Injector and Extractor for HTTPHeaders format
- func NewHTTPHeaderPropagator(headerKeys *HeadersConfig, metrics Metrics) *TextMapPropagator {
- return &TextMapPropagator{
- headerKeys: headerKeys,
- metrics: metrics,
- encodeValue: func(val string) string {
- return url.QueryEscape(val)
- },
- decodeValue: func(val string) string {
- // ignore decoding errors, cannot do anything about them
- if v, err := url.QueryUnescape(val); err == nil {
- return v
- }
- return val
- },
- }
- }
- // BinaryPropagator is a combined Injector and Extractor for Binary format
- type BinaryPropagator struct {
- tracer *Tracer
- buffers sync.Pool
- }
- // NewBinaryPropagator creates a combined Injector and Extractor for Binary format
- func NewBinaryPropagator(tracer *Tracer) *BinaryPropagator {
- return &BinaryPropagator{
- tracer: tracer,
- buffers: sync.Pool{New: func() interface{} { return &bytes.Buffer{} }},
- }
- }
- // Inject implements Injector of TextMapPropagator
- func (p *TextMapPropagator) Inject(
- sc SpanContext,
- abstractCarrier interface{},
- ) error {
- textMapWriter, ok := abstractCarrier.(opentracing.TextMapWriter)
- if !ok {
- return opentracing.ErrInvalidCarrier
- }
- // Do not encode the string with trace context to avoid accidental double-encoding
- // if people are using opentracing < 0.10.0. Our colon-separated representation
- // of the trace context is already safe for HTTP headers.
- textMapWriter.Set(p.headerKeys.TraceContextHeaderName, sc.String())
- for k, v := range sc.baggage {
- safeKey := p.addBaggageKeyPrefix(k)
- safeVal := p.encodeValue(v)
- textMapWriter.Set(safeKey, safeVal)
- }
- return nil
- }
- // Extract implements Extractor of TextMapPropagator
- func (p *TextMapPropagator) Extract(abstractCarrier interface{}) (SpanContext, error) {
- textMapReader, ok := abstractCarrier.(opentracing.TextMapReader)
- if !ok {
- return emptyContext, opentracing.ErrInvalidCarrier
- }
- var ctx SpanContext
- var baggage map[string]string
- err := textMapReader.ForeachKey(func(rawKey, value string) error {
- key := strings.ToLower(rawKey) // TODO not necessary for plain TextMap
- if key == p.headerKeys.TraceContextHeaderName {
- var err error
- safeVal := p.decodeValue(value)
- if ctx, err = ContextFromString(safeVal); err != nil {
- return err
- }
- } else if key == p.headerKeys.JaegerDebugHeader {
- ctx.debugID = p.decodeValue(value)
- } else if key == p.headerKeys.JaegerBaggageHeader {
- if baggage == nil {
- baggage = make(map[string]string)
- }
- for k, v := range p.parseCommaSeparatedMap(value) {
- baggage[k] = v
- }
- } else if strings.HasPrefix(key, p.headerKeys.TraceBaggageHeaderPrefix) {
- if baggage == nil {
- baggage = make(map[string]string)
- }
- safeKey := p.removeBaggageKeyPrefix(key)
- safeVal := p.decodeValue(value)
- baggage[safeKey] = safeVal
- }
- return nil
- })
- if err != nil {
- p.metrics.DecodingErrors.Inc(1)
- return emptyContext, err
- }
- if !ctx.traceID.IsValid() && ctx.debugID == "" && len(baggage) == 0 {
- return emptyContext, opentracing.ErrSpanContextNotFound
- }
- ctx.baggage = baggage
- return ctx, nil
- }
- // Inject implements Injector of BinaryPropagator
- func (p *BinaryPropagator) Inject(
- sc SpanContext,
- abstractCarrier interface{},
- ) error {
- carrier, ok := abstractCarrier.(io.Writer)
- if !ok {
- return opentracing.ErrInvalidCarrier
- }
- // Handle the tracer context
- if err := binary.Write(carrier, binary.BigEndian, sc.traceID); err != nil {
- return err
- }
- if err := binary.Write(carrier, binary.BigEndian, sc.spanID); err != nil {
- return err
- }
- if err := binary.Write(carrier, binary.BigEndian, sc.parentID); err != nil {
- return err
- }
- if err := binary.Write(carrier, binary.BigEndian, sc.samplingState.flags()); err != nil {
- return err
- }
- // Handle the baggage items
- if err := binary.Write(carrier, binary.BigEndian, int32(len(sc.baggage))); err != nil {
- return err
- }
- for k, v := range sc.baggage {
- if err := binary.Write(carrier, binary.BigEndian, int32(len(k))); err != nil {
- return err
- }
- io.WriteString(carrier, k)
- if err := binary.Write(carrier, binary.BigEndian, int32(len(v))); err != nil {
- return err
- }
- io.WriteString(carrier, v)
- }
- return nil
- }
- // W3C limits https://github.com/w3c/baggage/blob/master/baggage/HTTP_HEADER_FORMAT.md#limits
- const (
- maxBinaryBaggage = 180
- maxBinaryNameValueLen = 4096
- )
- // Extract implements Extractor of BinaryPropagator
- func (p *BinaryPropagator) Extract(abstractCarrier interface{}) (SpanContext, error) {
- carrier, ok := abstractCarrier.(io.Reader)
- if !ok {
- return emptyContext, opentracing.ErrInvalidCarrier
- }
- var ctx SpanContext
- ctx.samplingState = &samplingState{}
- if err := binary.Read(carrier, binary.BigEndian, &ctx.traceID); err != nil {
- return emptyContext, opentracing.ErrSpanContextCorrupted
- }
- if err := binary.Read(carrier, binary.BigEndian, &ctx.spanID); err != nil {
- return emptyContext, opentracing.ErrSpanContextCorrupted
- }
- if err := binary.Read(carrier, binary.BigEndian, &ctx.parentID); err != nil {
- return emptyContext, opentracing.ErrSpanContextCorrupted
- }
- var flags byte
- if err := binary.Read(carrier, binary.BigEndian, &flags); err != nil {
- return emptyContext, opentracing.ErrSpanContextCorrupted
- }
- ctx.samplingState.setFlags(flags)
- // Handle the baggage items
- var numBaggage int32
- if err := binary.Read(carrier, binary.BigEndian, &numBaggage); err != nil {
- return emptyContext, opentracing.ErrSpanContextCorrupted
- }
- if numBaggage > maxBinaryBaggage {
- return emptyContext, opentracing.ErrSpanContextCorrupted
- }
- if iNumBaggage := int(numBaggage); iNumBaggage > 0 {
- ctx.baggage = make(map[string]string, iNumBaggage)
- buf := p.buffers.Get().(*bytes.Buffer)
- defer p.buffers.Put(buf)
- var keyLen, valLen int32
- for i := 0; i < iNumBaggage; i++ {
- if err := binary.Read(carrier, binary.BigEndian, &keyLen); err != nil {
- return emptyContext, opentracing.ErrSpanContextCorrupted
- }
- buf.Reset()
- buf.Grow(int(keyLen))
- if n, err := io.CopyN(buf, carrier, int64(keyLen)); err != nil || int32(n) != keyLen {
- return emptyContext, opentracing.ErrSpanContextCorrupted
- }
- key := buf.String()
- if err := binary.Read(carrier, binary.BigEndian, &valLen); err != nil {
- return emptyContext, opentracing.ErrSpanContextCorrupted
- }
- if keyLen+valLen > maxBinaryNameValueLen {
- return emptyContext, opentracing.ErrSpanContextCorrupted
- }
- buf.Reset()
- buf.Grow(int(valLen))
- if n, err := io.CopyN(buf, carrier, int64(valLen)); err != nil || int32(n) != valLen {
- return emptyContext, opentracing.ErrSpanContextCorrupted
- }
- ctx.baggage[key] = buf.String()
- }
- }
- return ctx, nil
- }
- // Converts a comma separated key value pair list into a map
- // e.g. key1=value1, key2=value2, key3 = value3
- // is converted to map[string]string { "key1" : "value1",
- // "key2" : "value2",
- // "key3" : "value3" }
- func (p *TextMapPropagator) parseCommaSeparatedMap(value string) map[string]string {
- baggage := make(map[string]string)
- value, err := url.QueryUnescape(value)
- if err != nil {
- log.Printf("Unable to unescape %s, %v", value, err)
- return baggage
- }
- for _, kvpair := range strings.Split(value, ",") {
- kv := strings.Split(strings.TrimSpace(kvpair), "=")
- if len(kv) == 2 {
- baggage[strings.TrimSpace(kv[0])] = kv[1]
- } else {
- log.Printf("Malformed value passed in for %s", p.headerKeys.JaegerBaggageHeader)
- }
- }
- return baggage
- }
- // Converts a baggage item key into an http header format,
- // by prepending TraceBaggageHeaderPrefix and encoding the key string
- func (p *TextMapPropagator) addBaggageKeyPrefix(key string) string {
- // TODO encodeBaggageKeyAsHeader add caching and escaping
- return fmt.Sprintf("%v%v", p.headerKeys.TraceBaggageHeaderPrefix, key)
- }
- func (p *TextMapPropagator) removeBaggageKeyPrefix(key string) string {
- // TODO decodeBaggageHeaderKey add caching and escaping
- return key[len(p.headerKeys.TraceBaggageHeaderPrefix):]
- }
|