Merge branch 'main' into add_force_flush_log

opentelemetry-appender-tracing/benches/logs.rs

@@ -15,10 +15,10 @@
 
 use async_trait::async_trait;
 use criterion::{criterion_group, criterion_main, Criterion};
-use opentelemetry::logs::LogResult;
 use opentelemetry::{InstrumentationScope, KeyValue};
 use opentelemetry_appender_tracing::layer as tracing_layer;
 use opentelemetry_sdk::export::logs::{LogBatch, LogExporter};
+use opentelemetry_sdk::logs::LogResult;
 use opentelemetry_sdk::logs::{LogProcessor, LogRecord, LoggerProvider};
 use opentelemetry_sdk::Resource;
 use pprof::criterion::{Output, PProfProfiler};

opentelemetry-appender-tracing/src/layer.rs

@@ -210,12 +210,12 @@ const fn severity_of_level(level: &Level) -> Severity {
 mod tests {
     use crate::layer;
     use async_trait::async_trait;
-    use opentelemetry::logs::{LogResult, Severity};
+    use opentelemetry::logs::Severity;
     use opentelemetry::trace::TracerProvider as _;
     use opentelemetry::trace::{TraceContextExt, TraceFlags, Tracer};
     use opentelemetry::{logs::AnyValue, Key};
     use opentelemetry_sdk::export::logs::{LogBatch, LogExporter};
-    use opentelemetry_sdk::logs::{LogRecord, LoggerProvider};
+    use opentelemetry_sdk::logs::{LogRecord, LogResult, LoggerProvider};
     use opentelemetry_sdk::testing::logs::InMemoryLogExporter;
     use opentelemetry_sdk::trace;
     use opentelemetry_sdk::trace::{Sampler, TracerProvider};
@@ -334,7 +334,7 @@ mod tests {
             .expect("Atleast one log is expected to be present.");
 
         // Validate common fields
-        assert_eq!(log.instrumentation.name, "opentelemetry-appender-tracing");
+        assert_eq!(log.instrumentation.name(), "opentelemetry-appender-tracing");
         assert_eq!(log.record.severity_number, Some(Severity::Error));
 
         // Validate trace context is none.
@@ -428,7 +428,7 @@ mod tests {
             .expect("Atleast one log is expected to be present.");
 
         // validate common fields.
-        assert_eq!(log.instrumentation.name, "opentelemetry-appender-tracing");
+        assert_eq!(log.instrumentation.name(), "opentelemetry-appender-tracing");
         assert_eq!(log.record.severity_number, Some(Severity::Error));
 
         // validate trace context.
@@ -526,7 +526,7 @@ mod tests {
             .expect("Atleast one log is expected to be present.");
 
         // Validate common fields
-        assert_eq!(log.instrumentation.name, "opentelemetry-appender-tracing");
+        assert_eq!(log.instrumentation.name(), "opentelemetry-appender-tracing");
         assert_eq!(log.record.severity_number, Some(Severity::Error));
 
         // Validate trace context is none.
@@ -605,7 +605,7 @@ mod tests {
             .expect("Atleast one log is expected to be present.");
 
         // validate common fields.
-        assert_eq!(log.instrumentation.name, "opentelemetry-appender-tracing");
+        assert_eq!(log.instrumentation.name(), "opentelemetry-appender-tracing");
         assert_eq!(log.record.severity_number, Some(Severity::Error));
 
         // validate trace context.

opentelemetry-otlp/examples/basic-otlp-http/src/main.rs

@@ -2,7 +2,6 @@
 use once_cell::sync::Lazy;
 use opentelemetry::{
     global,
-    metrics::MetricError,
     trace::{TraceContextExt, TraceError, Tracer},
     InstrumentationScope, KeyValue,
 };
@@ -11,7 +10,7 @@ use opentelemetry_otlp::WithExportConfig;
 use opentelemetry_otlp::{LogExporter, MetricExporter, Protocol, SpanExporter};
 use opentelemetry_sdk::{
     logs::LoggerProvider,
-    metrics::{PeriodicReader, SdkMeterProvider},
+    metrics::{MetricError, PeriodicReader, SdkMeterProvider},
     runtime,
     trace::{self as sdktrace, Config, TracerProvider},
 };
@@ -31,7 +30,7 @@ static RESOURCE: Lazy<Resource> = Lazy::new(|| {
     )])
 });
 
-fn init_logs() -> Result<sdklogs::LoggerProvider, opentelemetry::logs::LogError> {
+fn init_logs() -> Result<sdklogs::LoggerProvider, opentelemetry_sdk::logs::LogError> {
     let exporter = LogExporter::builder()
         .with_http()
         .with_endpoint("http://localhost:4318/v1/logs")

opentelemetry-otlp/examples/basic-otlp/src/main.rs

@@ -1,12 +1,12 @@
 use once_cell::sync::Lazy;
-use opentelemetry::logs::LogError;
-use opentelemetry::metrics::MetricError;
 use opentelemetry::trace::{TraceContextExt, TraceError, Tracer};
 use opentelemetry::KeyValue;
 use opentelemetry::{global, InstrumentationScope};
 use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
 use opentelemetry_otlp::{LogExporter, MetricExporter, SpanExporter, WithExportConfig};
+use opentelemetry_sdk::logs::LogError;
 use opentelemetry_sdk::logs::LoggerProvider;
+use opentelemetry_sdk::metrics::MetricError;
 use opentelemetry_sdk::metrics::{PeriodicReader, SdkMeterProvider};
 use opentelemetry_sdk::trace::Config;
 use opentelemetry_sdk::{runtime, trace as sdktrace, Resource};

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

@@ -2,8 +2,8 @@ use std::sync::Arc;
 
 use async_trait::async_trait;
 use http::{header::CONTENT_TYPE, Method};
-use opentelemetry::logs::{LogError, LogResult};
 use opentelemetry_sdk::export::logs::{LogBatch, LogExporter};
+use opentelemetry_sdk::logs::{LogError, LogResult};
 
 use super::OtlpHttpClient;
 

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

@@ -2,8 +2,8 @@ use std::sync::Arc;
 
 use async_trait::async_trait;
 use http::{header::CONTENT_TYPE, Method};
-use opentelemetry::metrics::{MetricError, MetricResult};
 use opentelemetry_sdk::metrics::data::ResourceMetrics;
+use opentelemetry_sdk::metrics::{MetricError, MetricResult};
 
 use crate::{metric::MetricsClient, Error};
 

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

@@ -223,7 +223,7 @@ impl HttpExporterBuilder {
 
     /// Create a log exporter with the current configuration
     #[cfg(feature = "logs")]
-    pub fn build_log_exporter(mut self) -> opentelemetry::logs::LogResult<crate::LogExporter> {
+    pub fn build_log_exporter(mut self) -> opentelemetry_sdk::logs::LogResult<crate::LogExporter> {
         use crate::{
             OTEL_EXPORTER_OTLP_LOGS_ENDPOINT, OTEL_EXPORTER_OTLP_LOGS_HEADERS,
             OTEL_EXPORTER_OTLP_LOGS_TIMEOUT,
@@ -244,7 +244,7 @@ impl HttpExporterBuilder {
     pub fn build_metrics_exporter(
         mut self,
         temporality: opentelemetry_sdk::metrics::data::Temporality,
-    ) -> opentelemetry::metrics::MetricResult<crate::MetricExporter> {
+    ) -> opentelemetry_sdk::metrics::MetricResult<crate::MetricExporter> {
         use crate::{
             OTEL_EXPORTER_OTLP_METRICS_ENDPOINT, OTEL_EXPORTER_OTLP_METRICS_HEADERS,
             OTEL_EXPORTER_OTLP_METRICS_TIMEOUT,
@@ -315,7 +315,7 @@ impl OtlpHttpClient {
     fn build_logs_export_body(
         &self,
         logs: LogBatch<'_>,
-    ) -> opentelemetry::logs::LogResult<(Vec<u8>, &'static str)> {
+    ) -> opentelemetry_sdk::logs::LogResult<(Vec<u8>, &'static str)> {
         use opentelemetry_proto::tonic::collector::logs::v1::ExportLogsServiceRequest;
         let resource_logs = group_logs_by_resource_and_scope(logs, &self.resource);
         let req = ExportLogsServiceRequest { resource_logs };
@@ -324,7 +324,7 @@ impl OtlpHttpClient {
             #[cfg(feature = "http-json")]
             Protocol::HttpJson => match serde_json::to_string_pretty(&req) {
                 Ok(json) => Ok((json.into(), "application/json")),
-                Err(e) => Err(opentelemetry::logs::LogError::from(e.to_string())),
+                Err(e) => Err(opentelemetry_sdk::logs::LogError::from(e.to_string())),
             },
             _ => Ok((req.encode_to_vec(), "application/x-protobuf")),
         }
@@ -334,7 +334,7 @@ impl OtlpHttpClient {
     fn build_metrics_export_body(
         &self,
         metrics: &mut opentelemetry_sdk::metrics::data::ResourceMetrics,
-    ) -> opentelemetry::metrics::MetricResult<(Vec<u8>, &'static str)> {
+    ) -> opentelemetry_sdk::metrics::MetricResult<(Vec<u8>, &'static str)> {
         use opentelemetry_proto::tonic::collector::metrics::v1::ExportMetricsServiceRequest;
 
         let req: ExportMetricsServiceRequest = (&*metrics).into();
@@ -343,7 +343,9 @@ impl OtlpHttpClient {
             #[cfg(feature = "http-json")]
             Protocol::HttpJson => match serde_json::to_string_pretty(&req) {
                 Ok(json) => Ok((json.into(), "application/json")),
-                Err(e) => Err(opentelemetry::metrics::MetricError::Other(e.to_string())),
+                Err(e) => Err(opentelemetry_sdk::metrics::MetricError::Other(
+                    e.to_string(),
+                )),
             },
             _ => Ok((req.encode_to_vec(), "application/x-protobuf")),
         }

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

@@ -1,10 +1,10 @@
 use async_trait::async_trait;
 use core::fmt;
-use opentelemetry::logs::{LogError, LogResult};
 use opentelemetry_proto::tonic::collector::logs::v1::{
     logs_service_client::LogsServiceClient, ExportLogsServiceRequest,
 };
 use opentelemetry_sdk::export::logs::{LogBatch, LogExporter};
+use opentelemetry_sdk::logs::{LogError, LogResult};
 use tonic::{codegen::CompressionEncoding, service::Interceptor, transport::Channel, Request};
 
 use opentelemetry_proto::transform::logs::tonic::group_logs_by_resource_and_scope;

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

@@ -2,11 +2,11 @@ use core::fmt;
 use std::sync::Mutex;
 
 use async_trait::async_trait;
-use opentelemetry::metrics::{MetricError, MetricResult};
 use opentelemetry_proto::tonic::collector::metrics::v1::{
     metrics_service_client::MetricsServiceClient, ExportMetricsServiceRequest,
 };
 use opentelemetry_sdk::metrics::data::ResourceMetrics;
+use opentelemetry_sdk::metrics::{MetricError, MetricResult};
 use tonic::{codegen::CompressionEncoding, service::Interceptor, transport::Channel, Request};
 
 use super::BoxInterceptor;

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

@@ -254,7 +254,7 @@ impl TonicExporterBuilder {
     #[cfg(feature = "logs")]
     pub(crate) fn build_log_exporter(
         self,
-    ) -> Result<crate::logs::LogExporter, opentelemetry::logs::LogError> {
+    ) -> Result<crate::logs::LogExporter, opentelemetry_sdk::logs::LogError> {
         use crate::exporter::tonic::logs::TonicLogsClient;
 
         let (channel, interceptor, compression) = self.build_channel(
@@ -274,7 +274,7 @@ impl TonicExporterBuilder {
     pub(crate) fn build_metrics_exporter(
         self,
         temporality: opentelemetry_sdk::metrics::data::Temporality,
-    ) -> opentelemetry::metrics::MetricResult<crate::MetricExporter> {
+    ) -> opentelemetry_sdk::metrics::MetricResult<crate::MetricExporter> {
         use crate::MetricExporter;
         use metrics::TonicMetricsClient;
 

opentelemetry-otlp/src/lib.rs

@@ -391,6 +391,12 @@ impl ExportError for Error {
     }
 }
 
+impl opentelemetry::trace::ExportError for Error {
+    fn exporter_name(&self) -> &'static str {
+        "otlp"
+    }
+}
+
 /// The communication protocol to use when exporting data.
 #[cfg_attr(feature = "serialize", derive(Deserialize, Serialize))]
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]

opentelemetry-otlp/src/logs.rs

@@ -5,7 +5,7 @@
 use async_trait::async_trait;
 use std::fmt::Debug;
 
-use opentelemetry::logs::LogResult;
+use opentelemetry_sdk::logs::LogResult;
 
 use opentelemetry_sdk::export::logs::LogBatch;
 
@@ -62,14 +62,14 @@ impl LogExporterBuilder<NoExporterBuilderSet> {
 
 #[cfg(feature = "grpc-tonic")]
 impl LogExporterBuilder<TonicExporterBuilderSet> {
-    pub fn build(self) -> Result<LogExporter, opentelemetry::logs::LogError> {
+    pub fn build(self) -> Result<LogExporter, opentelemetry_sdk::logs::LogError> {
         self.client.0.build_log_exporter()
     }
 }
 
 #[cfg(any(feature = "http-proto", feature = "http-json"))]
 impl LogExporterBuilder<HttpExporterBuilderSet> {
-    pub fn build(self) -> Result<LogExporter, opentelemetry::logs::LogError> {
+    pub fn build(self) -> Result<LogExporter, opentelemetry_sdk::logs::LogError> {
         self.client.0.build_log_exporter()
     }
 }

opentelemetry-otlp/src/metric.rs

@@ -16,7 +16,7 @@ use crate::NoExporterBuilderSet;
 
 use async_trait::async_trait;
 use core::fmt;
-use opentelemetry::metrics::MetricResult;
+use opentelemetry_sdk::metrics::MetricResult;
 
 use opentelemetry_sdk::metrics::{
     data::{ResourceMetrics, Temporality},

opentelemetry-otlp/tests/integration_test/tests/logs.rs

@@ -2,21 +2,17 @@
 
 use integration_test_runner::logs_asserter::{read_logs_from_json, LogsAsserter};
 use log::{info, Level};
-use opentelemetry::logs::LogError;
 use opentelemetry::KeyValue;
 use opentelemetry_appender_log::OpenTelemetryLogBridge;
-use opentelemetry_otlp::{LogExporter, WithExportConfig};
-use opentelemetry_sdk::logs::LoggerProvider;
+use opentelemetry_otlp::LogExporter;
+use opentelemetry_sdk::logs::{LogError, LoggerProvider};
 use opentelemetry_sdk::{logs as sdklogs, runtime, Resource};
 use std::error::Error;
 use std::fs::File;
 use std::os::unix::fs::MetadataExt;
 
 fn init_logs() -> Result<sdklogs::LoggerProvider, LogError> {
-    let exporter = LogExporter::builder()
-        .with_tonic()
-        .with_endpoint("0.0.0.0:4317")
-        .build()?;
+    let exporter = LogExporter::builder().with_tonic().build()?;
 
     Ok(LoggerProvider::builder()
         .with_batch_exporter(exporter, runtime::Tokio)

opentelemetry-proto/src/transform/common.rs

@@ -64,9 +64,9 @@ pub mod tonic {
                 }
             } else {
                 InstrumentationScope {
-                    name: library.name.into_owned(),
-                    version: library.version.map(Cow::into_owned).unwrap_or_default(),
-                    attributes: Attributes::from(library.attributes).0,
+                    name: library.name().to_owned(),
+                    version: library.version().map(ToOwned::to_owned).unwrap_or_default(),
+                    attributes: Attributes::from(library.attributes().cloned()).0,
                     ..Default::default()
                 }
             }
@@ -95,13 +95,9 @@ pub mod tonic {
                 }
             } else {
                 InstrumentationScope {
-                    name: library.name.to_string(),
-                    version: library
-                        .version
-                        .as_ref()
-                        .map(ToString::to_string)
-                        .unwrap_or_default(),
-                    attributes: Attributes::from(library.attributes.clone()).0,
+                    name: library.name().to_owned(),
+                    version: library.version().map(ToOwned::to_owned).unwrap_or_default(),
+                    attributes: Attributes::from(library.attributes().cloned()).0,
                     ..Default::default()
                 }
             }
@@ -112,8 +108,8 @@ pub mod tonic {
     #[derive(Default, Debug)]
     pub struct Attributes(pub ::std::vec::Vec<crate::proto::tonic::common::v1::KeyValue>);
 
-    impl From<Vec<opentelemetry::KeyValue>> for Attributes {
-        fn from(kvs: Vec<opentelemetry::KeyValue>) -> Self {
+    impl<I: IntoIterator<Item = opentelemetry::KeyValue>> From<I> for Attributes {
+        fn from(kvs: I) -> Self {
             Attributes(
                 kvs.into_iter()
                     .map(|api_kv| KeyValue {

opentelemetry-proto/src/transform/logs.rs

@@ -167,9 +167,8 @@ pub mod tonic {
                 schema_url: resource.schema_url.clone().unwrap_or_default(),
                 scope_logs: vec![ScopeLogs {
                     schema_url: instrumentation
-                        .schema_url
-                        .clone()
-                        .map(Into::into)
+                        .schema_url()
+                        .map(ToOwned::to_owned)
                         .unwrap_or_default(),
                     scope: Some((instrumentation, log_record.target.clone()).into()),
                     log_records: vec![log_record.into()],
@@ -196,7 +195,7 @@ pub mod tonic {
                 let key = log_record
                     .target
                     .clone()
-                    .unwrap_or_else(|| Cow::Owned(instrumentation.name.clone().into_owned()));
+                    .unwrap_or_else(|| Cow::Owned(instrumentation.name().to_owned()));
                 scope_map
                     .entry(key)
                     .or_default()

opentelemetry-proto/src/transform/metrics.rs

@@ -137,9 +137,8 @@ pub mod tonic {
                 metrics: sm.metrics.iter().map(Into::into).collect(),
                 schema_url: sm
                     .scope
-                    .schema_url
-                    .as_ref()
-                    .map(ToString::to_string)
+                    .schema_url()
+                    .map(ToOwned::to_owned)
                     .unwrap_or_default(),
             }
         }

opentelemetry-proto/src/transform/trace.rs

@@ -102,9 +102,8 @@ pub mod tonic {
                 scope_spans: vec![ScopeSpans {
                     schema_url: source_span
                         .instrumentation_scope
-                        .schema_url
-                        .as_ref()
-                        .map(ToString::to_string)
+                        .schema_url()
+                        .map(ToOwned::to_owned)
                         .unwrap_or_default(),
                     scope: Some((source_span.instrumentation_scope, None).into()),
                     spans: vec![Span {