refactor(stacktrace): remove unused prefixTrie implementation

Deleted character-based prefixTrie implementation (~130 lines) as
segmentPrefixTrie is the only trie used in production code.

segmentPrefixTrie provides better performance for path-based prefix
matching and is the sole implementation used by the stacktrace filtering
system.

Author: kakkoyun

internal/stacktrace/trie.go

@@ -5,143 +5,6 @@
 
 package stacktrace
 
-import (
-	"sync"
-)
-
-// prefixTrie is a thread-safe trie data structure optimized for prefix matching.
-// It's designed for high-performance concurrent read operations with occasional writes.
-//
-// Memory vs Performance Trade-offs:
-// - Slightly higher initial memory overhead for data structure vs slice
-// - Zero allocations during lookups (same as slice)
-// - O(m) lookup time where m=string length (vs O(n) where n=prefix count)
-// - Performance varies: slower for early matches, much faster for no-match scenarios
-type prefixTrie struct {
-	root *trieNode
-	mu   sync.RWMutex
-}
-
-// trieNode represents a single node in the trie
-type trieNode struct {
-	children map[rune]*trieNode
-	isEnd    bool // true if this node represents the end of a prefix
-}
-
-// newPrefixTrie creates a new empty PrefixTrie
-func newPrefixTrie() *prefixTrie {
-	return &prefixTrie{
-		root: &trieNode{
-			children: make(map[rune]*trieNode),
-		},
-	}
-}
-
-// Insert adds a prefix to the trie
-func (t *prefixTrie) Insert(prefix string) {
-	if prefix == "" {
-		return
-	}
-
-	t.mu.Lock()
-	defer t.mu.Unlock()
-
-	node := t.root
-	for _, ch := range prefix {
-		if node.children[ch] == nil {
-			node.children[ch] = &trieNode{
-				children: make(map[rune]*trieNode),
-			}
-		}
-		node = node.children[ch]
-	}
-	node.isEnd = true
-}
-
-// HasPrefix checks if the given string has any of the prefixes stored in the trie.
-// Returns true if any prefix in the trie is a prefix of the input string.
-func (t *prefixTrie) HasPrefix(s string) (found bool) {
-	if s == "" {
-		return false
-	}
-
-	t.mu.RLock()
-	defer t.mu.RUnlock()
-
-	node := t.root
-	for _, ch := range s {
-		if node.isEnd {
-			return true
-		}
-
-		node = node.children[ch]
-		if node == nil {
-			return false
-		}
-	}
-
-	return node.isEnd
-}
-
-// InsertAll adds multiple prefixes to the trie in a single operation
-func (t *prefixTrie) InsertAll(prefixes []string) {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-
-	for _, prefix := range prefixes {
-		if prefix == "" {
-			continue
-		}
-
-		node := t.root
-		for _, ch := range prefix {
-			if node.children[ch] == nil {
-				node.children[ch] = &trieNode{
-					children: make(map[rune]*trieNode),
-				}
-			}
-			node = node.children[ch]
-		}
-		node.isEnd = true
-	}
-}
-
-// Size returns the number of prefixes stored in the trie
-func (t *prefixTrie) Size() int {
-	t.mu.RLock()
-	defer t.mu.RUnlock()
-
-	return t.countPrefixes(t.root)
-}
-
-// countPrefixes recursively counts the number of complete prefixes in the trie
-func (t *prefixTrie) countPrefixes(node *trieNode) int {
-	if node == nil {
-		return 0
-	}
-
-	count := 0
-	if node.isEnd {
-		count = 1
-	}
-
-	for _, child := range node.children {
-		count += t.countPrefixes(child)
-	}
-
-	return count
-}
-
-// Clear removes all prefixes from the trie
-func (t *prefixTrie) Clear() {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-
-	t.root = &trieNode{
-		children: make(map[rune]*trieNode),
-	}
-}
-
 // segmentPrefixTrie is a path segment-based trie optimized for "/" delimited paths.
 // It stores path segments (e.g., "github.com", "DataDog") as nodes instead of individual characters,
 // providing better memory efficiency and potentially faster lookups for module paths.

internal/stacktrace/trie_benchmark_test.go

@@ -84,18 +84,6 @@ func BenchmarkLinearSearch_BulkLookups(b *testing.B) {
 	}
 }
 
-func BenchmarkTrie_BulkLookups(b *testing.B) {
-	trie := newPrefixTrie()
-	trie.InsertAll(benchmarkPrefixes)
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		for _, testStr := range benchmarkTestStrings {
-			_ = trie.HasPrefix(testStr)
-		}
-	}
-}
-
 func BenchmarkSegmentTrie_BulkLookups(b *testing.B) {
 	trie := newSegmentPrefixTrie()
 	trie.InsertAll(benchmarkPrefixes)
@@ -121,17 +109,6 @@ func BenchmarkLinearSearch_SingleLookup_EarlyMatch(b *testing.B) {
 	}
 }
 
