feat: add support for OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT

msierks-pcln · msierks-pcln · commit 3542d6cda373 · 2025-07-28T12:48:09.000-05:00
diff --git a/opentelemetry-sdk/src/trace/config.rs b/opentelemetry-sdk/src/trace/config.rs
@@ -43,6 +43,20 @@ impl Default for Config {
             config.span_limits.max_attributes_per_span = max_attributes_per_span;
         }
 
+        if let Some(max_attribute_value_length) = env::var("OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT")
+            .ok()
+            .and_then(|count_limit| i32::from_str(&count_limit).ok())
+        {
+            config.span_limits.max_attribute_value_length = max_attribute_value_length;
+        } else {
+            if let Some(max_attribute_value_length) = env::var("OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT")
+                .ok()
+                .and_then(|count_limit| i32::from_str(&count_limit).ok())
+            {
+                config.span_limits.max_attribute_value_length = max_attribute_value_length;
+            }
+        }
+
         if let Some(max_events_per_span) = env::var("OTEL_SPAN_EVENT_COUNT_LIMIT")
             .ok()
             .and_then(|max_events| u32::from_str(&max_events).ok())
diff --git a/opentelemetry-sdk/src/trace/provider.rs b/opentelemetry-sdk/src/trace/provider.rs
@@ -378,6 +378,12 @@ impl TracerProviderBuilder {
         self
     }
 
