Add memory helpers to tracing package (#2703)

Moved memory attribute helpers into tracing package and added tracing
for memory usage during blast radius calculation recursion

GitOrigin-RevId: d9770471a5f32fcc5fd00bbd447e33eb3d332335

Author: carabasdaniel

tracing/memory.go

@@ -0,0 +1,69 @@
+package tracing
+
+import (
+	"runtime"
+
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/trace"
+)
+
+// safeUint64ToInt64 safely converts uint64 to int64 for OpenTelemetry attributes
+// Returns int64 max value if the uint64 exceeds int64 maximum to prevent overflow
+func safeUint64ToInt64(val uint64) int64 {
+	const maxInt64 = 9223372036854775807 // 2^63 - 1
+	if val > maxInt64 {                  // Check if val exceeds int64 max
+		return maxInt64 // Return int64 max value
+	}
+	return int64(val)
+}
+
+// MemoryStats represents memory statistics at a point in time, converted to int64 for safe use
+type MemoryStats struct {
+	Alloc      int64 // bytes allocated and not yet freed
+	HeapAlloc  int64 // bytes allocated and not yet freed (same as Alloc above but specifically for heap objects)
+	Sys        int64 // total bytes of memory obtained from the OS
+	NumGC      int64 // number of completed GC cycles
+	PauseTotal int64 // cumulative nanoseconds in GC stop-the-world pauses
+}
+
+// ReadMemoryStats captures current memory statistics and converts them to int64
+func ReadMemoryStats() MemoryStats {
+	var memStats runtime.MemStats
+	runtime.ReadMemStats(&memStats)
+	return MemoryStats{
+		Alloc:      safeUint64ToInt64(memStats.Alloc),
+		HeapAlloc:  safeUint64ToInt64(memStats.HeapAlloc),
+		Sys:        safeUint64ToInt64(memStats.Sys),
+		NumGC:      int64(memStats.NumGC),
+		PauseTotal: safeUint64ToInt64(memStats.PauseTotalNs),
+	}
+}
+
+// SetMemoryAttributes sets memory-related attributes on a span with the given prefix
+func SetMemoryAttributes(span trace.Span, prefix string, memStats MemoryStats) {
+	span.SetAttributes(
+		attribute.Int64(prefix+".memoryBytes", memStats.Alloc),
+		attribute.Int64(prefix+".memoryHeapBytes", memStats.HeapAlloc),
+		attribute.Int64(prefix+".memorySysBytes", memStats.Sys),
+		attribute.Int64(prefix+".memoryNumGC", memStats.NumGC),
+		attribute.Int64(prefix+".memoryPauseTotalNs", memStats.PauseTotal),
+	)
+}
+
+// SetMemoryDeltaAttributes sets memory delta attributes on a span with the given prefix
+// It calculates the difference between before and after memory stats
+func SetMemoryDeltaAttributes(span trace.Span, prefix string, before, after MemoryStats) {
+	deltaAlloc := after.Alloc - before.Alloc
+	deltaHeapAlloc := after.HeapAlloc - before.HeapAlloc
+	deltaSys := after.Sys - before.Sys
+	deltaNumGC := after.NumGC - before.NumGC
+	deltaPauseTotal := after.PauseTotal - before.PauseTotal
+
+	span.SetAttributes(
+		attribute.Int64(prefix+".memoryDeltaBytes", deltaAlloc),
+		attribute.Int64(prefix+".memoryDeltaHeapBytes", deltaHeapAlloc),
+		attribute.Int64(prefix+".memoryDeltaSysBytes", deltaSys),
+		attribute.Int64(prefix+".memoryDeltaNumGC", deltaNumGC),
+		attribute.Int64(prefix+".memoryDeltaPauseTotalNs", deltaPauseTotal),
+	)
+}

tracing/memory_test.go

@@ -0,0 +1,75 @@
+package tracing
+
+import (
+	"testing"
+)
+
+func TestSafeUint64ToInt64(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		input    uint64
+		expected int64
+	}{
+		{
+			name:     "small value",
+			input:    1000,
+			expected: 1000,
+		},
+		{
+			name:     "int64 max value",
+			input:    9223372036854775807, // 2^63 - 1
+			expected: 9223372036854775807,
+		},
+		{
+			name:     "int64 max + 1",
+			input:    9223372036854775808, // 2^63
+			expected: 9223372036854775807, // Should be clamped to int64 max
+		},
+		{
+			name:     "very large value",
+			input:    18446744073709551615, // uint64 max
+			expected: 9223372036854775807,  // Should be clamped to int64 max
+		},
+	}
+
+	for _, tt := range tests {
+		test := tt // capture loop variable
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+			result := safeUint64ToInt64(test.input)
+			if result != test.expected {
+				t.Errorf("safeUint64ToInt64(%d) = %d, expected %d", test.input, result, test.expected)
+			}
+		})
+	}
+}
+
+func TestReadMemoryStats(t *testing.T) {
+	t.Parallel()
+
+	stats := ReadMemoryStats()
+
+	// Basic sanity checks - these values should be reasonable
+	if stats.Alloc <= 0 {
+		t.Errorf("Alloc should be greater than 0, got %d", stats.Alloc)
+	}
+	if stats.HeapAlloc <= 0 {
+		t.Errorf("HeapAlloc should be greater than 0, got %d", stats.HeapAlloc)
+	}
+	if stats.Sys <= 0 {
+		t.Errorf("Sys should be greater than 0, got %d", stats.Sys)
+	}
+
+	// Verify that values are within int64 range (they should be since we convert them)
+	if stats.Alloc < 0 {
+		t.Errorf("Alloc should not be negative, got %d", stats.Alloc)
+	}
+	if stats.HeapAlloc < 0 {
+		t.Errorf("HeapAlloc should not be negative, got %d", stats.HeapAlloc)
+	}
+	if stats.Sys < 0 {
+		t.Errorf("Sys should not be negative, got %d", stats.Sys)
+	}
+}