Merge branch 'main' into http-1.0

Author: cijothomas

.github/workflows/ci.yml

@@ -150,6 +150,6 @@ jobs:
       - name: cargo llvm-cov
         run: cargo llvm-cov --locked --all-features --workspace --lcov --output-path lcov.info
       - name: Upload to codecov.io
-        uses: codecov/codecov-action@v3
+        uses: codecov/codecov-action@v4
         with:
-          fail_ci_if_error: false
+          fail_ci_if_error: true

opentelemetry-jaeger/src/exporter/config/collector/mod.rs

@@ -546,43 +546,8 @@ impl CollectorPipeline {
 #[cfg(test)]
 #[cfg(feature = "rt-tokio")]
 mod tests {
-    use opentelemetry_sdk::runtime::Tokio;
-
-    use crate::config::collector::http_client::test_http_client;
-
     use super::*;
 
-    #[test]
-    fn test_set_collector_endpoint() {
-        let invalid_uri = new_collector_pipeline()
-            .with_endpoint("127.0.0.1:14268/api/traces")
-            .with_http_client(test_http_client::TestHttpClient)
-            .build_uploader::<Tokio>();
-        assert!(invalid_uri.is_err());
-        assert_eq!(
-            format!("{:?}", invalid_uri.err().unwrap()),
-            "ConfigError { pipeline_name: \"collector\", config_name: \"collector_endpoint\", reason: \"invalid uri from the builder, invalid format\" }",
-        );
-
-        let valid_uri = new_collector_pipeline()
-            .with_http_client(test_http_client::TestHttpClient)
-            .with_endpoint("http://127.0.0.1:14268/api/traces")
-            .build_uploader::<Tokio>();
-
-        assert!(valid_uri.is_ok());
-    }
-
-    // Ignore this test as it is flaky and the opentelemetry-jaeger is on-track for deprecation
-    #[ignore]
-    #[test]
-    fn test_collector_exporter() {
-        let exporter = new_collector_pipeline()
-            .with_endpoint("http://127.0.0.1:14268/api/traces")
-            .with_http_client(test_http_client::TestHttpClient)
-            .build_collector_exporter::<Tokio>();
-        assert!(exporter.is_ok());
-    }
-
     #[test]
     fn test_resolve_endpoint() {
         struct TestCase<'a> {

opentelemetry-sdk/benches/metric_counter.rs

@@ -13,8 +13,8 @@ fn create_counter() -> Counter<u64> {
         .with_reader(ManualReader::builder().build())
         .build();
     let meter = meter_provider.meter("benchmarks");
-    let counter = meter.u64_counter("counter_bench").init();
-    counter
+
+    meter.u64_counter("counter_bench").init()
 }
 
 fn criterion_benchmark(c: &mut Criterion) {

opentelemetry-sdk/src/logs/log_emitter.rs

@@ -13,8 +13,8 @@ use opentelemetry::{
 #[cfg(feature = "logs_level_enabled")]
 use opentelemetry::logs::Severity;
 
-use std::sync::atomic::AtomicBool;
 use std::{borrow::Cow, sync::Arc};
+use std::{sync::atomic::AtomicBool, time::SystemTime};
 
 use once_cell::sync::Lazy;
 
@@ -242,6 +242,9 @@ impl opentelemetry::logs::Logger for Logger {
             if let Some(ref trace_context) = trace_context {
                 cloned_record.trace_context = Some(trace_context.clone());
             }
+            if cloned_record.observed_timestamp.is_none() {
+                cloned_record.observed_timestamp = Some(SystemTime::now());
+            }
             let data = LogData {
                 record: cloned_record,
                 instrumentation: self.instrumentation_library().clone(),

opentelemetry-sdk/src/logs/record.rs

@@ -5,11 +5,14 @@ use opentelemetry::{
 };
 use std::{borrow::Cow, time::SystemTime};
 
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Default, Clone)]
 #[non_exhaustive]
 /// LogRecord represents all data carried by a log record, and
 /// is provided to `LogExporter`s as input.
 pub struct LogRecord {
+    /// Event name. Optional as not all the logging API support it.
+    pub event_name: Option<Cow<'static, str>>,
+
     /// Record timestamp
     pub timestamp: Option<SystemTime>,
 
@@ -32,6 +35,13 @@ pub struct LogRecord {
 }
 
 impl opentelemetry::logs::LogRecord for LogRecord {
+    fn set_event_name<T>(&mut self, name: T)
+    where
+        T: Into<Cow<'static, str>>,
+    {
+        self.event_name = Some(name.into());
+    }
+
     fn set_timestamp(&mut self, timestamp: SystemTime) {
         self.timestamp = Some(timestamp);
     }

opentelemetry-sdk/src/metrics/meter_provider.rs

@@ -253,6 +253,7 @@ mod tests {
     use crate::testing::metrics::metric_reader::TestMetricReader;
     use crate::Resource;
     use opentelemetry::global;
+    use opentelemetry::metrics::MeterProvider;
     use opentelemetry::{Key, KeyValue, Value};
     use std::env;
 
@@ -433,4 +434,28 @@ mod tests {
         // Now the shutdown should be invoked
         assert!(reader.is_shutdown());
     }
+
+    #[test]
+    fn same_meter_reused_same_scope() {
+        let provider = super::SdkMeterProvider::builder().build();
+        let _meter1 = provider.meter("test");
+        let _meter2 = provider.meter("test");
+        assert_eq!(provider.inner.meters.lock().unwrap().len(), 1);
+        let _meter3 =
+            provider.versioned_meter("test", Some("1.0.0"), Some("http://example.com"), None);
+        let _meter4 =
+            provider.versioned_meter("test", Some("1.0.0"), Some("http://example.com"), None);
+        let _meter5 =
+            provider.versioned_meter("test", Some("1.0.0"), Some("http://example.com"), None);
+        assert_eq!(provider.inner.meters.lock().unwrap().len(), 2);
+
+        // the below are different meters, as meter names are case sensitive
+        let _meter6 =
+            provider.versioned_meter("ABC", Some("1.0.0"), Some("http://example.com"), None);
+        let _meter7 =
+            provider.versioned_meter("Abc", Some("1.0.0"), Some("http://example.com"), None);
+        let _meter8 =
+            provider.versioned_meter("abc", Some("1.0.0"), Some("http://example.com"), None);
+        assert_eq!(provider.inner.meters.lock().unwrap().len(), 5);
+    }
 }

opentelemetry/benches/metrics.rs

@@ -6,8 +6,8 @@ use opentelemetry::{global, metrics::Counter, KeyValue};
 
 fn create_counter() -> Counter<u64> {
     let meter = global::meter("benchmarks");
-    let counter = meter.u64_counter("counter_bench").init();
-    counter
+
+    meter.u64_counter("counter_bench").init()
 }
 
 fn criterion_benchmark(c: &mut Criterion) {

opentelemetry/src/logs/noop.rs

@@ -41,6 +41,12 @@ pub struct NoopLogRecord;
 impl LogRecord for NoopLogRecord {
     // Implement the LogRecord trait methods with empty bodies.
     #[inline]
+    fn set_event_name<T>(&mut self, _name: T)
+    where
+        T: Into<Cow<'static, str>>,
+    {
+    }
+    #[inline]
     fn set_timestamp(&mut self, _timestamp: SystemTime) {}
     #[inline]
     fn set_observed_timestamp(&mut self, _timestamp: SystemTime) {}

opentelemetry/src/logs/record.rs

@@ -3,6 +3,13 @@ use std::{borrow::Cow, collections::HashMap, time::SystemTime};
 
 /// SDK implemented trait for managing log records
 pub trait LogRecord {
+    /// Sets the `event_name` of a record
+    fn set_event_name<T>(&mut self, _name: T)
+    where
+        T: Into<Cow<'static, str>>,
+    {
+    }
+
     /// Sets the time when the event occurred measured by the origin clock, i.e. the time at the source.
     fn set_timestamp(&mut self, timestamp: SystemTime);
 

opentelemetry/src/metrics/instruments/counter.rs

@@ -41,23 +41,19 @@ impl TryFrom<InstrumentBuilder<'_, Counter<u64>>> for Counter<u64> {
     type Error = MetricsError;
 
     fn try_from(builder: InstrumentBuilder<'_, Counter<u64>>) -> Result<Self, Self::Error> {
-        builder.meter.instrument_provider.u64_counter(
-            builder.name,
-            builder.description,
-            builder.unit,
-        )
+        builder
+            .instrument_provider
+            .u64_counter(builder.name, builder.description, builder.unit)
     }
 }
 
 impl TryFrom<InstrumentBuilder<'_, Counter<f64>>> for Counter<f64> {
     type Error = MetricsError;
 
     fn try_from(builder: InstrumentBuilder<'_, Counter<f64>>) -> Result<Self, Self::Error> {
-        builder.meter.instrument_provider.f64_counter(
-            builder.name,
-            builder.description,
-            builder.unit,
-        )
+        builder
+            .instrument_provider
+            .f64_counter(builder.name, builder.description, builder.unit)
     }
 }
 

opentelemetry/src/metrics/instruments/gauge.rs

@@ -42,7 +42,6 @@ impl TryFrom<InstrumentBuilder<'_, Gauge<u64>>> for Gauge<u64> {
 
     fn try_from(builder: InstrumentBuilder<'_, Gauge<u64>>) -> Result<Self, Self::Error> {
         builder
-            .meter
             .instrument_provider
             .u64_gauge(builder.name, builder.description, builder.unit)
     }
@@ -53,7 +52,6 @@ impl TryFrom<InstrumentBuilder<'_, Gauge<f64>>> for Gauge<f64> {
 
     fn try_from(builder: InstrumentBuilder<'_, Gauge<f64>>) -> Result<Self, Self::Error> {
         builder
-            .meter
             .instrument_provider
             .f64_gauge(builder.name, builder.description, builder.unit)
     }
@@ -64,7 +62,6 @@ impl TryFrom<InstrumentBuilder<'_, Gauge<i64>>> for Gauge<i64> {
 
     fn try_from(builder: InstrumentBuilder<'_, Gauge<i64>>) -> Result<Self, Self::Error> {
         builder
-            .meter
             .instrument_provider
             .i64_gauge(builder.name, builder.description, builder.unit)
     }

opentelemetry/src/metrics/instruments/histogram.rs

@@ -40,22 +40,18 @@ impl TryFrom<InstrumentBuilder<'_, Histogram<f64>>> for Histogram<f64> {
     type Error = MetricsError;
 
     fn try_from(builder: InstrumentBuilder<'_, Histogram<f64>>) -> Result<Self, Self::Error> {
-        builder.meter.instrument_provider.f64_histogram(
-            builder.name,
-            builder.description,
-            builder.unit,
-        )
+        builder
+            .instrument_provider
+            .f64_histogram(builder.name, builder.description, builder.unit)
     }
 }
 
 impl TryFrom<InstrumentBuilder<'_, Histogram<u64>>> for Histogram<u64> {
     type Error = MetricsError;
 
     fn try_from(builder: InstrumentBuilder<'_, Histogram<u64>>) -> Result<Self, Self::Error> {
-        builder.meter.instrument_provider.u64_histogram(
-            builder.name,
-            builder.description,
-            builder.unit,
-        )
+        builder
+            .instrument_provider
+            .u64_histogram(builder.name, builder.description, builder.unit)
     }
 }

opentelemetry/src/metrics/instruments/mod.rs

@@ -6,6 +6,8 @@ use std::borrow::Cow;
 use std::marker;
 use std::sync::Arc;
 
+use super::InstrumentProvider;
+
 pub(super) mod counter;
 pub(super) mod gauge;
 pub(super) mod histogram;
@@ -24,7 +26,7 @@ pub trait AsyncInstrument<T>: Send + Sync {
 
 /// Configuration for building a sync instrument.
 pub struct InstrumentBuilder<'a, T> {
-    meter: &'a Meter,
+    instrument_provider: &'a dyn InstrumentProvider,
     name: Cow<'static, str>,
     description: Option<Cow<'static, str>>,
     unit: Option<Unit>,
@@ -38,7 +40,7 @@ where
     /// Create a new instrument builder
     pub(crate) fn new(meter: &'a Meter, name: Cow<'static, str>) -> Self {
         InstrumentBuilder {
-            meter,
+            instrument_provider: meter.instrument_provider.as_ref(),
             name,
             description: None,
             unit: None,

opentelemetry/src/metrics/instruments/up_down_counter.rs

@@ -46,7 +46,7 @@ impl TryFrom<InstrumentBuilder<'_, UpDownCounter<i64>>> for UpDownCounter<i64> {
     type Error = MetricsError;
 
     fn try_from(builder: InstrumentBuilder<'_, UpDownCounter<i64>>) -> Result<Self, Self::Error> {
-        builder.meter.instrument_provider.i64_up_down_counter(
+        builder.instrument_provider.i64_up_down_counter(
             builder.name,
             builder.description,
             builder.unit,
@@ -58,7 +58,7 @@ impl TryFrom<InstrumentBuilder<'_, UpDownCounter<f64>>> for UpDownCounter<f64> {
     type Error = MetricsError;
 
     fn try_from(builder: InstrumentBuilder<'_, UpDownCounter<f64>>) -> Result<Self, Self::Error> {
-        builder.meter.instrument_provider.f64_up_down_counter(
+        builder.instrument_provider.f64_up_down_counter(
             builder.name,
             builder.description,
             builder.unit,