Merge branch 'main' into surface-http-status-errors

Author: cijothomas

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

@@ -31,7 +31,18 @@ impl LogExporter for OtlpHttpClient {
             request.headers_mut().insert(k.clone(), v.clone());
         }
 
-        client.send(request).await?;
+        let request_uri = request.uri().to_string();
+        let response = client.send(request).await?;
+
+        if !response.status().is_success() {
+            let error = format!(
+                "OpenTelemetry logs export failed. Url: {}, Status Code: {}, Response: {:?}",
+                response.status().as_u16(),
+                request_uri,
+                response.body()
+            );
+            return Err(LogError::Other(error.into()));
+        }
 
         Ok(())
     }

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

@@ -46,7 +46,18 @@ impl SpanExporter for OtlpHttpClient {
         }
 
         Box::pin(async move {
-            client.send(request).await?;
+            let request_uri = request.uri().to_string();
+            let response = client.send(request).await?;
+
+            if !response.status().is_success() {
+                let error = format!(
+                    "OpenTelemetry trace export failed. Url: {}, Status Code: {}, Response: {:?}",
+                    response.status().as_u16(),
+                    request_uri,
+                    response.body()
+                );
+                return Err(TraceError::Other(error.into()));
+            }
 
             Ok(())
         })

opentelemetry-sdk/CHANGELOG.md

