Remove mut self reference from SpanExporter::export() method.

opentelemetry-otlp/src/exporter/http/trace.rs

@@ -9,7 +9,7 @@
 };
 
 impl SpanExporter for OtlpHttpClient {
-    async fn export(&mut self, batch: Vec<SpanData>) -> OTelSdkResult {
+    async fn export(&self, batch: Vec<SpanData>) -> OTelSdkResult {
         let client = match self
             .client
             .lock()

opentelemetry-otlp/src/exporter/tonic/trace.rs

@@ -1,4 +1,5 @@
 use core::fmt;
+use tokio::sync::Mutex;
 
 use opentelemetry::otel_debug;
 use opentelemetry_proto::tonic::collector::trace::v1::{
@@ -23,7 +24,7 @@
 
 struct ClientInner {
     client: TraceServiceClient<Channel>,
-    interceptor: BoxInterceptor,
+    interceptor: Mutex<BoxInterceptor>,
 }
 
 impl fmt::Debug for TonicTracesClient {
@@ -50,26 +51,27 @@
         TonicTracesClient {
             inner: Some(ClientInner {
                 client,
-                interceptor,
+                interceptor: Mutex::new(interceptor),
             }),
             resource: Default::default(),
         }
     }
 }
 
 impl SpanExporter for TonicTracesClient {
-    async fn export(&mut self, batch: Vec<SpanData>) -> OTelSdkResult {
-        let (mut client, metadata, extensions) = match &mut self.inner {
+    async fn export(&self, batch: Vec<SpanData>) -> OTelSdkResult {
+        let (mut client, metadata, extensions) = match &self.inner {
             Some(inner) => {
-                let (m, e, _) = match inner.interceptor.call(Request::new(())) {
-                    Ok(res) => res.into_parts(),
-                    Err(e) => return Err(OTelSdkError::InternalFailure(e.to_string())),
-                };
+                let (m, e, _) = inner
+                    .interceptor
+                    .lock()
+                    .await // tokio::sync::Mutex doesn't return a poisoned error, so we can safely use the interceptor here
+                    .call(Request::new(()))
+                    .map_err(|e| OTelSdkError::InternalFailure(format!("error: {:?}", e)))?
+                    .into_parts();
                 (inner.client.clone(), m, e)
             }
-            None => {
-                return Err(OTelSdkError::AlreadyShutdown);
-            }
+            None => return Err(OTelSdkError::AlreadyShutdown),
         };
 
         let resource_spans = group_spans_by_resource_and_scope(batch, &self.resource);

opentelemetry-otlp/src/span.rs

@@ -141,8 +141,8 @@
 }
 
 impl opentelemetry_sdk::trace::SpanExporter for SpanExporter {
-    async fn export(&mut self, batch: Vec<SpanData>) -> OTelSdkResult {
-        match &mut self.client {
+    async fn export(&self, batch: Vec<SpanData>) -> OTelSdkResult {
+        match &self.client {
             #[cfg(feature = "grpc-tonic")]
             SupportedTransportClient::Tonic(client) => client.export(batch).await,
             #[cfg(any(feature = "http-proto", feature = "http-json"))]

opentelemetry-sdk/CHANGELOG.md

@@ -33,7 +33,17 @@
     }
 }
 ```
-
+- **Breaking** The SpanExporter::export() method no longer requires a mutable reference to self.
+  Before: 
+  ```rust
+    async fn export(&mut self, batch: Vec<SpanData>) -> OTelSdkResult 
+  ```
+  After: 
+  ```rust 
+    async fn export(&self, batch: Vec<SpanData>) -> OTelSdkResult  
+  ```
+  Custom exporters will need to internally synchronize any mutable state, if applicable.
+
 ## 0.28.0
 
 Released 2025-Feb-10

opentelemetry-sdk/benches/context.rs

@@ -136,7 +136,7 @@ fn parent_sampled_tracer(inner_sampler: Sampler) -> (SdkTracerProvider, BoxedTra
 struct NoopExporter;
 
 impl SpanExporter for NoopExporter {
-    async fn export(&mut self, _spans: Vec<SpanData>) -> OTelSdkResult {
+    async fn export(&self, _spans: Vec<SpanData>) -> OTelSdkResult {
         Ok(())
     }
 }

opentelemetry-sdk/benches/span_builder.rs

@@ -65,7 +65,7 @@ fn not_sampled_provider() -> (sdktrace::SdkTracerProvider, sdktrace::SdkTracer)
 struct NoopExporter;
 
 impl SpanExporter for NoopExporter {
-    async fn export(&mut self, _spans: Vec<SpanData>) -> OTelSdkResult {
+    async fn export(&self, _spans: Vec<SpanData>) -> OTelSdkResult {
         Ok(())
     }
 }

opentelemetry-sdk/benches/trace.rs

@@ -59,7 +59,7 @@ fn criterion_benchmark(c: &mut Criterion) {
 struct VoidExporter;
 
 impl SpanExporter for VoidExporter {
-    async fn export(&mut self, _spans: Vec<SpanData>) -> OTelSdkResult {
+    async fn export(&self, _spans: Vec<SpanData>) -> OTelSdkResult {
         Ok(())
     }
 }

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

@@ -41,7 +41,7 @@ pub struct TokioSpanExporter {
 }
 
 impl SpanExporter for TokioSpanExporter {
-    async fn export(&mut self, batch: Vec<SpanData>) -> OTelSdkResult {
+    async fn export(&self, batch: Vec<SpanData>) -> OTelSdkResult {
         batch.into_iter().try_for_each(|span_data| {
             self.tx_export
                 .send(span_data)
@@ -110,7 +110,7 @@ impl NoopSpanExporter {
 }
 
 impl SpanExporter for NoopSpanExporter {
-    async fn export(&mut self, _: Vec<SpanData>) -> OTelSdkResult {
+    async fn export(&self, _: Vec<SpanData>) -> OTelSdkResult {
         Ok(())
     }
 }

opentelemetry-sdk/src/trace/export.rs

@@ -28,7 +28,7 @@ pub trait SpanExporter: Send + Sync + Debug {
     /// Any retry logic that is required by the exporter is the responsibility
     /// of the exporter.
     fn export(
-        &mut self,
+        &self,
         batch: Vec<SpanData>,
     ) -> impl std::future::Future<Output = OTelSdkResult> + Send;
 

opentelemetry-sdk/src/trace/in_memory_exporter.rs

@@ -130,7 +130,7 @@ impl InMemorySpanExporter {
 }
 
 impl SpanExporter for InMemorySpanExporter {
-    async fn export(&mut self, batch: Vec<SpanData>) -> OTelSdkResult {
+    async fn export(&self, batch: Vec<SpanData>) -> OTelSdkResult {
         let result = self
             .spans
             .lock()

opentelemetry-sdk/src/trace/runtime_tests.rs

@@ -25,7 +25,7 @@
 
 #[cfg(any(feature = "rt-tokio", feature = "rt-tokio-current-thread"))]
 impl SpanExporter for SpanCountExporter {
-    async fn export(&mut self, batch: Vec<crate::trace::SpanData>) -> OTelSdkResult {
+    async fn export(&self, batch: Vec<crate::trace::SpanData>) -> OTelSdkResult {
         self.span_count.fetch_add(batch.len(), Ordering::SeqCst);
         Ok(())
     }

opentelemetry-sdk/src/trace/span_processor.rs

@@ -139,7 +139,7 @@ impl<T: SpanExporter> SpanProcessor for SimpleSpanProcessor<T> {
             .exporter
             .lock()
             .map_err(|_| OTelSdkError::InternalFailure("SimpleSpanProcessor mutex poison".into()))
-            .and_then(|mut exporter| futures_executor::block_on(exporter.export(vec![span])));
+            .and_then(|exporter| futures_executor::block_on(exporter.export(vec![span])));
 
         if let Err(err) = result {
             // TODO: check error type, and log `error` only if the error is user-actionable, else log `debug`
@@ -1022,7 +1022,7 @@ mod tests {
     }
 
     impl SpanExporter for MockSpanExporter {
-        async fn export(&mut self, batch: Vec<SpanData>) -> OTelSdkResult {
+        async fn export(&self, batch: Vec<SpanData>) -> OTelSdkResult {
             let exported_spans = self.exported_spans.clone();
             exported_spans.lock().unwrap().extend(batch);
             Ok(())

opentelemetry-sdk/src/trace/span_processor_with_async_runtime.rs

@@ -457,7 +457,7 @@ mod tests {
         D: Fn(Duration) -> DS + 'static + Send + Sync,
         DS: Future<Output = ()> + Send + Sync + 'static,
     {
-        async fn export(&mut self, _batch: Vec<SpanData>) -> OTelSdkResult {
+        async fn export(&self, _batch: Vec<SpanData>) -> OTelSdkResult {
             (self.delay_fn)(self.delay_for).await;
             Ok(())
         }

opentelemetry-stdout/src/trace/exporter.rs

@@ -2,15 +2,15 @@
 use core::fmt;
 use opentelemetry_sdk::error::{OTelSdkError, OTelSdkResult};
 use opentelemetry_sdk::trace::SpanData;
-use std::sync::atomic;
+use std::sync::atomic::{AtomicBool, Ordering};
 
 use opentelemetry_sdk::resource::Resource;
 
 /// An OpenTelemetry exporter that writes Spans to stdout on export.
 pub struct SpanExporter {
     resource: Resource,
-    is_shutdown: atomic::AtomicBool,
-    resource_emitted: bool,
+    is_shutdown: AtomicBool,
+    resource_emitted: AtomicBool,
 }
 
 impl fmt::Debug for SpanExporter {
@@ -23,23 +23,26 @@
     fn default() -> Self {
         SpanExporter {
             resource: Resource::builder().build(),
-            is_shutdown: atomic::AtomicBool::new(false),
-            resource_emitted: false,
+            is_shutdown: AtomicBool::new(false),
+            resource_emitted: AtomicBool::new(false),
         }
     }
 }
 
 impl opentelemetry_sdk::trace::SpanExporter for SpanExporter {
     /// Write Spans to stdout
-    async fn export(&mut self, batch: Vec<SpanData>) -> OTelSdkResult {
-        if self.is_shutdown.load(atomic::Ordering::SeqCst) {
+    async fn export(&self, batch: Vec<SpanData>) -> OTelSdkResult {
+        if self.is_shutdown.load(Ordering::SeqCst) {
             Err(OTelSdkError::AlreadyShutdown)
         } else {
             println!("Spans");
-            if self.resource_emitted {
+            if self
+                .resource_emitted
+                .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
+                .is_err()
+            {
                 print_spans(batch);
             } else {
-                self.resource_emitted = true;
                 println!("Resource");
                 if let Some(schema_url) = self.resource.schema_url() {
                     println!("\tResource SchemaUrl: {:?}", schema_url);
@@ -57,7 +60,7 @@
     }
 
     fn shutdown(&mut self) -> OTelSdkResult {
-        self.is_shutdown.store(true, atomic::Ordering::SeqCst);
+        self.is_shutdown.store(true, Ordering::SeqCst);
         Ok(())
     }
 

opentelemetry-zipkin/src/exporter/mod.rs

@@ -126,7 +126,7 @@
 
 impl trace::SpanExporter for ZipkinExporter {
     /// Export spans to Zipkin collector.
-    async fn export(&mut self, batch: Vec<trace::SpanData>) -> OTelSdkResult {
+    async fn export(&self, batch: Vec<trace::SpanData>) -> OTelSdkResult {
         zipkin_export(batch, self.uploader.clone(), self.local_endpoint.clone()).await
     }
 }