-func BenchmarkTrie_SingleLookup_EarlyMatch(b *testing.B) {
-	trie := newPrefixTrie()
-	trie.InsertAll(benchmarkPrefixes)
-	testStr := "cloud.google.com/go/storage/internal"
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		_ = trie.HasPrefix(testStr)
-	}
-}
-
 func BenchmarkSegmentTrie_SingleLookup_EarlyMatch(b *testing.B) {
 	trie := newSegmentPrefixTrie()
 	trie.InsertAll(benchmarkPrefixes)
@@ -156,17 +133,6 @@ func BenchmarkLinearSearch_SingleLookup_NoMatch(b *testing.B) {
 	}
 }
 
-func BenchmarkTrie_SingleLookup_NoMatch(b *testing.B) {
-	trie := newPrefixTrie()
-	trie.InsertAll(benchmarkPrefixes)
-	testStr := "example.com/mycompany/internal/service"
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		_ = trie.HasPrefix(testStr)
-	}
-}
-
 func BenchmarkSegmentTrie_SingleLookup_NoMatch(b *testing.B) {
 	trie := newSegmentPrefixTrie()
 	trie.InsertAll(benchmarkPrefixes)
@@ -187,14 +153,6 @@ func BenchmarkLinearSearch_Construction(b *testing.B) {
 	}
 }
 
-func BenchmarkTrie_Construction(b *testing.B) {
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		trie := newPrefixTrie()
-		trie.InsertAll(benchmarkPrefixes)
-	}
-}
-
 func BenchmarkSegmentTrie_Construction(b *testing.B) {
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
@@ -216,18 +174,6 @@ func BenchmarkLinearSearch_LookupAllocations(b *testing.B) {
 	}
 }
 
-func BenchmarkTrie_LookupAllocations(b *testing.B) {
-	trie := newPrefixTrie()
-	trie.InsertAll(benchmarkPrefixes)
-	testStr := "github.com/test/package/internal"
-	b.ResetTimer()
-	b.ReportAllocs()
-
-	for i := 0; i < b.N; i++ {
-		_ = trie.HasPrefix(testStr)
-	}
-}
-
 func BenchmarkSegmentTrie_LookupAllocations(b *testing.B) {
 	trie := newSegmentPrefixTrie()
 	trie.InsertAll(benchmarkPrefixes)
@@ -240,21 +186,6 @@ func BenchmarkSegmentTrie_LookupAllocations(b *testing.B) {
 	}
 }
 
-// Concurrent access benchmark
-
-func BenchmarkTrie_Parallel(b *testing.B) {
-	trie := newPrefixTrie()
-	trie.InsertAll(benchmarkPrefixes)
-	testStr := "cloud.google.com/go/storage/internal"
-	b.ResetTimer()
-
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			_ = trie.HasPrefix(testStr)
-		}
-	})
-}
-
 // Data structure memory overhead comparison
 // This measures the memory cost of the data structure itself, not lookup allocations
 
@@ -274,21 +205,6 @@ func BenchmarkDataStructureMemoryOverhead(b *testing.B) {
 			m2.Alloc-m1.Alloc, len(benchmarkPrefixes))
 	})
 
-	b.Run("Trie_DataStructure", func(b *testing.B) {
-		var m1, m2 runtime.MemStats
-		runtime.GC()
-		runtime.ReadMemStats(&m1)
-
-		trie := newPrefixTrie()
-		trie.InsertAll(benchmarkPrefixes)
-
-		runtime.GC()
-		runtime.ReadMemStats(&m2)
-		b.ReportMetric(float64(m2.Alloc-m1.Alloc), "bytes_overhead")
-		b.Logf("Character trie data structure overhead: %d bytes for %d prefixes",
-			m2.Alloc-m1.Alloc, len(benchmarkPrefixes))
-	})
-
 	b.Run("SegmentTrie_DataStructure", func(b *testing.B) {
 		var m1, m2 runtime.MemStats
 		runtime.GC()
@@ -308,21 +224,13 @@ func BenchmarkDataStructureMemoryOverhead(b *testing.B) {
 // Test correctness - ensure all implementations return the same results
 func TestImplementationConsistency(t *testing.T) {
 	linear := newLinearPrefixMatcher(benchmarkPrefixes)
-	charTrie := newPrefixTrie()
-	charTrie.InsertAll(benchmarkPrefixes)
 	segmentTrie := newSegmentPrefixTrie()
 	segmentTrie.InsertAll(benchmarkPrefixes)
 
 	for _, testStr := range benchmarkTestStrings {
 		linearResult := linear.HasPrefix(testStr)
-		charTrieResult := charTrie.HasPrefix(testStr)
 		segmentTrieResult := segmentTrie.HasPrefix(testStr)
 
-		if linearResult != charTrieResult {
-			t.Errorf("Linear vs Character Trie mismatch for %q: linear=%v, charTrie=%v",
-				testStr, linearResult, charTrieResult)
-		}
-
 		if linearResult != segmentTrieResult {
 			t.Errorf("Linear vs Segment Trie mismatch for %q: linear=%v, segmentTrie=%v",
 				testStr, linearResult, segmentTrieResult)