+    /// Specify the maximum allowed length of attribute values.
+    pub fn with_max_attribute_value_length(mut self, max_attribute_value_length: i32) -> Self {
+        self.config.span_limits.max_attribute_value_length = max_attribute_value_length;
+        self
+    }
+
     /// Specify the number of events to be recorded per span.
     pub fn with_max_links_per_span(mut self, max_links: u32) -> Self {
         self.config.span_limits.max_links_per_span = max_links;
diff --git a/opentelemetry-sdk/src/trace/span.rs b/opentelemetry-sdk/src/trace/span.rs
@@ -99,12 +99,21 @@ impl opentelemetry::trace::Span for Span {
     {
         let span_events_limit = self.span_limits.max_events_per_span as usize;
         let event_attributes_limit = self.span_limits.max_attributes_per_event as usize;
+        let span_attribute_value_limit = self.span_limits.max_attribute_value_length;
         self.with_data(|data| {
             if data.events.len() < span_events_limit {
                 let dropped_attributes_count =
                     attributes.len().saturating_sub(event_attributes_limit);
                 attributes.truncate(event_attributes_limit);
 
+                if span_attribute_value_limit > -1 {
+                    for attribute in attributes.iter_mut() {
+                        attribute
+                            .value
+                            .truncate(span_attribute_value_limit as usize);
+                    }
+                }
+
                 data.events.add_event(Event::new(
                     name,
                     timestamp,
@@ -134,10 +143,16 @@ impl opentelemetry::trace::Span for Span {
     /// Note that the OpenTelemetry project documents certain ["standard
     /// attributes"](https://github.com/open-telemetry/opentelemetry-specification/tree/v0.5.0/specification/trace/semantic_conventions/README.md)
     /// that have prescribed semantic meanings.
-    fn set_attribute(&mut self, attribute: KeyValue) {
+    fn set_attribute(&mut self, mut attribute: KeyValue) {
         let span_attribute_limit = self.span_limits.max_attributes_per_span as usize;
+        let span_attribute_value_limit = self.span_limits.max_attribute_value_length;
         self.with_data(|data| {
             if data.attributes.len() < span_attribute_limit {
+                if span_attribute_value_limit > -1 {
+                    attribute
+                        .value
+                        .truncate(span_attribute_value_limit as usize);
+                }
                 data.attributes.push(attribute);
             } else {
                 data.dropped_attributes_count += 1;
@@ -278,6 +293,7 @@ mod tests {
     use crate::trace::{SpanEvents, SpanLinks};
     use opentelemetry::trace::{self, SpanBuilder, TraceFlags, TraceId, Tracer};
     use opentelemetry::{trace::Span as _, trace::TracerProvider};
+    use opentelemetry::{Array, StringValue, Value};
     use std::time::Duration;
     use std::vec;
 
@@ -566,6 +582,59 @@ mod tests {
         );
     }
 
+    #[test]
+    fn exceed_span_attributes_value_length_limit() {
+        let max_attribute_value_length = 3;
+        let exporter = NoopSpanExporter::new();
+        let provider_builder = crate::trace::SdkTracerProvider::builder()
+            .with_simple_exporter(exporter)
+            .with_max_attribute_value_length(max_attribute_value_length);
+        let provider = provider_builder.build();
+        let tracer = provider.tracer("opentelemetry-test");
+
+        let mut initial_attributes = Vec::new();
+        initial_attributes.push(KeyValue::new("first", String::from("test data")));
+        initial_attributes.push(KeyValue::new(
+            "second",
+            Value::Array(
+                [
+                    StringValue::from("test data"),
+                    StringValue::from("test data, once again"),
+                ]
+                .to_vec()
+                .into(),
+            ),
+        ));
+        let span_builder = SpanBuilder::from_name("test_span").with_attributes(initial_attributes);
+
+        let mut span = tracer.build(span_builder);
+        span.set_attribute(KeyValue::new("third", "test data, after span builder"));
+
+        span.with_data(|data| {
+            assert_eq!(
+                data.attributes[0].value.as_str().len(),
+                max_attribute_value_length as usize,
+                "Span attribute values should be truncated to the max length"
+            );
+            if let Value::Array(attr) = &data.attributes[1].value {
+                if let Array::String(elems) = attr {
+                    for elem in elems {
+                        assert_eq!(
+                            elem.as_str().len(),
+                            max_attribute_value_length as usize,
+                            "Span attribute values should be truncated to the max length"
+                        );
+                    }
+                }
+            }
+            assert_eq!(
+                data.attributes[2].value.as_str().len(),
+                max_attribute_value_length as usize,
+                "Span attribute values should be truncated to the max length"
+            );
+        });
+    }
+
     #[test]
     fn exceed_event_attributes_limit() {
         let exporter = NoopSpanExporter::new();
diff --git a/opentelemetry-sdk/src/trace/span_limit.rs b/opentelemetry-sdk/src/trace/span_limit.rs
@@ -14,6 +14,7 @@
 /// index in the collection. The one added to collections later will be dropped first.
 pub(crate) const DEFAULT_MAX_EVENT_PER_SPAN: u32 = 128;
 pub(crate) const DEFAULT_MAX_ATTRIBUTES_PER_SPAN: u32 = 128;
+pub(crate) const DEFAULT_MAX_ATTRIBUTE_VALUE_LENGTH: i32 = -1;
 pub(crate) const DEFAULT_MAX_LINKS_PER_SPAN: u32 = 128;
 pub(crate) const DEFAULT_MAX_ATTRIBUTES_PER_EVENT: u32 = 128;
 pub(crate) const DEFAULT_MAX_ATTRIBUTES_PER_LINK: u32 = 128;
@@ -25,6 +26,8 @@ pub struct SpanLimits {
     pub max_events_per_span: u32,
     /// The max attributes that can be added to a `Span`.
     pub max_attributes_per_span: u32,
+    /// The max length of attribute values added to a `Span`.
+    pub max_attribute_value_length: i32,
     /// The max links that can be added to a `Span`.
     pub max_links_per_span: u32,
     /// The max attributes that can be added into an `Event`
@@ -38,6 +41,7 @@ impl Default for SpanLimits {
         SpanLimits {
             max_events_per_span: DEFAULT_MAX_EVENT_PER_SPAN,
             max_attributes_per_span: DEFAULT_MAX_ATTRIBUTES_PER_SPAN,
+            max_attribute_value_length: DEFAULT_MAX_ATTRIBUTE_VALUE_LENGTH,
             max_links_per_span: DEFAULT_MAX_LINKS_PER_SPAN,
             max_attributes_per_link: DEFAULT_MAX_ATTRIBUTES_PER_LINK,
             max_attributes_per_event: DEFAULT_MAX_ATTRIBUTES_PER_EVENT,
diff --git a/opentelemetry-sdk/src/trace/tracer.rs b/opentelemetry-sdk/src/trace/tracer.rs
@@ -73,6 +73,14 @@ impl SdkTracer {
             .saturating_sub(span_attributes_limit);
         attribute_options.truncate(span_attributes_limit);
         let dropped_attributes_count = dropped_attributes_count as u32;
+        let span_attribute_value_limit = span_limits.max_attribute_value_length;
+        if span_attribute_value_limit > -1 {
+            for attribute in attribute_options.iter_mut() {
+                attribute
+                    .value
+                    .truncate(span_attribute_value_limit as usize);
+            }
+        }
 
         // Links are available as Option<Vec<Link>> in the builder
         // If it is None, then there are no links to process.
diff --git a/opentelemetry/CHANGELOG.md b/opentelemetry/CHANGELOG.md
@@ -4,6 +4,7 @@
 
 - *Breaking* Change return type of `opentelemetry::global::set_tracer_provider` to Unit to align with metrics counterpart
 - Add `get_all` method to `opentelemetry::propagation::Extractor` to return all values of the given propagation key and provide a default implementation.
+- Add support for max span attribute value length; Applies to `Value::String` and `Array::String` only.
 
 ## 0.30.0
 
diff --git a/opentelemetry/src/common.rs b/opentelemetry/src/common.rs
@@ -263,6 +263,31 @@ impl StringValue {
     pub fn as_str(&self) -> &str {
         self.0.as_str()
     }
+
+    /// Shortens this `StringValue` to the specified character length.
+    pub fn truncate(&mut self, new_len: usize) {
+        let s = self.as_ref();
+        if s.len() > new_len {
+            let new_value = truncate_str(s, new_len).to_string();
+
+            match &self.0 {
+                OtelString::Owned(_) | OtelString::Static(_) => {
+                    self.0 = OtelString::Owned(new_value.into_boxed_str());
+                }
+                OtelString::RefCounted(_) => {
+                    self.0 = OtelString::RefCounted(Arc::from(new_value.as_str()))
+                }
+            }
+        }
+    }
+}
+
+/// Returns a str truncated to the specified character length.
+fn truncate_str(s: &str, new_len: usize) -> &str {
+    match s.char_indices().nth(new_len) {
+        None => s,
+        Some((idx, _)) => &s[..idx],
+    }
 }
 
 impl From<StringValue> for String {
@@ -327,6 +352,20 @@ impl Value {
             Value::Array(v) => format!("{v}").into(),
         }
     }
+
+    /// Shortens this `Value` to the specified length.
+    ///
+    /// Only String and Array(String) values are truncated.
+    pub fn truncate(&mut self, new_len: usize) {
+        match self {
+            Value::Array(ref mut a) => match a {
+                Array::String(ref mut v) => v.iter_mut().for_each(|s| s.truncate(new_len)),
+                _ => (),
+            },
+            Value::String(s) => s.truncate(new_len),
+            _ => (),
+        }
+    }
 }
 
 macro_rules! from_values {
@@ -628,7 +667,7 @@ impl InstrumentationScopeBuilder {
 mod tests {
     use std::hash::{Hash, Hasher};
 
-    use crate::{InstrumentationScope, KeyValue};
+    use crate::{Array, InstrumentationScope, KeyValue, Value};
 
     use rand::random;
     use std::collections::hash_map::DefaultHasher;
@@ -695,6 +734,81 @@ mod tests {
         }
     }
 
+    #[test]
+    fn value_truncate() {
+        for test in [
+            (0, Value::from(true), Value::from(true)),
+            (
+                0,
+                Value::Array(Array::Bool(vec![true, false])),
+                Value::Array(Array::Bool(vec![true, false])),
+            ),
+            (0, Value::from(42), Value::from(42)),
+            (
+                0,
+                Value::Array(Array::I64(vec![42, -1])),
+                Value::Array(Array::I64(vec![42, -1])),
+            ),
+            (0, Value::from(42.0), Value::from(42.0)),
+            (
+                0,
+                Value::Array(Array::F64(vec![42.0, -1.0])),
+                Value::Array(Array::F64(vec![42.0, -1.0])),
+            ),
+            (0, Value::from("value"), Value::from("")),
+            (
+                0,
+                Value::Array(Array::String(vec!["value-0".into(), "value-1".into()])),
+                Value::Array(Array::String(vec!["".into(), "".into()])),
+            ),
+            (1, Value::from("value"), Value::from("v")),
+            (
+                1,
+                Value::Array(Array::String(vec!["value-0".into(), "value-1".into()])),
+                Value::Array(Array::String(vec!["v".into(), "v".into()])),
+            ),
+            (5, Value::from("value"), Value::from("value")),
+            (
+                7,
+                Value::Array(Array::String(vec!["value-0".into(), "value-1".into()])),
+                Value::Array(Array::String(vec!["value-0".into(), "value-1".into()])),
+            ),
+            (
+                6,
+                Value::Array(Array::String(vec!["value".into(), "value-1".into()])),
+                Value::Array(Array::String(vec!["value".into(), "value-".into()])),
+            ),
+            (128, Value::from("value"), Value::from("value")),
+            (
+                128,
+                Value::Array(Array::String(vec!["value-0".into(), "value-1".into()])),
+                Value::Array(Array::String(vec!["value-0".into(), "value-1".into()])),
+            ),
+        ]
+        .iter_mut()
+        {
+            test.1.truncate(test.0);
+            assert_eq!(test.1, test.2)
+        }
+    }
+
+    #[test]
+    fn truncate_str() {
+        for test in [
+            (5, "", ""),
+            (0, "Zero", ""),
+            (10, "Short text", "Short text"),
+            (1, "Hello World!", "H"),
+            (6, "hello€€", "hello€"),
+            (2, "££££££", "££"),
+            (8, "hello€world", "hello€wo"),
+        ]
+        .iter()
+        {
+            assert_eq!(super::truncate_str(test.1, test.0), test.2);
+        }
+    }
+
     fn hash_helper<T: Hash>(item: &T) -> u64 {
         let mut hasher = DefaultHasher::new();
         item.hash(&mut hasher);
