From 8c443b2955d55ae4ac2ef08d414f8f57adbd62f5 Mon Sep 17 00:00:00 2001 From: Lalit Kumar Bhasin Date: Mon, 10 Feb 2025 20:54:57 -0800 Subject: [PATCH] Prepare for otel v0.28 (#168) --- .github/workflows/ci.yml | 2 +- Cargo.toml | 14 +-- examples/traceresponse/src/client.rs | 6 +- examples/traceresponse/src/server.rs | 6 +- opentelemetry-aws/CHANGELOG.md | 5 + opentelemetry-aws/Cargo.toml | 4 +- opentelemetry-aws/src/detector/lambda.rs | 51 ++++----- opentelemetry-aws/src/trace/id_generator.rs | 4 +- .../src/trace/xray_propagator.rs | 4 +- opentelemetry-contrib/CHANGELOG.md | 5 + opentelemetry-contrib/Cargo.toml | 4 +- opentelemetry-contrib/benches/new_span.rs | 13 +-- .../src/trace/exporter/jaeger_json.rs | 64 ++++++----- opentelemetry-datadog/CHANGELOG.md | 5 + opentelemetry-datadog/Cargo.toml | 4 +- .../benches/datadog_exporter.rs | 12 ++- opentelemetry-datadog/src/exporter/mod.rs | 102 ++++++++++-------- .../src/exporter/model/mod.rs | 16 +-- .../src/exporter/model/v03.rs | 2 +- .../src/exporter/model/v05.rs | 2 +- opentelemetry-datadog/src/lib.rs | 25 +++-- opentelemetry-etw-logs/CHANGELOG.md | 5 + opentelemetry-etw-logs/Cargo.toml | 5 +- opentelemetry-etw-logs/examples/basic.rs | 6 +- opentelemetry-etw-logs/src/logs/exporter.rs | 61 ++++++----- .../src/logs/reentrant_logprocessor.rs | 20 ++-- opentelemetry-etw-metrics/CHANGELOG.md | 6 ++ opentelemetry-etw-metrics/Cargo.toml | 4 +- opentelemetry-etw-metrics/benches/exporter.rs | 12 ++- opentelemetry-etw-metrics/examples/basic.rs | 13 +-- opentelemetry-etw-metrics/src/exporter/mod.rs | 26 ++--- opentelemetry-resource-detectors/CHANGELOG.md | 6 ++ opentelemetry-resource-detectors/Cargo.toml | 4 +- opentelemetry-resource-detectors/src/host.rs | 56 +++++----- opentelemetry-resource-detectors/src/os.rs | 18 ++-- .../src/process.rs | 29 +++-- opentelemetry-stackdriver/CHANGELOG.md | 4 + opentelemetry-stackdriver/Cargo.toml | 4 +- opentelemetry-stackdriver/src/lib.rs | 38 ++++--- opentelemetry-user-events-logs/CHANGELOG.md | 4 + opentelemetry-user-events-logs/Cargo.toml | 5 +- .../examples/basic-logs.rs | 6 +- .../src/logs/exporter.rs | 42 ++++---- .../src/logs/reentrant_logprocessor.rs | 10 +- .../CHANGELOG.md | 8 ++ opentelemetry-user-events-metrics/Cargo.toml | 4 +- .../examples/basic-metrics.rs | 13 +-- .../src/exporter/mod.rs | 43 +++++--- opentelemetry-zpages/CHANGELOG.md | 9 +- opentelemetry-zpages/Cargo.toml | 6 +- opentelemetry-zpages/examples/zpages.rs | 4 +- opentelemetry-zpages/src/lib.rs | 6 +- opentelemetry-zpages/src/trace/aggregator.rs | 4 +- opentelemetry-zpages/src/trace/mod.rs | 10 +- .../src/trace/span_processor.rs | 9 +- opentelemetry-zpages/src/trace/span_queue.rs | 2 +- scripts/msrv_config.json | 7 +- stress/src/etw_logs.rs | 6 +- stress/src/user_events.rs | 6 +- 59 files changed, 499 insertions(+), 372 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 2b9714ed..d1330575 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -53,7 +53,7 @@ jobs: msrv: strategy: matrix: - rust: ["1.71.1"] + rust: ["1.75.0"] runs-on: ubuntu-latest continue-on-error: true steps: diff --git a/Cargo.toml b/Cargo.toml index 9e60d682..7c232761 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -13,13 +13,13 @@ resolver = "2" debug = 1 [workspace.dependencies] -opentelemetry = "0.27" -opentelemetry-appender-tracing = "0.27" -opentelemetry-http = "0.27" -opentelemetry-proto = { version = "0.27", default-features = false } -opentelemetry_sdk = { version = "0.27", default-features = false } -opentelemetry-stdout = "0.27" -opentelemetry-semantic-conventions = { version = "0.27", features = [ +opentelemetry = "0.28" +opentelemetry-appender-tracing = "0.28" +opentelemetry-http = "0.28" +opentelemetry-proto = { version = "0.28", default-features = false } +opentelemetry_sdk = { version = "0.28", default-features = false } +opentelemetry-stdout = "0.28" +opentelemetry-semantic-conventions = { version = "0.28", features = [ "semconv_experimental", ] } criterion = "0.5" diff --git a/examples/traceresponse/src/client.rs b/examples/traceresponse/src/client.rs index 2b313895..c5095b7f 100644 --- a/examples/traceresponse/src/client.rs +++ b/examples/traceresponse/src/client.rs @@ -9,15 +9,15 @@ use opentelemetry::{ }; use opentelemetry_contrib::trace::propagator::trace_context_response::TraceContextResponsePropagator; use opentelemetry_http::{Bytes, HeaderExtractor, HeaderInjector}; -use opentelemetry_sdk::{propagation::TraceContextPropagator, trace::TracerProvider}; +use opentelemetry_sdk::{propagation::TraceContextPropagator, trace::SdkTracerProvider}; use opentelemetry_stdout::SpanExporter; -fn init_traces() -> Result { +fn init_traces() -> Result { global::set_text_map_propagator(TraceContextPropagator::new()); // Install stdout exporter pipeline to be able to retrieve the collected spans. // For the demonstration, use `Sampler::AlwaysOn` sampler to sample all traces. In a production // application, use `Sampler::ParentBased` or `Sampler::TraceIdRatioBased` with a desired ratio. - Ok(TracerProvider::builder() + Ok(SdkTracerProvider::builder() .with_simple_exporter(SpanExporter::default()) .build()) } diff --git a/examples/traceresponse/src/server.rs b/examples/traceresponse/src/server.rs index 2ba73995..64e91525 100644 --- a/examples/traceresponse/src/server.rs +++ b/examples/traceresponse/src/server.rs @@ -11,7 +11,7 @@ use opentelemetry::{ }; use opentelemetry_contrib::trace::propagator::trace_context_response::TraceContextResponsePropagator; use opentelemetry_http::{Bytes, HeaderExtractor, HeaderInjector}; -use opentelemetry_sdk::{propagation::TraceContextPropagator, trace::TracerProvider}; +use opentelemetry_sdk::{propagation::TraceContextPropagator, trace::SdkTracerProvider}; use opentelemetry_stdout::SpanExporter; use std::{convert::Infallible, net::SocketAddr}; use tokio::net::TcpListener; @@ -45,13 +45,13 @@ async fn handle( Ok(res) } -fn init_traces() -> Result { +fn init_traces() -> Result { global::set_text_map_propagator(TraceContextPropagator::new()); // Install stdout exporter pipeline to be able to retrieve the collected spans. // For the demonstration, use `Sampler::AlwaysOn` sampler to sample all traces. In a production // application, use `Sampler::ParentBased` or `Sampler::TraceIdRatioBased` with a desired ratio. - Ok(TracerProvider::builder() + Ok(SdkTracerProvider::builder() .with_simple_exporter(SpanExporter::default()) .build()) } diff --git a/opentelemetry-aws/CHANGELOG.md b/opentelemetry-aws/CHANGELOG.md index dff53287..88e2a8c4 100644 --- a/opentelemetry-aws/CHANGELOG.md +++ b/opentelemetry-aws/CHANGELOG.md @@ -2,6 +2,11 @@ ## vNext +## v0.16.0 + +- Bump msrv to 1.75.0 +- Bump opentelemetry and opentelemetry_sdk versions to 0.27.0 + ## v0.15.0 - Bump opentelemetry and opentelemetry_sdk versions to 0.27.0 diff --git a/opentelemetry-aws/Cargo.toml b/opentelemetry-aws/Cargo.toml index 6a466100..f673f61a 100644 --- a/opentelemetry-aws/Cargo.toml +++ b/opentelemetry-aws/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "opentelemetry-aws" -version = "0.15.0" +version = "0.16.0" description = "AWS exporters and propagators for OpenTelemetry" homepage = "https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/main/opentelemetry-aws" repository = "https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/main/opentelemetry-aws" @@ -12,7 +12,7 @@ categories = [ keywords = ["opentelemetry", "tracing"] license = "Apache-2.0" edition = "2021" -rust-version = "1.70.0" +rust-version = "1.75.0" [package.metadata.docs.rs] all-features = true diff --git a/opentelemetry-aws/src/detector/lambda.rs b/opentelemetry-aws/src/detector/lambda.rs index 3564fb84..55080803 100644 --- a/opentelemetry-aws/src/detector/lambda.rs +++ b/opentelemetry-aws/src/detector/lambda.rs @@ -3,7 +3,6 @@ use opentelemetry_sdk::resource::ResourceDetector; use opentelemetry_sdk::Resource; use opentelemetry_semantic_conventions as semconv; use std::env; -use std::time::Duration; // For a complete list of reserved environment variables in Lambda, see: // https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html @@ -18,12 +17,12 @@ const AWS_LAMBDA_LOG_GROUP_NAME_ENV_VAR: &str = "AWS_LAMBDA_LOG_GROUP_NAME"; pub struct LambdaResourceDetector; impl ResourceDetector for LambdaResourceDetector { - fn detect(&self, _: Duration) -> Resource { + fn detect(&self) -> Resource { let lambda_name = env::var(AWS_LAMBDA_FUNCTION_NAME_ENV_VAR).unwrap_or_default(); // If no lambda name is provided, it means that // we're not on a Lambda environment, so we return empty resource. if lambda_name.is_empty() { - return Resource::empty(); + return Resource::builder_empty().build(); } let aws_region = env::var(AWS_REGION_ENV_VAR).unwrap_or_default(); @@ -50,7 +49,9 @@ impl ResourceDetector for LambdaResourceDetector { ), ]; - Resource::new(attributes) + Resource::builder_empty() + .with_attributes(attributes) + .build() } } @@ -75,26 +76,28 @@ mod tests { "/aws/lambda/my-lambda-function", ); - let expected = Resource::new([ - KeyValue::new(semconv::resource::CLOUD_PROVIDER, "aws"), - KeyValue::new(semconv::resource::CLOUD_REGION, "eu-west-3"), - KeyValue::new( - semconv::resource::FAAS_INSTANCE, - "2023/01/01/[$LATEST]5d1edb9e525d486696cf01a3503487bc", - ), - KeyValue::new(semconv::resource::FAAS_NAME, "my-lambda-function"), - KeyValue::new(semconv::resource::FAAS_VERSION, "$LATEST"), - KeyValue::new(semconv::resource::FAAS_MAX_MEMORY, 128 * 1024 * 1024), - KeyValue::new( - semconv::resource::AWS_LOG_GROUP_NAMES, - Value::Array(Array::from(vec![StringValue::from( - "/aws/lambda/my-lambda-function".to_string(), - )])), - ), - ]); + let expected = Resource::builder_empty() + .with_attributes([ + KeyValue::new(semconv::resource::CLOUD_PROVIDER, "aws"), + KeyValue::new(semconv::resource::CLOUD_REGION, "eu-west-3"), + KeyValue::new( + semconv::resource::FAAS_INSTANCE, + "2023/01/01/[$LATEST]5d1edb9e525d486696cf01a3503487bc", + ), + KeyValue::new(semconv::resource::FAAS_NAME, "my-lambda-function"), + KeyValue::new(semconv::resource::FAAS_VERSION, "$LATEST"), + KeyValue::new(semconv::resource::FAAS_MAX_MEMORY, 128 * 1024 * 1024), + KeyValue::new( + semconv::resource::AWS_LOG_GROUP_NAMES, + Value::Array(Array::from(vec![StringValue::from( + "/aws/lambda/my-lambda-function".to_string(), + )])), + ), + ]) + .build(); let detector = LambdaResourceDetector {}; - let got = detector.detect(Duration::from_secs(0)); + let got = detector.detect(); assert_eq!(expected, got); @@ -109,7 +112,7 @@ mod tests { #[sealed_test] fn test_aws_lambda_detector_returns_empty_if_no_lambda_environment() { let detector = LambdaResourceDetector {}; - let got = detector.detect(Duration::from_secs(0)); - assert_eq!(Resource::empty(), got); + let got = detector.detect(); + assert_eq!(Resource::builder_empty().build(), got); } } diff --git a/opentelemetry-aws/src/trace/id_generator.rs b/opentelemetry-aws/src/trace/id_generator.rs index 04cb22d1..62888513 100644 --- a/opentelemetry-aws/src/trace/id_generator.rs +++ b/opentelemetry-aws/src/trace/id_generator.rs @@ -24,9 +24,9 @@ use std::time::{Duration, UNIX_EPOCH}; /// /// ``` /// use opentelemetry::trace::{TraceId}; -/// use opentelemetry_sdk::trace::{self, IdGenerator, TracerProvider}; +/// use opentelemetry_sdk::trace::{self, IdGenerator, SdkTracerProvider}; /// use opentelemetry_aws::trace::XrayIdGenerator; -/// let _provider: TracerProvider = TracerProvider::builder() +/// let _provider:SdkTracerProvider = SdkTracerProvider::builder() /// .with_config(trace::config().with_id_generator(XrayIdGenerator::default())) /// .build(); /// ``` diff --git a/opentelemetry-aws/src/trace/xray_propagator.rs b/opentelemetry-aws/src/trace/xray_propagator.rs index 29aa5b4d..eb40920a 100644 --- a/opentelemetry-aws/src/trace/xray_propagator.rs +++ b/opentelemetry-aws/src/trace/xray_propagator.rs @@ -10,7 +10,7 @@ //! ```no_run //! use opentelemetry::{global, trace::{Tracer, TracerProvider as _}}; //! use opentelemetry_aws::trace::XrayPropagator; -//! use opentelemetry_sdk::trace::TracerProvider; +//! use opentelemetry_sdk::trace::SdkTracerProvider; //! use opentelemetry_stdout::SpanExporter; //! use opentelemetry_http::HeaderInjector; //! @@ -18,7 +18,7 @@ //! async fn main() -> std::result::Result<(), Box> { //! // Set the global propagator to X-Ray propagator //! global::set_text_map_propagator(XrayPropagator::default()); -//! let provider = TracerProvider::builder() +//! let provider = SdkTracerProvider::builder() //! .with_simple_exporter(SpanExporter::default()) //! .build(); //! let tracer = provider.tracer("readme_example"); diff --git a/opentelemetry-contrib/CHANGELOG.md b/opentelemetry-contrib/CHANGELOG.md index 18dd21ec..b7e478ff 100644 --- a/opentelemetry-contrib/CHANGELOG.md +++ b/opentelemetry-contrib/CHANGELOG.md @@ -2,6 +2,11 @@ ## vNext +## v0.20.0 + +- Bump msrv to 1.75.0 +- Bump opentelemetry and opentelemetry_sdk versions to 0.28 +- Bump opentelemetry-semantic-conventions version to 0.28 - [Breaking] `JaegerJsonExporter::install_batch()` now returns `TracerProvider`. Additionally, global tracer provider now needs to be set by the user by calling `global::set_tracer_provider(tracer_provider.clone())` (original PR [opentelemetry-rust#1812](https://github.com/open-telemetry/opentelemetry-rust/pull/1812)) diff --git a/opentelemetry-contrib/Cargo.toml b/opentelemetry-contrib/Cargo.toml index 18a7f062..5a80244c 100644 --- a/opentelemetry-contrib/Cargo.toml +++ b/opentelemetry-contrib/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "opentelemetry-contrib" -version = "0.19.0" +version = "0.20.0" description = "Rust contrib repo for OpenTelemetry" homepage = "https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/main/opentelemetry-contrib" repository = "https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/main/opentelemetry-contrib" @@ -12,7 +12,7 @@ categories = [ keywords = ["opentelemetry", "tracing"] license = "Apache-2.0" edition = "2021" -rust-version = "1.70.0" +rust-version = "1.75.0" [package.metadata.docs.rs] all-features = true diff --git a/opentelemetry-contrib/benches/new_span.rs b/opentelemetry-contrib/benches/new_span.rs index 6b1e2ec5..7893a287 100644 --- a/opentelemetry-contrib/benches/new_span.rs +++ b/opentelemetry-contrib/benches/new_span.rs @@ -12,8 +12,9 @@ use opentelemetry_contrib::trace::{ new_span_if_parent_sampled, new_span_if_recording, TracerSource, }; use opentelemetry_sdk::{ - export::trace::{ExportResult, SpanData, SpanExporter}, - trace::{Sampler, TracerProvider}, + error::OTelSdkResult, + trace::{Sampler, SdkTracerProvider}, + trace::{SpanData, SpanExporter}, }; #[cfg(not(target_os = "windows"))] use pprof::criterion::{Output, PProfProfiler}; @@ -120,7 +121,7 @@ impl Environment { } } - fn setup(&self) -> (Option, BoxedTracer, Option) { + fn setup(&self) -> (Option, BoxedTracer, Option) { match self { Environment::InContext => { let guard = Context::current() @@ -150,8 +151,8 @@ impl Display for Environment { } } -fn parent_sampled_tracer(inner_sampler: Sampler) -> (TracerProvider, BoxedTracer) { - let provider = TracerProvider::builder() +fn parent_sampled_tracer(inner_sampler: Sampler) -> (SdkTracerProvider, BoxedTracer) { + let provider = SdkTracerProvider::builder() .with_sampler(Sampler::ParentBased(Box::new(inner_sampler))) .with_simple_exporter(NoopExporter) .build(); @@ -163,7 +164,7 @@ fn parent_sampled_tracer(inner_sampler: Sampler) -> (TracerProvider, BoxedTracer struct NoopExporter; impl SpanExporter for NoopExporter { - fn export(&mut self, _spans: Vec) -> BoxFuture<'static, ExportResult> { + fn export(&mut self, _spans: Vec) -> BoxFuture<'static, OTelSdkResult> { Box::pin(futures_util::future::ready(Ok(()))) } } diff --git a/opentelemetry-contrib/src/trace/exporter/jaeger_json.rs b/opentelemetry-contrib/src/trace/exporter/jaeger_json.rs index 5d478432..600ea55d 100644 --- a/opentelemetry-contrib/src/trace/exporter/jaeger_json.rs +++ b/opentelemetry-contrib/src/trace/exporter/jaeger_json.rs @@ -5,16 +5,13 @@ use async_trait::async_trait; use futures_core::future::BoxFuture; use futures_util::FutureExt; use opentelemetry::trace::SpanId; -#[cfg(any( - feature = "rt-tokio", - feature = "rt-async-std", - feature = "rt-tokio-current-thread" -))] -use opentelemetry::trace::TraceError; +#[allow(unused_imports)] +use opentelemetry_sdk::error::OTelSdkError; +use opentelemetry_sdk::runtime::RuntimeChannel; use opentelemetry_sdk::{ - export::trace::{ExportResult, SpanData, SpanExporter}, - runtime::RuntimeChannel, - trace::TracerProvider, + error::OTelSdkResult, + trace::SdkTracerProvider, + trace::{SpanData, SpanExporter}, }; use std::collections::HashMap; use std::path::{Path, PathBuf}; @@ -46,16 +43,15 @@ impl JaegerJsonExporter { } /// Install the exporter using the internal provided runtime - pub fn install_batch(self) -> TracerProvider { - let runtime = self.runtime.clone(); - TracerProvider::builder() - .with_batch_exporter(self, runtime) + pub fn install_batch(self) -> SdkTracerProvider { + SdkTracerProvider::builder() + .with_batch_exporter(self) .build() } } impl SpanExporter for JaegerJsonExporter { - fn export(&mut self, batch: Vec) -> BoxFuture<'static, ExportResult> { + fn export(&mut self, batch: Vec) -> BoxFuture<'static, OTelSdkResult> { let mut trace_map = HashMap::new(); for span in batch { @@ -212,36 +208,36 @@ fn opentelemetry_value_to_json(value: &opentelemetry::Value) -> (&str, serde_jso #[async_trait] pub trait JaegerJsonRuntime: RuntimeChannel + std::fmt::Debug { /// Create a new directory if the given path does not exist yet - async fn create_dir(&self, path: &Path) -> ExportResult; + async fn create_dir(&self, path: &Path) -> OTelSdkResult; /// Write the provided content to a new file at the given path - async fn write_to_file(&self, path: &Path, content: &[u8]) -> ExportResult; + async fn write_to_file(&self, path: &Path, content: &[u8]) -> OTelSdkResult; } #[cfg(feature = "rt-tokio")] #[async_trait] impl JaegerJsonRuntime for opentelemetry_sdk::runtime::Tokio { - async fn create_dir(&self, path: &Path) -> ExportResult { + async fn create_dir(&self, path: &Path) -> OTelSdkResult { if tokio::fs::metadata(path).await.is_err() { tokio::fs::create_dir_all(path) .await - .map_err(|e| TraceError::Other(Box::new(e)))? + .map_err(|e| OTelSdkError::InternalFailure(format!("{:?}", e)))? } Ok(()) } - async fn write_to_file(&self, path: &Path, content: &[u8]) -> ExportResult { + async fn write_to_file(&self, path: &Path, content: &[u8]) -> OTelSdkResult { use tokio::io::AsyncWriteExt; let mut file = tokio::fs::File::create(path) .await - .map_err(|e| TraceError::Other(Box::new(e)))?; + .map_err(|e| OTelSdkError::InternalFailure(format!("{:?}", e)))?; file.write_all(content) .await - .map_err(|e| TraceError::Other(Box::new(e)))?; + .map_err(|e| OTelSdkError::InternalFailure(format!("{:?}", e)))?; file.sync_data() .await - .map_err(|e| TraceError::Other(Box::new(e)))?; + .map_err(|e| OTelSdkError::InternalFailure(format!("{:?}", e)))?; Ok(()) } @@ -250,28 +246,28 @@ impl JaegerJsonRuntime for opentelemetry_sdk::runtime::Tokio { #[cfg(feature = "rt-tokio-current-thread")] #[async_trait] impl JaegerJsonRuntime for opentelemetry_sdk::runtime::TokioCurrentThread { - async fn create_dir(&self, path: &Path) -> ExportResult { + async fn create_dir(&self, path: &Path) -> OTelSdkResult { if tokio::fs::metadata(path).await.is_err() { tokio::fs::create_dir_all(path) .await - .map_err(|e| TraceError::Other(Box::new(e)))? + .map_err(|e| OTelSdkError::InternalFailure(format!("{:?}", e)))? } Ok(()) } - async fn write_to_file(&self, path: &Path, content: &[u8]) -> ExportResult { + async fn write_to_file(&self, path: &Path, content: &[u8]) -> OTelSdkResult { use tokio::io::AsyncWriteExt; let mut file = tokio::fs::File::create(path) .await - .map_err(|e| TraceError::Other(Box::new(e)))?; + .map_err(|e| OTelSdkError::InternalFailure(format!("{:?}", e)))?; file.write_all(content) .await - .map_err(|e| TraceError::Other(Box::new(e)))?; + .map_err(|e| OTelSdkError::InternalFailure(format!("{:?}", e)))?; file.sync_data() .await - .map_err(|e| TraceError::Other(Box::new(e)))?; + .map_err(|e| OTelSdkError::InternalFailure(format!("{:?}", e)))?; Ok(()) } @@ -280,27 +276,27 @@ impl JaegerJsonRuntime for opentelemetry_sdk::runtime::TokioCurrentThread { #[cfg(feature = "rt-async-std")] #[async_trait] impl JaegerJsonRuntime for opentelemetry_sdk::runtime::AsyncStd { - async fn create_dir(&self, path: &Path) -> ExportResult { + async fn create_dir(&self, path: &Path) -> OTelSdkResult { if async_std::fs::metadata(path).await.is_err() { async_std::fs::create_dir_all(path) .await - .map_err(|e| TraceError::Other(Box::new(e)))?; + .map_err(|e| OTelSdkError::InternalFailure(format!("{:?}", e)))?; } Ok(()) } - async fn write_to_file(&self, path: &Path, content: &[u8]) -> ExportResult { + async fn write_to_file(&self, path: &Path, content: &[u8]) -> OTelSdkResult { use async_std::io::WriteExt; let mut file = async_std::fs::File::create(path) .await - .map_err(|e| TraceError::Other(Box::new(e)))?; + .map_err(|e| OTelSdkError::InternalFailure(format!("{:?}", e)))?; file.write_all(content) .await - .map_err(|e| TraceError::Other(Box::new(e)))?; + .map_err(|e| OTelSdkError::InternalFailure(format!("{:?}", e)))?; file.sync_data() .await - .map_err(|e| TraceError::Other(Box::new(e)))?; + .map_err(|e| OTelSdkError::InternalFailure(format!("{:?}", e)))?; Ok(()) } diff --git a/opentelemetry-datadog/CHANGELOG.md b/opentelemetry-datadog/CHANGELOG.md index b67b0951..e5554cdf 100644 --- a/opentelemetry-datadog/CHANGELOG.md +++ b/opentelemetry-datadog/CHANGELOG.md @@ -2,6 +2,11 @@ ## vNext +## v0.16.0 + +- Bump mvrv to 1.75.0 +- Bump opentelemetry and opentelemetry_sdk versions to 0.28 +- Bump opentelemetry-http and opentelemetry-semantic-conventions versions to 0.28 - Bump thiserror to 2.0 - [Breaking] Replace `opentelemetry::global::shutdown_tracer_provider()` with `tracer_provider.shutdown()` (original PR [opentelemetry-rust#2369](https://github.com/open-telemetry/opentelemetry-rust/pull/2369)) - [Breaking] `DatadogPipelineBuilder::install_simple()` and `DatadogPipelineBuilder::install_batch()` now return `TracerProvider`. diff --git a/opentelemetry-datadog/Cargo.toml b/opentelemetry-datadog/Cargo.toml index a75185cd..6617739d 100644 --- a/opentelemetry-datadog/Cargo.toml +++ b/opentelemetry-datadog/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "opentelemetry-datadog" -version = "0.15.0" +version = "0.16.0" description = "Datadog exporters and propagators for OpenTelemetry" homepage = "https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/main/opentelemetry-datadog" repository = "https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/main/opentelemetry-datadog" @@ -9,7 +9,7 @@ categories = ["development-tools::debugging", "development-tools::profiling"] keywords = ["opentelemetry", "tracing"] license = "Apache-2.0" edition = "2021" -rust-version = "1.70.0" +rust-version = "1.75.0" [package.metadata.docs.rs] all-features = true diff --git a/opentelemetry-datadog/benches/datadog_exporter.rs b/opentelemetry-datadog/benches/datadog_exporter.rs index d97c3bcd..11c62902 100644 --- a/opentelemetry-datadog/benches/datadog_exporter.rs +++ b/opentelemetry-datadog/benches/datadog_exporter.rs @@ -1,5 +1,6 @@ use std::time::{Duration, SystemTime}; +use bytes::Bytes; use criterion::{black_box, criterion_group, criterion_main, Criterion}; use http::Request; use opentelemetry::{ @@ -9,7 +10,7 @@ use opentelemetry::{ use opentelemetry_datadog::{new_pipeline, ApiVersion}; use opentelemetry_http::HttpClient; use opentelemetry_sdk::{ - export::trace::{SpanData, SpanExporter}, + trace::{SpanData, SpanExporter}, trace::{SpanEvents, SpanLinks}, }; use rand::seq::SliceRandom; @@ -26,6 +27,15 @@ impl HttpClient for DummyClient { ) -> Result, opentelemetry_http::HttpError> { Ok(http::Response::new("dummy response".into())) } + async fn send_bytes( + &self, + request: Request, + ) -> Result, opentelemetry_http::HttpError> { + Ok(http::Response::builder() + .status(200) + .body(request.into_body()) + .unwrap()) + } } fn get_http_method(rng: &mut ThreadRng) -> String { diff --git a/opentelemetry-datadog/src/exporter/mod.rs b/opentelemetry-datadog/src/exporter/mod.rs index 5514e8a7..fe9ab618 100644 --- a/opentelemetry-datadog/src/exporter/mod.rs +++ b/opentelemetry-datadog/src/exporter/mod.rs @@ -8,20 +8,20 @@ pub use model::FieldMappingFn; use crate::exporter::model::FieldMapping; use futures_core::future::BoxFuture; use http::{Method, Request, Uri}; +use opentelemetry::Key; use opentelemetry::{trace::TraceError, KeyValue}; use opentelemetry_http::{HttpClient, ResponseExt}; use opentelemetry_sdk::{ - export::trace::{ExportResult, SpanData, SpanExporter}, + error::{OTelSdkError, OTelSdkResult}, resource::{ResourceDetector, SdkProvidedResourceDetector}, - runtime::RuntimeChannel, - trace::{Config, TracerProvider}, + trace::{Config, SdkTracerProvider}, + trace::{SpanData, SpanExporter}, Resource, }; use opentelemetry_semantic_conventions as semcov; use std::borrow::Cow; use std::fmt::{Debug, Formatter}; use std::sync::Arc; -use std::time::Duration; use url::Url; use self::model::unified_tags::UnifiedTags; @@ -94,16 +94,19 @@ impl DatadogExporter { fn build_request( &self, mut batch: Vec, - ) -> Result>, TraceError> { + ) -> Result>, OTelSdkError> { let traces: Vec<&[SpanData]> = group_into_traces(&mut batch); let trace_count = traces.len(); - let data = self.api_version.encode( - &self.model_config, - traces, - &self.mapping, - &self.unified_tags, - self.resource.as_ref(), - )?; + let data = self + .api_version + .encode( + &self.model_config, + traces, + &self.mapping, + &self.unified_tags, + self.resource.as_ref(), + ) + .map_err(|e| OTelSdkError::InternalFailure(format!("{:?}", e)))?; let req = Request::builder() .method(Method::POST) .uri(self.request_url.clone()) @@ -115,9 +118,8 @@ impl DatadogExporter { env!("CARGO_PKG_VERSION"), ) .body(data) - .map_err::(Into::into)?; - - Ok(req) + .map_err(|e| OTelSdkError::InternalFailure(format!("{:?}", e))); + Ok(req)? } } @@ -214,28 +216,32 @@ impl DatadogPipelineBuilder { let service_name = self.unified_tags.service(); if let Some(service_name) = service_name { let config = if let Some(mut cfg) = self.trace_config.take() { - cfg.resource = Cow::Owned(Resource::new( - cfg.resource - .iter() - .filter(|(k, _v)| k.as_str() != semcov::resource::SERVICE_NAME) - .map(|(k, v)| KeyValue::new(k.clone(), v.clone())), - )); + cfg.resource = Cow::Owned( + Resource::builder() + .with_attributes( + cfg.resource + .iter() + .filter(|(k, _v)| k.as_str() != semcov::resource::SERVICE_NAME) + .map(|(k, v)| KeyValue::new(k.clone(), v.clone())), + ) + .build(), + ); cfg } else { let mut cfg = Config::default(); - cfg.resource = Cow::Owned(Resource::empty()); + cfg.resource = Cow::Owned(Resource::builder_empty().build()); cfg }; (config, service_name) } else { let service_name = SdkProvidedResourceDetector - .detect(Duration::from_secs(0)) - .get(semcov::resource::SERVICE_NAME.into()) + .detect() + .get(&Key::new(semcov::resource::SERVICE_NAME)) .unwrap() .to_string(); let mut cfg = Config::default(); // use a empty resource to prevent TracerProvider to assign a service name. - cfg.resource = Cow::Owned(Resource::empty()); + cfg.resource = Cow::Owned(Resource::builder_empty().build()); (cfg, service_name) } } @@ -281,10 +287,10 @@ impl DatadogPipelineBuilder { } /// Install the Datadog trace exporter pipeline using a simple span processor. - pub fn install_simple(mut self) -> Result { + pub fn install_simple(mut self) -> Result { let (config, service_name) = self.build_config_and_service_name(); let exporter = self.build_exporter_with_service_name(service_name)?; - Ok(TracerProvider::builder() + Ok(SdkTracerProvider::builder() .with_simple_exporter(exporter) .with_resource(config.resource.into_owned()) .build()) @@ -292,14 +298,11 @@ impl DatadogPipelineBuilder { /// Install the Datadog trace exporter pipeline using a batch span processor with the specified /// runtime. - pub fn install_batch( - mut self, - runtime: R, - ) -> Result { + pub fn install_batch(mut self) -> Result { let (config, service_name) = self.build_config_and_service_name(); let exporter = self.build_exporter_with_service_name(service_name)?; - Ok(TracerProvider::builder() - .with_batch_exporter(exporter, runtime) + Ok(SdkTracerProvider::builder() + .with_batch_exporter(exporter) .with_resource(config.resource.into_owned()) .build()) } @@ -405,14 +408,23 @@ fn group_into_traces(spans: &mut [SpanData]) -> Vec<&[SpanData]> { async fn send_request( client: Arc, request: http::Request>, -) -> ExportResult { - let _ = client.send(request).await?.error_for_status()?; +) -> OTelSdkResult { + #[allow(deprecated)] + let response = client + .send(request) + .await + .map_err(|e| OTelSdkError::InternalFailure(format!("HTTP request failed: {}", e)))?; + + response + .error_for_status() + .map_err(|e| OTelSdkError::InternalFailure(format!("HTTP response error: {}", e)))?; + Ok(()) } impl SpanExporter for DatadogExporter { /// Export spans to datadog-agent - fn export(&mut self, batch: Vec) -> BoxFuture<'static, ExportResult> { + fn export(&mut self, batch: Vec) -> BoxFuture<'static, OTelSdkResult> { let request = match self.build_request(batch) { Ok(req) => req, Err(err) => return Box::pin(std::future::ready(Err(err))), @@ -444,18 +456,13 @@ fn mapping_debug(f: &Option) -> String { .to_string() } -impl opentelemetry::trace::ExportError for model::Error { - fn exporter_name(&self) -> &'static str { - "DatadogExporter" - } -} - #[cfg(test)] mod tests { use super::*; use crate::ApiVersion::Version05; use crate::exporter::model::tests::get_span; + use bytes::Bytes; #[test] fn test_out_of_order_group() { @@ -513,6 +520,15 @@ mod tests { ) -> Result, opentelemetry_http::HttpError> { Ok(http::Response::new("dummy response".into())) } + async fn send_bytes( + &self, + request: Request, + ) -> Result, opentelemetry_http::HttpError> { + Ok(http::Response::builder() + .status(200) + .body(request.into_body()) + .unwrap()) + } } #[test] @@ -537,7 +553,7 @@ mod tests { new_pipeline() .with_service_name("test_service") .with_http_client(DummyClient) - .install_batch(opentelemetry_sdk::runtime::AsyncStd {}) + .install_batch() .unwrap(); } } diff --git a/opentelemetry-datadog/src/exporter/model/mod.rs b/opentelemetry-datadog/src/exporter/model/mod.rs index 2dbf8a32..7b7d557f 100644 --- a/opentelemetry-datadog/src/exporter/model/mod.rs +++ b/opentelemetry-datadog/src/exporter/model/mod.rs @@ -1,10 +1,8 @@ use crate::exporter::ModelConfig; use http::uri; +use opentelemetry::trace::ExportError; use opentelemetry_sdk::{ - export::{ - trace::{self, SpanData}, - ExportError, - }, + trace::{self, SpanData}, Resource, }; use std::fmt::Debug; @@ -54,7 +52,7 @@ static DD_MEASURED_KEY: &str = "_dd.measured"; /// // the custom mapping below will change the all spans' name to datadog spans /// .with_name_mapping(|span, model_config|{"datadog spans"}) /// .with_agent_endpoint("http://localhost:8126") -/// .install_batch(opentelemetry_sdk::runtime::Tokio)?; +/// .install_batch()?; /// global::set_tracer_provider(provider.clone()); /// let tracer = global::tracer("opentelemetry-datadog-demo"); /// @@ -255,7 +253,9 @@ pub(crate) mod tests { service_name: "service_name".to_string(), ..Default::default() }; - let resource = Resource::new(vec![KeyValue::new("host.name", "test")]); + let resource = Resource::builder_empty() + .with_attribute(KeyValue::new("host.name", "test")) + .build(); let encoded = base64::encode(ApiVersion::Version03.encode( &model_config, traces.iter().map(|x| &x[..]).collect(), @@ -279,7 +279,9 @@ pub(crate) mod tests { service_name: "service_name".to_string(), ..Default::default() }; - let resource = Resource::new(vec![KeyValue::new("host.name", "test")]); + let resource = Resource::builder() + .with_attribute(KeyValue::new("host.name", "test")) + .build(); let mut unified_tags = UnifiedTags::new(); unified_tags.set_env(Some(String::from("test-env"))); diff --git a/opentelemetry-datadog/src/exporter/model/v03.rs b/opentelemetry-datadog/src/exporter/model/v03.rs index 0cbba9c1..6a6b0b4f 100644 --- a/opentelemetry-datadog/src/exporter/model/v03.rs +++ b/opentelemetry-datadog/src/exporter/model/v03.rs @@ -1,7 +1,7 @@ use crate::exporter::model::{Error, SAMPLING_PRIORITY_KEY}; use crate::exporter::ModelConfig; use opentelemetry::trace::Status; -use opentelemetry_sdk::export::trace::SpanData; +use opentelemetry_sdk::trace::SpanData; use opentelemetry_sdk::Resource; use std::time::SystemTime; diff --git a/opentelemetry-datadog/src/exporter/model/v05.rs b/opentelemetry-datadog/src/exporter/model/v05.rs index ef3080a5..cef89a8d 100644 --- a/opentelemetry-datadog/src/exporter/model/v05.rs +++ b/opentelemetry-datadog/src/exporter/model/v05.rs @@ -3,7 +3,7 @@ use crate::exporter::model::{DD_MEASURED_KEY, SAMPLING_PRIORITY_KEY}; use crate::exporter::{Error, ModelConfig}; use crate::propagator::DatadogTraceState; use opentelemetry::trace::Status; -use opentelemetry_sdk::export::trace::SpanData; +use opentelemetry_sdk::trace::SpanData; use opentelemetry_sdk::Resource; use std::time::SystemTime; diff --git a/opentelemetry-datadog/src/lib.rs b/opentelemetry-datadog/src/lib.rs index a3bca324..9d36cfc3 100644 --- a/opentelemetry-datadog/src/lib.rs +++ b/opentelemetry-datadog/src/lib.rs @@ -36,7 +36,8 @@ //! ## Performance //! //! For optimal performance, a batch exporter is recommended as the simple exporter will export -//! each span synchronously on drop. You can enable the [`rt-tokio`], [`rt-tokio-current-thread`] +//! each span synchronously on drop. The default batch exporter uses a dedicated thread for exprt, +//! but you can enable the async batch exporter with [`rt-tokio`], [`rt-tokio-current-thread`] //! or [`rt-async-std`] features and specify a runtime on the pipeline to have a batch exporter //! configured for you automatically. //! @@ -49,7 +50,7 @@ //! ```no_run //! # fn main() -> Result<(), opentelemetry::trace::TraceError> { //! let provider = opentelemetry_datadog::new_pipeline() -//! .install_batch(opentelemetry_sdk::runtime::Tokio)?; +//! .install_batch()?; //! # Ok(()) //! # } //! ``` @@ -82,16 +83,15 @@ //! ```no_run //! use opentelemetry::{global, KeyValue, trace::{Tracer, TracerProvider}, InstrumentationScope}; //! use opentelemetry_sdk::{trace::{self, RandomIdGenerator, Sampler}, Resource}; -//! use opentelemetry_sdk::export::trace::ExportResult; //! use opentelemetry_datadog::{new_pipeline, ApiVersion, Error}; //! use opentelemetry_http::{HttpClient, HttpError}; //! use opentelemetry_semantic_conventions as semcov; //! use async_trait::async_trait; //! use bytes::Bytes; //! use futures_util::io::AsyncReadExt as _; -//! use http::{Request, Response}; -//! use http_body_util::BodyExt; +//! use http::{Request, Response, StatusCode}; //! use std::convert::TryInto as _; +//! use http_body_util::BodyExt; //! //! // `reqwest` and `surf` are supported through features, if you prefer an //! // alternate http client you can add support by implementing `HttpClient` as @@ -112,9 +112,16 @@ //! .status(status) //! .body(body.to_bytes().into())?) //! } +//! async fn send_bytes(&self, request: Request) -> Result, HttpError> { +//! let (parts, body) = request.into_parts(); +//! //TODO - Implement a proper client +//! Ok(Response::builder() +//! .status(StatusCode::OK) +//! .body(Bytes::from("Dummy response")) +//! .unwrap()) +//! } //! } //! -//! fn main() -> Result<(), opentelemetry::trace::TraceError> { //! #[allow(deprecated)] //! let provider = new_pipeline() //! .with_service_name("my_app") @@ -125,7 +132,7 @@ //! .with_sampler(Sampler::AlwaysOn) //! .with_id_generator(RandomIdGenerator::default()) //! ) -//! .install_batch(opentelemetry_sdk::runtime::Tokio)?; +//! .install_batch().unwrap(); //! global::set_tracer_provider(provider.clone()); //! //! let scope = InstrumentationScope::builder("opentelemetry-datadog") @@ -139,10 +146,8 @@ //! // Traced app logic here... //! }); //! -//! provider.shutdown()?; // sending remaining spans before exit +//! let _ = provider.shutdown(); // sending remaining spans before exit //! -//! Ok(()) -//! } //! ``` mod exporter; diff --git a/opentelemetry-etw-logs/CHANGELOG.md b/opentelemetry-etw-logs/CHANGELOG.md index 4e45b1dd..8e46f19c 100644 --- a/opentelemetry-etw-logs/CHANGELOG.md +++ b/opentelemetry-etw-logs/CHANGELOG.md @@ -2,6 +2,11 @@ ## vNext +## v0.7.0 + +- Bump msrv to 1.75.0 +- Bump opentelemetry and opentelemetry_sdk versions to 0.28 + ## v0.6.0 ### Changed diff --git a/opentelemetry-etw-logs/Cargo.toml b/opentelemetry-etw-logs/Cargo.toml index a134d97b..54cc3a85 100644 --- a/opentelemetry-etw-logs/Cargo.toml +++ b/opentelemetry-etw-logs/Cargo.toml @@ -1,12 +1,12 @@ [package] name = "opentelemetry-etw-logs" description = "OpenTelemetry logs exporter to ETW (Event Tracing for Windows)" -version = "0.6.0" +version = "0.7.0" edition = "2021" homepage = "https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/main/opentelemetry-etw-logs" repository = "https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/main/opentelemetry-etw-logs" readme = "README.md" -rust-version = "1.70.0" +rust-version = "1.75.0" keywords = ["opentelemetry", "log", "trace", "etw"] license = "Apache-2.0" @@ -15,7 +15,6 @@ tracelogging = "1.2.1" tracelogging_dynamic = "1.2.1" opentelemetry = { workspace = true, features = ["logs"] } opentelemetry_sdk = { workspace = true, features = ["logs"] } -async-trait = { version = "0.1" } serde_json = "1.0.113" [dev-dependencies] diff --git a/opentelemetry-etw-logs/examples/basic.rs b/opentelemetry-etw-logs/examples/basic.rs index 7d3866cf..9dcaeb20 100644 --- a/opentelemetry-etw-logs/examples/basic.rs +++ b/opentelemetry-etw-logs/examples/basic.rs @@ -40,12 +40,12 @@ use opentelemetry_appender_tracing::layer; use opentelemetry_etw_logs::{ExporterConfig, ReentrantLogProcessor}; -use opentelemetry_sdk::logs::LoggerProvider; +use opentelemetry_sdk::logs::SdkLoggerProvider; use std::collections::HashMap; use tracing::error; use tracing_subscriber::prelude::*; -fn init_logger() -> LoggerProvider { +fn init_logger() -> SdkLoggerProvider { let exporter_config = ExporterConfig { default_keyword: 1, keywords_map: HashMap::new(), @@ -56,7 +56,7 @@ fn init_logger() -> LoggerProvider { None, exporter_config, ); - LoggerProvider::builder() + SdkLoggerProvider::builder() .with_log_processor(reenterant_processor) .build() } diff --git a/opentelemetry-etw-logs/src/logs/exporter.rs b/opentelemetry-etw-logs/src/logs/exporter.rs index debb6df2..1f5afa73 100644 --- a/opentelemetry-etw-logs/src/logs/exporter.rs +++ b/opentelemetry-etw-logs/src/logs/exporter.rs @@ -1,4 +1,3 @@ -use async_trait::async_trait; use std::borrow::Cow; use std::collections::HashMap; use std::fmt::Debug; @@ -11,6 +10,7 @@ use opentelemetry::{ logs::{AnyValue, Severity}, Key, }; +use opentelemetry_sdk::error::{OTelSdkError, OTelSdkResult}; use std::{str, time::SystemTime}; use crate::logs::converters::IntoJson; @@ -173,10 +173,11 @@ impl ETWExporter { pub(crate) fn export_log_data( &self, - log_record: &opentelemetry_sdk::logs::LogRecord, + log_record: &opentelemetry_sdk::logs::SdkLogRecord, instrumentation: &opentelemetry::InstrumentationScope, - ) -> opentelemetry_sdk::export::logs::ExportResult { - let level = self.get_severity_level(log_record.severity_number.unwrap_or(Severity::Debug)); + ) -> opentelemetry_sdk::error::OTelSdkResult { + let level = + self.get_severity_level(log_record.severity_number().unwrap_or(Severity::Debug)); let keyword = match self .exporter_config @@ -210,19 +211,21 @@ impl ETWExporter { match result { 0 => Ok(()), - _ => Err(format!("Failed to write event to ETW. ETW reason: {result}").into()), + _ => Err(OTelSdkError::InternalFailure(format!( + "Failed to write event to ETW. ETW reason: {result}" + ))), } } fn populate_part_a( &self, event: &mut tld::EventBuilder, - log_record: &opentelemetry_sdk::logs::LogRecord, + log_record: &opentelemetry_sdk::logs::SdkLogRecord, field_tag: u32, ) { let event_time: SystemTime = log_record - .timestamp - .or(log_record.observed_timestamp) + .timestamp() + .or(log_record.observed_timestamp()) .unwrap_or_else(SystemTime::now); const COUNT_TIME: u8 = 1u8; @@ -237,7 +240,7 @@ impl ETWExporter { fn populate_part_b( &self, event: &mut tld::EventBuilder, - log_record: &opentelemetry_sdk::logs::LogRecord, + log_record: &opentelemetry_sdk::logs::SdkLogRecord, level: tld::Level, event_id: Option, event_name: Option<&str>, @@ -248,8 +251,8 @@ impl ETWExporter { let field_count = COUNT_TYPE_NAME + COUNT_SEVERITY_NUMBER - + log_record.body.is_some() as u8 - + log_record.severity_text.is_some() as u8 + + log_record.body().is_some() as u8 + + log_record.severity_text().is_some() as u8 + event_id.is_some() as u8 + event_name.is_some() as u8; @@ -259,13 +262,13 @@ impl ETWExporter { // Fill fields of PartB struct event.add_str8("_typeName", "Logs", tld::OutType::Default, 0); - if let Some(body) = log_record.body.clone() { - add_attribute_to_event(event, &Key::new("body"), &body); + if let Some(body) = log_record.body() { + add_attribute_to_event(event, &Key::new("body"), body); } event.add_u8("severityNumber", level.as_int(), tld::OutType::Default, 0); - if let Some(severity_text) = &log_record.severity_text { + if let Some(severity_text) = &log_record.severity_text() { event.add_str8("severityText", severity_text, tld::OutType::Default, 0); } @@ -281,7 +284,7 @@ impl ETWExporter { fn populate_part_c<'a>( &'a self, event: &mut tld::EventBuilder, - log_record: &'a opentelemetry_sdk::logs::LogRecord, + log_record: &'a opentelemetry_sdk::logs::SdkLogRecord, field_tag: u32, ) -> (Option, Option<&'a str>) { //populate CS PartC @@ -337,16 +340,18 @@ impl Debug for ETWExporter { } } -#[async_trait] -impl opentelemetry_sdk::export::logs::LogExporter for ETWExporter { - async fn export( - &mut self, - batch: opentelemetry_sdk::export::logs::LogBatch<'_>, - ) -> opentelemetry_sdk::logs::LogResult<()> { - for (log_record, instrumentation) in batch.iter() { - let _ = self.export_log_data(log_record, instrumentation); +impl opentelemetry_sdk::logs::LogExporter for ETWExporter { + #[allow(clippy::manual_async_fn)] + fn export( + &self, + batch: opentelemetry_sdk::logs::LogBatch<'_>, + ) -> impl std::future::Future + Send { + async move { + for (log_record, instrumentation) in batch.iter() { + let _ = self.export_log_data(log_record, instrumentation); + } + Ok(()) } - Ok(()) } #[cfg(feature = "logs_level_enabled")] @@ -408,7 +413,10 @@ fn add_attribute_to_event(event: &mut tld::EventBuilder, key: &Key, value: &AnyV #[cfg(test)] mod tests { use super::*; + use opentelemetry::logs::Logger; + use opentelemetry::logs::LoggerProvider; use opentelemetry::logs::Severity; + use opentelemetry_sdk::logs::SdkLoggerProvider; #[test] fn test_export_log_data() { @@ -418,7 +426,10 @@ mod tests { None, ExporterConfig::default(), ); - let record = Default::default(); + let record = SdkLoggerProvider::builder() + .build() + .logger("test") + .create_log_record(); let instrumentation = Default::default(); let result = exporter.export_log_data(&record, &instrumentation); diff --git a/opentelemetry-etw-logs/src/logs/reentrant_logprocessor.rs b/opentelemetry-etw-logs/src/logs/reentrant_logprocessor.rs index 868c12c4..8a4a6e83 100644 --- a/opentelemetry-etw-logs/src/logs/reentrant_logprocessor.rs +++ b/opentelemetry-etw-logs/src/logs/reentrant_logprocessor.rs @@ -1,11 +1,11 @@ use std::fmt::Debug; use opentelemetry::InstrumentationScope; -use opentelemetry_sdk::logs::LogRecord; -use opentelemetry_sdk::logs::LogResult; +use opentelemetry_sdk::error::OTelSdkResult; +use opentelemetry_sdk::logs::SdkLogRecord; #[cfg(feature = "logs_level_enabled")] -use opentelemetry_sdk::export::logs::LogExporter; +use opentelemetry_sdk::logs::LogExporter; use crate::logs::exporter::ExporterConfig; use crate::logs::exporter::*; @@ -33,19 +33,19 @@ impl ReentrantLogProcessor { } impl opentelemetry_sdk::logs::LogProcessor for ReentrantLogProcessor { - fn emit(&self, data: &mut LogRecord, instrumentation: &InstrumentationScope) { + fn emit(&self, data: &mut SdkLogRecord, instrumentation: &InstrumentationScope) { _ = self.event_exporter.export_log_data(data, instrumentation); } // This is a no-op as this processor doesn't keep anything // in memory to be flushed out. - fn force_flush(&self) -> LogResult<()> { + fn force_flush(&self) -> OTelSdkResult { Ok(()) } // This is a no-op no special cleanup is required before // shutdown. - fn shutdown(&self) -> LogResult<()> { + fn shutdown(&self) -> OTelSdkResult { Ok(()) } @@ -63,7 +63,10 @@ impl opentelemetry_sdk::logs::LogProcessor for ReentrantLogProcessor { #[cfg(test)] mod tests { use super::*; + use opentelemetry::logs::Logger; + use opentelemetry::logs::LoggerProvider; use opentelemetry_sdk::logs::LogProcessor; + use opentelemetry_sdk::logs::SdkLoggerProvider; #[test] fn test_shutdown() { @@ -98,7 +101,10 @@ mod tests { ExporterConfig::default(), ); - let mut record = Default::default(); + let mut record = SdkLoggerProvider::builder() + .build() + .logger("test") + .create_log_record(); let instrumentation = Default::default(); processor.emit(&mut record, &instrumentation); } diff --git a/opentelemetry-etw-metrics/CHANGELOG.md b/opentelemetry-etw-metrics/CHANGELOG.md index 12067a2a..356f1c4a 100644 --- a/opentelemetry-etw-metrics/CHANGELOG.md +++ b/opentelemetry-etw-metrics/CHANGELOG.md @@ -2,6 +2,12 @@ ## vNext +## v0.7.0 + +- Bump msrv to 1.75.0 +- Bump opentelemetry and opentelemetry_sdk versions to 0.28 +- Bump opentelemetry-proto version to 0.28 + ## v0.6.0 - Bump opentelemetry and opentelemetry_sdk versions to 0.27 diff --git a/opentelemetry-etw-metrics/Cargo.toml b/opentelemetry-etw-metrics/Cargo.toml index 4fae806c..21f13966 100644 --- a/opentelemetry-etw-metrics/Cargo.toml +++ b/opentelemetry-etw-metrics/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "opentelemetry-etw-metrics" -version = "0.6.0" +version = "0.7.0" edition = "2021" description = "OpenTelemetry metrics exporter to ETW (Event Tracing for Windows)" homepage = "https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/main/opentelemetry-etw-metrics" @@ -8,7 +8,7 @@ repository = "https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/ readme = "README.md" keywords = ["opentelemetry", "metrics", "etw"] license = "Apache-2.0" -rust-version = "1.71.1" +rust-version = "1.75.0" [dependencies] opentelemetry = { workspace = true, features = ["metrics"] } diff --git a/opentelemetry-etw-metrics/benches/exporter.rs b/opentelemetry-etw-metrics/benches/exporter.rs index 5ffa1e56..a5a6d507 100644 --- a/opentelemetry-etw-metrics/benches/exporter.rs +++ b/opentelemetry-etw-metrics/benches/exporter.rs @@ -18,7 +18,7 @@ use opentelemetry_etw_metrics::MetricsExporter; use opentelemetry_sdk::{ metrics::{ - data::{DataPoint, Metric, ResourceMetrics, ScopeMetrics, Sum}, + data::{Metric, ResourceMetrics, ScopeMetrics, Sum, SumDataPoint}, exporter::PushMetricExporter, Temporality, }, @@ -34,10 +34,8 @@ async fn export(exporter: &MetricsExporter, resource_metrics: &mut ResourceMetri fn create_resource_metrics() -> ResourceMetrics { // Metric does not implement clone so this helper function is used to create a metric fn create_metric() -> Metric { - let data_point = DataPoint { + let data_point = SumDataPoint { attributes: vec![KeyValue::new("datapoint key", "datapoint value")], - start_time: Some(std::time::SystemTime::now()), - time: Some(std::time::SystemTime::now()), value: 1.0_f64, exemplars: vec![], }; @@ -45,6 +43,8 @@ fn create_resource_metrics() -> ResourceMetrics { let sum: Sum = Sum { data_points: vec![data_point.clone(); 2_000], temporality: Temporality::Delta, + start_time: std::time::SystemTime::now(), + time: std::time::SystemTime::now(), is_monotonic: true, }; @@ -57,7 +57,9 @@ fn create_resource_metrics() -> ResourceMetrics { } ResourceMetrics { - resource: Resource::new(vec![KeyValue::new("service.name", "my-service")]), + resource: Resource::builder() + .with_attributes(vec![KeyValue::new("service.name", "my-service")]) + .build(), scope_metrics: vec![ScopeMetrics { scope: InstrumentationScope::default(), metrics: vec![ diff --git a/opentelemetry-etw-metrics/examples/basic.rs b/opentelemetry-etw-metrics/examples/basic.rs index 79be9402..19af8885 100644 --- a/opentelemetry-etw-metrics/examples/basic.rs +++ b/opentelemetry-etw-metrics/examples/basic.rs @@ -3,19 +3,20 @@ use opentelemetry::{global, metrics::MeterProvider as _, KeyValue}; use opentelemetry_etw_metrics::MetricsExporter; use opentelemetry_sdk::{ metrics::{PeriodicReader, SdkMeterProvider}, - runtime, Resource, + Resource, }; const SERVICE_NAME: &str = "service-name"; fn setup_meter_provider() -> SdkMeterProvider { let exporter = MetricsExporter::new(); - let reader = PeriodicReader::builder(exporter, runtime::Tokio).build(); + let reader = PeriodicReader::builder(exporter).build(); SdkMeterProvider::builder() - .with_resource(Resource::new(vec![KeyValue::new( - "service.name", - SERVICE_NAME, - )])) + .with_resource( + Resource::builder() + .with_attributes(vec![KeyValue::new("service.name", SERVICE_NAME)]) + .build(), + ) .with_reader(reader) .build() } diff --git a/opentelemetry-etw-metrics/src/exporter/mod.rs b/opentelemetry-etw-metrics/src/exporter/mod.rs index ce1fc3a6..bba7419d 100644 --- a/opentelemetry-etw-metrics/src/exporter/mod.rs +++ b/opentelemetry-etw-metrics/src/exporter/mod.rs @@ -10,8 +10,9 @@ use opentelemetry_proto::tonic::{ Sum as TonicSum, Summary as TonicSummary, }, }; +use opentelemetry_sdk::error::{OTelSdkError, OTelSdkResult}; use opentelemetry_sdk::metrics::{ - data::ResourceMetrics, exporter::PushMetricExporter, MetricError, MetricResult, Temporality, + data::ResourceMetrics, exporter::PushMetricExporter, Temporality, }; use std::fmt::{Debug, Formatter}; @@ -44,7 +45,7 @@ impl Debug for MetricsExporter { fn emit_export_metric_service_request( export_metric_service_request: &ExportMetricsServiceRequest, encoding_buffer: &mut Vec, -) -> MetricResult<()> { +) -> OTelSdkResult { if (export_metric_service_request.encoded_len()) > etw::MAX_EVENT_SIZE { otel_warn!(name: "MetricExportFailedDueToMaxSizeLimit", size = export_metric_service_request.encoded_len(), max_size = etw::MAX_EVENT_SIZE); } else { @@ -55,7 +56,7 @@ fn emit_export_metric_service_request( export_metric_service_request .encode(encoding_buffer) - .map_err(|err| MetricError::Other(err.to_string()))?; + .map_err(|err| OTelSdkError::InternalFailure(err.to_string()))?; let result = etw::write(encoding_buffer); // TODO: Better logging/internal metrics needed here for non-failure @@ -72,7 +73,7 @@ fn emit_export_metric_service_request( #[async_trait] impl PushMetricExporter for MetricsExporter { - async fn export(&self, metrics: &mut ResourceMetrics) -> MetricResult<()> { + async fn export(&self, metrics: &mut ResourceMetrics) -> OTelSdkResult { let schema_url: String = metrics .resource .schema_url() @@ -191,11 +192,11 @@ impl PushMetricExporter for MetricsExporter { Ok(()) } - async fn force_flush(&self) -> MetricResult<()> { + async fn force_flush(&self) -> OTelSdkResult { Ok(()) } - fn shutdown(&self) -> MetricResult<()> { + fn shutdown(&self) -> OTelSdkResult { etw::unregister(); Ok(()) @@ -211,7 +212,7 @@ mod tests { use opentelemetry::{metrics::MeterProvider as _, KeyValue}; use opentelemetry_sdk::{ metrics::{PeriodicReader, SdkMeterProvider}, - runtime, Resource, + Resource, }; use crate::etw; @@ -219,12 +220,13 @@ mod tests { #[tokio::test(flavor = "multi_thread")] async fn emit_metrics_that_combined_exceed_etw_max_event_size() { let exporter = super::MetricsExporter::new(); - let reader = PeriodicReader::builder(exporter, runtime::Tokio).build(); + let reader = PeriodicReader::builder(exporter).build(); let meter_provider = SdkMeterProvider::builder() - .with_resource(Resource::new(vec![KeyValue::new( - "service.name", - "service-name", - )])) + .with_resource( + Resource::builder() + .with_attributes(vec![KeyValue::new("service.name", "service-name")]) + .build(), + ) .with_reader(reader) .build(); diff --git a/opentelemetry-resource-detectors/CHANGELOG.md b/opentelemetry-resource-detectors/CHANGELOG.md index fe5bdaba..c7d6bfd3 100644 --- a/opentelemetry-resource-detectors/CHANGELOG.md +++ b/opentelemetry-resource-detectors/CHANGELOG.md @@ -2,6 +2,12 @@ ## vNext +## v0.7.0 + +- Bump msrv to 1.75.0 +- Bump opentelemetry and opentelemetry_sdk versions to 0.28 +- Bump opentelemetry-semantic-conventions version to 0.28 + ## v0.6.0 ### Changed diff --git a/opentelemetry-resource-detectors/Cargo.toml b/opentelemetry-resource-detectors/Cargo.toml index 4a189472..c3150c69 100644 --- a/opentelemetry-resource-detectors/Cargo.toml +++ b/opentelemetry-resource-detectors/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "opentelemetry-resource-detectors" -version = "0.6.0" +version = "0.7.0" edition = "2021" description = "A collection of community supported resource detectors for OpenTelemetry" homepage = "https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/main/opentelemetry-resource-detectors" @@ -8,7 +8,7 @@ repository = "https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/ readme = "README.md" keywords = ["opentelemetry", "resource", "detector"] license = "Apache-2.0" -rust-version = "1.70.0" +rust-version = "1.75.0" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html diff --git a/opentelemetry-resource-detectors/src/host.rs b/opentelemetry-resource-detectors/src/host.rs index febed0d0..8a2c2ec2 100644 --- a/opentelemetry-resource-detectors/src/host.rs +++ b/opentelemetry-resource-detectors/src/host.rs @@ -11,7 +11,6 @@ use std::fs::read_to_string; use std::path::Path; #[cfg(target_os = "macos")] use std::process::Command; -use std::time::Duration; /// Detect host information. /// @@ -24,25 +23,27 @@ pub struct HostResourceDetector { } impl ResourceDetector for HostResourceDetector { - fn detect(&self, _timeout: Duration) -> Resource { - Resource::new( - [ - // Get host.id - (self.host_id_detect)().map(|host_id| { - KeyValue::new( - opentelemetry_semantic_conventions::attribute::HOST_ID, - host_id, - ) - }), - // Get host.arch - Some(KeyValue::new( - opentelemetry_semantic_conventions::attribute::HOST_ARCH, - ARCH, - )), - ] - .into_iter() - .flatten(), - ) + fn detect(&self) -> Resource { + Resource::builder_empty() + .with_attributes( + [ + // Get host.id + (self.host_id_detect)().map(|host_id| { + KeyValue::new( + opentelemetry_semantic_conventions::attribute::HOST_ID, + host_id, + ) + }), + // Get host.arch + Some(KeyValue::new( + opentelemetry_semantic_conventions::attribute::HOST_ARCH, + ARCH, + )), + ] + .into_iter() + .flatten(), + ) + .build() } } @@ -91,20 +92,19 @@ mod tests { use super::HostResourceDetector; use opentelemetry::{Key, Value}; use opentelemetry_sdk::resource::ResourceDetector; - use std::time::Duration; #[cfg(target_os = "linux")] #[test] fn test_host_resource_detector_linux() { - let resource = HostResourceDetector::default().detect(Duration::from_secs(0)); + let resource = HostResourceDetector::default().detect(); assert_eq!(resource.len(), 2); assert!(resource - .get(Key::from_static_str( + .get(&Key::from_static_str( opentelemetry_semantic_conventions::attribute::HOST_ID )) .is_some()); assert!(resource - .get(Key::from_static_str( + .get(&Key::from_static_str( opentelemetry_semantic_conventions::attribute::HOST_ARCH )) .is_some()) @@ -130,17 +130,17 @@ mod tests { #[test] fn test_resource_host_arch_value() { - let resource = HostResourceDetector::default().detect(Duration::from_secs(0)); + let resource = HostResourceDetector::default().detect(); assert!(resource - .get(Key::from_static_str( + .get(&Key::from_static_str( opentelemetry_semantic_conventions::attribute::HOST_ARCH )) .is_some()); #[cfg(target_arch = "x86_64")] assert_eq!( - resource.get(Key::from_static_str( + resource.get(&Key::from_static_str( opentelemetry_semantic_conventions::attribute::HOST_ARCH )), Some(Value::from("x86_64")) @@ -148,7 +148,7 @@ mod tests { #[cfg(target_arch = "aarch64")] assert_eq!( - resource.get(Key::from_static_str( + resource.get(&Key::from_static_str( opentelemetry_semantic_conventions::attribute::HOST_ARCH )), Some(Value::from("aarch64")) diff --git a/opentelemetry-resource-detectors/src/os.rs b/opentelemetry-resource-detectors/src/os.rs index 7dc37b69..8a578619 100644 --- a/opentelemetry-resource-detectors/src/os.rs +++ b/opentelemetry-resource-detectors/src/os.rs @@ -5,7 +5,6 @@ use opentelemetry::KeyValue; use opentelemetry_sdk::resource::ResourceDetector; use opentelemetry_sdk::Resource; use std::env::consts::OS; -use std::time::Duration; /// Detect runtime operating system information. /// @@ -17,11 +16,13 @@ use std::time::Duration; pub struct OsResourceDetector; impl ResourceDetector for OsResourceDetector { - fn detect(&self, _timeout: Duration) -> Resource { - Resource::new(vec![KeyValue::new( - opentelemetry_semantic_conventions::attribute::OS_TYPE, - OS, - )]) + fn detect(&self) -> Resource { + Resource::builder_empty() + .with_attributes(vec![KeyValue::new( + opentelemetry_semantic_conventions::attribute::OS_TYPE, + OS, + )]) + .build() } } @@ -31,14 +32,13 @@ mod tests { use super::OsResourceDetector; use opentelemetry::{Key, Value}; use opentelemetry_sdk::resource::ResourceDetector; - use std::time::Duration; #[test] fn test_os_resource_detector() { - let resource = OsResourceDetector.detect(Duration::from_secs(0)); + let resource = OsResourceDetector.detect(); assert_eq!(resource.len(), 1); assert_eq!( - resource.get(Key::from_static_str( + resource.get(&Key::from_static_str( opentelemetry_semantic_conventions::attribute::OS_TYPE )), Some(Value::from("linux")) diff --git a/opentelemetry-resource-detectors/src/process.rs b/opentelemetry-resource-detectors/src/process.rs index cafd8e24..c8a49e72 100644 --- a/opentelemetry-resource-detectors/src/process.rs +++ b/opentelemetry-resource-detectors/src/process.rs @@ -7,7 +7,6 @@ use opentelemetry_sdk::resource::ResourceDetector; use opentelemetry_sdk::Resource; use std::env::args_os; use std::process::id; -use std::time::Duration; /// Detect process information. /// @@ -19,22 +18,24 @@ use std::time::Duration; pub struct ProcessResourceDetector; impl ResourceDetector for ProcessResourceDetector { - fn detect(&self, _timeout: Duration) -> Resource { + fn detect(&self) -> Resource { let arguments = args_os(); let cmd_arg_val = arguments .into_iter() .map(|arg| arg.to_string_lossy().into_owned().into()) .collect::>(); - Resource::new(vec![ - KeyValue::new( - opentelemetry_semantic_conventions::attribute::PROCESS_COMMAND_ARGS, - Value::Array(cmd_arg_val.into()), - ), - KeyValue::new( - opentelemetry_semantic_conventions::attribute::PROCESS_PID, - id() as i64, - ), - ]) + Resource::builder_empty() + .with_attributes(vec![ + KeyValue::new( + opentelemetry_semantic_conventions::attribute::PROCESS_COMMAND_ARGS, + Value::Array(cmd_arg_val.into()), + ), + KeyValue::new( + opentelemetry_semantic_conventions::attribute::PROCESS_PID, + id() as i64, + ), + ]) + .build() } } @@ -44,11 +45,9 @@ mod tests { use super::ProcessResourceDetector; use opentelemetry_sdk::resource::ResourceDetector; - use std::time::Duration; - #[test] fn test_processor_resource_detector() { - let resource = ProcessResourceDetector.detect(Duration::from_secs(0)); + let resource = ProcessResourceDetector.detect(); assert_eq!(resource.len(), 2); // we cannot assert on the values because it changes along with runtime. } } diff --git a/opentelemetry-stackdriver/CHANGELOG.md b/opentelemetry-stackdriver/CHANGELOG.md index 39af5ba6..4ada9950 100644 --- a/opentelemetry-stackdriver/CHANGELOG.md +++ b/opentelemetry-stackdriver/CHANGELOG.md @@ -4,6 +4,10 @@ ### Changed +## v0.25.0 + +- Bump msrv to 1.75.0 +- Update to opentelemetry v0.28.0, opentelemetry_sdk v0.28.0, opentelemetry-semantic-conventions v0.28.0 - Remove `server` feature from tonic dependency - Bump thiserror to 2.0 diff --git a/opentelemetry-stackdriver/Cargo.toml b/opentelemetry-stackdriver/Cargo.toml index 81d51608..c157402f 100644 --- a/opentelemetry-stackdriver/Cargo.toml +++ b/opentelemetry-stackdriver/Cargo.toml @@ -1,13 +1,13 @@ [package] name = "opentelemetry-stackdriver" -version = "0.24.0" +version = "0.25.0" description = "A Rust opentelemetry exporter that uploads traces to Google Stackdriver trace." documentation = "https://docs.rs/opentelemetry-stackdriver/" repository = "https://github.com/open-telemetry/opentelemetry-rust-contrib" license = "Apache-2.0" edition = "2021" exclude = ["/proto"] -rust-version = "1.71.1" +rust-version = "1.75.0" [dependencies] async-trait = "0.1.48" diff --git a/opentelemetry-stackdriver/src/lib.rs b/opentelemetry-stackdriver/src/lib.rs index e2f0f76e..7437da32 100644 --- a/opentelemetry-stackdriver/src/lib.rs +++ b/opentelemetry-stackdriver/src/lib.rs @@ -31,8 +31,9 @@ use opentelemetry::{ trace::{SpanId, TraceError}, Key, KeyValue, Value, }; +use opentelemetry_sdk::error::{OTelSdkError, OTelSdkResult}; use opentelemetry_sdk::{ - export::trace::{ExportResult, SpanData, SpanExporter}, + trace::{SpanData, SpanExporter}, Resource, }; use opentelemetry_semantic_conventions as semconv; @@ -87,11 +88,11 @@ impl StackDriverExporter { } impl SpanExporter for StackDriverExporter { - fn export(&mut self, batch: Vec) -> BoxFuture<'static, ExportResult> { + fn export(&mut self, batch: Vec) -> BoxFuture<'static, OTelSdkResult> { match self.tx.try_send(batch) { - Err(e) => Box::pin(std::future::ready(Err(TraceError::Other(Box::new( - e.into_send_error(), - ))))), + Err(e) => Box::pin(std::future::ready(Err(OTelSdkError::InternalFailure( + format!("{:?}", e), + )))), Ok(()) => { self.pending_count.fetch_add(1, Ordering::Relaxed); Box::pin(std::future::ready(Ok(()))) @@ -99,13 +100,14 @@ impl SpanExporter for StackDriverExporter { } } - fn shutdown(&mut self) { + fn shutdown(&mut self) -> OTelSdkResult { let start = Instant::now(); while (Instant::now() - start) < self.maximum_shutdown_duration && self.pending_count() > 0 { std::thread::yield_now(); // Spin for a bit and give the inner export some time to upload, with a timeout. } + Ok(()) } fn set_resource(&mut self, resource: &Resource) { @@ -890,10 +892,12 @@ mod tests { )); // serviceAttribute = "service.name" - let resources = Resource::new([KeyValue::new( - semcov::resource::SERVICE_NAME, - "Test Service Name", - )]); + let resources = Resource::builder_empty() + .with_attributes([KeyValue::new( + semcov::resource::SERVICE_NAME, + "Test Service Name", + )]) + .build(); let actual = Attributes::new(attributes, Some(&resources)); assert_eq!(actual.attribute_map.len(), 8); @@ -940,10 +944,12 @@ mod tests { #[test] fn test_too_many() { - let resources = Resource::new([KeyValue::new( - semconv::attribute::USER_AGENT_ORIGINAL, - "Test Service Name UA", - )]); + let resources = Resource::builder_empty() + .with_attributes([KeyValue::new( + semconv::attribute::USER_AGENT_ORIGINAL, + "Test Service Name UA", + )]) + .build(); let mut attributes = Vec::with_capacity(32); for i in 0..32 { attributes.push(KeyValue::new( @@ -972,7 +978,7 @@ mod tests { // hostAttribute = "http.target" - let resources = Resource::new([]); + let resources = Resource::builder_empty().with_attributes([]).build(); let actual = Attributes::new(attributes, Some(&resources)); assert_eq!(actual.attribute_map.len(), 1); assert_eq!(actual.dropped_attributes_count, 0); @@ -988,7 +994,7 @@ mod tests { fn test_attributes_mapping_dropped_attributes_count() { let attributes = vec![KeyValue::new("answer", Value::I64(42)),KeyValue::new("long_attribute_key_dvwmacxpeefbuemoxljmqvldjxmvvihoeqnuqdsyovwgljtnemouidabhkmvsnauwfnaihekcfwhugejboiyfthyhmkpsaxtidlsbwsmirebax", Value::String("Some value".into()))]; - let resources = Resource::new([]); + let resources = Resource::builder_empty().with_attributes([]).build(); let actual = Attributes::new(attributes, Some(&resources)); assert_eq!( actual, diff --git a/opentelemetry-user-events-logs/CHANGELOG.md b/opentelemetry-user-events-logs/CHANGELOG.md index 0ecd91bf..4f32d758 100644 --- a/opentelemetry-user-events-logs/CHANGELOG.md +++ b/opentelemetry-user-events-logs/CHANGELOG.md @@ -2,6 +2,10 @@ ## vNext +## v0.9.0 + +- Bump msrv to 1.75.0 +- Bump opentelemetry and opentelemetry_sdk versions to 0.28 - Renamed `logs_level_enabled` flag to `spec_unstable_logs_enabled` to be consistent with core repo. ## v0.8.0 diff --git a/opentelemetry-user-events-logs/Cargo.toml b/opentelemetry-user-events-logs/Cargo.toml index 90caa929..259e2777 100644 --- a/opentelemetry-user-events-logs/Cargo.toml +++ b/opentelemetry-user-events-logs/Cargo.toml @@ -1,12 +1,12 @@ [package] name = "opentelemetry-user-events-logs" description = "OpenTelemetry-Rust exporter to userevents" -version = "0.8.0" +version = "0.9.0" edition = "2021" homepage = "https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/main/opentelemetry-user-events-logs" repository = "https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/main/opentelemetry-user-events-logs" readme = "README.md" -rust-version = "1.70.0" +rust-version = "1.75.0" keywords = ["opentelemetry", "log", "trace", "user_events"] license = "Apache-2.0" @@ -15,7 +15,6 @@ eventheader = "0.4.0" eventheader_dynamic = "0.4.0" opentelemetry = { workspace = true, features = ["logs"] } opentelemetry_sdk = { workspace = true, features = ["logs"] } -async-trait = { version="0.1" } chrono = { version = "0.4", default-features = false, features = ["std"] } [dev-dependencies] diff --git a/opentelemetry-user-events-logs/examples/basic-logs.rs b/opentelemetry-user-events-logs/examples/basic-logs.rs index c0329b15..b24069b4 100644 --- a/opentelemetry-user-events-logs/examples/basic-logs.rs +++ b/opentelemetry-user-events-logs/examples/basic-logs.rs @@ -1,20 +1,20 @@ //! run with `$ cargo run --example basic-logs --all-features use opentelemetry_appender_tracing::layer; -use opentelemetry_sdk::logs::LoggerProvider; +use opentelemetry_sdk::logs::SdkLoggerProvider; use opentelemetry_user_events_logs::{ExporterConfig, ReentrantLogProcessor, UserEventsExporter}; use std::collections::HashMap; use tracing::error; use tracing_subscriber::prelude::*; -fn init_logger() -> LoggerProvider { +fn init_logger() -> SdkLoggerProvider { let exporter_config = ExporterConfig { default_keyword: 1, keywords_map: HashMap::new(), }; let exporter = UserEventsExporter::new("test", None, exporter_config); let reenterant_processor = ReentrantLogProcessor::new(exporter); - LoggerProvider::builder() + SdkLoggerProvider::builder() .with_log_processor(reenterant_processor) .build() } diff --git a/opentelemetry-user-events-logs/src/logs/exporter.rs b/opentelemetry-user-events-logs/src/logs/exporter.rs index b69a5e0a..639ff19e 100644 --- a/opentelemetry-user-events-logs/src/logs/exporter.rs +++ b/opentelemetry-user-events-logs/src/logs/exporter.rs @@ -1,4 +1,3 @@ -use async_trait::async_trait; use eventheader::{FieldFormat, Level, Opcode}; use eventheader_dynamic::EventBuilder; use std::borrow::Cow; @@ -6,6 +5,7 @@ use std::collections::HashMap; use std::fmt::Debug; use opentelemetry::{logs::AnyValue, logs::Severity, Key}; +use opentelemetry_sdk::error::OTelSdkResult; use std::{cell::RefCell, str, time::SystemTime}; /// Provider group associated with the user_events exporter @@ -165,12 +165,12 @@ impl UserEventsExporter { pub(crate) fn export_log_data( &self, - log_record: &opentelemetry_sdk::logs::LogRecord, + log_record: &opentelemetry_sdk::logs::SdkLogRecord, instrumentation: &opentelemetry::InstrumentationScope, - ) -> opentelemetry_sdk::export::logs::ExportResult { + ) -> opentelemetry_sdk::error::OTelSdkResult { let mut level: Level = Level::Invalid; - if log_record.severity_number.is_some() { - level = self.get_severity_level(log_record.severity_number.unwrap()); + if log_record.severity_number().is_some() { + level = self.get_severity_level(log_record.severity_number().unwrap()); } let keyword = self @@ -201,8 +201,8 @@ impl UserEventsExporter { // populate CS PartA let mut cs_a_count = 0; let event_time: SystemTime = log_record - .timestamp - .or(log_record.observed_timestamp) + .timestamp() + .or(log_record.observed_timestamp()) .unwrap_or_else(SystemTime::now); cs_a_count += 1; // for event_time eb.add_struct("PartA", cs_a_count, 0); @@ -256,10 +256,10 @@ impl UserEventsExporter { eb.add_str("_typeName", "Logs", FieldFormat::Default, 0); cs_b_count += 1; - if log_record.body.is_some() { + if log_record.body().is_some() { eb.add_str( "body", - match log_record.body.as_ref().unwrap() { + match log_record.body().as_ref().unwrap() { AnyValue::Int(value) => value.to_string(), AnyValue::String(value) => value.to_string(), AnyValue::Boolean(value) => value.to_string(), @@ -278,10 +278,10 @@ impl UserEventsExporter { eb.add_value("severityNumber", level.as_int(), FieldFormat::SignedInt, 0); cs_b_count += 1; } - if log_record.severity_text.is_some() { + if log_record.severity_text().is_some() { eb.add_str( "severityText", - log_record.severity_text.as_ref().unwrap(), + log_record.severity_text().as_ref().unwrap(), FieldFormat::SignedInt, 0, ); @@ -311,16 +311,18 @@ impl Debug for UserEventsExporter { } } -#[async_trait] -impl opentelemetry_sdk::export::logs::LogExporter for UserEventsExporter { - async fn export( - &mut self, - batch: opentelemetry_sdk::export::logs::LogBatch<'_>, - ) -> opentelemetry_sdk::logs::LogResult<()> { - for (record, instrumentation) in batch.iter() { - let _ = self.export_log_data(record, instrumentation); +impl opentelemetry_sdk::logs::LogExporter for UserEventsExporter { + #[allow(clippy::manual_async_fn)] + fn export( + &self, + batch: opentelemetry_sdk::logs::LogBatch<'_>, + ) -> impl std::future::Future + Send { + async move { + for (record, instrumentation) in batch.iter() { + let _ = self.export_log_data(record, instrumentation); + } + Ok(()) } - Ok(()) } #[cfg(feature = "spec_unstable_logs_enabled")] diff --git a/opentelemetry-user-events-logs/src/logs/reentrant_logprocessor.rs b/opentelemetry-user-events-logs/src/logs/reentrant_logprocessor.rs index ed408d21..a1dc2d65 100644 --- a/opentelemetry-user-events-logs/src/logs/reentrant_logprocessor.rs +++ b/opentelemetry-user-events-logs/src/logs/reentrant_logprocessor.rs @@ -1,9 +1,9 @@ use std::fmt::Debug; -use opentelemetry_sdk::logs::LogResult; +use opentelemetry_sdk::error::OTelSdkResult; #[cfg(feature = "spec_unstable_logs_enabled")] -use opentelemetry_sdk::export::logs::LogExporter; +use opentelemetry_sdk::logs::LogExporter; use crate::logs::exporter::*; @@ -28,7 +28,7 @@ impl ReentrantLogProcessor { impl opentelemetry_sdk::logs::LogProcessor for ReentrantLogProcessor { fn emit( &self, - record: &mut opentelemetry_sdk::logs::LogRecord, + record: &mut opentelemetry_sdk::logs::SdkLogRecord, instrumentation: &opentelemetry::InstrumentationScope, ) { _ = self.event_exporter.export_log_data(record, instrumentation); @@ -36,13 +36,13 @@ impl opentelemetry_sdk::logs::LogProcessor for ReentrantLogProcessor { // This is a no-op as this processor doesn't keep anything // in memory to be flushed out. - fn force_flush(&self) -> LogResult<()> { + fn force_flush(&self) -> OTelSdkResult { Ok(()) } // This is a no-op no special cleanup is required before // shutdown. - fn shutdown(&self) -> LogResult<()> { + fn shutdown(&self) -> OTelSdkResult { Ok(()) } diff --git a/opentelemetry-user-events-metrics/CHANGELOG.md b/opentelemetry-user-events-metrics/CHANGELOG.md index 76bb6655..74e8bfa1 100644 --- a/opentelemetry-user-events-metrics/CHANGELOG.md +++ b/opentelemetry-user-events-metrics/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog +## vNext + +## v0.9.0 + +- Bump msrv to 1.75.0 +- Bump opentelemetry and opentelemetry_sdk versions to 0.28 +- Bump opentelemetry-proto version to 0.28 + ## v0.8.0 ### Changed diff --git a/opentelemetry-user-events-metrics/Cargo.toml b/opentelemetry-user-events-metrics/Cargo.toml index 3f17bbc0..2f067ecd 100644 --- a/opentelemetry-user-events-metrics/Cargo.toml +++ b/opentelemetry-user-events-metrics/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "opentelemetry-user-events-metrics" -version = "0.8.0" +version = "0.9.0" description = "OpenTelemetry metrics exporter to user events" homepage = "https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/main/opentelemetry-user-events-metrics" repository = "https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/main/opentelemetry-user-events-metrics" @@ -8,7 +8,7 @@ readme = "README.md" keywords = ["opentelemetry", "metrics", "user-events"] license = "Apache-2.0" edition = "2021" -rust-version = "1.71.1" +rust-version = "1.75.0" [dependencies] opentelemetry = { workspace = true, features = ["metrics"] } diff --git a/opentelemetry-user-events-metrics/examples/basic-metrics.rs b/opentelemetry-user-events-metrics/examples/basic-metrics.rs index bcec937d..24af2fe0 100644 --- a/opentelemetry-user-events-metrics/examples/basic-metrics.rs +++ b/opentelemetry-user-events-metrics/examples/basic-metrics.rs @@ -2,19 +2,20 @@ use opentelemetry::{metrics::MeterProvider as _, KeyValue}; use opentelemetry_sdk::{ metrics::{PeriodicReader, SdkMeterProvider}, - runtime, Resource, + Resource, }; use opentelemetry_user_events_metrics::MetricsExporter; use std::thread; use std::time::Duration; fn init_metrics(exporter: MetricsExporter) -> SdkMeterProvider { - let reader = PeriodicReader::builder(exporter, runtime::Tokio).build(); + let reader = PeriodicReader::builder(exporter).build(); SdkMeterProvider::builder() - .with_resource(Resource::new(vec![KeyValue::new( - "service.name", - "metric-demo", - )])) + .with_resource( + Resource::builder_empty() + .with_attributes(vec![KeyValue::new("service.name", "metric-demo")]) + .build(), + ) .with_reader(reader) .build() } diff --git a/opentelemetry-user-events-metrics/src/exporter/mod.rs b/opentelemetry-user-events-metrics/src/exporter/mod.rs index 1f19ce09..3aba53d4 100644 --- a/opentelemetry-user-events-metrics/src/exporter/mod.rs +++ b/opentelemetry-user-events-metrics/src/exporter/mod.rs @@ -1,5 +1,7 @@ use async_trait::async_trait; +use opentelemetry::{otel_debug, otel_warn}; use opentelemetry_proto::tonic::collector::metrics::v1::ExportMetricsServiceRequest; +use opentelemetry_sdk::error::{OTelSdkError, OTelSdkResult}; use opentelemetry_sdk::metrics::data; use opentelemetry_sdk::metrics::exporter::PushMetricExporter; use opentelemetry_sdk::metrics::{ @@ -8,9 +10,6 @@ use opentelemetry_sdk::metrics::{ }, Temporality, }; -use opentelemetry_sdk::metrics::{MetricError, MetricResult}; - -use opentelemetry::{otel_debug, otel_warn}; use crate::tracepoint; use eventheader::_internal as ehi; @@ -54,7 +53,7 @@ impl MetricsExporter { resource_metric: &ResourceMetrics, metric_name: &str, metric_type: &str, - ) -> MetricResult<()> { + ) -> OTelSdkResult { // Allocate a local buffer for each write operation // TODO: Investigate if this can be optimized to avoid reallocation or // allocate a fixed buffer size for all writes @@ -80,7 +79,7 @@ impl MetricsExporter { metric_name = metric_name, metric_type = metric_type, size = byte_array.len()); - return Err(MetricError::Other(err.to_string())); + return Err(OTelSdkError::InternalFailure(err.to_string())); } } @@ -93,7 +92,7 @@ impl MetricsExporter { metric_type = metric_type, size = byte_array.len() ); - return Err(MetricError::Other( + return Err(OTelSdkError::InternalFailure( "Event size exceeds maximum allowed limit".into(), )); } @@ -110,7 +109,7 @@ impl MetricsExporter { #[async_trait] impl PushMetricExporter for MetricsExporter { - async fn export(&self, metrics: &mut ResourceMetrics) -> MetricResult<()> { + async fn export(&self, metrics: &mut ResourceMetrics) -> OTelSdkResult { otel_debug!(name: "ExportStart", message = "Starting metrics export"); if !self.trace_point.enabled() { // TODO - This can flood the logs if the tracepoint is disabled for long periods of time @@ -137,6 +136,8 @@ impl PushMetricExporter for MetricsExporter { unit: metric.unit.clone(), data: Box::new(data::Histogram { temporality: histogram.temporality, + start_time: histogram.start_time, + time: histogram.time, data_points: vec![data_point.clone()], }), }], @@ -162,6 +163,8 @@ impl PushMetricExporter for MetricsExporter { unit: metric.unit.clone(), data: Box::new(data::Histogram { temporality: histogram.temporality, + start_time: histogram.start_time, + time: histogram.time, data_points: vec![data_point.clone()], }), }], @@ -187,6 +190,8 @@ impl PushMetricExporter for MetricsExporter { unit: metric.unit.clone(), data: Box::new(data::Gauge { data_points: vec![data_point.clone()], + start_time: gauge.start_time, + time: gauge.time, }), }], }], @@ -211,6 +216,8 @@ impl PushMetricExporter for MetricsExporter { unit: metric.unit.clone(), data: Box::new(data::Gauge { data_points: vec![data_point.clone()], + start_time: gauge.start_time, + time: gauge.time, }), }], }], @@ -235,6 +242,8 @@ impl PushMetricExporter for MetricsExporter { unit: metric.unit.clone(), data: Box::new(data::Gauge { data_points: vec![data_point.clone()], + start_time: gauge.start_time, + time: gauge.time, }), }], }], @@ -261,6 +270,8 @@ impl PushMetricExporter for MetricsExporter { temporality: sum.temporality, data_points: vec![data_point.clone()], is_monotonic: sum.is_monotonic, + start_time: sum.start_time, + time: sum.time, }), }], }], @@ -285,6 +296,8 @@ impl PushMetricExporter for MetricsExporter { temporality: sum.temporality, data_points: vec![data_point.clone()], is_monotonic: sum.is_monotonic, + start_time: sum.start_time, + time: sum.time, }), }], }], @@ -309,6 +322,8 @@ impl PushMetricExporter for MetricsExporter { temporality: sum.temporality, data_points: vec![data_point.clone()], is_monotonic: sum.is_monotonic, + start_time: sum.start_time, + time: sum.time, }), }], }], @@ -333,11 +348,11 @@ impl PushMetricExporter for MetricsExporter { unit: metric.unit.clone(), data: Box::new(data::ExponentialHistogram { temporality: exp_hist.temporality, + start_time: exp_hist.start_time, + time: exp_hist.time, data_points: vec![ExponentialHistogramDataPoint { attributes: data_point.attributes.clone(), count: data_point.count, - start_time: data_point.start_time, - time: data_point.time, min: data_point.min, max: data_point.max, sum: data_point.sum, @@ -386,11 +401,11 @@ impl PushMetricExporter for MetricsExporter { unit: metric.unit.clone(), data: Box::new(data::ExponentialHistogram { temporality: exp_hist.temporality, + start_time: exp_hist.start_time, + time: exp_hist.time, data_points: vec![ExponentialHistogramDataPoint { attributes: data_point.attributes.clone(), count: data_point.count, - start_time: data_point.start_time, - time: data_point.time, min: data_point.min, max: data_point.max, sum: data_point.sum, @@ -436,7 +451,7 @@ impl PushMetricExporter for MetricsExporter { errors.len(), errors.join("; ") ); - return Err(MetricError::Other(error_message)); + return Err(OTelSdkError::InternalFailure(error_message)); } } Ok(()) @@ -446,11 +461,11 @@ impl PushMetricExporter for MetricsExporter { Temporality::Delta } - async fn force_flush(&self) -> MetricResult<()> { + async fn force_flush(&self) -> OTelSdkResult { Ok(()) // In this implementation, flush does nothing } - fn shutdown(&self) -> MetricResult<()> { + fn shutdown(&self) -> OTelSdkResult { // TracepointState automatically unregisters when dropped // https://github.com/microsoft/LinuxTracepoints-Rust/blob/main/eventheader/src/native.rs#L618 Ok(()) diff --git a/opentelemetry-zpages/CHANGELOG.md b/opentelemetry-zpages/CHANGELOG.md index 754f2b44..a49047da 100644 --- a/opentelemetry-zpages/CHANGELOG.md +++ b/opentelemetry-zpages/CHANGELOG.md @@ -2,11 +2,18 @@ ## vNext +## v0.13.0 + +### Changed + +- Bump msrv to 1.75.0 +- Bump opentelemetry version to 0.28, opentelemetry_sdk version to 0.28 + ## v0.12.0 ### Changed -- Bump opentelemetry version to 0.26, opentelemetry_sdk version to 0.27 +- Bump opentelemetry version to 0.27, opentelemetry_sdk version to 0.27 ## v0.11.0 diff --git a/opentelemetry-zpages/Cargo.toml b/opentelemetry-zpages/Cargo.toml index a62be2f6..b10093fd 100644 --- a/opentelemetry-zpages/Cargo.toml +++ b/opentelemetry-zpages/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "opentelemetry-zpages" -version = "0.12.0" +version = "0.13.0" description = "ZPages implementation for OpenTelemetry" homepage = "https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/main/opentelemetry-zpages" repository = "https://github.com/open-telemetry/opentelemetry-rust-contrib/tree/main/opentelemetry-zpages" @@ -13,7 +13,7 @@ categories = [ keywords = ["opentelemetry", "zipkin", "tracing", "async"] license = "Apache-2.0" edition = "2021" -rust-version = "1.71.1" +rust-version = "1.75.0" [package.metadata.docs.rs] all-features = true @@ -24,7 +24,7 @@ with-serde = [] [dependencies] opentelemetry = { workspace = true } -opentelemetry_sdk = { workspace = true, default-features = false, features = ["trace"] } +opentelemetry_sdk = { workspace = true, default-features = false, features = ["trace", "experimental_async_runtime" ] } opentelemetry-proto = { workspace = true, features = ["zpages", "gen-tonic", "with-serde"], default-features = false } async-channel = "1.6" futures-channel = "0.3" diff --git a/opentelemetry-zpages/examples/zpages.rs b/opentelemetry-zpages/examples/zpages.rs index 457a8c8d..58b173d7 100644 --- a/opentelemetry-zpages/examples/zpages.rs +++ b/opentelemetry-zpages/examples/zpages.rs @@ -7,7 +7,7 @@ use opentelemetry::{ trace::{Span, Status}, }; use opentelemetry_sdk::runtime::Tokio; -use opentelemetry_sdk::trace::TracerProvider; +use opentelemetry_sdk::trace::SdkTracerProvider; use opentelemetry_zpages::{tracez, TracezError, TracezQuerier, TracezResponse}; use rand::Rng; use std::str::FromStr; @@ -90,7 +90,7 @@ fn tracez_response_or_server_error(resp: Result) -> #[tokio::main] async fn main() { let (processor, querier) = tracez(5, Tokio); - let provider = TracerProvider::builder() + let provider = SdkTracerProvider::builder() .with_span_processor(processor) .build(); global::set_tracer_provider(provider); diff --git a/opentelemetry-zpages/src/lib.rs b/opentelemetry-zpages/src/lib.rs index 7842c10d..6a7d1e89 100644 --- a/opentelemetry-zpages/src/lib.rs +++ b/opentelemetry-zpages/src/lib.rs @@ -17,12 +17,12 @@ //! ```no_run //! # use opentelemetry_zpages::tracez; //! # use opentelemetry::{global, trace::Tracer}; -//! # use opentelemetry_sdk::{runtime::Tokio, trace::TracerProvider}; +//! # use opentelemetry_sdk::{runtime::Tokio, trace::SdkTracerProvider}; //! # use std::sync::Arc; //! //! # fn main() { //! let (processor, querier) = tracez(5, Tokio); -//! let provider = TracerProvider::builder() +//! let provider = SdkTracerProvider::builder() //! .with_span_processor(processor) //! .build(); //! global::set_tracer_provider(provider); @@ -38,7 +38,7 @@ //! //! //! [`ZPagesSpanProcessor`]: trace::span_processor::ZPagesSpanProcessor -//! [`TracerProvider`]: opentelemetry_sdk::trace::TracerProvider +//! [`TracerProvider`]: opentelemetry_sdk::trace::SdkTracerProvider //! [here]: https://github.com/open-telemetry/opentelemetry-rust/tree/main/examples/zpages #![warn( future_incompatible, diff --git a/opentelemetry-zpages/src/trace/aggregator.rs b/opentelemetry-zpages/src/trace/aggregator.rs index 333746b0..f9abdf4d 100644 --- a/opentelemetry-zpages/src/trace/aggregator.rs +++ b/opentelemetry-zpages/src/trace/aggregator.rs @@ -8,7 +8,7 @@ use async_channel::Receiver; use futures_util::StreamExt as _; use opentelemetry::trace::Status; use opentelemetry_proto::tonic::tracez::v1::TracezCounts; -use opentelemetry_sdk::export::trace::SpanData; +use opentelemetry_sdk::trace::SpanData; use std::collections::HashMap; use std::time::{Duration, SystemTime, UNIX_EPOCH}; @@ -198,7 +198,7 @@ mod tests { TracezMessage, }; use opentelemetry::trace::{SpanContext, SpanId, Status, TraceFlags, TraceId, TraceState}; - use opentelemetry_sdk::{export::trace::SpanData, testing::trace::new_test_export_span_data}; + use opentelemetry_sdk::{testing::trace::new_test_export_span_data, trace::SpanData}; use std::borrow::Cow; use std::cmp::min; use std::time::{Duration, SystemTime}; diff --git a/opentelemetry-zpages/src/trace/mod.rs b/opentelemetry-zpages/src/trace/mod.rs index 4e455934..260af66f 100644 --- a/opentelemetry-zpages/src/trace/mod.rs +++ b/opentelemetry-zpages/src/trace/mod.rs @@ -3,7 +3,7 @@ use async_channel::{SendError, Sender}; use futures_channel::oneshot::{self, Canceled}; use opentelemetry_proto::tonic::tracez::v1::{ErrorData, LatencyData, RunningData, TracezCounts}; -use opentelemetry_sdk::{export::trace::SpanData, runtime::Runtime}; +use opentelemetry_sdk::{runtime::Runtime, trace::SpanData}; use serde::ser::SerializeSeq; use serde::Serializer; use std::fmt::Formatter; @@ -14,23 +14,23 @@ pub(crate) mod span_processor; pub(crate) mod span_queue; /// Create tracez components. This function will return a [`ZPagesSpanProcessor`] that should be installed -/// into the [`TracerProvider`] and a [`TracezQuerier`] for http server to access the aggregated +/// into the [`SdkTracerProvider`] and a [`TracezQuerier`] for http server to access the aggregated /// information on spans. /// /// The `sample_size` config how may spans to sample for each unique span name. /// /// [`ZPagesSpanProcessor`]: span_processor::ZPagesSpanProcessor -/// [`TracerProvider`]: opentelemetry_sdk::trace::TracerProvider +/// [`SdkTracerProvider`]: opentelemetry_sdk::trace::SdkTracerProvider /// /// ## Example /// ```no_run /// # use opentelemetry_zpages::tracez; /// # use opentelemetry::{global, trace::Tracer}; -/// # use opentelemetry_sdk::{runtime::Tokio, trace::TracerProvider}; +/// # use opentelemetry_sdk::{runtime::Tokio, trace::SdkTracerProvider}; /// # use std::sync::Arc; /// # fn main() { /// let (processor, querier) = tracez(5, Tokio); // sample 5 spans for each unique span name -/// let provider = TracerProvider::builder() +/// let provider = SdkTracerProvider::builder() /// .with_span_processor(processor) /// .build(); /// global::set_tracer_provider(provider); diff --git a/opentelemetry-zpages/src/trace/span_processor.rs b/opentelemetry-zpages/src/trace/span_processor.rs index b72ec093..8ac0c6c5 100644 --- a/opentelemetry-zpages/src/trace/span_processor.rs +++ b/opentelemetry-zpages/src/trace/span_processor.rs @@ -6,9 +6,10 @@ //! [`SpanAggregator`]:../struct.SpanAggregator.html use crate::trace::TracezMessage; use async_channel::Sender; -use opentelemetry::{trace::TraceResult, Context}; +use opentelemetry::Context; use opentelemetry_sdk::{ - export::trace::SpanData, + error::OTelSdkResult, + trace::SpanData, trace::{Span, SpanProcessor}, }; use std::fmt::Formatter; @@ -48,12 +49,12 @@ impl SpanProcessor for ZPagesSpanProcessor { let _ = self.tx.try_send(TracezMessage::SpanEnd(span)); } - fn force_flush(&self) -> TraceResult<()> { + fn force_flush(&self) -> OTelSdkResult { // do nothing Ok(()) } - fn shutdown(&self) -> TraceResult<()> { + fn shutdown(&self) -> OTelSdkResult { // do nothing Ok(()) } diff --git a/opentelemetry-zpages/src/trace/span_queue.rs b/opentelemetry-zpages/src/trace/span_queue.rs index 9597133b..1f3232e1 100644 --- a/opentelemetry-zpages/src/trace/span_queue.rs +++ b/opentelemetry-zpages/src/trace/span_queue.rs @@ -1,7 +1,7 @@ //! # Span Queue use opentelemetry::trace::SpanContext; -use opentelemetry_sdk::export::trace::SpanData; +use opentelemetry_sdk::trace::SpanData; use std::collections::HashMap; /// This queue maintains an ordered list of elements, Elements are diff --git a/scripts/msrv_config.json b/scripts/msrv_config.json index aed48eb7..518efe65 100644 --- a/scripts/msrv_config.json +++ b/scripts/msrv_config.json @@ -1,10 +1,5 @@ { - "//": [ - "setting the version to 1.71.1 for all packages is temporary,", - "because cargo-msrv doesn't work with Rust <1.71", - "and the next OTel version will raise MSRV to 1.75.0 anyway" - ], - "1.71.1": [ + "1.75.0": [ "opentelemetry-aws", "opentelemetry-contrib", "opentelemetry-datadog", diff --git a/stress/src/etw_logs.rs b/stress/src/etw_logs.rs index 40198ce3..a9e5e979 100644 --- a/stress/src/etw_logs.rs +++ b/stress/src/etw_logs.rs @@ -20,14 +20,14 @@ use opentelemetry_appender_tracing::layer; use opentelemetry_etw_logs::{ExporterConfig, ReentrantLogProcessor}; -use opentelemetry_sdk::logs::LoggerProvider; +use opentelemetry_sdk::logs::SdkLoggerProvider; use std::collections::HashMap; use tracing::info; use tracing_subscriber::prelude::*; mod throughput; // Function to initialize the logger -fn init_logger() -> LoggerProvider { +fn init_logger() -> SdkLoggerProvider { let exporter_config = ExporterConfig { default_keyword: 1, keywords_map: HashMap::new(), @@ -38,7 +38,7 @@ fn init_logger() -> LoggerProvider { None, exporter_config, ); - LoggerProvider::builder() + SdkLoggerProvider::builder() .with_log_processor(reenterant_processor) .build() } diff --git a/stress/src/user_events.rs b/stress/src/user_events.rs index d35b391b..f2d9001c 100644 --- a/stress/src/user_events.rs +++ b/stress/src/user_events.rs @@ -23,7 +23,7 @@ // Threads: 16 - Average Throughput: 297,232 iterations/sec use opentelemetry_appender_tracing::layer; -use opentelemetry_sdk::logs::LoggerProvider; +use opentelemetry_sdk::logs::SdkLoggerProvider; use opentelemetry_user_events_logs::{ExporterConfig, ReentrantLogProcessor, UserEventsExporter}; use std::collections::HashMap; use tracing::info; @@ -31,14 +31,14 @@ use tracing_subscriber::prelude::*; mod throughput; // Function to initialize the logger -fn init_logger() -> LoggerProvider { +fn init_logger() -> SdkLoggerProvider { let exporter_config = ExporterConfig { default_keyword: 1, keywords_map: HashMap::new(), }; let exporter = UserEventsExporter::new("testprovider", None, exporter_config); let reentrant_processor = ReentrantLogProcessor::new(exporter); - LoggerProvider::builder() + SdkLoggerProvider::builder() .with_log_processor(reentrant_processor) .build() }