@@ -6,6 +6,7 @@
 
 - [#1410](https://github.com/open-telemetry/opentelemetry-rust/pull/1410) Add experimental synchronous gauge
 - [#1471](https://github.com/open-telemetry/opentelemetry-rust/pull/1471) Configure batch log record processor via [`OTEL_BLRP_*`](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/configuration/sdk-environment-variables.md#batch-logrecord-processor) environment variables and via `OtlpLogPipeline::with_batch_config`
+- [#1503](https://github.com/open-telemetry/opentelemetry-rust/pull/1503) Make the documentation for In-Memory exporters visible.
 
 ### Changed
 

opentelemetry-sdk/src/lib.rs

@@ -136,7 +136,7 @@ pub mod propagation;
 pub mod resource;
 pub mod runtime;
 #[cfg(any(feature = "testing", test))]
-#[doc(hidden)]
+#[cfg_attr(docsrs, doc(cfg(any(feature = "testing", test))))]
 pub mod testing;
 #[cfg(feature = "trace")]
 #[cfg_attr(docsrs, doc(cfg(feature = "trace")))]

opentelemetry-sdk/src/testing/logs/mod.rs

@@ -1,3 +1,6 @@
-pub use in_memory_exporter::{InMemoryLogsExporter, InMemoryLogsExporterBuilder};
+//! In-Memory log exporter for testing purpose.
 
-mod in_memory_exporter;
+/// The `in_memory_exporter` module provides in-memory log exporter.
+/// For detailed usage and examples, see `in_memory_exporter`.
+pub mod in_memory_exporter;
+pub use in_memory_exporter::{InMemoryLogsExporter, InMemoryLogsExporterBuilder};

opentelemetry-sdk/src/testing/metrics/mod.rs

@@ -1,5 +1,10 @@
-pub use in_memory_exporter::{InMemoryMetricsExporter, InMemoryMetricsExporterBuilder};
-pub use metric_reader::TestMetricReader;
+//! In-Memory metrics exporter for testing purpose.
 
+/// The `in_memory_exporter` module provides in-memory metrics exporter.
+/// For detailed usage and examples, see `in_memory_exporter`.
 pub mod in_memory_exporter;
+pub use in_memory_exporter::{InMemoryMetricsExporter, InMemoryMetricsExporterBuilder};
+
+#[doc(hidden)]
 pub mod metric_reader;
+pub use metric_reader::TestMetricReader;

opentelemetry-sdk/src/testing/mod.rs

@@ -1,3 +1,5 @@
+//! In-Memory exporters for testing purpose.
+
 #[cfg(all(feature = "testing", feature = "trace"))]
 pub mod trace;
 

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

@@ -1,172 +1,10 @@
-pub use in_memory_exporter::{InMemorySpanExporter, InMemorySpanExporterBuilder};
-
-mod in_memory_exporter;
-
-use crate::{
-    export::{
-        trace::{ExportResult, SpanData, SpanExporter},
-        ExportError,
-    },
-    trace::{Config, SpanEvents, SpanLinks},
-    InstrumentationLibrary,
-};
-use async_trait::async_trait;
-use crossbeam_channel::{unbounded, Receiver, SendError, Sender};
-use futures_util::future::BoxFuture;
-pub use opentelemetry::testing::trace::TestSpan;
-use opentelemetry::trace::{
-    SpanContext, SpanId, SpanKind, Status, TraceFlags, TraceId, TraceState,
-};
-use std::fmt::{Display, Formatter};
-
-pub fn new_test_export_span_data() -> SpanData {
-    let config = Config::default();
-    SpanData {
-        span_context: SpanContext::new(
-            TraceId::from_u128(1),
-            SpanId::from_u64(1),
-            TraceFlags::SAMPLED,
-            false,
-            TraceState::default(),
-        ),
-        parent_span_id: SpanId::INVALID,
-        span_kind: SpanKind::Internal,
-        name: "opentelemetry".into(),
-        start_time: opentelemetry::time::now(),
-        end_time: opentelemetry::time::now(),
-        attributes: Vec::new(),
-        dropped_attributes_count: 0,
-        events: SpanEvents::default(),
-        links: SpanLinks::default(),
-        status: Status::Unset,
-        resource: config.resource,
-        instrumentation_lib: InstrumentationLibrary::default(),
-    }
-}
-
-#[derive(Debug)]
-pub struct TestSpanExporter {
-    tx_export: Sender<SpanData>,
-    tx_shutdown: Sender<()>,
-}
-
-#[async_trait]
-impl SpanExporter for TestSpanExporter {
-    fn export(&mut self, batch: Vec<SpanData>) -> BoxFuture<'static, ExportResult> {
-        for span_data in batch {
-            if let Err(err) = self
-                .tx_export
-                .send(span_data)
-                .map_err::<TestExportError, _>(Into::into)
-            {
-                return Box::pin(std::future::ready(Err(Into::into(err))));
-            }
-        }
-        Box::pin(std::future::ready(Ok(())))
-    }
-
-    fn shutdown(&mut self) {
-        let _ = self.tx_shutdown.send(()); // ignore error
-    }
-}
-
-pub fn new_test_exporter() -> (TestSpanExporter, Receiver<SpanData>, Receiver<()>) {
-    let (tx_export, rx_export) = unbounded();
-    let (tx_shutdown, rx_shutdown) = unbounded();
-    let exporter = TestSpanExporter {
-        tx_export,
-        tx_shutdown,
-    };
-    (exporter, rx_export, rx_shutdown)
-}
-
-#[derive(Debug)]
-pub struct TokioSpanExporter {
-    tx_export: tokio::sync::mpsc::UnboundedSender<SpanData>,
-    tx_shutdown: tokio::sync::mpsc::UnboundedSender<()>,
-}
-
-impl SpanExporter for TokioSpanExporter {
-    fn export(&mut self, batch: Vec<SpanData>) -> BoxFuture<'static, ExportResult> {
-        for span_data in batch {
-            if let Err(err) = self
-                .tx_export
-                .send(span_data)
-                .map_err::<TestExportError, _>(Into::into)
-            {
-                return Box::pin(std::future::ready(Err(Into::into(err))));
-            }
-        }
-        Box::pin(std::future::ready(Ok(())))
-    }
+//! In-Memory trace exporter for testing purpose.
 
-    fn shutdown(&mut self) {
-        self.tx_shutdown.send(()).unwrap();
-    }
-}
-
-pub fn new_tokio_test_exporter() -> (
-    TokioSpanExporter,
-    tokio::sync::mpsc::UnboundedReceiver<SpanData>,
-    tokio::sync::mpsc::UnboundedReceiver<()>,
-) {
-    let (tx_export, rx_export) = tokio::sync::mpsc::unbounded_channel();
-    let (tx_shutdown, rx_shutdown) = tokio::sync::mpsc::unbounded_channel();
-    let exporter = TokioSpanExporter {
-        tx_export,
-        tx_shutdown,
-    };
-    (exporter, rx_export, rx_shutdown)
-}
-
-#[derive(Debug)]
-pub struct TestExportError(String);
-
-impl std::error::Error for TestExportError {}
-
-impl ExportError for TestExportError {
-    fn exporter_name(&self) -> &'static str {
-        "test"
-    }
-}
-
-impl Display for TestExportError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-#[cfg(any(feature = "rt-tokio", feature = "rt-tokio-current-thread"))]
-impl<T> From<tokio::sync::mpsc::error::SendError<T>> for TestExportError {
-    fn from(err: tokio::sync::mpsc::error::SendError<T>) -> Self {
-        TestExportError(err.to_string())
-    }
-}
-
-impl<T> From<crossbeam_channel::SendError<T>> for TestExportError {
-    fn from(err: SendError<T>) -> Self {
-        TestExportError(err.to_string())
-    }
-}
-
-/// A no-op instance of an [`SpanExporter`].
-///
-/// [`SpanExporter`]: crate::export::trace::SpanExporter
-#[derive(Debug, Default)]
-pub struct NoopSpanExporter {
-    _private: (),
-}
-
-impl NoopSpanExporter {
-    /// Create a new noop span exporter
-    pub fn new() -> Self {
-        NoopSpanExporter { _private: () }
-    }
-}
+/// The `in_memory_exporter` module provides in-memory trace exporter.
+/// For detailed usage and examples, see `in_memory_exporter`.
+pub mod in_memory_exporter;
+pub use in_memory_exporter::{InMemorySpanExporter, InMemorySpanExporterBuilder};
 
-#[async_trait::async_trait]
-impl SpanExporter for NoopSpanExporter {
-    fn export(&mut self, _: Vec<SpanData>) -> BoxFuture<'static, ExportResult> {
-        Box::pin(std::future::ready(Ok(())))
-    }
-}
+#[doc(hidden)]
+mod span_exporters;
+pub use span_exporters::*;