fix(otlp): add explicit test case for negative structured metadata bytes

Signed-off-by: Jordan Rushing <rushing.jordan@gmail.com>

Author: JordanRushing

pkg/loghttp/push/otlp_test.go

@@ -987,8 +987,6 @@ func TestOTLPLogAttributesAsIndexLabels(t *testing.T) {
 func TestOTLPStructuredMetadataCalculation(t *testing.T) {
 	now := time.Unix(0, time.Now().UnixNano())
 
-	// Create test with resource, scope, and entry metadata that would previously cause negative calculations
-	// when subtracting resource/scope attribute sizes from the total structured metadata size
 	generateLogs := func() plog.Logs {
 		ld := plog.NewLogs()
 
@@ -1069,6 +1067,88 @@ func TestOTLPStructuredMetadataCalculation(t *testing.T) {
 	require.True(t, entryMetadataFound, "Entry metadata should be present in the entry")
 }
 
+func TestNegativeMetadataScenarioExplicit(t *testing.T) {
+	// This test explicitly demonstrates how negative structured metadata size values
+	// could occur when subtracting resource/scope attributes from total structured metadata size
+
+	// Setup: Create metadata with a label that would be excluded from size calculation
+	resourceMeta := push.LabelsAdapter{
+		{Name: "resource_key", Value: "resource_value"}, // 27 bytes
+		{Name: "excluded_label", Value: "value"},        // This would be excluded from size calculation
+	}
+
+	scopeMeta := push.LabelsAdapter{
+		{Name: "scope_key", Value: "scope_value"}, // 21 bytes
+	}
+
+	entryMeta := push.LabelsAdapter{
+		{Name: "entry_key", Value: "entry_value"}, // 21 bytes
+	}
+
+	// ExcludedStructuredMetadataLabels would exclude certain labels
+	// from size calculations.
+	calculateSize := func(labels push.LabelsAdapter) int {
+		size := 0
+		for _, label := range labels {
+			// Simulate a label being excluded from size calc
+			if label.Name != "excluded_label" {
+				size += len(label.Name) + len(label.Value)
+			}
+		}
+		return size
+	}
+
+	// Calculate sizes with simulated exclusions
+	resourceSize := calculateSize(resourceMeta) // 27 bytes (excluded_label not counted)
+	scopeSize := calculateSize(scopeMeta)       // 21 bytes
+	entrySize := calculateSize(entryMeta)       // 21 bytes
+
+	// The original approach:
+	// 1. Add resource and scope attributes to entry metadata
+	combined := make(push.LabelsAdapter, 0)
+	combined = append(combined, entryMeta...)
+	combined = append(combined, resourceMeta...)
+	combined = append(combined, scopeMeta...)
+
+	// 2. Calculate combined size (with certain labels excluded)
+	combinedSize := calculateSize(combined) // Should be 27 + 21 + 21 = 69 bytes
+
+	// 3. Calculate entry-specific metadata by subtraction
+	//    metadataSize := int64(combinedSize - resourceSize - scopeSize)
+	oldCalculation := combinedSize - resourceSize - scopeSize
+
+	// Should be: 69 - 27 - 21 = 21 bytes, which equals entrySize
+
+	t.Logf("Resource size: %d bytes", resourceSize)
+	t.Logf("Scope size: %d bytes", scopeSize)
+	t.Logf("Entry size: %d bytes", entrySize)
+	t.Logf("Combined size: %d bytes", combinedSize)
+	t.Logf("Old calculation (combined - resource - scope): %d bytes", oldCalculation)
+
+	// Now, to demonstrate how this could produce negative values:
+	// In reality, due to potential inconsistencies in how labels were excluded/combined/normalized,
+	// the combined size could be LESS than the sum of parts
+	simulatedRealCombinedSize := resourceSize + scopeSize - 5 // 5 bytes less than sum
+
+	// Using the original calculation method:
+	simulatedRealCalculation := simulatedRealCombinedSize - resourceSize - scopeSize
+	// This will be: (27 + 21 - 5) - 27 - 21 = 43 - 48 = -5 bytes
+
+	t.Logf("Simulated real combined size: %d bytes", simulatedRealCombinedSize)
+	t.Logf("Simulated real calculation (old method): %d bytes", simulatedRealCalculation)
+
+	// This would be a negative value!
+	require.Less(t, simulatedRealCalculation, 0,
+		"This demonstrates how the old calculation could produce negative values")
+
+	// Directly use entry's size before combining
+	t.Logf("New calculation (direct entry size): %d bytes", entrySize)
+	require.Equal(t, entrySize, 20,
+		"New calculation provides correct entry size")
+	require.Greater(t, entrySize, 0,
+		"New calculation always produces non-negative values")
+}
+
 func TestOTLPSeverityTextAsLabel(t *testing.T) {
 	now := time.Unix(0, time.Now().UnixNano())