From 1b41f6c1878ce31b55e4e7a4acc18dac7767c676 Mon Sep 17 00:00:00 2001 From: Fabien Savy Date: Tue, 22 Oct 2024 09:06:27 +0200 Subject: [PATCH] Rename InstrumentationLibrary to InstrumentationScope --- opentelemetry-appender-log/src/lib.rs | 14 ++-- .../benches/logs.rs | 4 +- opentelemetry-appender-tracing/src/layer.rs | 14 ++-- .../examples/basic-otlp-http/src/main.rs | 19 +++-- .../examples/basic-otlp/src/main.rs | 20 +++-- .../expected/serialized_traces.json | 39 +--------- opentelemetry-proto/src/transform/common.rs | 8 +- opentelemetry-proto/src/transform/logs.rs | 12 +-- opentelemetry-proto/src/transform/trace.rs | 12 +-- .../benches/batch_span_processor.rs | 2 +- opentelemetry-sdk/benches/log.rs | 4 +- opentelemetry-sdk/benches/log_exporter.rs | 10 +-- opentelemetry-sdk/benches/log_processor.rs | 14 ++-- opentelemetry-sdk/src/export/logs/mod.rs | 16 ++-- opentelemetry-sdk/src/export/trace.rs | 2 +- opentelemetry-sdk/src/instrumentation.rs | 4 +- opentelemetry-sdk/src/lib.rs | 2 +- opentelemetry-sdk/src/logs/log_emitter.rs | 34 ++++---- opentelemetry-sdk/src/logs/log_processor.rs | 46 +++++------ opentelemetry-sdk/src/logs/mod.rs | 26 +++---- .../src/metrics/meter_provider.rs | 59 ++++++-------- opentelemetry-sdk/src/metrics/mod.rs | 29 +++---- .../src/testing/logs/in_memory_exporter.rs | 8 +- .../src/testing/trace/span_exporters.rs | 4 +- opentelemetry-sdk/src/trace/mod.rs | 24 +++--- opentelemetry-sdk/src/trace/provider.rs | 8 +- opentelemetry-sdk/src/trace/span.rs | 2 +- opentelemetry-sdk/src/trace/span_processor.rs | 2 +- opentelemetry-sdk/src/trace/tracer.rs | 23 ++---- opentelemetry-stdout/examples/basic.rs | 19 ++--- opentelemetry-stdout/src/common.rs | 2 +- opentelemetry-stdout/src/trace/exporter.rs | 8 +- opentelemetry-zipkin/src/exporter/mod.rs | 26 +++---- .../src/exporter/model/mod.rs | 4 +- .../src/exporter/model/span.rs | 2 +- opentelemetry/src/common.rs | 77 ++++++------------- opentelemetry/src/global/metrics.rs | 26 +++---- opentelemetry/src/global/mod.rs | 9 +-- opentelemetry/src/global/trace.rs | 42 ++++------ opentelemetry/src/lib.rs | 2 +- opentelemetry/src/logs/logger.rs | 26 +++---- opentelemetry/src/logs/noop.rs | 6 +- opentelemetry/src/metrics/meter.rs | 27 ++++--- opentelemetry/src/metrics/noop.rs | 2 +- opentelemetry/src/trace/mod.rs | 10 +-- opentelemetry/src/trace/noop.rs | 6 +- opentelemetry/src/trace/tracer_provider.rs | 21 +++-- stress/src/logs.rs | 4 +- 48 files changed, 328 insertions(+), 452 deletions(-) diff --git a/opentelemetry-appender-log/src/lib.rs b/opentelemetry-appender-log/src/lib.rs index aad48177fc..0fe09acde3 100644 --- a/opentelemetry-appender-log/src/lib.rs +++ b/opentelemetry-appender-log/src/lib.rs @@ -97,11 +97,10 @@ use log::{Level, Metadata, Record}; use opentelemetry::{ logs::{AnyValue, LogRecord, Logger, LoggerProvider, Severity}, - InstrumentationLibrary, Key, + InstrumentationScope, Key, }; #[cfg(feature = "experimental_metadata_attributes")] use opentelemetry_semantic_conventions::attribute::{CODE_FILEPATH, CODE_LINENO, CODE_NAMESPACE}; -use std::sync::Arc; pub struct OpenTelemetryLogBridge where @@ -170,13 +169,12 @@ where L: Logger + Send + Sync, { pub fn new(provider: &P) -> Self { - let library = Arc::new( - InstrumentationLibrary::builder("opentelemetry-log-appender") - .with_version(env!("CARGO_PKG_VERSION")) - .build(), - ); + let scope = InstrumentationScope::builder("opentelemetry-log-appender") + .with_version(env!("CARGO_PKG_VERSION")) + .build(); + OpenTelemetryLogBridge { - logger: provider.library_logger(library), + logger: provider.logger_with_scope(scope), _phantom: Default::default(), } } diff --git a/opentelemetry-appender-tracing/benches/logs.rs b/opentelemetry-appender-tracing/benches/logs.rs index a5ebb83249..0237e4a769 100644 --- a/opentelemetry-appender-tracing/benches/logs.rs +++ b/opentelemetry-appender-tracing/benches/logs.rs @@ -16,7 +16,7 @@ use async_trait::async_trait; use criterion::{criterion_group, criterion_main, Criterion}; use opentelemetry::logs::LogResult; -use opentelemetry::{InstrumentationLibrary, KeyValue}; +use opentelemetry::{InstrumentationScope, KeyValue}; use opentelemetry_appender_tracing::layer as tracing_layer; use opentelemetry_sdk::export::logs::{LogBatch, LogExporter}; use opentelemetry_sdk::logs::{LogProcessor, LogRecord, LoggerProvider}; @@ -55,7 +55,7 @@ impl NoopProcessor { } impl LogProcessor for NoopProcessor { - fn emit(&self, _: &mut LogRecord, _: &InstrumentationLibrary) { + fn emit(&self, _: &mut LogRecord, _: &InstrumentationScope) { // no-op } diff --git a/opentelemetry-appender-tracing/src/layer.rs b/opentelemetry-appender-tracing/src/layer.rs index 46ed73d5eb..0408eec64c 100644 --- a/opentelemetry-appender-tracing/src/layer.rs +++ b/opentelemetry-appender-tracing/src/layer.rs @@ -1,8 +1,8 @@ use opentelemetry::{ logs::{AnyValue, LogRecord, Logger, LoggerProvider, Severity}, - InstrumentationLibrary, Key, + InstrumentationScope, Key, }; -use std::{borrow::Cow, sync::Arc}; +use std::borrow::Cow; use tracing_core::Level; #[cfg(feature = "experimental_metadata_attributes")] use tracing_core::Metadata; @@ -136,14 +136,12 @@ where L: Logger + Send + Sync, { pub fn new(provider: &P) -> Self { - let library = Arc::new( - InstrumentationLibrary::builder(INSTRUMENTATION_LIBRARY_NAME) - .with_version(Cow::Borrowed(env!("CARGO_PKG_VERSION"))) - .build(), - ); + let scope = InstrumentationScope::builder(INSTRUMENTATION_LIBRARY_NAME) + .with_version(Cow::Borrowed(env!("CARGO_PKG_VERSION"))) + .build(); OpenTelemetryTracingBridge { - logger: provider.library_logger(library), + logger: provider.logger_with_scope(scope), _phantom: Default::default(), } } diff --git a/opentelemetry-otlp/examples/basic-otlp-http/src/main.rs b/opentelemetry-otlp/examples/basic-otlp-http/src/main.rs index 775a5174db..6e46885210 100644 --- a/opentelemetry-otlp/examples/basic-otlp-http/src/main.rs +++ b/opentelemetry-otlp/examples/basic-otlp-http/src/main.rs @@ -3,7 +3,7 @@ use opentelemetry::{ global, metrics::MetricsError, trace::{TraceContextExt, TraceError, Tracer}, - InstrumentationLibrary, KeyValue, + InstrumentationScope, KeyValue, }; use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge; use opentelemetry_otlp::Protocol; @@ -13,7 +13,7 @@ use opentelemetry_sdk::{ logs::{self as sdklogs}, Resource, }; -use std::{error::Error, sync::Arc}; +use std::error::Error; use tracing::info; use tracing_subscriber::prelude::*; use tracing_subscriber::EnvFilter; @@ -121,14 +121,13 @@ async fn main() -> Result<(), Box> { .init(); let common_scope_attributes = vec![KeyValue::new("scope-key", "scope-value")]; - let library = Arc::new( - InstrumentationLibrary::builder("basic") - .with_version("1.0") - .with_attributes(common_scope_attributes) - .build(), - ); - let tracer = global::library_tracer(library.clone()); - let meter = global::library_meter(library); + let scope = InstrumentationScope::builder("basic") + .with_version("1.0") + .with_attributes(common_scope_attributes) + .build(); + + let tracer = global::tracer_with_scope(scope.clone()); + let meter = global::meter_with_scope(scope); let counter = meter .u64_counter("test_counter") diff --git a/opentelemetry-otlp/examples/basic-otlp/src/main.rs b/opentelemetry-otlp/examples/basic-otlp/src/main.rs index 7a206d4644..2f6e70b3f8 100644 --- a/opentelemetry-otlp/examples/basic-otlp/src/main.rs +++ b/opentelemetry-otlp/examples/basic-otlp/src/main.rs @@ -1,15 +1,14 @@ use once_cell::sync::Lazy; use opentelemetry::logs::LogError; use opentelemetry::metrics::MetricsError; -use opentelemetry::trace::{TraceContextExt, TraceError, Tracer, TracerProvider}; +use opentelemetry::trace::{TraceContextExt, TraceError, Tracer}; use opentelemetry::KeyValue; -use opentelemetry::{global, InstrumentationLibrary}; +use opentelemetry::{global, InstrumentationScope}; use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge; use opentelemetry_otlp::{ExportConfig, WithExportConfig}; use opentelemetry_sdk::trace::Config; use opentelemetry_sdk::{runtime, trace as sdktrace, Resource}; use std::error::Error; -use std::sync::Arc; use tracing::info; use tracing_subscriber::prelude::*; use tracing_subscriber::EnvFilter; @@ -110,14 +109,13 @@ async fn main() -> Result<(), Box> { .init(); let common_scope_attributes = vec![KeyValue::new("scope-key", "scope-value")]; - let library = Arc::new( - InstrumentationLibrary::builder("basic") - .with_version("1.0") - .with_attributes(common_scope_attributes) - .build(), - ); - let tracer = global::tracer_provider().library_tracer(library.clone()); - let meter = global::library_meter(library); + let scope = InstrumentationScope::builder("basic") + .with_version("1.0") + .with_attributes(common_scope_attributes) + .build(); + + let tracer = global::tracer_with_scope(scope.clone()); + let meter = global::meter_with_scope(scope); let counter = meter .u64_counter("test_counter") diff --git a/opentelemetry-otlp/tests/integration_test/expected/serialized_traces.json b/opentelemetry-otlp/tests/integration_test/expected/serialized_traces.json index e5982877cf..f1d64108ad 100644 --- a/opentelemetry-otlp/tests/integration_test/expected/serialized_traces.json +++ b/opentelemetry-otlp/tests/integration_test/expected/serialized_traces.json @@ -26,7 +26,7 @@ "spanId": "cd7cf7bf939930b7", "traceState": "", "parentSpanId": "d58cf2d702a061e0", - "flags": 0, + "flags": 1, "name": "Sub operation...", "kind": 1, "startTimeUnixNano": "1703985537070566698", @@ -55,40 +55,13 @@ "message": "", "code": 0 } - } - ], - "schemaUrl": "" - } - ], - "schemaUrl": "" - }, - { - "resource": { - "attributes": [ - { - "key": "service.name", - "value": { - "stringValue": "basic-otlp-tracing-example" - } - } - ], - "droppedAttributesCount": 0 - }, - "scopeSpans": [ - { - "scope": { - "name": "ex.com/basic", - "version": "", - "attributes": [], - "droppedAttributesCount": 0 - }, - "spans": [ + }, { "traceId": "9b458af7378cba65253d7042d34fc72e", "spanId": "d58cf2d702a061e0", "traceState": "", "parentSpanId": "", - "flags": 0, + "flags": 1, "name": "operation", "kind": 1, "startTimeUnixNano": "1703985537070558635", @@ -112,12 +85,6 @@ "value": { "intValue": "100" } - }, - { - "key": "number/int", - "value": { - "intValue": "100" - } } ], "droppedAttributesCount": 0 diff --git a/opentelemetry-proto/src/transform/common.rs b/opentelemetry-proto/src/transform/common.rs index ff42479288..5e869de295 100644 --- a/opentelemetry-proto/src/transform/common.rs +++ b/opentelemetry-proto/src/transform/common.rs @@ -44,13 +44,13 @@ pub mod tonic { impl From<( - opentelemetry_sdk::InstrumentationLibrary, + opentelemetry_sdk::InstrumentationScope, Option>, )> for InstrumentationScope { fn from( data: ( - opentelemetry_sdk::InstrumentationLibrary, + opentelemetry_sdk::InstrumentationScope, Option>, ), ) -> Self { @@ -75,13 +75,13 @@ pub mod tonic { impl From<( - &opentelemetry_sdk::InstrumentationLibrary, + &opentelemetry_sdk::InstrumentationScope, Option>, )> for InstrumentationScope { fn from( data: ( - &opentelemetry_sdk::InstrumentationLibrary, + &opentelemetry_sdk::InstrumentationScope, Option>, ), ) -> Self { diff --git a/opentelemetry-proto/src/transform/logs.rs b/opentelemetry-proto/src/transform/logs.rs index 4cd2c1617b..df67320da0 100644 --- a/opentelemetry-proto/src/transform/logs.rs +++ b/opentelemetry-proto/src/transform/logs.rs @@ -142,7 +142,7 @@ pub mod tonic { From<( ( &opentelemetry_sdk::logs::LogRecord, - &opentelemetry::InstrumentationLibrary, + &opentelemetry::InstrumentationScope, ), &ResourceAttributesWithSchema, )> for ResourceLogs @@ -151,7 +151,7 @@ pub mod tonic { data: ( ( &opentelemetry_sdk::logs::LogRecord, - &opentelemetry::InstrumentationLibrary, + &opentelemetry::InstrumentationScope, ), &ResourceAttributesWithSchema, ), @@ -188,7 +188,7 @@ pub mod tonic { Cow<'static, str>, Vec<( &opentelemetry_sdk::logs::LogRecord, - &opentelemetry::InstrumentationLibrary, + &opentelemetry::InstrumentationScope, )>, >, (log_record, instrumentation)| { @@ -234,19 +234,19 @@ pub mod tonic { mod tests { use crate::transform::common::tonic::ResourceAttributesWithSchema; use opentelemetry::logs::LogRecord as _; - use opentelemetry::InstrumentationLibrary; + use opentelemetry::InstrumentationScope; use opentelemetry_sdk::{export::logs::LogBatch, logs::LogRecord, Resource}; use std::time::SystemTime; fn create_test_log_data( instrumentation_name: &str, _message: &str, - ) -> (LogRecord, InstrumentationLibrary) { + ) -> (LogRecord, InstrumentationScope) { let mut logrecord = LogRecord::default(); logrecord.set_timestamp(SystemTime::now()); logrecord.set_observed_timestamp(SystemTime::now()); let instrumentation = - InstrumentationLibrary::builder(instrumentation_name.to_string()).build(); + InstrumentationScope::builder(instrumentation_name.to_string()).build(); (logrecord, instrumentation) } diff --git a/opentelemetry-proto/src/transform/trace.rs b/opentelemetry-proto/src/transform/trace.rs index 12871b33aa..7d8a4f9652 100644 --- a/opentelemetry-proto/src/transform/trace.rs +++ b/opentelemetry-proto/src/transform/trace.rs @@ -101,12 +101,12 @@ pub mod tonic { schema_url: resource.schema_url.clone().unwrap_or_default(), scope_spans: vec![ScopeSpans { schema_url: source_span - .instrumentation_lib + .instrumentation_scope .schema_url .as_ref() .map(ToString::to_string) .unwrap_or_default(), - scope: Some((source_span.instrumentation_lib, None).into()), + scope: Some((source_span.instrumentation_scope, None).into()), spans: vec![Span { trace_id: source_span.span_context.trace_id().to_bytes().to_vec(), span_id: source_span.span_context.span_id().to_bytes().to_vec(), @@ -158,9 +158,9 @@ pub mod tonic { // Group spans by their instrumentation library let scope_map = spans.iter().fold( HashMap::new(), - |mut scope_map: HashMap<&opentelemetry_sdk::InstrumentationLibrary, Vec<&SpanData>>, + |mut scope_map: HashMap<&opentelemetry_sdk::InstrumentationScope, Vec<&SpanData>>, span| { - let instrumentation = &span.instrumentation_lib; + let instrumentation = &span.instrumentation_scope; scope_map.entry(instrumentation).or_default().push(span); scope_map }, @@ -202,7 +202,7 @@ mod tests { use opentelemetry_sdk::export::trace::SpanData; use opentelemetry_sdk::resource::Resource; use opentelemetry_sdk::trace::{SpanEvents, SpanLinks}; - use opentelemetry_sdk::InstrumentationLibrary; + use opentelemetry_sdk::InstrumentationScope; use std::borrow::Cow; use std::time::{Duration, SystemTime}; @@ -227,7 +227,7 @@ mod tests { events: SpanEvents::default(), links: SpanLinks::default(), status: Status::Unset, - instrumentation_lib: InstrumentationLibrary::builder(instrumentation_name).build(), + instrumentation_scope: InstrumentationScope::builder(instrumentation_name).build(), } } diff --git a/opentelemetry-sdk/benches/batch_span_processor.rs b/opentelemetry-sdk/benches/batch_span_processor.rs index abc7d0df02..ed20c45a06 100644 --- a/opentelemetry-sdk/benches/batch_span_processor.rs +++ b/opentelemetry-sdk/benches/batch_span_processor.rs @@ -32,7 +32,7 @@ fn get_span_data() -> Vec { events: SpanEvents::default(), links: SpanLinks::default(), status: Status::Unset, - instrumentation_lib: Default::default(), + instrumentation_scope: Default::default(), }) .collect::>() } diff --git a/opentelemetry-sdk/benches/log.rs b/opentelemetry-sdk/benches/log.rs index 20d3503100..ca8a76a414 100644 --- a/opentelemetry-sdk/benches/log.rs +++ b/opentelemetry-sdk/benches/log.rs @@ -25,7 +25,7 @@ use opentelemetry::logs::{ }; use opentelemetry::trace::Tracer; use opentelemetry::trace::TracerProvider as _; -use opentelemetry::{InstrumentationLibrary, Key}; +use opentelemetry::{InstrumentationScope, Key}; use opentelemetry_sdk::logs::{LogProcessor, LogRecord, Logger, LoggerProvider}; use opentelemetry_sdk::trace; use opentelemetry_sdk::trace::{Sampler, TracerProvider}; @@ -34,7 +34,7 @@ use opentelemetry_sdk::trace::{Sampler, TracerProvider}; struct NoopProcessor; impl LogProcessor for NoopProcessor { - fn emit(&self, _data: &mut LogRecord, _library: &InstrumentationLibrary) {} + fn emit(&self, _data: &mut LogRecord, _scope: &InstrumentationScope) {} fn force_flush(&self) -> LogResult<()> { Ok(()) diff --git a/opentelemetry-sdk/benches/log_exporter.rs b/opentelemetry-sdk/benches/log_exporter.rs index 3549c08af5..c3c027f3e1 100644 --- a/opentelemetry-sdk/benches/log_exporter.rs +++ b/opentelemetry-sdk/benches/log_exporter.rs @@ -18,7 +18,7 @@ use criterion::{criterion_group, criterion_main, Criterion}; use opentelemetry::logs::{LogRecord as _, LogResult, Logger as _, LoggerProvider as _, Severity}; -use opentelemetry::InstrumentationLibrary; +use opentelemetry::InstrumentationScope; use opentelemetry_sdk::export::logs::LogBatch; use opentelemetry_sdk::logs::LogProcessor; use opentelemetry_sdk::logs::LogRecord; @@ -65,9 +65,9 @@ impl ExportingProcessorWithFuture { } impl LogProcessor for ExportingProcessorWithFuture { - fn emit(&self, record: &mut LogRecord, library: &InstrumentationLibrary) { + fn emit(&self, record: &mut LogRecord, scope: &InstrumentationScope) { let mut exporter = self.exporter.lock().expect("lock error"); - let logs = [(record as &LogRecord, library)]; + let logs = [(record as &LogRecord, scope)]; futures_executor::block_on(exporter.export(LogBatch::new(&logs))); } @@ -94,8 +94,8 @@ impl ExportingProcessorWithoutFuture { } impl LogProcessor for ExportingProcessorWithoutFuture { - fn emit(&self, record: &mut LogRecord, library: &InstrumentationLibrary) { - let logs = [(record as &LogRecord, library)]; + fn emit(&self, record: &mut LogRecord, scope: &InstrumentationScope) { + let logs = [(record as &LogRecord, scope)]; self.exporter .lock() .expect("lock error") diff --git a/opentelemetry-sdk/benches/log_processor.rs b/opentelemetry-sdk/benches/log_processor.rs index 1bc0a130b4..5ae9554191 100644 --- a/opentelemetry-sdk/benches/log_processor.rs +++ b/opentelemetry-sdk/benches/log_processor.rs @@ -19,7 +19,7 @@ use std::{ use criterion::{criterion_group, criterion_main, Criterion}; use opentelemetry::logs::{LogRecord as _, LogResult, Logger as _, LoggerProvider as _, Severity}; -use opentelemetry::InstrumentationLibrary; +use opentelemetry::InstrumentationScope; use opentelemetry_sdk::logs::{LogProcessor, LogRecord, Logger, LoggerProvider}; // Run this benchmark with: @@ -43,7 +43,7 @@ fn create_log_record(logger: &Logger) -> LogRecord { struct NoopProcessor; impl LogProcessor for NoopProcessor { - fn emit(&self, _data: &mut LogRecord, _library: &InstrumentationLibrary) {} + fn emit(&self, _data: &mut LogRecord, _scope: &InstrumentationScope) {} fn force_flush(&self) -> LogResult<()> { Ok(()) @@ -58,7 +58,7 @@ impl LogProcessor for NoopProcessor { struct CloningProcessor; impl LogProcessor for CloningProcessor { - fn emit(&self, data: &mut LogRecord, _library: &InstrumentationLibrary) { + fn emit(&self, data: &mut LogRecord, _scope: &InstrumentationScope) { let _data_cloned = data.clone(); } @@ -73,8 +73,8 @@ impl LogProcessor for CloningProcessor { #[derive(Debug)] struct SendToChannelProcessor { - sender: std::sync::mpsc::Sender<(LogRecord, InstrumentationLibrary)>, - receiver: Arc>>, + sender: std::sync::mpsc::Sender<(LogRecord, InstrumentationScope)>, + receiver: Arc>>, } impl SendToChannelProcessor { @@ -101,8 +101,8 @@ impl SendToChannelProcessor { } impl LogProcessor for SendToChannelProcessor { - fn emit(&self, record: &mut LogRecord, library: &InstrumentationLibrary) { - let res = self.sender.send((record.clone(), library.clone())); + fn emit(&self, record: &mut LogRecord, scope: &InstrumentationScope) { + let res = self.sender.send((record.clone(), scope.clone())); if res.is_err() { println!("Error sending log data to channel {0}", res.err().unwrap()); } diff --git a/opentelemetry-sdk/src/export/logs/mod.rs b/opentelemetry-sdk/src/export/logs/mod.rs index 8056f28222..ef6f29b8dd 100644 --- a/opentelemetry-sdk/src/export/logs/mod.rs +++ b/opentelemetry-sdk/src/export/logs/mod.rs @@ -6,7 +6,7 @@ use async_trait::async_trait; use opentelemetry::logs::Severity; use opentelemetry::{ logs::{LogError, LogResult}, - InstrumentationLibrary, + InstrumentationScope, }; use std::fmt::Debug; @@ -22,8 +22,8 @@ use std::fmt::Debug; #[derive(Debug)] pub struct LogBatch<'a> { /// The data field contains a slice of tuples, where each tuple consists of a reference to - /// a `LogRecord` and a reference to an `InstrumentationLibrary`. - data: &'a [(&'a LogRecord, &'a InstrumentationLibrary)], + /// a `LogRecord` and a reference to an `InstrumentationScope`. + data: &'a [(&'a LogRecord, &'a InstrumentationScope)], } impl<'a> LogBatch<'a> { @@ -32,7 +32,7 @@ impl<'a> LogBatch<'a> { /// # Arguments /// /// * `data` - A slice of tuples, where each tuple consists of a reference to a `LogRecord` - /// and a reference to an `InstrumentationLibrary`. These tuples represent the log records + /// and a reference to an `InstrumentationScope`. These tuples represent the log records /// and their associated instrumentation libraries to be exported. /// /// # Returns @@ -42,7 +42,7 @@ impl<'a> LogBatch<'a> { /// Note - this is not a public function, and should not be used directly. This would be /// made private in the future. - pub fn new(data: &'a [(&'a LogRecord, &'a InstrumentationLibrary)]) -> LogBatch<'a> { + pub fn new(data: &'a [(&'a LogRecord, &'a InstrumentationScope)]) -> LogBatch<'a> { LogBatch { data } } } @@ -51,13 +51,13 @@ impl LogBatch<'_> { /// Returns an iterator over the log records and instrumentation libraries in the batch. /// /// Each item yielded by the iterator is a tuple containing references to a `LogRecord` - /// and an `InstrumentationLibrary`. + /// and an `InstrumentationScope`. /// /// # Returns /// - /// An iterator that yields references to the `LogRecord` and `InstrumentationLibrary` in the batch. + /// An iterator that yields references to the `LogRecord` and `InstrumentationScope` in the batch. /// - pub fn iter(&self) -> impl Iterator { + pub fn iter(&self) -> impl Iterator { self.data .iter() .map(|(record, library)| (*record, *library)) diff --git a/opentelemetry-sdk/src/export/trace.rs b/opentelemetry-sdk/src/export/trace.rs index 4b43e00c36..2c6ad1dec2 100644 --- a/opentelemetry-sdk/src/export/trace.rs +++ b/opentelemetry-sdk/src/export/trace.rs @@ -96,5 +96,5 @@ pub struct SpanData { /// Span status pub status: Status, /// Instrumentation library that produced this span - pub instrumentation_lib: crate::InstrumentationLibrary, + pub instrumentation_scope: crate::InstrumentationScope, } diff --git a/opentelemetry-sdk/src/instrumentation.rs b/opentelemetry-sdk/src/instrumentation.rs index 75a74efa73..618e990eb7 100644 --- a/opentelemetry-sdk/src/instrumentation.rs +++ b/opentelemetry-sdk/src/instrumentation.rs @@ -1,5 +1,5 @@ -pub use opentelemetry::InstrumentationLibrary; +pub use opentelemetry::InstrumentationScope; /// A logical unit of the application code with which the emitted telemetry can /// be associated. -pub type Scope = InstrumentationLibrary; +pub type Scope = InstrumentationScope; diff --git a/opentelemetry-sdk/src/lib.rs b/opentelemetry-sdk/src/lib.rs index 66b279e6b7..cef431fc08 100644 --- a/opentelemetry-sdk/src/lib.rs +++ b/opentelemetry-sdk/src/lib.rs @@ -146,6 +146,6 @@ pub mod trace; #[doc(hidden)] pub mod util; -pub use instrumentation::{InstrumentationLibrary, Scope}; +pub use instrumentation::{InstrumentationScope, Scope}; #[doc(inline)] pub use resource::Resource; diff --git a/opentelemetry-sdk/src/logs/log_emitter.rs b/opentelemetry-sdk/src/logs/log_emitter.rs index 2f3150fefa..a984f0a4ce 100644 --- a/opentelemetry-sdk/src/logs/log_emitter.rs +++ b/opentelemetry-sdk/src/logs/log_emitter.rs @@ -4,7 +4,7 @@ use opentelemetry::{ logs::{LogError, LogResult}, otel_debug, trace::TraceContextExt, - Context, InstrumentationLibrary, + Context, InstrumentationScope, }; #[cfg(feature = "logs_level_enabled")] @@ -48,12 +48,12 @@ pub struct LoggerProvider { impl opentelemetry::logs::LoggerProvider for LoggerProvider { type Logger = Logger; - fn library_logger(&self, library: Arc) -> Self::Logger { + fn logger_with_scope(&self, scope: InstrumentationScope) -> Self::Logger { // If the provider is shutdown, new logger will refer a no-op logger provider. if self.inner.is_shutdown.load(Ordering::Relaxed) { - return Logger::new(library, NOOP_LOGGER_PROVIDER.clone()); + return Logger::new(scope, NOOP_LOGGER_PROVIDER.clone()); } - Logger::new(library, self.clone()) + Logger::new(scope, self.clone()) } } @@ -217,19 +217,13 @@ impl Builder { /// /// [`LogRecord`]: opentelemetry::logs::LogRecord pub struct Logger { - instrumentation_lib: Arc, + scope: InstrumentationScope, provider: LoggerProvider, } impl Logger { - pub(crate) fn new( - instrumentation_lib: Arc, - provider: LoggerProvider, - ) -> Self { - Logger { - instrumentation_lib, - provider, - } + pub(crate) fn new(scope: InstrumentationScope, provider: LoggerProvider) -> Self { + Logger { scope, provider } } /// LoggerProvider associated with this logger. @@ -238,8 +232,8 @@ impl Logger { } /// Instrumentation library information of this logger. - pub fn instrumentation_library(&self) -> &InstrumentationLibrary { - &self.instrumentation_lib + pub fn instrumentation_scope(&self) -> &InstrumentationScope { + &self.scope } } @@ -271,7 +265,7 @@ impl opentelemetry::logs::Logger for Logger { } for p in processors { - p.emit(&mut record, self.instrumentation_library()); + p.emit(&mut record, self.instrumentation_scope()); } } @@ -285,7 +279,7 @@ impl opentelemetry::logs::Logger for Logger { || processor.event_enabled( level, target, - self.instrumentation_library().name.as_ref(), + self.instrumentation_scope().name.as_ref(), ); } enabled @@ -333,7 +327,7 @@ mod tests { } impl LogProcessor for ShutdownTestLogProcessor { - fn emit(&self, _data: &mut LogRecord, _library: &InstrumentationLibrary) { + fn emit(&self, _data: &mut LogRecord, _scope: &InstrumentationScope) { self.is_shutdown .lock() .map(|is_shutdown| { @@ -712,7 +706,7 @@ mod tests { } impl LogProcessor for LazyLogProcessor { - fn emit(&self, _data: &mut LogRecord, _library: &InstrumentationLibrary) { + fn emit(&self, _data: &mut LogRecord, _scope: &InstrumentationScope) { // nothing to do. } @@ -743,7 +737,7 @@ mod tests { } impl LogProcessor for CountingShutdownProcessor { - fn emit(&self, _data: &mut LogRecord, _library: &InstrumentationLibrary) { + fn emit(&self, _data: &mut LogRecord, _scope: &InstrumentationScope) { // nothing to do } diff --git a/opentelemetry-sdk/src/logs/log_processor.rs b/opentelemetry-sdk/src/logs/log_processor.rs index 47489881b0..9313033c66 100644 --- a/opentelemetry-sdk/src/logs/log_processor.rs +++ b/opentelemetry-sdk/src/logs/log_processor.rs @@ -13,7 +13,7 @@ use futures_util::{ use opentelemetry::logs::Severity; use opentelemetry::{ logs::{LogError, LogResult}, - otel_debug, otel_error, otel_warn, InstrumentationLibrary, + otel_debug, otel_error, otel_warn, InstrumentationScope, }; use std::sync::atomic::AtomicBool; @@ -57,7 +57,7 @@ pub trait LogProcessor: Send + Sync + Debug { /// # Parameters /// - `record`: A mutable reference to `LogData` representing the log record. /// - `instrumentation`: The instrumentation library associated with the log record. - fn emit(&self, data: &mut LogRecord, instrumentation: &InstrumentationLibrary); + fn emit(&self, data: &mut LogRecord, instrumentation: &InstrumentationScope); /// Force the logs lying in the cache to be exported. fn force_flush(&self) -> LogResult<()>; /// Shuts down the processor. @@ -95,7 +95,7 @@ impl SimpleLogProcessor { } impl LogProcessor for SimpleLogProcessor { - fn emit(&self, record: &mut LogRecord, instrumentation: &InstrumentationLibrary) { + fn emit(&self, record: &mut LogRecord, instrumentation: &InstrumentationScope) { // noop after shutdown if self.is_shutdown.load(std::sync::atomic::Ordering::Relaxed) { // this is a warning, as the user is trying to log after the processor has been shutdown @@ -168,7 +168,7 @@ impl Debug for BatchLogProcessor { } impl LogProcessor for BatchLogProcessor { - fn emit(&self, record: &mut LogRecord, instrumentation: &InstrumentationLibrary) { + fn emit(&self, record: &mut LogRecord, instrumentation: &InstrumentationScope) { let result = self.message_sender.try_send(BatchMessage::ExportLog(( record.clone(), instrumentation.clone(), @@ -320,7 +320,7 @@ async fn export_with_timeout( time_out: Duration, exporter: &mut E, runtime: &R, - batch: Vec<(LogRecord, InstrumentationLibrary)>, + batch: Vec<(LogRecord, InstrumentationScope)>, ) -> ExportResult where R: RuntimeChannel, @@ -331,7 +331,7 @@ where } // TBD - Can we avoid this conversion as it involves heap allocation with new vector? - let log_vec: Vec<(&LogRecord, &InstrumentationLibrary)> = batch + let log_vec: Vec<(&LogRecord, &InstrumentationScope)> = batch .iter() .map(|log_data| (&log_data.0, &log_data.1)) .collect(); @@ -515,7 +515,7 @@ where #[derive(Debug)] enum BatchMessage { /// Export logs, usually called when the log is emitted. - ExportLog((LogRecord, InstrumentationLibrary)), + ExportLog((LogRecord, InstrumentationScope)), /// Flush the current buffer to the backend, it can be triggered by /// pre configured interval or a call to `force_push` function. Flush(Option>), @@ -550,7 +550,7 @@ mod tests { use opentelemetry::logs::AnyValue; use opentelemetry::logs::LogRecord as _; use opentelemetry::logs::{Logger, LoggerProvider as _}; - use opentelemetry::InstrumentationLibrary; + use opentelemetry::InstrumentationScope; use opentelemetry::Key; use opentelemetry::{logs::LogResult, KeyValue}; use std::sync::atomic::{AtomicUsize, Ordering}; @@ -795,7 +795,7 @@ mod tests { ); let mut record: LogRecord = Default::default(); - let instrumentation: InstrumentationLibrary = Default::default(); + let instrumentation: InstrumentationScope = Default::default(); processor.emit(&mut record, &instrumentation); processor.force_flush().unwrap(); @@ -813,7 +813,7 @@ mod tests { let processor = SimpleLogProcessor::new(Box::new(exporter.clone())); let mut record: LogRecord = Default::default(); - let instrumentation: InstrumentationLibrary = Default::default(); + let instrumentation: InstrumentationScope = Default::default(); processor.emit(&mut record, &instrumentation); @@ -883,11 +883,11 @@ mod tests { #[derive(Debug)] struct FirstProcessor { - pub(crate) logs: Arc>>, + pub(crate) logs: Arc>>, } impl LogProcessor for FirstProcessor { - fn emit(&self, record: &mut LogRecord, instrumentation: &InstrumentationLibrary) { + fn emit(&self, record: &mut LogRecord, instrumentation: &InstrumentationScope) { // add attribute record.add_attribute( Key::from_static_str("processed_by"), @@ -913,11 +913,11 @@ mod tests { #[derive(Debug)] struct SecondProcessor { - pub(crate) logs: Arc>>, + pub(crate) logs: Arc>>, } impl LogProcessor for SecondProcessor { - fn emit(&self, record: &mut LogRecord, instrumentation: &InstrumentationLibrary) { + fn emit(&self, record: &mut LogRecord, instrumentation: &InstrumentationScope) { assert!(record.attributes_contains( &Key::from_static_str("processed_by"), &AnyValue::String("FirstProcessor".into()) @@ -994,7 +994,7 @@ mod tests { let processor = SimpleLogProcessor::new(Box::new(exporter.clone())); let mut record: LogRecord = Default::default(); - let instrumentation: InstrumentationLibrary = Default::default(); + let instrumentation: InstrumentationScope = Default::default(); processor.emit(&mut record, &instrumentation); @@ -1007,7 +1007,7 @@ mod tests { let processor = SimpleLogProcessor::new(Box::new(exporter.clone())); let mut record: LogRecord = Default::default(); - let instrumentation: InstrumentationLibrary = Default::default(); + let instrumentation: InstrumentationScope = Default::default(); processor.emit(&mut record, &instrumentation); @@ -1024,7 +1024,7 @@ mod tests { let processor_clone = Arc::clone(&processor); let handle = tokio::spawn(async move { let mut record: LogRecord = Default::default(); - let instrumentation: InstrumentationLibrary = Default::default(); + let instrumentation: InstrumentationScope = Default::default(); processor_clone.emit(&mut record, &instrumentation); }); handles.push(handle); @@ -1043,7 +1043,7 @@ mod tests { let processor = SimpleLogProcessor::new(Box::new(exporter.clone())); let mut record: LogRecord = Default::default(); - let instrumentation: InstrumentationLibrary = Default::default(); + let instrumentation: InstrumentationScope = Default::default(); processor.emit(&mut record, &instrumentation); @@ -1090,7 +1090,7 @@ mod tests { let processor = SimpleLogProcessor::new(Box::new(exporter.clone())); let mut record: LogRecord = Default::default(); - let instrumentation: InstrumentationLibrary = Default::default(); + let instrumentation: InstrumentationScope = Default::default(); // This will panic because an tokio async operation within exporter without a runtime. processor.emit(&mut record, &instrumentation); @@ -1146,7 +1146,7 @@ mod tests { let processor_clone = Arc::clone(&processor); let handle = tokio::spawn(async move { let mut record: LogRecord = Default::default(); - let instrumentation: InstrumentationLibrary = Default::default(); + let instrumentation: InstrumentationScope = Default::default(); processor_clone.emit(&mut record, &instrumentation); }); handles.push(handle); @@ -1170,7 +1170,7 @@ mod tests { let processor = SimpleLogProcessor::new(Box::new(exporter.clone())); let mut record: LogRecord = Default::default(); - let instrumentation: InstrumentationLibrary = Default::default(); + let instrumentation: InstrumentationScope = Default::default(); processor.emit(&mut record, &instrumentation); @@ -1189,7 +1189,7 @@ mod tests { let processor = SimpleLogProcessor::new(Box::new(exporter.clone())); let mut record: LogRecord = Default::default(); - let instrumentation: InstrumentationLibrary = Default::default(); + let instrumentation: InstrumentationScope = Default::default(); processor.emit(&mut record, &instrumentation); @@ -1209,7 +1209,7 @@ mod tests { let processor = SimpleLogProcessor::new(Box::new(exporter.clone())); let mut record: LogRecord = Default::default(); - let instrumentation: InstrumentationLibrary = Default::default(); + let instrumentation: InstrumentationScope = Default::default(); processor.emit(&mut record, &instrumentation); diff --git a/opentelemetry-sdk/src/logs/mod.rs b/opentelemetry-sdk/src/logs/mod.rs index b71cbcd190..6dc22fe1f3 100644 --- a/opentelemetry-sdk/src/logs/mod.rs +++ b/opentelemetry-sdk/src/logs/mod.rs @@ -10,14 +10,14 @@ pub use log_processor::{ }; pub use record::{LogRecord, TraceContext}; -use opentelemetry::InstrumentationLibrary; +use opentelemetry::InstrumentationScope; /// `LogData` represents a single log event without resource context. #[derive(Clone, Debug)] pub struct LogData { /// Log record pub record: LogRecord, /// Instrumentation details for the emitter who produced this `LogEvent`. - pub instrumentation: InstrumentationLibrary, + pub instrumentation: InstrumentationScope, } #[cfg(all(test, feature = "testing"))] @@ -30,7 +30,6 @@ mod tests { use opentelemetry::{logs::AnyValue, Key, KeyValue}; use std::borrow::Borrow; use std::collections::HashMap; - use std::sync::Arc; #[test] fn logging_sdk_test() { @@ -105,18 +104,17 @@ mod tests { #[test] fn logger_attributes() { let provider = LoggerProvider::builder().build(); - let library = Arc::new( - InstrumentationLibrary::builder("test_logger") - .with_schema_url("https://opentelemetry.io/schema/1.0.0") - .with_attributes(vec![(KeyValue::new("test_k", "test_v"))]) - .build(), - ); - let logger = provider.library_logger(library); - let instrumentation_library = logger.instrumentation_library(); - let attributes = &instrumentation_library.attributes; - assert_eq!(instrumentation_library.name, "test_logger"); + let scope = InstrumentationScope::builder("test_logger") + .with_schema_url("https://opentelemetry.io/schema/1.0.0") + .with_attributes(vec![(KeyValue::new("test_k", "test_v"))]) + .build(); + + let logger = provider.logger_with_scope(scope); + let instrumentation_scope = logger.instrumentation_scope(); + let attributes = &instrumentation_scope.attributes; + assert_eq!(instrumentation_scope.name, "test_logger"); assert_eq!( - instrumentation_library.schema_url, + instrumentation_scope.schema_url, Some("https://opentelemetry.io/schema/1.0.0".into()) ); assert_eq!(attributes.len(), 1); diff --git a/opentelemetry-sdk/src/metrics/meter_provider.rs b/opentelemetry-sdk/src/metrics/meter_provider.rs index 5998cce675..fdf762b70b 100644 --- a/opentelemetry-sdk/src/metrics/meter_provider.rs +++ b/opentelemetry-sdk/src/metrics/meter_provider.rs @@ -10,7 +10,7 @@ use std::{ use opentelemetry::{ global, metrics::{Meter, MeterProvider, MetricsError, Result}, - InstrumentationLibrary, + InstrumentationScope, }; use crate::{instrumentation::Scope, Resource}; @@ -145,14 +145,14 @@ impl Drop for SdkMeterProviderInner { } } impl MeterProvider for SdkMeterProvider { - fn library_meter(&self, library: Arc) -> Meter { + fn meter_with_scope(&self, scope: InstrumentationScope) -> Meter { if self.inner.is_shutdown.load(Ordering::Relaxed) { return Meter::new(Arc::new(NoopMeter::new())); } if let Ok(mut meters) = self.inner.meters.lock() { let meter = meters - .entry(InstrumentationLibrary::clone(&library)) + .entry(scope) .or_insert_with_key(|scope| { Arc::new(SdkMeter::new(scope.clone(), self.inner.pipes.clone())) }) @@ -241,10 +241,9 @@ mod tests { use crate::testing::metrics::metric_reader::TestMetricReader; use crate::Resource; use opentelemetry::metrics::MeterProvider; - use opentelemetry::{global, InstrumentationLibrary}; + use opentelemetry::{global, InstrumentationScope}; use opentelemetry::{Key, KeyValue, Value}; use std::env; - use std::sync::Arc; #[test] fn test_meter_provider_resource() { @@ -436,40 +435,30 @@ mod tests { let _meter2 = provider.meter("test"); assert_eq!(provider.inner.meters.lock().unwrap().len(), 1); - let library = Arc::new( - InstrumentationLibrary::builder("test") - .with_version("1.0.0") - .with_schema_url("http://example.com") - .build(), - ); + let scope = InstrumentationScope::builder("test") + .with_version("1.0.0") + .with_schema_url("http://example.com") + .build(); - let _meter3 = provider.library_meter(library.clone()); - let _meter4 = provider.library_meter(library.clone()); - let _meter5 = provider.library_meter(library); + let _meter3 = provider.meter_with_scope(scope.clone()); + let _meter4 = provider.meter_with_scope(scope.clone()); + let _meter5 = provider.meter_with_scope(scope); assert_eq!(provider.inner.meters.lock().unwrap().len(), 2); // these are different meters because meter names are case sensitive - let library = Arc::new( - InstrumentationLibrary::builder("ABC") - .with_version("1.0.0") - .with_schema_url("http://example.com") - .build(), - ); - let _meter6 = provider.library_meter(library); - let library = Arc::new( - InstrumentationLibrary::builder("Abc") - .with_version("1.0.0") - .with_schema_url("http://example.com") - .build(), - ); - let _meter7 = provider.library_meter(library); - let library = Arc::new( - InstrumentationLibrary::builder("abc") - .with_version("1.0.0") - .with_schema_url("http://example.com") - .build(), - ); - let _meter8 = provider.library_meter(library); + let mut library = InstrumentationScope::builder("ABC") + .with_version("1.0.0") + .with_schema_url("http://example.com") + .build(); + + let _meter6 = provider.meter_with_scope(library.clone()); + + library.name = "Abc".into(); + let _meter7 = provider.meter_with_scope(library.clone()); + + library.name = "abc".into(); + let _meter8 = provider.meter_with_scope(library); + assert_eq!(provider.inner.meters.lock().unwrap().len(), 5); } } diff --git a/opentelemetry-sdk/src/metrics/mod.rs b/opentelemetry-sdk/src/metrics/mod.rs index 85b0d7f94d..58cde6f068 100644 --- a/opentelemetry-sdk/src/metrics/mod.rs +++ b/opentelemetry-sdk/src/metrics/mod.rs @@ -134,7 +134,7 @@ mod tests { use crate::testing::metrics::InMemoryMetricsExporterBuilder; use crate::{runtime, testing::metrics::InMemoryMetricsExporter}; use opentelemetry::metrics::{Counter, Meter, UpDownCounter}; - use opentelemetry::InstrumentationLibrary; + use opentelemetry::InstrumentationScope; use opentelemetry::{metrics::MeterProvider as _, KeyValue}; use rand::{rngs, Rng, SeedableRng}; use std::borrow::Cow; @@ -638,23 +638,16 @@ mod tests { // Act // Meters are identical except for scope attributes, but scope attributes are not an identifying property. // Hence there should be a single metric stream output for this test. - let library = Arc::new( - InstrumentationLibrary::builder("test.meter") - .with_version("v0.1.0") - .with_schema_url("http://example.com") - .with_attributes(vec![KeyValue::new("key", "value1")]) - .build(), - ); - let meter1 = meter_provider.library_meter(library); - - let library = Arc::new( - InstrumentationLibrary::builder("test.meter") - .with_version("v0.1.0") - .with_schema_url("http://example.com") - .with_attributes(vec![KeyValue::new("key", "value2")]) - .build(), - ); - let meter2 = meter_provider.library_meter(library); + let mut scope = InstrumentationScope::builder("test.meter") + .with_version("v0.1.0") + .with_schema_url("http://example.com") + .with_attributes(vec![KeyValue::new("key", "value1")]) + .build(); + + let meter1 = meter_provider.meter_with_scope(scope.clone()); + + scope.attributes = vec![KeyValue::new("key", "value2")]; + let meter2 = meter_provider.meter_with_scope(scope); let counter1 = meter1 .u64_counter("my_counter") diff --git a/opentelemetry-sdk/src/testing/logs/in_memory_exporter.rs b/opentelemetry-sdk/src/testing/logs/in_memory_exporter.rs index 958ab11fe1..0db7913adc 100644 --- a/opentelemetry-sdk/src/testing/logs/in_memory_exporter.rs +++ b/opentelemetry-sdk/src/testing/logs/in_memory_exporter.rs @@ -3,7 +3,7 @@ use crate::logs::LogRecord; use crate::Resource; use async_trait::async_trait; use opentelemetry::logs::{LogError, LogResult}; -use opentelemetry::InstrumentationLibrary; +use opentelemetry::InstrumentationScope; use std::borrow::Cow; use std::sync::{Arc, Mutex}; @@ -56,17 +56,17 @@ pub struct OwnedLogData { /// Log record, which can be borrowed or owned. pub record: LogRecord, /// Instrumentation details for the emitter who produced this `LogEvent`. - pub instrumentation: InstrumentationLibrary, + pub instrumentation: InstrumentationScope, } /// `LogDataWithResource` associates a [`LogRecord`] with a [`Resource`] and -/// [`InstrumentationLibrary`]. +/// [`InstrumentationScope`]. #[derive(Clone, Debug)] pub struct LogDataWithResource { /// Log record pub record: LogRecord, /// Instrumentation details for the emitter who produced this `LogData`. - pub instrumentation: InstrumentationLibrary, + pub instrumentation: InstrumentationScope, /// Resource for the emitter who produced this `LogData`. pub resource: Cow<'static, Resource>, } diff --git a/opentelemetry-sdk/src/testing/trace/span_exporters.rs b/opentelemetry-sdk/src/testing/trace/span_exporters.rs index c92a64f399..1e4d9efcb2 100644 --- a/opentelemetry-sdk/src/testing/trace/span_exporters.rs +++ b/opentelemetry-sdk/src/testing/trace/span_exporters.rs @@ -4,7 +4,7 @@ use crate::{ ExportError, }, trace::{SpanEvents, SpanLinks}, - InstrumentationLibrary, + InstrumentationScope, }; use futures_util::future::BoxFuture; pub use opentelemetry::testing::trace::TestSpan; @@ -32,7 +32,7 @@ pub fn new_test_export_span_data() -> SpanData { events: SpanEvents::default(), links: SpanLinks::default(), status: Status::Unset, - instrumentation_lib: InstrumentationLibrary::default(), + instrumentation_scope: InstrumentationScope::default(), } } diff --git a/opentelemetry-sdk/src/trace/mod.rs b/opentelemetry-sdk/src/trace/mod.rs index edf31cb68f..7ce5e7b977 100644 --- a/opentelemetry-sdk/src/trace/mod.rs +++ b/opentelemetry-sdk/src/trace/mod.rs @@ -40,7 +40,6 @@ mod runtime_tests; #[cfg(all(test, feature = "testing"))] mod tests { - use std::sync::Arc; use super::*; use crate::{ @@ -50,7 +49,7 @@ mod tests { use opentelemetry::trace::{ SamplingDecision, SamplingResult, SpanKind, Status, TraceContextExt, TraceState, }; - use opentelemetry::{testing::trace::TestSpan, InstrumentationLibrary}; + use opentelemetry::{testing::trace::TestSpan, InstrumentationScope}; use opentelemetry::{ trace::{ Event, Link, Span, SpanBuilder, SpanContext, SpanId, TraceFlags, TraceId, Tracer, @@ -84,7 +83,7 @@ mod tests { assert_eq!(exported_spans.len(), 1); let span = &exported_spans[0]; assert_eq!(span.name, "span_name_updated"); - assert_eq!(span.instrumentation_lib.name, "test_tracer"); + assert_eq!(span.instrumentation_scope.name, "test_tracer"); assert_eq!(span.attributes.len(), 1); assert_eq!(span.events.len(), 1); assert_eq!(span.events[0].name, "test-event"); @@ -119,7 +118,7 @@ mod tests { assert_eq!(exported_spans.len(), 1); let span = &exported_spans[0]; assert_eq!(span.name, "span_name"); - assert_eq!(span.instrumentation_lib.name, "test_tracer"); + assert_eq!(span.instrumentation_scope.name, "test_tracer"); assert_eq!(span.attributes.len(), 1); assert_eq!(span.events.len(), 1); assert_eq!(span.events[0].name, "test-event"); @@ -156,7 +155,7 @@ mod tests { let span = &exported_spans[0]; assert_eq!(span.name, "span_name"); assert_eq!(span.span_kind, SpanKind::Server); - assert_eq!(span.instrumentation_lib.name, "test_tracer"); + assert_eq!(span.instrumentation_scope.name, "test_tracer"); assert_eq!(span.attributes.len(), 1); assert_eq!(span.events.len(), 1); assert_eq!(span.events[0].name, "test-event"); @@ -328,14 +327,13 @@ mod tests { #[test] fn tracer_attributes() { let provider = TracerProvider::builder().build(); - let library = Arc::new( - InstrumentationLibrary::builder("basic") - .with_attributes(vec![KeyValue::new("test_k", "test_v")]) - .build(), - ); - let tracer = provider.library_tracer(library); - let instrumentation_library = tracer.instrumentation_library(); - let attributes = &instrumentation_library.attributes; + let scope = InstrumentationScope::builder("basic") + .with_attributes(vec![KeyValue::new("test_k", "test_v")]) + .build(); + + let tracer = provider.tracer_with_scope(scope); + let instrumentation_scope = tracer.instrumentation_scope(); + let attributes = &instrumentation_scope.attributes; assert_eq!(attributes.len(), 1); assert_eq!(attributes[0].key, "test_k".into()); assert_eq!(attributes[0].value, "test_v".into()); diff --git a/opentelemetry-sdk/src/trace/provider.rs b/opentelemetry-sdk/src/trace/provider.rs index da201f1eb2..de79d4c932 100644 --- a/opentelemetry-sdk/src/trace/provider.rs +++ b/opentelemetry-sdk/src/trace/provider.rs @@ -13,7 +13,7 @@ use crate::trace::{ BatchSpanProcessor, Config, RandomIdGenerator, Sampler, SimpleSpanProcessor, SpanLimits, Tracer, }; use crate::{export::trace::SpanExporter, trace::SpanProcessor}; -use crate::{InstrumentationLibrary, Resource}; +use crate::{InstrumentationScope, Resource}; use once_cell::sync::{Lazy, OnceCell}; use opentelemetry::trace::TraceError; use opentelemetry::{global, trace::TraceResult}; @@ -181,11 +181,11 @@ impl opentelemetry::trace::TracerProvider for TracerProvider { /// This implementation of `TracerProvider` produces `Tracer` instances. type Tracer = Tracer; - fn library_tracer(&self, library: Arc) -> Self::Tracer { + fn tracer_with_scope(&self, scope: InstrumentationScope) -> Self::Tracer { if self.is_shutdown.load(Ordering::Relaxed) { - return Tracer::new(library, NOOP_TRACER_PROVIDER.clone()); + return Tracer::new(scope, NOOP_TRACER_PROVIDER.clone()); } - Tracer::new(library, self.clone()) + Tracer::new(scope, self.clone()) } } diff --git a/opentelemetry-sdk/src/trace/span.rs b/opentelemetry-sdk/src/trace/span.rs index ea03d9ab53..25a5df0da1 100644 --- a/opentelemetry-sdk/src/trace/span.rs +++ b/opentelemetry-sdk/src/trace/span.rs @@ -263,7 +263,7 @@ fn build_export_data( events: data.events, links: data.links, status: data.status, - instrumentation_lib: tracer.instrumentation_library().clone(), + instrumentation_scope: tracer.instrumentation_scope().clone(), } } diff --git a/opentelemetry-sdk/src/trace/span_processor.rs b/opentelemetry-sdk/src/trace/span_processor.rs index e49ec9ee60..be0921c51d 100644 --- a/opentelemetry-sdk/src/trace/span_processor.rs +++ b/opentelemetry-sdk/src/trace/span_processor.rs @@ -741,7 +741,7 @@ mod tests { events: SpanEvents::default(), links: SpanLinks::default(), status: Status::Unset, - instrumentation_lib: Default::default(), + instrumentation_scope: Default::default(), }; processor.on_end(unsampled); assert!(exporter.get_finished_spans().unwrap().is_empty()); diff --git a/opentelemetry-sdk/src/trace/tracer.rs b/opentelemetry-sdk/src/trace/tracer.rs index f3182d388e..fa590e90c6 100644 --- a/opentelemetry-sdk/src/trace/tracer.rs +++ b/opentelemetry-sdk/src/trace/tracer.rs @@ -13,19 +13,18 @@ use crate::{ span::{Span, SpanData}, IdGenerator, ShouldSample, SpanEvents, SpanLimits, SpanLinks, }, - InstrumentationLibrary, + InstrumentationScope, }; use opentelemetry::{ trace::{SamplingDecision, SpanBuilder, SpanContext, SpanKind, TraceContextExt, TraceFlags}, Context, KeyValue, }; use std::fmt; -use std::sync::Arc; /// `Tracer` implementation to create and manage spans #[derive(Clone)] pub struct Tracer { - instrumentation_lib: Arc, + scope: InstrumentationScope, provider: TracerProvider, } @@ -34,22 +33,16 @@ impl fmt::Debug for Tracer { /// Omitting `provider` here is necessary to avoid cycles. fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_struct("Tracer") - .field("name", &self.instrumentation_lib.name) - .field("version", &self.instrumentation_lib.version) + .field("name", &self.scope.name) + .field("version", &self.scope.version) .finish() } } impl Tracer { /// Create a new tracer (used internally by `TracerProvider`s). - pub(crate) fn new( - instrumentation_lib: Arc, - provider: TracerProvider, - ) -> Self { - Tracer { - instrumentation_lib, - provider, - } + pub(crate) fn new(scope: InstrumentationScope, provider: TracerProvider) -> Self { + Tracer { scope, provider } } /// TracerProvider associated with this tracer. @@ -58,8 +51,8 @@ impl Tracer { } /// Instrumentation library information of this tracer. - pub(crate) fn instrumentation_library(&self) -> &InstrumentationLibrary { - &self.instrumentation_lib + pub(crate) fn instrumentation_scope(&self) -> &InstrumentationScope { + &self.scope } fn build_recording_span( diff --git a/opentelemetry-stdout/examples/basic.rs b/opentelemetry-stdout/examples/basic.rs index 4ad6c62ed6..da12e26432 100644 --- a/opentelemetry-stdout/examples/basic.rs +++ b/opentelemetry-stdout/examples/basic.rs @@ -64,20 +64,17 @@ fn init_logs() -> opentelemetry_sdk::logs::LoggerProvider { #[cfg(feature = "trace")] fn emit_span() { - use std::sync::Arc; - use opentelemetry::{ - trace::{SpanContext, SpanId, TraceFlags, TraceId, TraceState, TracerProvider}, - InstrumentationLibrary, + trace::{SpanContext, SpanId, TraceFlags, TraceId, TraceState}, + InstrumentationScope, }; - let library = Arc::new( - InstrumentationLibrary::builder("stdout-example") - .with_version("v1") - .with_attributes([KeyValue::new("scope_key", "scope_value")]) - .build(), - ); - let tracer = global::tracer_provider().library_tracer(library); + let scope = InstrumentationScope::builder("stdout-example") + .with_version("v1") + .with_attributes([KeyValue::new("scope_key", "scope_value")]) + .build(); + + let tracer = global::tracer_with_scope(scope); let mut span = tracer.start("example-span"); span.set_attribute(KeyValue::new("attribute_key1", "attribute_value1")); span.set_attribute(KeyValue::new("attribute_key2", "attribute_value2")); diff --git a/opentelemetry-stdout/src/common.rs b/opentelemetry-stdout/src/common.rs index 236accea7c..32bafdbe2b 100644 --- a/opentelemetry-stdout/src/common.rs +++ b/opentelemetry-stdout/src/common.rs @@ -235,7 +235,7 @@ impl From for Scope { Scope { name: value.name, version: value.version, - attributes: value.attributes.into_iter().map(Into::into).collect(), + attributes: value.attributes.iter().map(Into::into).collect(), dropped_attributes_count: 0, } } diff --git a/opentelemetry-stdout/src/trace/exporter.rs b/opentelemetry-stdout/src/trace/exporter.rs index a5c057ca46..798e6b4247 100644 --- a/opentelemetry-stdout/src/trace/exporter.rs +++ b/opentelemetry-stdout/src/trace/exporter.rs @@ -72,14 +72,14 @@ fn print_spans(batch: Vec) { for (i, span) in batch.into_iter().enumerate() { println!("Span #{}", i); println!("\tInstrumentation Scope"); - println!("\t\tName : {:?}", &span.instrumentation_lib.name); - if let Some(version) = &span.instrumentation_lib.version { + println!("\t\tName : {:?}", &span.instrumentation_scope.name); + if let Some(version) = &span.instrumentation_scope.version { println!("\t\tVersion : {:?}", version); } - if let Some(schema_url) = &span.instrumentation_lib.schema_url { + if let Some(schema_url) = &span.instrumentation_scope.schema_url { println!("\t\tSchemaUrl: {:?}", schema_url); } - span.instrumentation_lib + span.instrumentation_scope .attributes .iter() .enumerate() diff --git a/opentelemetry-zipkin/src/exporter/mod.rs b/opentelemetry-zipkin/src/exporter/mod.rs index 4c8d1b004f..e7466c6a2d 100644 --- a/opentelemetry-zipkin/src/exporter/mod.rs +++ b/opentelemetry-zipkin/src/exporter/mod.rs @@ -6,7 +6,7 @@ use async_trait::async_trait; use futures_core::future::BoxFuture; use http::Uri; use model::endpoint::Endpoint; -use opentelemetry::{global, trace::TraceError, InstrumentationLibrary, KeyValue}; +use opentelemetry::{global, trace::TraceError, InstrumentationScope, KeyValue}; use opentelemetry_http::HttpClient; use opentelemetry_sdk::{ export::{trace, ExportError}, @@ -144,13 +144,11 @@ impl ZipkinPipelineBuilder { let mut provider_builder = TracerProvider::builder().with_simple_exporter(exporter); provider_builder = provider_builder.with_config(config); let provider = provider_builder.build(); - let library = Arc::new( - InstrumentationLibrary::builder("opentelemetry-zipkin") - .with_version(env!("CARGO_PKG_VERSION")) - .with_schema_url(semcov::SCHEMA_URL) - .build(), - ); - let tracer = opentelemetry::trace::TracerProvider::library_tracer(&provider, library); + let scope = InstrumentationScope::builder("opentelemetry-zipkin") + .with_version(env!("CARGO_PKG_VERSION")) + .with_schema_url(semcov::SCHEMA_URL) + .build(); + let tracer = opentelemetry::trace::TracerProvider::tracer_with_scope(&provider, scope); let _ = global::set_tracer_provider(provider); Ok(tracer) } @@ -163,13 +161,11 @@ impl ZipkinPipelineBuilder { let mut provider_builder = TracerProvider::builder().with_batch_exporter(exporter, runtime); provider_builder = provider_builder.with_config(config); let provider = provider_builder.build(); - let library = Arc::new( - InstrumentationLibrary::builder("opentelemetry-zipkin") - .with_version(env!("CARGO_PKG_VERSION")) - .with_schema_url(semcov::SCHEMA_URL) - .build(), - ); - let tracer = opentelemetry::trace::TracerProvider::library_tracer(&provider, library); + let scope = InstrumentationScope::builder("opentelemetry-zipkin") + .with_version(env!("CARGO_PKG_VERSION")) + .with_schema_url(semcov::SCHEMA_URL) + .build(); + let tracer = opentelemetry::trace::TracerProvider::tracer_with_scope(&provider, scope); let _ = global::set_tracer_provider(provider); Ok(tracer) } diff --git a/opentelemetry-zipkin/src/exporter/model/mod.rs b/opentelemetry-zipkin/src/exporter/model/mod.rs index b143848f31..15646429c9 100644 --- a/opentelemetry-zipkin/src/exporter/model/mod.rs +++ b/opentelemetry-zipkin/src/exporter/model/mod.rs @@ -46,11 +46,11 @@ pub(crate) fn into_zipkin_span(local_endpoint: Endpoint, span_data: SpanData) -> [ ( INSTRUMENTATION_LIBRARY_NAME, - Some(span_data.instrumentation_lib.name), + Some(span_data.instrumentation_scope.name), ), ( INSTRUMENTATION_LIBRARY_VERSION, - span_data.instrumentation_lib.version, + span_data.instrumentation_scope.version, ), ] .into_iter() diff --git a/opentelemetry-zipkin/src/exporter/model/span.rs b/opentelemetry-zipkin/src/exporter/model/span.rs index 8c9c7fd5a1..51223be92b 100644 --- a/opentelemetry-zipkin/src/exporter/model/span.rs +++ b/opentelemetry-zipkin/src/exporter/model/span.rs @@ -165,7 +165,7 @@ mod tests { events: SpanEvents::default(), links: SpanLinks::default(), status, - instrumentation_lib: Default::default(), + instrumentation_scope: Default::default(), }; let local_endpoint = Endpoint::new("test".into(), None); let span = into_zipkin_span(local_endpoint, span_data); diff --git a/opentelemetry/src/common.rs b/opentelemetry/src/common.rs index 26a520ac21..e2465687a1 100644 --- a/opentelemetry/src/common.rs +++ b/opentelemetry/src/common.rs @@ -402,7 +402,7 @@ pub trait ExportError: std::error::Error + Send + Sync + 'static { /// Information about a library or crate providing instrumentation. /// -/// An instrumentation library should be named to follow any naming conventions +/// An instrumentation scope should be named to follow any naming conventions /// of the instrumented library (e.g. 'middleware' for a web framework). /// /// See the [instrumentation libraries] spec for more information. @@ -410,37 +410,28 @@ pub trait ExportError: std::error::Error + Send + Sync + 'static { /// [instrumentation libraries]: https://github.com/open-telemetry/opentelemetry-specification/blob/v1.9.0/specification/overview.md#instrumentation-libraries #[derive(Debug, Default, Clone)] #[non_exhaustive] -pub struct InstrumentationLibrary { +pub struct InstrumentationScope { /// The library name. /// /// This should be the name of the crate providing the instrumentation. pub name: Cow<'static, str>, /// The library version. - /// - /// # Examples - /// - /// ``` - /// let library = opentelemetry::InstrumentationLibrary::builder("my-crate"). - /// with_version(env!("CARGO_PKG_VERSION")). - /// with_schema_url("https://opentelemetry.io/schemas/1.17.0"). - /// build(); - /// ``` pub version: Option>, - /// [Schema url] used by this library. + /// [Schema URL] used by this library. /// - /// [Schema url]: https://github.com/open-telemetry/opentelemetry-specification/blob/v1.9.0/specification/schemas/overview.md#schema-url + /// [Schema URL]: https://github.com/open-telemetry/opentelemetry-specification/blob/v1.9.0/specification/schemas/overview.md#schema-url pub schema_url: Option>, /// Specifies the instrumentation scope attributes to associate with emitted telemetry. pub attributes: Vec, } -// Uniqueness for InstrumentationLibrary/InstrumentationScope does not depend on attributes -impl Eq for InstrumentationLibrary {} +// Uniqueness for InstrumentationScope does not depend on attributes +impl Eq for InstrumentationScope {} -impl PartialEq for InstrumentationLibrary { +impl PartialEq for InstrumentationScope { fn eq(&self, other: &Self) -> bool { self.name == other.name && self.version == other.version @@ -448,7 +439,7 @@ impl PartialEq for InstrumentationLibrary { } } -impl hash::Hash for InstrumentationLibrary { +impl hash::Hash for InstrumentationScope { fn hash(&self, state: &mut H) { self.name.hash(state); self.version.hash(state); @@ -456,28 +447,10 @@ impl hash::Hash for InstrumentationLibrary { } } -impl InstrumentationLibrary { - /// Deprecated, use [`InstrumentationLibrary::builder()`] - /// - /// Create an new instrumentation library. - #[deprecated(since = "0.23.0", note = "Please use builder() instead")] - pub fn new( - name: impl Into>, - version: Option>>, - schema_url: Option>>, - attributes: Option>, - ) -> InstrumentationLibrary { - InstrumentationLibrary { - name: name.into(), - version: version.map(Into::into), - schema_url: schema_url.map(Into::into), - attributes: attributes.unwrap_or_default(), - } - } - - /// Create a new builder to create an [InstrumentationLibrary] - pub fn builder>>(name: T) -> InstrumentationLibraryBuilder { - InstrumentationLibraryBuilder { +impl InstrumentationScope { + /// Create a new builder to create an [InstrumentationScope] + pub fn builder>>(name: T) -> InstrumentationScopeBuilder { + InstrumentationScopeBuilder { name: name.into(), version: None, schema_url: None, @@ -486,9 +459,9 @@ impl InstrumentationLibrary { } } -/// Configuration options for [InstrumentationLibrary]. +/// Configuration options for [InstrumentationScope]. /// -/// An instrumentation library is a library or crate providing instrumentation. +/// An instrumentation scope is a library or crate providing instrumentation. /// It should be named to follow any naming conventions of the instrumented /// library (e.g. 'middleware' for a web framework). /// @@ -498,7 +471,7 @@ impl InstrumentationLibrary { /// /// [instrumentation libraries]: https://github.com/open-telemetry/opentelemetry-specification/blob/v1.9.0/specification/overview.md#instrumentation-libraries #[derive(Debug)] -pub struct InstrumentationLibraryBuilder { +pub struct InstrumentationScopeBuilder { name: Cow<'static, str>, version: Option>, @@ -508,13 +481,13 @@ pub struct InstrumentationLibraryBuilder { attributes: Option>, } -impl InstrumentationLibraryBuilder { - /// Configure the version for the instrumentation library +impl InstrumentationScopeBuilder { + /// Configure the version for the instrumentation scope /// /// # Examples /// /// ``` - /// let library = opentelemetry::InstrumentationLibrary::builder("my-crate") + /// let scope = opentelemetry::InstrumentationScope::builder("my-crate") /// .with_version("v0.1.0") /// .build(); /// ``` @@ -523,12 +496,12 @@ impl InstrumentationLibraryBuilder { self } - /// Configure the Schema URL for the instrumentation library + /// Configure the Schema URL for the instrumentation scope /// /// # Examples /// /// ``` - /// let library = opentelemetry::InstrumentationLibrary::builder("my-crate") + /// let scope = opentelemetry::InstrumentationScope::builder("my-crate") /// .with_schema_url("https://opentelemetry.io/schemas/1.17.0") /// .build(); /// ``` @@ -537,14 +510,14 @@ impl InstrumentationLibraryBuilder { self } - /// Configure the attributes for the instrumentation library + /// Configure the attributes for the instrumentation scope /// /// # Examples /// /// ``` /// use opentelemetry::KeyValue; /// - /// let library = opentelemetry::InstrumentationLibrary::builder("my-crate") + /// let scope = opentelemetry::InstrumentationScope::builder("my-crate") /// .with_attributes([KeyValue::new("k", "v")]) /// .build(); /// ``` @@ -556,9 +529,9 @@ impl InstrumentationLibraryBuilder { self } - /// Create a new [InstrumentationLibrary] from this configuration - pub fn build(self) -> InstrumentationLibrary { - InstrumentationLibrary { + /// Create a new [InstrumentationScope] from this configuration + pub fn build(self) -> InstrumentationScope { + InstrumentationScope { name: self.name, version: self.version, schema_url: self.schema_url, diff --git a/opentelemetry/src/global/metrics.rs b/opentelemetry/src/global/metrics.rs index cb0637964f..abc24a2fe9 100644 --- a/opentelemetry/src/global/metrics.rs +++ b/opentelemetry/src/global/metrics.rs @@ -1,5 +1,5 @@ use crate::metrics::{self, Meter, MeterProvider}; -use crate::InstrumentationLibrary; +use crate::InstrumentationScope; use once_cell::sync::Lazy; use std::sync::{Arc, RwLock}; @@ -40,26 +40,24 @@ pub fn meter(name: &'static str) -> Meter { /// Creates a [`Meter`] with the given instrumentation library. /// -/// This is a shortcut `global::meter_provider().library_meter(...)` +/// This is a shortcut `global::meter_provider().meter_with_scope(...)` /// /// # Example /// /// ``` /// use std::sync::Arc; -/// use opentelemetry::global::library_meter; -/// use opentelemetry::InstrumentationLibrary; +/// use opentelemetry::global::meter_with_scope; +/// use opentelemetry::InstrumentationScope; /// use opentelemetry::KeyValue; /// -/// let library = Arc::new( -/// InstrumentationLibrary::builder("io.opentelemetry") -/// .with_version("0.17") -/// .with_schema_url("https://opentelemetry.io/schema/1.2.0") -/// .with_attributes(vec![(KeyValue::new("key", "value"))]) -/// .build(), -/// ); +/// let scope = InstrumentationScope::builder("io.opentelemetry") +/// .with_version("0.17") +/// .with_schema_url("https://opentelemetry.io/schema/1.2.0") +/// .with_attributes(vec![(KeyValue::new("key", "value"))]) +/// .build(); /// -/// let meter = library_meter(library); +/// let meter = meter_with_scope(scope); /// ``` -pub fn library_meter(library: Arc) -> Meter { - meter_provider().library_meter(library) +pub fn meter_with_scope(scope: InstrumentationScope) -> Meter { + meter_provider().meter_with_scope(scope) } diff --git a/opentelemetry/src/global/mod.rs b/opentelemetry/src/global/mod.rs index b73e40a9cc..be787edd29 100644 --- a/opentelemetry/src/global/mod.rs +++ b/opentelemetry/src/global/mod.rs @@ -53,19 +53,18 @@ //! use std::sync::Arc; //! use opentelemetry::trace::{Tracer, TracerProvider}; //! use opentelemetry::global; -//! use opentelemetry::InstrumentationLibrary; +//! use opentelemetry::InstrumentationScope; //! //! pub fn my_traced_library_function() { //! // End users of your library will configure their global tracer provider //! // so you can use the global tracer without any setup //! -//! let library = Arc::new(InstrumentationLibrary::builder("my_library-name") +//! let scope = InstrumentationScope::builder("my_library-name") //! .with_version(env!("CARGO_PKG_VERSION")) //! .with_schema_url("https://opentelemetry.io/schemas/1.17.0") -//! .build() -//! ); +//! .build(); //! -//! let tracer = global::tracer_provider().library_tracer(library); +//! let tracer = global::tracer_provider().tracer_with_scope(scope); //! //! tracer.in_span("doing_library_work", |cx| { //! // Traced library logic here... diff --git a/opentelemetry/src/global/trace.rs b/opentelemetry/src/global/trace.rs index 89553de7e7..efa1d18803 100644 --- a/opentelemetry/src/global/trace.rs +++ b/opentelemetry/src/global/trace.rs @@ -1,5 +1,5 @@ use crate::trace::{noop::NoopTracerProvider, SpanContext, Status}; -use crate::InstrumentationLibrary; +use crate::InstrumentationScope; use crate::{trace, trace::TracerProvider, Context, KeyValue}; use once_cell::sync::Lazy; use std::borrow::Cow; @@ -305,10 +305,7 @@ where pub trait ObjectSafeTracerProvider { /// Creates a versioned named tracer instance that is a trait object through the underlying /// `TracerProvider`. - fn boxed_tracer( - &self, - library: Arc, - ) -> Box; + fn boxed_tracer(&self, scope: InstrumentationScope) -> Box; } impl ObjectSafeTracerProvider for P @@ -318,11 +315,8 @@ where P: trace::TracerProvider, { /// Return a versioned boxed tracer - fn boxed_tracer( - &self, - library: Arc, - ) -> Box { - Box::new(self.library_tracer(library)) + fn boxed_tracer(&self, scope: InstrumentationScope) -> Box { + Box::new(self.tracer_with_scope(scope)) } } @@ -360,8 +354,8 @@ impl trace::TracerProvider for GlobalTracerProvider { type Tracer = BoxedTracer; /// Create a tracer using the global provider. - fn library_tracer(&self, library: Arc) -> Self::Tracer { - BoxedTracer(self.provider.boxed_tracer(library)) + fn tracer_with_scope(&self, scope: InstrumentationScope) -> Self::Tracer { + BoxedTracer(self.provider.boxed_tracer(scope)) } } @@ -398,30 +392,28 @@ pub fn tracer(name: impl Into>) -> BoxedTracer { /// Creates a [`Tracer`] with the given instrumentation library /// via the configured [`GlobalTracerProvider`]. /// -/// This is a shortcut `global::tracer_provider().library_tracer(...)` +/// This is a shortcut `global::tracer_provider().tracer_with_scope(...)` /// /// # Example /// /// ``` /// use std::sync::Arc; -/// use opentelemetry::global::library_tracer; -/// use opentelemetry::InstrumentationLibrary; +/// use opentelemetry::global::tracer_with_scope; +/// use opentelemetry::InstrumentationScope; /// use opentelemetry::KeyValue; /// -/// let library = Arc::new( -/// InstrumentationLibrary::builder("io.opentelemetry") -/// .with_version("0.17") -/// .with_schema_url("https://opentelemetry.io/schema/1.2.0") -/// .with_attributes(vec![(KeyValue::new("key", "value"))]) -/// .build(), -/// ); +/// let scope = InstrumentationScope::builder("io.opentelemetry") +/// .with_version("0.17") +/// .with_schema_url("https://opentelemetry.io/schema/1.2.0") +/// .with_attributes(vec![(KeyValue::new("key", "value"))]) +/// .build(); /// -/// let meter = library_tracer(library); +/// let meter = tracer_with_scope(scope); /// ``` /// /// [`Tracer`]: crate::trace::Tracer -pub fn library_tracer(library: Arc) -> BoxedTracer { - tracer_provider().library_tracer(library) +pub fn tracer_with_scope(scope: InstrumentationScope) -> BoxedTracer { + tracer_provider().tracer_with_scope(scope) } /// Sets the given [`TracerProvider`] instance as the current global provider. diff --git a/opentelemetry/src/lib.rs b/opentelemetry/src/lib.rs index 6e42f506de..0131bd28dc 100644 --- a/opentelemetry/src/lib.rs +++ b/opentelemetry/src/lib.rs @@ -204,7 +204,7 @@ mod common; pub mod testing; pub use common::{ - Array, ExportError, InstrumentationLibrary, InstrumentationLibraryBuilder, Key, KeyValue, + Array, ExportError, InstrumentationScope, InstrumentationScopeBuilder, Key, KeyValue, StringValue, Value, }; diff --git a/opentelemetry/src/logs/logger.rs b/opentelemetry/src/logs/logger.rs index d71415adff..3ea975ab04 100644 --- a/opentelemetry/src/logs/logger.rs +++ b/opentelemetry/src/logs/logger.rs @@ -1,6 +1,6 @@ -use std::{borrow::Cow, sync::Arc}; +use std::borrow::Cow; -use crate::{logs::LogRecord, InstrumentationLibrary}; +use crate::{logs::LogRecord, InstrumentationScope}; #[cfg(feature = "logs_level_enabled")] use super::Severity; @@ -35,8 +35,7 @@ pub trait LoggerProvider { /// # Examples /// /// ``` - /// use std::sync::Arc; - /// use opentelemetry::InstrumentationLibrary; + /// use opentelemetry::InstrumentationScope; /// use opentelemetry::logs::LoggerProvider; /// use opentelemetry_sdk::logs::LoggerProvider as SdkLoggerProvider; /// @@ -46,15 +45,14 @@ pub trait LoggerProvider { /// let logger = provider.logger("my_app"); /// /// // logger used in libraries/crates that optionally includes version and schema url - /// let library = Arc::new( - /// InstrumentationLibrary::builder(env!("CARGO_PKG_NAME")) - /// .with_version(env!("CARGO_PKG_VERSION")) - /// .with_schema_url("https://opentelemetry.io/schema/1.0.0") - /// .build(), - /// ); - /// let logger = provider.library_logger(library); + /// let scope = InstrumentationScope::builder(env!("CARGO_PKG_NAME")) + /// .with_version(env!("CARGO_PKG_VERSION")) + /// .with_schema_url("https://opentelemetry.io/schema/1.0.0") + /// .build(); + /// + /// let logger = provider.logger_with_scope(scope); /// ``` - fn library_logger(&self, library: Arc) -> Self::Logger; + fn logger_with_scope(&self, scope: InstrumentationScope) -> Self::Logger; /// Returns a new logger with the given name. /// @@ -62,7 +60,7 @@ pub trait LoggerProvider { /// providing instrumentation. If the name is empty, then an /// implementation-defined default name may be used instead. fn logger(&self, name: impl Into>) -> Self::Logger { - let library = Arc::new(InstrumentationLibrary::builder(name).build()); - self.library_logger(library) + let scope = InstrumentationScope::builder(name).build(); + self.logger_with_scope(scope) } } diff --git a/opentelemetry/src/logs/noop.rs b/opentelemetry/src/logs/noop.rs index 91c2e7bf97..ce94a379a3 100644 --- a/opentelemetry/src/logs/noop.rs +++ b/opentelemetry/src/logs/noop.rs @@ -1,8 +1,8 @@ -use std::{borrow::Cow, sync::Arc, time::SystemTime}; +use std::{borrow::Cow, time::SystemTime}; use crate::{ logs::{AnyValue, LogRecord, Logger, LoggerProvider, Severity}, - InstrumentationLibrary, Key, + InstrumentationScope, Key, }; /// A no-op implementation of a [`LoggerProvider`]. @@ -19,7 +19,7 @@ impl NoopLoggerProvider { impl LoggerProvider for NoopLoggerProvider { type Logger = NoopLogger; - fn library_logger(&self, _library: Arc) -> Self::Logger { + fn logger_with_scope(&self, _scope: InstrumentationScope) -> Self::Logger { NoopLogger(()) } } diff --git a/opentelemetry/src/metrics/meter.rs b/opentelemetry/src/metrics/meter.rs index c3a2976fb6..a99ea98d86 100644 --- a/opentelemetry/src/metrics/meter.rs +++ b/opentelemetry/src/metrics/meter.rs @@ -6,7 +6,7 @@ use crate::metrics::{ AsyncInstrumentBuilder, Gauge, InstrumentBuilder, InstrumentProvider, ObservableCounter, ObservableGauge, ObservableUpDownCounter, UpDownCounter, }; -use crate::InstrumentationLibrary; +use crate::InstrumentationScope; use super::{Counter, Histogram, HistogramBuilder}; @@ -19,25 +19,24 @@ pub trait MeterProvider { /// /// ``` /// use std::sync::Arc; - /// use opentelemetry::InstrumentationLibrary; + /// use opentelemetry::InstrumentationScope; /// use opentelemetry::metrics::MeterProvider; /// use opentelemetry_sdk::metrics::SdkMeterProvider; /// /// let provider = SdkMeterProvider::default(); /// - /// // logger used in applications/binaries + /// // meter used in applications/binaries /// let meter = provider.meter("my_app"); /// - /// // logger used in libraries/crates that optionally includes version and schema url - /// let library = std::sync::Arc::new( - /// InstrumentationLibrary::builder(env!("CARGO_PKG_NAME")) - /// .with_version(env!("CARGO_PKG_VERSION")) - /// .with_schema_url("https://opentelemetry.io/schema/1.0.0") - /// .build(), - /// ); - /// let logger = provider.library_meter(library); + /// // meter used in libraries/crates that optionally includes version and schema url + /// let scope = InstrumentationScope::builder(env!("CARGO_PKG_NAME")) + /// .with_version(env!("CARGO_PKG_VERSION")) + /// .with_schema_url("https://opentelemetry.io/schema/1.0.0") + /// .build(); + /// + /// let meter = provider.meter_with_scope(scope); /// ``` - fn library_meter(&self, library: Arc) -> Meter; + fn meter_with_scope(&self, scope: InstrumentationScope) -> Meter; /// Returns a new [Meter] with the provided name and default configuration. /// @@ -60,8 +59,8 @@ pub trait MeterProvider { /// let meter = provider.meter("my_app"); /// ``` fn meter(&self, name: &'static str) -> Meter { - let library = Arc::new(InstrumentationLibrary::builder(name).build()); - self.library_meter(library) + let scope = InstrumentationScope::builder(name).build(); + self.meter_with_scope(scope) } } diff --git a/opentelemetry/src/metrics/noop.rs b/opentelemetry/src/metrics/noop.rs index c293d0f08c..80201ad06a 100644 --- a/opentelemetry/src/metrics/noop.rs +++ b/opentelemetry/src/metrics/noop.rs @@ -25,7 +25,7 @@ impl NoopMeterProvider { } impl MeterProvider for NoopMeterProvider { - fn library_meter(&self, _library: Arc) -> Meter { + fn meter_with_scope(&self, _scope: crate::InstrumentationScope) -> Meter { Meter::new(Arc::new(NoopMeter::new())) } } diff --git a/opentelemetry/src/trace/mod.rs b/opentelemetry/src/trace/mod.rs index f43ef713b5..6d109fbc79 100644 --- a/opentelemetry/src/trace/mod.rs +++ b/opentelemetry/src/trace/mod.rs @@ -44,7 +44,7 @@ //! //! ``` //! use opentelemetry::{global, trace::{Span, Tracer, TracerProvider}}; -//! use opentelemetry::InstrumentationLibrary; +//! use opentelemetry::InstrumentationScope; //! use std::sync::Arc; //! //! fn my_library_function() { @@ -53,12 +53,12 @@ //! let tracer_provider = global::tracer_provider(); //! //! // Get a tracer for this library -//! let library = Arc::new(InstrumentationLibrary::builder("my_name") +//! let scope = InstrumentationScope::builder("my_name") //! .with_version(env!("CARGO_PKG_VERSION")) //! .with_schema_url("https://opentelemetry.io/schemas/1.17.0") -//! .build() -//! ); -//! let tracer = tracer_provider.library_tracer(library); +//! .build(); +//! +//! let tracer = tracer_provider.tracer_with_scope(scope); //! //! // Create spans //! let mut span = tracer.start("doing_work"); diff --git a/opentelemetry/src/trace/noop.rs b/opentelemetry/src/trace/noop.rs index d46a657a2e..4cb8ac4513 100644 --- a/opentelemetry/src/trace/noop.rs +++ b/opentelemetry/src/trace/noop.rs @@ -6,9 +6,9 @@ use crate::{ propagation::{text_map_propagator::FieldIter, Extractor, Injector, TextMapPropagator}, trace::{self, TraceContextExt as _}, - Context, InstrumentationLibrary, KeyValue, + Context, InstrumentationScope, KeyValue, }; -use std::{borrow::Cow, sync::Arc, time::SystemTime}; +use std::{borrow::Cow, time::SystemTime}; /// A no-op instance of a `TracerProvider`. #[derive(Clone, Debug, Default)] @@ -27,7 +27,7 @@ impl trace::TracerProvider for NoopTracerProvider { type Tracer = NoopTracer; /// Returns a new `NoopTracer` instance. - fn library_tracer(&self, _library: Arc) -> Self::Tracer { + fn tracer_with_scope(&self, _scope: InstrumentationScope) -> Self::Tracer { NoopTracer::new() } } diff --git a/opentelemetry/src/trace/tracer_provider.rs b/opentelemetry/src/trace/tracer_provider.rs index e01616827a..900b36b009 100644 --- a/opentelemetry/src/trace/tracer_provider.rs +++ b/opentelemetry/src/trace/tracer_provider.rs @@ -1,5 +1,5 @@ -use crate::{trace::Tracer, InstrumentationLibrary}; -use std::{borrow::Cow, sync::Arc}; +use crate::{trace::Tracer, InstrumentationScope}; +use std::borrow::Cow; /// Types that can create instances of [`Tracer`]. /// @@ -29,8 +29,8 @@ pub trait TracerProvider { /// let tracer = provider.tracer("my_app"); /// ``` fn tracer(&self, name: impl Into>) -> Self::Tracer { - let library = InstrumentationLibrary::builder(name).build(); - self.library_tracer(Arc::new(library)) + let scope = InstrumentationScope::builder(name).build(); + self.tracer_with_scope(scope) } /// Returns a new versioned tracer with the given instrumentation library. @@ -38,7 +38,7 @@ pub trait TracerProvider { /// # Examples /// /// ``` - /// use opentelemetry::{global, InstrumentationLibrary, trace::TracerProvider}; + /// use opentelemetry::{global, InstrumentationScope, trace::TracerProvider}; /// /// let provider = global::tracer_provider(); /// @@ -46,14 +46,13 @@ pub trait TracerProvider { /// let tracer = provider.tracer("my_app"); /// /// // tracer used in libraries/crates that optionally includes version and schema url - /// let library = std::sync::Arc::new( - /// InstrumentationLibrary::builder(env!("CARGO_PKG_NAME")) + /// let scope = + /// InstrumentationScope::builder(env!("CARGO_PKG_NAME")) /// .with_version(env!("CARGO_PKG_VERSION")) /// .with_schema_url("https://opentelemetry.io/schema/1.0.0") - /// .build(), - /// ); + /// .build(); /// - /// let tracer = provider.library_tracer(library); + /// let tracer = provider.tracer_with_scope(scope); /// ``` - fn library_tracer(&self, library: Arc) -> Self::Tracer; + fn tracer_with_scope(&self, scope: InstrumentationScope) -> Self::Tracer; } diff --git a/stress/src/logs.rs b/stress/src/logs.rs index 7744708db9..17fcf2833e 100644 --- a/stress/src/logs.rs +++ b/stress/src/logs.rs @@ -9,7 +9,7 @@ ~44 M /sec */ -use opentelemetry::InstrumentationLibrary; +use opentelemetry::InstrumentationScope; use opentelemetry_appender_tracing::layer; use opentelemetry_sdk::logs::{LogProcessor, LoggerProvider}; use tracing::error; @@ -24,7 +24,7 @@ impl LogProcessor for NoOpLogProcessor { fn emit( &self, _record: &mut opentelemetry_sdk::logs::LogRecord, - _library: &InstrumentationLibrary, + _scope: &InstrumentationScope, ) { }