refactor: avoid instrumentation_scope clone for every single span processor

Author: taisho6339

opentelemetry-proto/src/transform/trace.rs

@@ -125,7 +125,7 @@ pub mod tonic {
                         .schema_url()
                         .map(ToOwned::to_owned)
                         .unwrap_or_default(),
-                    scope: Some((source_span.instrumentation_scope, None).into()),
+                    scope: Some((source_span.instrumentation_scope.as_ref().clone(), None).into()),
                     spans: vec![Span {
                         trace_id: source_span.span_context.trace_id().to_bytes().to_vec(),
                         span_id: source_span.span_context.span_id().to_bytes().to_vec(),

opentelemetry-sdk/benches/span.rs

@@ -32,6 +32,11 @@ use opentelemetry_sdk::{
 use pprof::criterion::{Output, PProfProfiler};
 
 fn criterion_benchmark(c: &mut Criterion) {
+    // Benchmark to measure the effect of Arc<InstrumentationScope> optimization
+    // This benchmark creates spans with multiple processors to demonstrate
+    // the performance improvement when using Arc instead of cloning InstrumentationScope
+    span_end_multiple_processors(c);
+
     trace_benchmark_group(c, "span-creation-simple", |tracer| {
         // Simple span creation
         // There is not ability to specify anything other than the name.
@@ -134,6 +139,43 @@ impl SpanExporter for VoidExporter {
     }
 }
 
+/// Benchmark span end with multiple processors
+///
+/// This benchmark demonstrates the performance benefit of using Arc instead of cloning
+/// InstrumentationScope for each processor. The benefit scales with the number of processors:
+/// - With 1 processor: minimal difference (baseline)
+/// - With 3+ processors: significant improvement due to Arc::clone vs full clone
+fn span_end_multiple_processors(c: &mut Criterion) {
+    let mut group = c.benchmark_group("span-end-multiple-processors");
+
+    // Test with different numbers of processors to show the scaling benefit
+    for num_processors in [1, 3, 5, 10] {
+        group.bench_function(format!("{}-processors", num_processors), |b| {
+            // Build provider with multiple simple exporters
+            let mut builder =
+                sdktrace::SdkTracerProvider::builder().with_sampler(sdktrace::Sampler::AlwaysOn);
+
+            for _ in 0..num_processors {
+                builder = builder.with_simple_exporter(VoidExporter);
+            }
+
+            let provider = builder.build();
+            let tracer = provider.tracer("benchmark-tracer");
+
+            b.iter(|| {
+                // Create and immediately end a span
+                // This triggers build_export_data which clones the instrumentation scope
+                // With Arc, this is just an atomic increment per processor
+                // Without Arc, this would be a full 120-byte clone per processor
+                let mut span = tracer.start("test-span");
+                span.end();
+            });
+        });
+    }
+
+    group.finish();
+}
+
 fn trace_benchmark_group<F: Fn(&sdktrace::SdkTracer)>(c: &mut Criterion, name: &str, f: F) {
     let mut group = c.benchmark_group(name);
 

opentelemetry-sdk/src/testing/trace/span_exporters.rs

@@ -10,6 +10,7 @@ use opentelemetry::{
     InstrumentationScope,
 };
 use std::fmt::{Display, Formatter};
+use std::sync::Arc;
 
 pub fn new_test_export_span_data() -> SpanData {
     SpanData {
@@ -31,7 +32,7 @@ pub fn new_test_export_span_data() -> SpanData {
         events: SpanEvents::default(),
         links: SpanLinks::default(),
         status: Status::Unset,
-        instrumentation_scope: InstrumentationScope::default(),
+        instrumentation_scope: Arc::new(InstrumentationScope::default()),
     }
 }
 

opentelemetry-sdk/src/trace/export.rs

@@ -5,6 +5,7 @@ use opentelemetry::trace::{SpanContext, SpanId, SpanKind, Status};
 use opentelemetry::{InstrumentationScope, KeyValue};
 use std::borrow::Cow;
 use std::fmt::Debug;
+use std::sync::Arc;
 use std::time::{Duration, SystemTime};
 
 /// `SpanExporter` defines the interface that protocol-specific exporters must
@@ -104,5 +105,5 @@ pub struct SpanData {
     /// Span status
     pub status: Status,
     /// Instrumentation scope that produced this span
-    pub instrumentation_scope: InstrumentationScope,
+    pub instrumentation_scope: Arc<InstrumentationScope>,
 }

opentelemetry-sdk/src/trace/span.rs

@@ -12,6 +12,7 @@ use crate::trace::SpanLimits;
 use opentelemetry::trace::{Event, Link, SpanContext, SpanId, SpanKind, Status};
 use opentelemetry::KeyValue;
 use std::borrow::Cow;
+use std::sync::Arc;
 use std::time::SystemTime;
 
 /// Single operation within a trace.
@@ -266,7 +267,7 @@ fn build_export_data(
         events: data.events,
         links: data.links,
         status: data.status,
-        instrumentation_scope: tracer.instrumentation_scope().clone(),
+        instrumentation_scope: Arc::clone(tracer.instrumentation_scope()),
     }
 }
 

opentelemetry-sdk/src/trace/tracer.rs

@@ -20,11 +20,12 @@ use opentelemetry::{
     Context, InstrumentationScope, KeyValue,
 };
 use std::fmt;
+use std::sync::Arc;
 
 /// `Tracer` implementation to create and manage spans
 #[derive(Clone)]
 pub struct SdkTracer {
-    scope: InstrumentationScope,
+    scope: Arc<InstrumentationScope>,
     provider: SdkTracerProvider,
 }
 
@@ -42,7 +43,10 @@ impl fmt::Debug for SdkTracer {
 impl SdkTracer {
     /// Create a new tracer (used internally by `TracerProvider`s).
     pub(crate) fn new(scope: InstrumentationScope, provider: SdkTracerProvider) -> Self {
-        SdkTracer { scope, provider }
+        SdkTracer {
+            scope: Arc::new(scope),
+            provider,
+        }
     }
 
     /// TracerProvider associated with this tracer.
@@ -51,7 +55,7 @@ impl SdkTracer {
     }
 
     /// Instrumentation scope of this tracer.
-    pub(crate) fn instrumentation_scope(&self) -> &InstrumentationScope {
+    pub(crate) fn instrumentation_scope(&self) -> &Arc<InstrumentationScope> {
         &self.scope
     }