diff --git a/tracing-opentelemetry/src/metrics.rs b/tracing-opentelemetry/src/metrics.rs index 04bf2f14aa..861ff2cb33 100644 --- a/tracing-opentelemetry/src/metrics.rs +++ b/tracing-opentelemetry/src/metrics.rs @@ -11,9 +11,9 @@ use tracing_subscriber::{registry::LookupSpan, subscribe::Context, Subscribe}; const CARGO_PKG_VERSION: &str = env!("CARGO_PKG_VERSION"); const INSTRUMENTATION_LIBRARY_NAME: &str = "tracing/tracing-opentelemetry"; -const METRIC_PREFIX_MONOTONIC_COUNTER: &str = "MONOTONIC_COUNTER_"; -const METRIC_PREFIX_COUNTER: &str = "COUNTER_"; -const METRIC_PREFIX_VALUE: &str = "VALUE_"; +const METRIC_PREFIX_MONOTONIC_COUNTER: &str = "monotonic_counter."; +const METRIC_PREFIX_COUNTER: &str = "counter."; +const METRIC_PREFIX_VALUE: &str = "value."; const I64_MAX: u64 = i64::MAX as u64; #[derive(Default)] @@ -142,18 +142,18 @@ impl<'a> Visit for MetricVisitor<'a> { } fn record_u64(&mut self, field: &Field, value: u64) { - if field.name().starts_with(METRIC_PREFIX_MONOTONIC_COUNTER) { + if let Some(metric_name) = field.name().strip_prefix(METRIC_PREFIX_MONOTONIC_COUNTER) { self.instruments.update_metric( self.meter, InstrumentType::CounterU64(value), - field.name(), + metric_name, ); - } else if field.name().starts_with(METRIC_PREFIX_COUNTER) { + } else if let Some(metric_name) = field.name().strip_prefix(METRIC_PREFIX_COUNTER) { if value <= I64_MAX { self.instruments.update_metric( self.meter, InstrumentType::UpDownCounterI64(value as i64), - field.name(), + metric_name, ); } else { eprintln!( @@ -163,55 +163,55 @@ impl<'a> Visit for MetricVisitor<'a> { value ); } - } else if field.name().starts_with(METRIC_PREFIX_VALUE) { + } else if let Some(metric_name) = field.name().strip_prefix(METRIC_PREFIX_VALUE) { self.instruments.update_metric( self.meter, InstrumentType::ValueRecorderU64(value), - field.name(), + metric_name, ); } } fn record_f64(&mut self, field: &Field, value: f64) { - if field.name().starts_with(METRIC_PREFIX_MONOTONIC_COUNTER) { + if let Some(metric_name) = field.name().strip_prefix(METRIC_PREFIX_MONOTONIC_COUNTER) { self.instruments.update_metric( self.meter, InstrumentType::CounterF64(value), - field.name(), + metric_name, ); - } else if field.name().starts_with(METRIC_PREFIX_COUNTER) { + } else if let Some(metric_name) = field.name().strip_prefix(METRIC_PREFIX_COUNTER) { self.instruments.update_metric( self.meter, InstrumentType::UpDownCounterF64(value), - field.name(), + metric_name, ); - } else if field.name().starts_with(METRIC_PREFIX_VALUE) { + } else if let Some(metric_name) = field.name().strip_prefix(METRIC_PREFIX_VALUE) { self.instruments.update_metric( self.meter, InstrumentType::ValueRecorderF64(value), - field.name(), + metric_name, ); } } fn record_i64(&mut self, field: &Field, value: i64) { - if field.name().starts_with(METRIC_PREFIX_MONOTONIC_COUNTER) { + if let Some(metric_name) = field.name().strip_prefix(METRIC_PREFIX_MONOTONIC_COUNTER) { self.instruments.update_metric( self.meter, InstrumentType::CounterU64(value as u64), - field.name(), + metric_name, ); - } else if field.name().starts_with(METRIC_PREFIX_COUNTER) { + } else if let Some(metric_name) = field.name().strip_prefix(METRIC_PREFIX_COUNTER) { self.instruments.update_metric( self.meter, InstrumentType::UpDownCounterI64(value), - field.name(), + metric_name, ); - } else if field.name().starts_with(METRIC_PREFIX_VALUE) { + } else if let Some(metric_name) = field.name().strip_prefix(METRIC_PREFIX_VALUE) { self.instruments.update_metric( self.meter, InstrumentType::ValueRecorderI64(value), - field.name(), + metric_name, ); } } @@ -247,25 +247,25 @@ impl<'a> Visit for MetricVisitor<'a> { /// To publish a new metric from your instrumentation point, all that is needed /// is to add a key-value pair to your `tracing::Event` that contains a specific /// prefix. One of the following: -/// - `MONOTONIC_COUNTER_` (non-negative numbers): Used when the counter should +/// - `monotonic_counter.` (non-negative numbers): Used when the counter should /// only ever increase -/// - `COUNTER_`: Used when the counter can go up or down -/// - `VALUE_`: Used for discrete data points (i.e., summing them does not make +/// - `counter.`: Used when the counter can go up or down +/// - `value.`: Used for discrete data points (i.e., summing them does not make /// semantic sense) /// /// Examples: /// ``` /// # use tracing::info; -/// info!(MONOTONIC_COUNTER_FOO = 1); -/// info!(MONOTONIC_COUNTER_BAR = 1.1); +/// info!(monotonic_counter.foo = 1); +/// info!(monotonic_counter.bar = 1.1); /// -/// info!(COUNTER_BAZ = 1); -/// info!(COUNTER_BAZ = -1); -/// info!(COUNTER_XYZ = 1.1); +/// info!(counter.baz = 1); +/// info!(counter.baz = -1); +/// info!(counter.xyz = 1.1); /// -/// info!(VALUE_QUX = 1); -/// info!(VALUE_ABC = -1); -/// info!(VALUE_DEF = 1.1); +/// info!(value.qux = 1); +/// info!(value.abc = -1); +/// info!(value.def = 1.1); /// ``` /// /// # Mixing data types @@ -279,15 +279,15 @@ impl<'a> Visit for MetricVisitor<'a> { /// Don't do this: /// ``` /// # use tracing::info; -/// info!(MONOTONIC_COUNTER_FOO = 1); -/// info!(MONOTONIC_COUNTER_FOO = 1.0); +/// info!(monotonic_counter.foo = 1); +/// info!(monotonic_counter.foo = 1.0); /// ``` /// /// Do this: /// ``` /// # use tracing::info; -/// info!(MONOTONIC_COUNTER_FOO = 1_f64); -/// info!(MONOTONIC_COUNTER_FOO = 1.1); +/// info!(monotonic_counter.foo = 1_f64); +/// info!(monotonic_counter.foo = 1.1); /// ``` /// /// This is because all data published for a given metric name must be the same @@ -304,17 +304,17 @@ impl<'a> Visit for MetricVisitor<'a> { /// ``` /// # use tracing::info; /// // The subscriber receives an i64 -/// info!(COUNTER_BAZ = 1); +/// info!(counter.baz = 1); /// /// // The subscriber receives an i64 -/// info!(COUNTER_BAZ = -1); +/// info!(counter.baz = -1); /// /// // The subscriber receives a u64, but casts it to i64 internally -/// info!(COUNTER_BAZ = 1_u64); +/// info!(counter.baz = 1_u64); /// /// // The subscriber receives a u64, but cannot cast it to i64 because of /// // overflow. An error is printed to stderr, and the metric is dropped. -/// info!(COUNTER_BAZ = (i64::MAX as u64) + 1) +/// info!(counter.baz = (i64::MAX as u64) + 1) /// ``` /// /// # Under-the-hood diff --git a/tracing-opentelemetry/tests/metrics_publishing.rs b/tracing-opentelemetry/tests/metrics_publishing.rs index 3588b925ec..cc501845cb 100644 --- a/tracing-opentelemetry/tests/metrics_publishing.rs +++ b/tracing-opentelemetry/tests/metrics_publishing.rs @@ -30,126 +30,126 @@ const INSTRUMENTATION_LIBRARY_NAME: &str = "tracing/tracing-opentelemetry"; #[tokio::test] async fn u64_counter_is_exported() { let subscriber = init_subscriber( - "MONOTONIC_COUNTER_HELLO_WORLD".to_string(), + "hello_world".to_string(), InstrumentKind::Counter, NumberKind::U64, Number::from(1_u64), ); tracing::collect::with_default(subscriber, || { - tracing::info!(MONOTONIC_COUNTER_HELLO_WORLD = 1_u64); + tracing::info!(monotonic_counter.hello_world = 1_u64); }); } #[tokio::test] async fn u64_counter_is_exported_i64_at_instrumentation_point() { let subscriber = init_subscriber( - "MONOTONIC_COUNTER_HELLO_WORLD2".to_string(), + "hello_world2".to_string(), InstrumentKind::Counter, NumberKind::U64, Number::from(1_u64), ); tracing::collect::with_default(subscriber, || { - tracing::info!(MONOTONIC_COUNTER_HELLO_WORLD2 = 1_i64); + tracing::info!(monotonic_counter.hello_world2 = 1_i64); }); } #[tokio::test] async fn f64_counter_is_exported() { let subscriber = init_subscriber( - "MONOTONIC_COUNTER_FLOAT_HELLO_WORLD".to_string(), + "float_hello_world".to_string(), InstrumentKind::Counter, NumberKind::F64, Number::from(1.000000123_f64), ); tracing::collect::with_default(subscriber, || { - tracing::info!(MONOTONIC_COUNTER_FLOAT_HELLO_WORLD = 1.000000123_f64); + tracing::info!(monotonic_counter.float_hello_world = 1.000000123_f64); }); } #[tokio::test] async fn i64_up_down_counter_is_exported() { let subscriber = init_subscriber( - "COUNTER_PEBCAK".to_string(), + "pebcak".to_string(), InstrumentKind::UpDownCounter, NumberKind::I64, Number::from(-5_i64), ); tracing::collect::with_default(subscriber, || { - tracing::info!(COUNTER_PEBCAK = -5_i64); + tracing::info!(counter.pebcak = -5_i64); }); } #[tokio::test] async fn i64_up_down_counter_is_exported_u64_at_instrumentation_point() { let subscriber = init_subscriber( - "COUNTER_PEBCAK2".to_string(), + "pebcak2".to_string(), InstrumentKind::UpDownCounter, NumberKind::I64, Number::from(5_i64), ); tracing::collect::with_default(subscriber, || { - tracing::info!(COUNTER_PEBCAK2 = 5_u64); + tracing::info!(counter.pebcak2 = 5_u64); }); } #[tokio::test] async fn f64_up_down_counter_is_exported() { let subscriber = init_subscriber( - "COUNTER_PEBCAK_BLAH".to_string(), + "pebcak_blah".to_string(), InstrumentKind::UpDownCounter, NumberKind::F64, Number::from(99.123_f64), ); tracing::collect::with_default(subscriber, || { - tracing::info!(COUNTER_PEBCAK_BLAH = 99.123_f64); + tracing::info!(counter.pebcak_blah = 99.123_f64); }); } #[tokio::test] async fn u64_value_is_exported() { let subscriber = init_subscriber( - "VALUE_ABCDEFG".to_string(), + "abcdefg".to_string(), InstrumentKind::ValueRecorder, NumberKind::U64, Number::from(9_u64), ); tracing::collect::with_default(subscriber, || { - tracing::info!(VALUE_ABCDEFG = 9_u64); + tracing::info!(value.abcdefg = 9_u64); }); } #[tokio::test] async fn i64_value_is_exported() { let subscriber = init_subscriber( - "VALUE_ABCDEFG_AUENATSOU".to_string(), + "abcdefg_auenatsou".to_string(), InstrumentKind::ValueRecorder, NumberKind::I64, Number::from(-19_i64), ); tracing::collect::with_default(subscriber, || { - tracing::info!(VALUE_ABCDEFG_AUENATSOU = -19_i64); + tracing::info!(value.abcdefg_auenatsou = -19_i64); }); } #[tokio::test] async fn f64_value_is_exported() { let subscriber = init_subscriber( - "VALUE_ABCDEFG_RACECAR".to_string(), + "abcdefg_racecar".to_string(), InstrumentKind::ValueRecorder, NumberKind::F64, Number::from(777.0012_f64), ); tracing::collect::with_default(subscriber, || { - tracing::info!(VALUE_ABCDEFG_RACECAR = 777.0012_f64); + tracing::info!(value.abcdefg_racecar = 777.0012_f64); }); }