feat(stacktrace): optimize parseSymbol with zero-allocation implementation

Replace regex-based symbol parsing with string operations to eliminate
per-frame allocations in stack capture.

Performance improvements:
- parseSymbol: 0 allocs/op (was ~2 allocs/op)
- BenchmarkCaptureWithRedaction/depth_10: 38→6 allocs/op (84% reduction)
- BenchmarkCaptureWithRedaction/depth_50: 118→6 allocs/op (95% reduction)
- Speed: 19.2µs→4.1µs @ depth=10 (79% faster)
- Memory: 8966B→5296B @ depth=10 (41% reduction)

Allocations are now constant regardless of stack depth.

Author: kakkoyun

internal/stacktrace/parse_symbol_bench_test.go

@@ -0,0 +1,26 @@
+// Unless explicitly stated otherwise all files in this repository are licensed
+// under the Apache License Version 2.0.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2016 Datadog, Inc.
+
+package stacktrace
+
+import "testing"
+
+func BenchmarkParseSymbol(b *testing.B) {
+	testCases := []string{
+		"github.com/DataDog/dd-trace-go/v2/internal/stacktrace.TestFunc",
+		"github.com/DataDog/dd-trace-go/v2/internal/stacktrace.(*Event).NewException",
+		"github.com/DataDog/dd-trace-go/v2/internal/stacktrace.TestFunc.func1",
+		"os/exec.(*Cmd).Run.func1",
+		"test.(*Test).Method",
+		"test.main",
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		for _, tc := range testCases {
+			_ = parseSymbol(tc)
+		}
+	}
+}

internal/stacktrace/stacktrace.go

@@ -10,7 +10,6 @@ package stacktrace
 
 import (
 	"errors"
-	"regexp"
 	"runtime"
 	"slices"
 	"strconv"
@@ -179,28 +178,70 @@ func (q *queue[T]) Remove() T {
 	return item
 }
 
-var symbolRegex = regexp.MustCompile(`^(([^(]+/)?([^(/.]+)?)(\.\(([^/)]+)\))?\.([^/()]+)$`)
-
-// parseSymbol parses a symbol name into its package, receiver and function
-// ex: github.com/DataDog/dd-trace-go/v2/internal/stacktrace.(*Event).NewException
-// -> package: github.com/DataDog/dd-trace-go/v2/internal/stacktrace
-// -> receiver: *Event
-// -> function: NewException
+// parseSymbol parses a symbol name into its package, receiver and function using
+// zero-allocation string operations. This is a hot path called once per stack frame.
+//
+// Handles various Go symbol formats:
+//   - Simple function: pkg.Function
+//   - Method with receiver: pkg.(*Type).Method or pkg.(Type).Method
+//   - Lambda/closure: pkg.Function.func1 or pkg.(*Type).Method.func1
+//   - Generics: pkg.(*Type[...]).Method or pkg.Function[...]
+//
+// Examples:
+//   github.com/DataDog/dd-trace-go/v2/internal/stacktrace.(*Event).NewException
+//     -> package: github.com/DataDog/dd-trace-go/v2/internal/stacktrace
+//     -> receiver: *Event
+//     -> function: NewException
+//   github.com/DataDog/dd-trace-go/v2/internal/stacktrace.TestFunc.func1
+//     -> package: github.com/DataDog/dd-trace-go/v2/internal/stacktrace
+//     -> receiver: ""
+//     -> function: TestFunc.func1
 func parseSymbol(name string) symbol {
-	matches := symbolRegex.FindStringSubmatch(name)
-	if len(matches) != 7 {
-		log.Error("Failed to parse symbol for stacktrace: %s", name)
-		return symbol{
-			Package:  "",
-			Receiver: "",
-			Function: "",
+	// Check for receiver first: pkg.(*Type) or pkg.(Type)
+	// Look for ".(" which marks the start of a receiver
+	if idx := strings.Index(name, ".("); idx != -1 {
+		// Find the closing paren of the receiver
+		receiverEnd := strings.IndexByte(name[idx+2:], ')')
+		if receiverEnd != -1 {
+			pkg := name[:idx]
+			receiver := name[idx+2 : idx+2+receiverEnd]
+			// Everything after ")." is the function (which may contain dots for lambdas)
+			fn := name[idx+2+receiverEnd+2:] // +2 for ")."
+			return symbol{
+				Package:  pkg,
+				Receiver: receiver,
+				Function: fn,
+			}
 		}
 	}
 
+	// No receiver case: need to find where package ends and function begins
+	// Package path ends at the last '/' followed by a segment before first '.'
+	// Examples:
+	//   "pkg.Function" -> pkg: "pkg", fn: "Function"
+	//   "pkg.Function.func1" -> pkg: "pkg", fn: "Function.func1"
+	//   "github.com/org/pkg.Function" -> pkg: "github.com/org/pkg", fn: "Function"
+
+	// Find the last slash to identify where the package name starts
+	lastSlash := strings.LastIndexByte(name, '/')
+
+	// Find the first dot after the last slash (or from the beginning if no slash)
+	searchStart := 0
+	if lastSlash != -1 {
+		searchStart = lastSlash + 1
+	}
+
+	firstDotAfterSlash := strings.IndexByte(name[searchStart:], '.')
+	if firstDotAfterSlash == -1 {
+		// No dots after last slash, the whole thing is the function name
+		return symbol{Function: name}
+	}
+
+	// Package ends at this dot, function starts after it
+	pkgEnd := searchStart + firstDotAfterSlash
 	return symbol{
-		Package:  matches[1],
-		Receiver: matches[5],
-		Function: matches[6],
+		Package:  name[:pkgEnd],
+		Function: name[pkgEnd+1:], // Everything after the dot, including nested dots for lambdas
 	}
 }