feat(ext/telemetry): honor OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT (#34787)

This honors the OpenTelemetry SDK attribute-count limit environment
variables for spans, which were previously ignored (spans recorded an
unbounded number of attributes).

Resolution order (per spec):
1. `OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT`
2. `OTEL_ATTRIBUTE_COUNT_LIMIT` (general fallback)
3. default `128`

Once a span's (or span event's / link's) attribute collection reaches
the limit, additional attributes are dropped and counted in
`droppedAttributesCount`, as required by the spec. When neither env var
is set, the default of 128 preserves existing behavior.

Author: crowlbot

ext/telemetry/lib.rs

@@ -945,6 +945,7 @@ pub struct OtelGlobals {
   pub id_generator: DenoIdGenerator,
   pub meter_provider: SdkMeterProvider,
   pub builtin_instrumentation_scope: InstrumentationScope,
+  pub span_attribute_count_limit: usize,
   pub sampler: Sampler,
   pub config: OtelConfig,
 }
@@ -959,6 +960,40 @@ impl OtelGlobals {
   }
 }
 
+/// Default maximum number of attributes per span (and per span event / link),
+/// as defined by the OpenTelemetry SDK spec for `OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT`
+/// (and `OTEL_ATTRIBUTE_COUNT_LIMIT`).
+const DEFAULT_ATTRIBUTE_COUNT_LIMIT: usize = 128;
+
+/// Resolve the span attribute count limit from the environment, honoring
+/// `OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT` and falling back to the general
+/// `OTEL_ATTRIBUTE_COUNT_LIMIT`, then to the spec default of 128.
+///
+/// See <https://opentelemetry.io/docs/specs/otel/configuration/sdk-environment-variables/#attribute-limits>
+fn span_attribute_count_limit_from_env(sys: &impl TelemetrySys) -> usize {
+  [
+    "OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT",
+    "OTEL_ATTRIBUTE_COUNT_LIMIT",
+  ]
+  .into_iter()
+  .find_map(|name| {
+    sys
+      .env_var(name)
+      .ok()
+      .and_then(|v| v.trim().parse::<usize>().ok())
+  })
+  .unwrap_or(DEFAULT_ATTRIBUTE_COUNT_LIMIT)
+}
+
+/// The effective span attribute count limit from the initialized globals,
+/// falling back to the spec default if telemetry is not yet initialized.
+fn attribute_count_limit() -> usize {
+  OTEL_GLOBALS
+    .get()
+    .map(|g| g.span_attribute_count_limit)
+    .unwrap_or(DEFAULT_ATTRIBUTE_COUNT_LIMIT)
+}
+
 /// Head-based trace sampler configured via the `OTEL_TRACES_SAMPLER` and
 /// `OTEL_TRACES_SAMPLER_ARG` environment variables.
 ///
@@ -1268,6 +1303,7 @@ pub fn init(
     DenoIdGenerator::random()
   };
 
+  let span_attribute_count_limit = span_attribute_count_limit_from_env(sys);
   let sampler = Sampler::from_env(sys)?;
 
   OTEL_GLOBALS
@@ -1277,6 +1313,7 @@ pub fn init(
       id_generator,
       meter_provider,
       builtin_instrumentation_scope,
+      span_attribute_count_limit,
       sampler,
       config,
     })
