212 lines
6.5 KiB
Go
212 lines
6.5 KiB
Go
// Copyright The OpenTelemetry 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
|
|
//
|
|
// 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 trace // import "go.opentelemetry.io/otel/trace"
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"regexp"
|
|
"strings"
|
|
)
|
|
|
|
var (
|
|
maxListMembers = 32
|
|
|
|
listDelimiter = ","
|
|
|
|
// based on the W3C Trace Context specification, see
|
|
// https://www.w3.org/TR/trace-context-1/#tracestate-header
|
|
noTenantKeyFormat = `[a-z][_0-9a-z\-\*\/]{0,255}`
|
|
withTenantKeyFormat = `[a-z0-9][_0-9a-z\-\*\/]{0,240}@[a-z][_0-9a-z\-\*\/]{0,13}`
|
|
valueFormat = `[\x20-\x2b\x2d-\x3c\x3e-\x7e]{0,255}[\x21-\x2b\x2d-\x3c\x3e-\x7e]`
|
|
|
|
keyRe = regexp.MustCompile(`^((` + noTenantKeyFormat + `)|(` + withTenantKeyFormat + `))$`)
|
|
valueRe = regexp.MustCompile(`^(` + valueFormat + `)$`)
|
|
memberRe = regexp.MustCompile(`^\s*((` + noTenantKeyFormat + `)|(` + withTenantKeyFormat + `))=(` + valueFormat + `)\s*$`)
|
|
|
|
errInvalidKey errorConst = "invalid tracestate key"
|
|
errInvalidValue errorConst = "invalid tracestate value"
|
|
errInvalidMember errorConst = "invalid tracestate list-member"
|
|
errMemberNumber errorConst = "too many list-members in tracestate"
|
|
errDuplicate errorConst = "duplicate list-member in tracestate"
|
|
)
|
|
|
|
type member struct {
|
|
Key string
|
|
Value string
|
|
}
|
|
|
|
func newMember(key, value string) (member, error) {
|
|
if !keyRe.MatchString(key) {
|
|
return member{}, fmt.Errorf("%w: %s", errInvalidKey, key)
|
|
}
|
|
if !valueRe.MatchString(value) {
|
|
return member{}, fmt.Errorf("%w: %s", errInvalidValue, value)
|
|
}
|
|
return member{Key: key, Value: value}, nil
|
|
}
|
|
|
|
func parseMember(m string) (member, error) {
|
|
matches := memberRe.FindStringSubmatch(m)
|
|
if len(matches) != 5 {
|
|
return member{}, fmt.Errorf("%w: %s", errInvalidMember, m)
|
|
}
|
|
|
|
return member{
|
|
Key: matches[1],
|
|
Value: matches[4],
|
|
}, nil
|
|
|
|
}
|
|
|
|
// String encodes member into a string compliant with the W3C Trace Context
|
|
// specification.
|
|
func (m member) String() string {
|
|
return fmt.Sprintf("%s=%s", m.Key, m.Value)
|
|
}
|
|
|
|
// TraceState provides additional vendor-specific trace identification
|
|
// information across different distributed tracing systems. It represents an
|
|
// immutable list consisting of key/value pairs, each pair is referred to as a
|
|
// list-member.
|
|
//
|
|
// TraceState conforms to the W3C Trace Context specification
|
|
// (https://www.w3.org/TR/trace-context-1). All operations that create or copy
|
|
// a TraceState do so by validating all input and will only produce TraceState
|
|
// that conform to the specification. Specifically, this means that all
|
|
// list-member's key/value pairs are valid, no duplicate list-members exist,
|
|
// and the maximum number of list-members (32) is not exceeded.
|
|
type TraceState struct { //nolint:revive // revive complains about stutter of `trace.TraceState`
|
|
// list is the members in order.
|
|
list []member
|
|
}
|
|
|
|
var _ json.Marshaler = TraceState{}
|
|
|
|
// ParseTraceState attempts to decode a TraceState from the passed
|
|
// string. It returns an error if the input is invalid according to the W3C
|
|
// Trace Context specification.
|
|
func ParseTraceState(tracestate string) (TraceState, error) {
|
|
if tracestate == "" {
|
|
return TraceState{}, nil
|
|
}
|
|
|
|
wrapErr := func(err error) error {
|
|
return fmt.Errorf("failed to parse tracestate: %w", err)
|
|
}
|
|
|
|
var members []member
|
|
found := make(map[string]struct{})
|
|
for _, memberStr := range strings.Split(tracestate, listDelimiter) {
|
|
if len(memberStr) == 0 {
|
|
continue
|
|
}
|
|
|
|
m, err := parseMember(memberStr)
|
|
if err != nil {
|
|
return TraceState{}, wrapErr(err)
|
|
}
|
|
|
|
if _, ok := found[m.Key]; ok {
|
|
return TraceState{}, wrapErr(errDuplicate)
|
|
}
|
|
found[m.Key] = struct{}{}
|
|
|
|
members = append(members, m)
|
|
if n := len(members); n > maxListMembers {
|
|
return TraceState{}, wrapErr(errMemberNumber)
|
|
}
|
|
}
|
|
|
|
return TraceState{list: members}, nil
|
|
}
|
|
|
|
// MarshalJSON marshals the TraceState into JSON.
|
|
func (ts TraceState) MarshalJSON() ([]byte, error) {
|
|
return json.Marshal(ts.String())
|
|
}
|
|
|
|
// String encodes the TraceState into a string compliant with the W3C
|
|
// Trace Context specification. The returned string will be invalid if the
|
|
// TraceState contains any invalid members.
|
|
func (ts TraceState) String() string {
|
|
members := make([]string, len(ts.list))
|
|
for i, m := range ts.list {
|
|
members[i] = m.String()
|
|
}
|
|
return strings.Join(members, listDelimiter)
|
|
}
|
|
|
|
// Get returns the value paired with key from the corresponding TraceState
|
|
// list-member if it exists, otherwise an empty string is returned.
|
|
func (ts TraceState) Get(key string) string {
|
|
for _, member := range ts.list {
|
|
if member.Key == key {
|
|
return member.Value
|
|
}
|
|
}
|
|
|
|
return ""
|
|
}
|
|
|
|
// Insert adds a new list-member defined by the key/value pair to the
|
|
// TraceState. If a list-member already exists for the given key, that
|
|
// list-member's value is updated. The new or updated list-member is always
|
|
// moved to the beginning of the TraceState as specified by the W3C Trace
|
|
// Context specification.
|
|
//
|
|
// If key or value are invalid according to the W3C Trace Context
|
|
// specification an error is returned with the original TraceState.
|
|
//
|
|
// If adding a new list-member means the TraceState would have more members
|
|
// then is allowed, the new list-member will be inserted and the right-most
|
|
// list-member will be dropped in the returned TraceState.
|
|
func (ts TraceState) Insert(key, value string) (TraceState, error) {
|
|
m, err := newMember(key, value)
|
|
if err != nil {
|
|
return ts, err
|
|
}
|
|
|
|
cTS := ts.Delete(key)
|
|
if cTS.Len()+1 <= maxListMembers {
|
|
cTS.list = append(cTS.list, member{})
|
|
}
|
|
// When the number of members exceeds capacity, drop the "right-most".
|
|
copy(cTS.list[1:], cTS.list)
|
|
cTS.list[0] = m
|
|
|
|
return cTS, nil
|
|
}
|
|
|
|
// Delete returns a copy of the TraceState with the list-member identified by
|
|
// key removed.
|
|
func (ts TraceState) Delete(key string) TraceState {
|
|
members := make([]member, ts.Len())
|
|
copy(members, ts.list)
|
|
for i, member := range ts.list {
|
|
if member.Key == key {
|
|
members = append(members[:i], members[i+1:]...)
|
|
// TraceState should contain no duplicate members.
|
|
break
|
|
}
|
|
}
|
|
return TraceState{list: members}
|
|
}
|
|
|
|
// Len returns the number of list-members in the TraceState.
|
|
func (ts TraceState) Len() int {
|
|
return len(ts.list)
|
|
}
|