otelconf: add support for tracer provider limits (#8687)

Signed-off-by: alex boten <223565+codeboten@users.noreply.github.com>

Author: codeboten

CHANGELOG.md

@@ -12,6 +12,7 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 - Configuration file can now be set via `OTEL_CONFIG_FILE` in `go.opentelemetry.io/contrib/otelconf`. (#8639)
 - Added support for `service` resource detector in `go.opentelemetry.io/contrib/otelconf`. (#8674)
+- Added support for `attribute_count_limit` and `attribute_value_length_limit` in tracer provider configuration in `go.opentelemetry.io/contrib/otelconf`. (#8687)
 - Added support for `attribute_count_limit` and `attribute_value_length_limit` in logger provider configuration in `go.opentelemetry.io/contrib/otelconf`. (#8686)
 
 ### Changed

otelconf/trace.go

@@ -48,10 +48,33 @@ func tracerProvider(cfg configOptions, res *resource.Resource) (trace.TracerProv
 	if len(errs) > 0 {
 		return noop.NewTracerProvider(), noopShutdown, errors.Join(errs...)
 	}
+
+	if cfg.opentelemetryConfig.TracerProvider.Limits != nil {
+		opts = spanProcessorLimits(opts, *cfg.opentelemetryConfig.TracerProvider.Limits)
+	}
 	tp := sdktrace.NewTracerProvider(opts...)
 	return tp, tp.Shutdown, nil
 }
 
+func spanProcessorLimits(opts []sdktrace.TracerProviderOption, limits SpanLimits) []sdktrace.TracerProviderOption {
+	spanLimits := sdktrace.NewSpanLimits()
+	hasLimits := false
+
+	if limits.AttributeCountLimit != nil {
+		spanLimits.AttributeCountLimit = *limits.AttributeCountLimit
+		hasLimits = true
+	}
+	if limits.AttributeValueLengthLimit != nil {
+		spanLimits.AttributeValueLengthLimit = *limits.AttributeValueLengthLimit
+		hasLimits = true
+	}
+
+	if hasLimits {
+		opts = append(opts, sdktrace.WithRawSpanLimits(spanLimits))
+	}
+	return opts
+}
+
 func parentBasedSampler(s *ParentBasedSampler) (sdktrace.Sampler, error) {
 	var rootSampler sdktrace.Sampler
 	var opts []sdktrace.ParentBasedSamplerOption

otelconf/trace_test.go

@@ -109,11 +109,29 @@ func TestTracerProvider(t *testing.T) {
 			wantProvider: noop.NewTracerProvider(),
 			wantErr:      errInvalidSamplerConfiguration,
 		},
+		{
+			name: "with-limits",
+			cfg: configOptions{
+				opentelemetryConfig: OpenTelemetryConfiguration{
+					TracerProvider: &TracerProvider{
+						Limits: &SpanLimits{
+							AttributeCountLimit:       ptr(50),
+							AttributeValueLengthLimit: ptr(100),
+						},
+					},
+				},
+			},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			tp, shutdown, err := tracerProvider(tt.cfg, resource.Default())
-			require.Equal(t, tt.wantProvider, tp)
+			if tt.wantProvider != nil {
+				require.Equal(t, tt.wantProvider, tp)
+			} else {
+				require.NotNil(t, tp)
+				require.IsType(t, &sdktrace.TracerProvider{}, tp)
+			}
 			assert.ErrorIs(t, err, tt.wantErr)
 			require.NoError(t, shutdown(t.Context()))
 		})
@@ -170,6 +188,51 @@ func TestTracerProviderOptions(t *testing.T) {
 	assert.NotContains(t, buf.String(), "foo")
 }
 
+func TestSpanProcessorLimits(t *testing.T) {
+	tests := []struct {
+		name               string
+		limits             SpanLimits
+		wantAdditionalOpts int
+	}{
+		{
+			name:               "no-limits",
+			limits:             SpanLimits{},
+			wantAdditionalOpts: 0,
+		},
+		{
+			name: "attribute-count-limit-only",
+			limits: SpanLimits{
+				AttributeCountLimit: ptr(50),
+			},
+			wantAdditionalOpts: 1,
+		},
+		{
+			name: "attribute-value-length-limit-only",
+			limits: SpanLimits{
+				AttributeValueLengthLimit: ptr(100),
+			},
+			wantAdditionalOpts: 1,
+		},
+		{
+			name: "both-limits",
+			limits: SpanLimits{
+				AttributeCountLimit:       ptr(50),
+				AttributeValueLengthLimit: ptr(100),
+			},
+			wantAdditionalOpts: 1,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			initialOpts := []sdktrace.TracerProviderOption{}
+			result := spanProcessorLimits(initialOpts, tt.limits)
+
+			assert.Len(t, result, tt.wantAdditionalOpts, "unexpected number of options returned")
+		})
+	}
+}
+
 func TestSpanProcessor(t *testing.T) {
 	consoleExporter, err := stdouttrace.New(
 		stdouttrace.WithPrettyPrint(),