@@ -1584,16 +1621,17 @@ macro_rules! attr_raw {
 }
 
 macro_rules! attr {
-  ($scope:ident, $attributes:expr $(=> $dropped_attributes_count:expr)?, $name:expr, $value:expr) => {
-    let attr = attr_raw!($scope, $name, $value);
-    if let Some(kv) = attr {
+  ($scope:ident, $attributes:expr => $dropped_attributes_count:expr, $limit:expr, $name:expr, $value:expr) => {
+    // Enforce the configured per-element attribute count limit
+    // (`OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT`): once the limit is reached, further
+    // attributes are dropped and counted, matching the OpenTelemetry SDK spec.
+    if $attributes.len() >= $limit {
+      $dropped_attributes_count += 1;
+    } else if let Some(kv) = attr_raw!($scope, $name, $value) {
       $attributes.push(kv);
+    } else {
+      $dropped_attributes_count += 1;
     }
-    $(
-      else {
-        $dropped_attributes_count += 1;
-      }
-    )?
   };
 }
 
@@ -2213,14 +2251,15 @@ fn op_otel_span_attribute1<'s>(
   else {
     return;
   };
+  let limit = attribute_count_limit();
   let mut state = span.0.borrow_mut();
   if let OtelSpanState::Recording(span) = &mut **state {
     let Some((attributes, dropped_attributes_count)) =
       span_attributes(span, location)
     else {
       return;
     };
-    attr!(scope, attributes => *dropped_attributes_count, key, value);
+    attr!(scope, attributes => *dropped_attributes_count, limit, key, value);
   }
 }
 
@@ -2239,15 +2278,16 @@ fn op_otel_span_attribute2<'s>(
   else {
     return;
   };
+  let limit = attribute_count_limit();
   let mut state = span.0.borrow_mut();
   if let OtelSpanState::Recording(span) = &mut **state {
     let Some((attributes, dropped_attributes_count)) =
       span_attributes(span, location)
     else {
       return;
     };
-    attr!(scope, attributes => *dropped_attributes_count, key1, value1);
-    attr!(scope, attributes => *dropped_attributes_count, key2, value2);
+    attr!(scope, attributes => *dropped_attributes_count, limit, key1, value1);
+    attr!(scope, attributes => *dropped_attributes_count, limit, key2, value2);
   }
 }
 
@@ -2269,16 +2309,17 @@ fn op_otel_span_attribute3<'s>(
   else {
     return;
   };
+  let limit = attribute_count_limit();
   let mut state = span.0.borrow_mut();
   if let OtelSpanState::Recording(span) = &mut **state {
     let Some((attributes, dropped_attributes_count)) =
       span_attributes(span, location)
     else {
       return;
     };
-    attr!(scope, attributes => *dropped_attributes_count, key1, value1);
-    attr!(scope, attributes => *dropped_attributes_count, key2, value2);
-    attr!(scope, attributes => *dropped_attributes_count, key3, value3);
+    attr!(scope, attributes => *dropped_attributes_count, limit, key1, value1);
+    attr!(scope, attributes => *dropped_attributes_count, limit, key2, value2);
+    attr!(scope, attributes => *dropped_attributes_count, limit, key3, value3);
   }
 }
 

tests/specs/cli/otel_basic/__test__.jsonc

@@ -167,6 +167,13 @@
       },
       "output": "grpc_trailers_error.out"
     },
+    "span_attribute_limit": {
+      "args": "run -A main.ts span_attribute_limit.ts",
+      "envs": {
+        "OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT": "2"
+      },
+      "output": "span_attribute_limit.out"
+    },
     "traces_sampler_always_on": {
       "args": "run -A main.ts traces_sampler.ts",
       "envs": {

tests/specs/cli/otel_basic/span_attribute_limit.out

@@ -0,0 +1,40 @@
+{
+  "spans": [
+    {
+      "traceId": "00000000000000000000000000000001",
+      "spanId": "0000000000000001",
+      "traceState": "",
+      "parentSpanId": "",
+      "flags": 1,
+      "name": "span",
+      "kind": 1,
+      "startTimeUnixNano": "[WILDCARD]",
+      "endTimeUnixNano": "[WILDCARD]",
+      "attributes": [
+        {
+          "key": "a",
+          "value": {
+            "stringValue": "1"
+          }
+        },
+        {
+          "key": "b",
+          "value": {
+            "stringValue": "2"
+          }
+        }
+      ],
+      "droppedAttributesCount": 3,
+      "events": [],
+      "droppedEventsCount": 0,
+      "links": [],
+      "droppedLinksCount": 0,
+      "status": {
+        "message": "",
+        "code": 0
+      }
+    }
+  ],
+  "logs": [],
+  "metrics": []
+}

tests/specs/cli/otel_basic/span_attribute_limit.ts

@@ -0,0 +1,12 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+
+import { trace } from "npm:@opentelemetry/api@1.9.0";
+
+const tracer = trace.getTracer("example-tracer");
+
+tracer.startActiveSpan("span", (span) => {
+  // With OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT=2, only the first two attributes are
+  // recorded; the rest are dropped and counted in droppedAttributesCount.
+  span.setAttributes({ a: "1", b: "2", c: "3", d: "4", e: "5" });
+  span.end();
+});