[exporter/loadbalancing] Stabilize attribute routing keys and non-string value handling (#46420)

#### Description

- Implement stable attribute routing key encoding for loadbalancing
exporter as `name=value|` segments with explicit missing markers
(`name=|`) across traces and metrics.
- Centralize attribute value conversion in `attribute_routing.go` so
routing key stringification logic lives in one place and is reused by
both signals.
- Add/update tests for:
  - collision avoidance with segmented keys
  - non-string attribute routing behavior
  - deterministic map/slice stringification behavior
- Update docs/changelog to document the routing key format and
non-string handling.

<!-- Issue number (e.g. #1234) or full URL to issue, if applicable. -->
#### Link to tracking issue
Resolve #46094
Resolve #46095

<!--Describe what testing was performed and which tests were added.-->
#### Testing

Added unit test for attribute routing.

#### Documentation

Updated `exporter/loadbalancingexporter/README.md` to describe attribute
routing logic.

---------

Co-authored-by: Antonio Jimenez <antonjim@thousandEyes.com>
Co-authored-by: Andrew Wilkins <axw@elastic.co>

Author: 3 people

.chloggen/feat_46094_46095.yaml

@@ -0,0 +1,29 @@
+# Use this changelog template to create an entry for release notes.
+
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: "enhancement"
+
+# The name of the component, or a single word describing the area of concern, (e.g. receiver/filelog)
+component: "exporter/loadbalancing"
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: "Add stable attribute routing key encoding for traces and metrics in the loadbalancing exporter"
+
+# Mandatory: One or more tracking issues related to the change. You can use the PR number here if no issue exists.
+issues: [46094, 46095]
+
+# (Optional) One or more lines of additional information to render under the primary note.
+# These lines will be padded with 2 spaces and then inserted directly into the document.
+# Use pipe (|) for multiline entries.
+subtext: |
+  Routing keys now encode attributes as `name=value|` segments, including explicit markers for missing attributes.
+  Non-string attribute values are deterministically stringified and used consistently across traces and metrics.
+
+# If your change doesn't affect end users or the exported elements of any package,
+# you should instead start your pull request title with [chore] or use the "Skip Changelog" label.
+# Optional: The change log or logs in which this entry should be included.
+# e.g. '[user]' or '[user, api]'
+# Include 'user' if the change is relevant to end users.
+# Include 'api' if there is a change to a library API.
+# Default: '[user]'
+change_logs: [user]

exporter/loadbalancingexporter/README.md

@@ -124,7 +124,7 @@ Refer to [config.yaml](./testdata/config.yaml) for detailed examples on using th
   * `metric`: Routes metrics based on their metric name. Invalid for spans.
   * `streamID`: Routes metrics based on their datapoint streamID. That's the unique hash of all it's attributes, plus the attributes and identifying information of its resource, scope, and metric data.
 * loadbalancing exporter supports set of standard [queuing, retry and timeout settings](https://github.com/open-telemetry/opentelemetry-collector/blob/main/exporter/exporterhelper/README.md), but they are disable by default to maintain compatibility
-* The `routing_attributes` property is used to list the attributes that should be used if the `routing_key` is `attributes`.
+* The `routing_attributes` property is used to list the attributes that should be used if the `routing_key` is `attributes`. For both traces and metrics, keys are encoded in configured order as `name=value|name=value|`, and missing attributes are encoded as `name=|`. Non-string values are deterministically stringified.
 
 Simple example
 

exporter/loadbalancingexporter/attribute_routing.go

@@ -0,0 +1,25 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package loadbalancingexporter // import "github.com/open-telemetry/opentelemetry-collector-contrib/exporter/loadbalancingexporter"
+
+import (
+	"go.opentelemetry.io/collector/pdata/pcommon"
+)
+
+// buildAttributeRoutingKey encodes a missing attribute as "name=|".
+func buildAttributeRoutingKey(attr string) string {
+	return attr + "=|"
+}
+
+// buildAttributeRoutingKeyStrValue encodes a single string attribute key/value pair as
+// "name=value|".
+func buildAttributeRoutingKeyStrValue(attr, value string) string {
+	return attr + "=" + value + "|"
+}
+
+// buildAttributeRoutingKeyValue encodes a single attribute key/value pair as
+// "name=value|".
+func buildAttributeRoutingKeyValue(attr string, value pcommon.Value) string {
+	return attr + "=" + value.AsString() + "|"
+}

exporter/loadbalancingexporter/attribute_routing_test.go

@@ -0,0 +1,60 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package loadbalancingexporter
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"go.opentelemetry.io/collector/pdata/pcommon"
+)
+
+func TestBuildAttributeRoutingKeyValue_Primitives(t *testing.T) {
+	tests := []struct {
+		name  string
+		value pcommon.Value
+		want  string
+	}{
+		{name: "string", value: pcommon.NewValueStr("abc"), want: "k=abc|"},
+		{name: "int", value: pcommon.NewValueInt(42), want: "k=42|"},
+		{name: "double", value: pcommon.NewValueDouble(3.5), want: "k=3.5|"},
+		{name: "bool", value: pcommon.NewValueBool(true), want: "k=true|"},
+		{name: "empty", value: pcommon.NewValueEmpty(), want: "k=|"},
+		{
+			name: "bytes",
+			value: func() pcommon.Value {
+				v := pcommon.NewValueBytes()
+				v.Bytes().FromRaw([]byte{0x01, 0xFF})
+				return v
+			}(),
+			want: "k=Af8=|",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			assert.Equal(t, tc.want, buildAttributeRoutingKeyValue("k", tc.value))
+		})
+	}
+}
+
+func TestBuildAttributeRoutingKeyValue_MapAndSliceDeterministic(t *testing.T) {
+	m1 := pcommon.NewValueMap()
+	m1.Map().PutInt("b", 2)
+	m1.Map().PutStr("a", "x")
+
+	m2 := pcommon.NewValueMap()
+	m2.Map().PutStr("a", "x")
+	m2.Map().PutInt("b", 2)
+
+	assert.Equal(t, "k={\"a\":\"x\",\"b\":2}|", buildAttributeRoutingKeyValue("k", m1))
+	assert.Equal(t, buildAttributeRoutingKeyValue("k", m1), buildAttributeRoutingKeyValue("k", m2))
+
+	s := pcommon.NewValueSlice()
+	s.Slice().AppendEmpty().SetInt(1)
+	s.Slice().AppendEmpty().SetStr("x")
+	s.Slice().AppendEmpty().SetBool(false)
+
+	assert.Equal(t, "k=[1,\"x\",false]|", buildAttributeRoutingKeyValue("k", s))
+}

exporter/loadbalancingexporter/config.go

@@ -51,6 +51,8 @@ type Config struct {
 	// For traces, attributes can come from resource, scope, or span, plus the pseudo attributes "span.kind" and
 	// "span.name".
 	// For metrics, attributes can come from resource, scope, or datapoint attributes.
+	// Keys are encoded as "name=value|name=value|" in the order configured. Missing attributes are encoded as "name=|".
+	// Non-string values are deterministically stringified.
 	RoutingAttributes []string `mapstructure:"routing_attributes"`
 }
 

exporter/loadbalancingexporter/config.schema.yaml

@@ -86,7 +86,7 @@ properties:
   resolver:
     $ref: resolver_settings
   routing_attributes:
-    description: RoutingAttributes creates a composite routing key from the listed attributes. For traces, attributes can come from resource, scope, or span, plus the pseudo attributes "span.kind" and "span.name". For metrics, attributes can come from resource, scope, or datapoint attributes.
+    description: RoutingAttributes creates a composite routing key from the listed attributes. For traces, attributes can come from resource, scope, or span, plus the pseudo attributes "span.kind" and "span.name". For metrics, attributes can come from resource, scope, or datapoint attributes. Keys are encoded as "name=value|name=value|" in the order configured. Missing attributes are encoded as "name=|". Non-string values are deterministically stringified.
     type: array
     items:
       type: string

exporter/loadbalancingexporter/generated_package_test.go

@@ -6,6 +6,7 @@ package loadbalancingexporter
 import (
 	"context"
 	"errors"
+	"net"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -145,6 +146,14 @@ func TestWithDNSResolverNoEndpoints(t *testing.T) {
 	require.NotNil(t, p)
 	require.NoError(t, err)
 
+	dnsRes, ok := p.res.(*dnsResolver)
+	require.True(t, ok)
+	dnsRes.resolver = &mockDNSResolver{
+		onLookupIPAddr: func(context.Context, string) ([]net.IPAddr, error) {
+			return nil, nil
+		},
+	}
+
 	err = p.Start(t.Context(), componenttest.NewNopHost())
 	require.NoError(t, err)
 	defer func() { assert.NoError(t, p.Shutdown(t.Context())) }()

exporter/loadbalancingexporter/loadbalancer_test.go

@@ -73,6 +73,7 @@ func TestLogExporterStart(t *testing.T) {
 			"ok",
 			func() *logExporterImp {
 				p, _ := newLogsExporter(exportertest.NewNopSettings(metadata.Type), simpleConfig())
+				p.loadBalancer.res = &mockResolver{}
 				return p
 			}(),
 			nil,

exporter/loadbalancingexporter/log_exporter_test.go

@@ -96,4 +96,5 @@ tests:
         # Ignore goroutines spawned by net.Resolver for DNS lookups on Windows
         # These can remain in syscall state during test cleanup
         - internal/poll.runtime_pollWait
+        - syscall.SyscallN
         - syscall.Syscall6