Add W3C tracestate benchmark tests

Author: yuanyuanzhao3

pkg/sampling/w3ctracestate_benchmark_test.go

@@ -0,0 +1,356 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package sampling
+
+import (
+	"strconv"
+	"strings"
+	"sync/atomic"
+	"testing"
+)
+
+func BenchmarkNewW3CTraceState(b *testing.B) {
+	benchmarks := []struct {
+		name  string
+		input string
+	}{
+		{
+			name:  "Empty",
+			input: "",
+		},
+		{
+			name:  "OTelThresholdOnly",
+			input: "ot=th:c",
+		},
+		{
+			name:  "OTelWithRValue",
+			input: "ot=th:100;rv:abcdabcdabcdff",
+		},
+		{
+			name:  "OTelWithExtraFields",
+			input: "ot=th:c;rv:d29d6a7215ced0;pn:abc",
+		},
+		{
+			name:  "SingleVendor",
+			input: "zz=vendorcontent",
+		},
+		{
+			name:  "OTelPlusOneVendor",
+			input: "ot=th:c,zz=vendorcontent",
+		},
+		{
+			name:  "OTelPlusMultipleVendors",
+			input: "ot=th:c;rv:d29d6a7215ced0;pn:abc,zz=vendorcontent,aa=value1,bb=value2",
+		},
+		{
+			name:  "MultipleVendorsNoOTel",
+			input: "vendor1=value1,vendor2=value2,vendor3=value3",
+		},
+		{
+			name:  "WithWhitespace",
+			input: " ot=th:1 , other=value ",
+		},
+		{
+			name:  "MultiTenantKey",
+			input: "tenant@system=value,ot=th:5",
+		},
+		{
+			name:  "LongValue",
+			input: "ot=th:c,vendor=" + strings.Repeat("x", 200),
+		},
+		{
+			name:  "ManyPairs",
+			input: generateManyPairs(20),
+		},
+		{
+			name:  "MaxPairs",
+			input: generateManyPairs(32),
+		},
+	}
+
+	for _, bm := range benchmarks {
+		b.Run(bm.name, func(b *testing.B) {
+			b.ReportAllocs()
+			for i := 0; i < b.N; i++ {
+				_, _ = NewW3CTraceState(bm.input)
+			}
+		})
+	}
+}
+
+// generateManyPairs creates a tracestate string with the specified number of key-value pairs.
+func generateManyPairs(n int) string {
+	var sb strings.Builder
+	sb.WriteString("ot=th:c")
+	for i := 1; i < n; i++ {
+		sb.WriteString(",v")
+		sb.WriteString(strings.Repeat("x", i%10))
+		sb.WriteString("=val")
+	}
+	return sb.String()
+}
+
+func BenchmarkNewW3CTraceStateParallel(b *testing.B) {
+	// Benchmark parallel execution with a typical real-world input
+	input := "ot=th:c;rv:d29d6a7215ced0;pn:abc,zz=vendorcontent"
+
+	b.ReportAllocs()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			_, _ = NewW3CTraceState(input)
+		}
+	})
+}
+
+func BenchmarkW3CTracestateRegex(b *testing.B) {
+	benchmarks := []struct {
+		name  string
+		input string
+	}{
+		{
+			name:  "Empty",
+			input: "",
+		},
+		{
+			name:  "OTelThresholdOnly",
+			input: "ot=th:c",
+		},
+		{
+			name:  "OTelWithRValue",
+			input: "ot=th:100;rv:abcdabcdabcdff",
+		},
+		{
+			name:  "OTelWithExtraFields",
+			input: "ot=th:c;rv:d29d6a7215ced0;pn:abc",
+		},
+		{
+			name:  "SingleVendor",
+			input: "zz=vendorcontent",
+		},
+		{
+			name:  "OTelPlusOneVendor",
+			input: "ot=th:c,zz=vendorcontent",
+		},
+		{
+			name:  "OTelPlusMultipleVendors",
+			input: "ot=th:c;rv:d29d6a7215ced0;pn:abc,zz=vendorcontent,aa=value1,bb=value2",
+		},
+		{
+			name:  "MultipleVendorsNoOTel",
+			input: "vendor1=value1,vendor2=value2,vendor3=value3",
+		},
+		{
+			name:  "WithWhitespace",
+			input: " ot=th:1 , other=value ",
+		},
+		{
+			name:  "MultiTenantKey",
+			input: "tenant@system=value,ot=th:5",
+		},
+		{
+			name:  "LongValue",
+			input: "ot=th:c,vendor=" + strings.Repeat("x", 200),
+		},
+		{
+			name:  "ManyPairs",
+			input: generateManyPairs(20),
+		},
+		{
+			name:  "MaxPairs",
+			input: generateManyPairs(32),
+		},
+	}
+
+	for _, bm := range benchmarks {
+		b.Run(bm.name, func(b *testing.B) {
+			b.ReportAllocs()
+			for i := 0; i < b.N; i++ {
+				_ = w3cTracestateRe.MatchString(bm.input)
+			}
+		})
+	}
+}
+
+// =============================================================================
+// Application-level Optimization Strategy: Lock-Free Last-Value Cache
+// =============================================================================
+
+// w3cTraceStateCacheEntry holds an immutable cache entry.
+// Using an immutable struct allows lock-free atomic swaps.
+type w3cTraceStateCacheEntry struct {
+	input  string
+	result W3CTraceState
+	err    error
+}
+
+// w3cTraceStateCache is a lock-free single-entry cache for consecutive identical inputs.
+// This works well when spans from the same trace share the same tracestate.
+// Uses atomic.Pointer for lock-free reads and writes - no mutex contention.
+type w3cTraceStateCache struct {
+	entry atomic.Pointer[w3cTraceStateCacheEntry]
+}
+
+func (c *w3cTraceStateCache) parse(input string) (W3CTraceState, error) {
+	// Lock-free read
+	if entry := c.entry.Load(); entry != nil && entry.input == input {
+		return entry.result, entry.err
+	}
+
+	// Cache miss - parse and store
+	result, err := NewW3CTraceState(input)
+
+	// Lock-free write (atomic swap)
+	c.entry.Store(&w3cTraceStateCacheEntry{
+		input:  input,
+		result: result,
+		err:    err,
+	})
+
+	return result, err
+}
+
+func BenchmarkW3CTraceStateCached(b *testing.B) {
+	cache := &w3cTraceStateCache{}
+	input := "ot=th:c;rv:d29d6a7215ced0;pn:abc,zz=vendorcontent"
+
+	b.Run("CacheHit", func(b *testing.B) {
+		// Prime the cache
+		_, _ = cache.parse(input)
+
+		b.ReportAllocs()
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			_, _ = cache.parse(input)
+		}
+	})
+
+	b.Run("CacheMiss", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			// Each iteration has a different input = cache miss
+			_, _ = cache.parse(input + strconv.Itoa(i%100))
+		}
+	})
+
+	b.Run("AlternatingInputs", func(b *testing.B) {
+		// Simulate alternating between two traces
+		input1 := "ot=th:c;rv:d29d6a7215ced0"
+		input2 := "ot=th:5;rv:abcdef12345678"
+
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			if i%2 == 0 {
+				_, _ = cache.parse(input1)
+			} else {
+				_, _ = cache.parse(input2)
+			}
+		}
+	})
+
+	// Parallel benchmark - demonstrates no mutex contention
+	b.Run("ParallelCacheHit", func(b *testing.B) {
+		// Prime the cache
+		_, _ = cache.parse(input)
+
+		b.ReportAllocs()
+		b.ResetTimer()
+		b.RunParallel(func(pb *testing.PB) {
+			for pb.Next() {
+				_, _ = cache.parse(input)
+			}
+		})
+	})
+}
+
+// =============================================================================
+// Benchmark: Hand-written Validator vs Regex
+// =============================================================================
+
+func BenchmarkW3CTracestateValidation(b *testing.B) {
+	benchmarks := []struct {
+		name  string
+		input string
+	}{
+		{"OTelThresholdOnly", "ot=th:c"},
+		{"OTelWithRValue", "ot=th:100;rv:abcdabcdabcdff"},
+		{"OTelPlusMultipleVendors", "ot=th:c;rv:d29d6a7215ced0;pn:abc,zz=vendorcontent,aa=value1,bb=value2"},
+		{"LongValue", "ot=th:c,vendor=" + strings.Repeat("x", 200)},
+		{"ManyPairs", generateManyPairs(20)},
+		{"MaxPairs", generateManyPairs(32)},
+	}
+
+	for _, bm := range benchmarks {
+		b.Run("Regex/"+bm.name, func(b *testing.B) {
+			b.ReportAllocs()
+			for i := 0; i < b.N; i++ {
+				_ = w3cTracestateRe.MatchString(bm.input)
+			}
+		})
+
+		b.Run("NoRegex/"+bm.name, func(b *testing.B) {
+			b.ReportAllocs()
+			for i := 0; i < b.N; i++ {
+				_ = W3CTraceStateIsValid(bm.input)
+			}
+		})
+	}
+}
+
+// =============================================================================
+// Simulating Real-World Trace Patterns
+// =============================================================================
+
+func BenchmarkW3CTraceStateRealWorldPatterns(b *testing.B) {
+	// Simulate a batch of spans from the same trace (common in collectors)
+	sameTraceInputs := make([]string, 100)
+	tracestate := "ot=th:c;rv:d29d6a7215ced0;pn:abc,zz=vendorcontent"
+	for i := range sameTraceInputs {
+		sameTraceInputs[i] = tracestate
+	}
+
+	b.Run("SameTrace_NoCache", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			for _, input := range sameTraceInputs {
+				_, _ = NewW3CTraceState(input)
+			}
+		}
+	})
+
+	cache := &w3cTraceStateCache{}
+	b.Run("SameTrace_WithCache", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			for _, input := range sameTraceInputs {
+				_, _ = cache.parse(input)
+			}
+		}
+	})
+
+	// Simulate mixed traces (10 different traces, 10 spans each)
+	mixedInputs := make([]string, 100)
+	for i := range mixedInputs {
+		traceIdx := i / 10 // 10 spans per trace
+		mixedInputs[i] = "ot=th:" + strconv.Itoa(traceIdx) + ";rv:d29d6a7215ced0"
+	}
+
+	b.Run("MixedTraces_NoCache", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			for _, input := range mixedInputs {
+				_, _ = NewW3CTraceState(input)
+			}
+		}
+	})
+
+	cache2 := &w3cTraceStateCache{}
+	b.Run("MixedTraces_WithCache", func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			for _, input := range mixedInputs {
+				_, _ = cache2.parse(input)
+			}
+		}
+	})
+}