Merge branch 'main' into remove-env-logger

Author: TommyCpp

.github/ISSUE_TEMPLATE/config.yml

@@ -4,7 +4,7 @@ contact_links:
     about: Please ask questions here.
   - name: Slack
     url: https://cloud-native.slack.com/archives/C03GDP0H023
-    about: Or the `#otel-rust` channel in the CNCF Slack instance. (Not terribly responsive.)
+    about: Or the `#otel-rust` channel in the CNCF Slack instance.
   - name: "⚠️ Report a security vulnerability"
     url: "https://github.com/open-telemetry/opentelemetry-rust/security/advisories/new"
     about: "Report a security vulnerability."

.github/repository-settings.md

@@ -0,0 +1,18 @@
+# Log of local changes
+
+Maintainers are expected to maintain this log. This is required as per
+[OpenTelemetry Community
+guidelines](https://github.com/open-telemetry/community/blob/main/docs/how-to-configure-new-repository.md#collaborators-and-teams).
+
+## May 6th 2024
+
+Modified branch protection for main branch to require the following CI checks as
+we now added Windows to CI.
+test (ubuntu-latest, stable)
+test (stable, windows-latest)
+
+## April 30th 2024
+
+Modified branch protection for main branch to require the following CI checks:
+docs
+test (stable)

.github/workflows/ci.yml

@@ -12,10 +12,17 @@ jobs:
   test:
     strategy:
       matrix:
+        # test both stable and beta versions of Rust on ubuntu-latest
+        os: [ubuntu-latest]
         rust: [stable, beta]
-    runs-on: ubuntu-latest
+        # test only stable version of Rust on Windows
+        include:
+          - rust: stable
+            os: windows-latest
+    runs-on: ${{ matrix.os }}
     steps:
     - name: Free disk space
+      if: ${{ matrix.os == 'ubuntu-latest'}}
       run: |
         df -h
         sudo rm -rf /usr/local/lib/android
@@ -32,7 +39,7 @@ jobs:
       run: rustup set profile minimal
     - uses: arduino/setup-protoc@v3
     - name: Test
-      run: ./scripts/test.sh
+      run: bash ./scripts/test.sh
   lint:
     runs-on: ubuntu-latest
     steps:
@@ -48,12 +55,12 @@ jobs:
         command: fmt
         args: --all -- --check
     - name: Lint
-      run: ./scripts/lint.sh
+      run: bash ./scripts/lint.sh
   external-types:
     strategy:
       matrix:
         example: [opentelemetry, opentelemetry-sdk, opentelemetry-otlp, opentelemetry-zipkin]
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-latest # TODO: Check if this could be covered for Windows. The step used currently fails on Windows.
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@nightly
@@ -68,8 +75,9 @@ jobs:
   non-default-examples:
     strategy:
       matrix:
+        os: [ windows-latest, ubuntu-latest ]
         example: [opentelemetry-otlp/examples/basic-otlp]
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
     steps:
     - uses: actions/checkout@v4
       with:
@@ -83,21 +91,24 @@ jobs:
         cd ${{ matrix.example }}
         cargo build --verbose
   msrv:
-    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        os: [ windows-latest, ubuntu-latest ]
+    runs-on: ${{ matrix.os }}
     steps:
     - uses: actions/checkout@v4
       with:
         submodules: true
     - uses: dtolnay/rust-toolchain@1.65.0
     - name: Patch dependencies versions # some dependencies bump MSRV without major version bump
-      run: ./scripts/patch_dependencies.sh
+      run: bash ./scripts/patch_dependencies.sh
     - name: Run tests
       run: cargo --version &&
         cargo check --lib --manifest-path=opentelemetry/Cargo.toml --features trace,metrics,testing &&
         cargo check --lib --manifest-path=opentelemetry-jaeger/Cargo.toml --features rt-tokio &&
         cargo check --lib --manifest-path=opentelemetry-zipkin/Cargo.toml
   cargo-deny:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-latest # This uses the step `EmbarkStudios/cargo-deny-action@v1` which is only supported on Linux
     continue-on-error: true # Prevent sudden announcement of a new advisory from failing ci
     steps:
       - uses: actions/checkout@v4

Cargo.toml

@@ -27,7 +27,7 @@ futures-util = { version = "0.3", default-features = false }
 hyper = { version = "0.14", default-features = false }
 http = { version = "0.2", default-features = false }
 isahc = { version = "1.4", default-features = false }
-log = "0.4"
+log = "0.4.21"
 once_cell = "1.13"
 ordered-float = "4.0"
 pin-project-lite = "0.2"

README.md

@@ -25,11 +25,18 @@ observability tools.
 
 ## Project Status
 
-| Signal  | Status     |
-| ------- | ---------- |
-| Logs    | Alpha*     |
-| Metrics | Alpha      |
-| Traces  | Beta       |
+| Signal/Component      | Overall Status     |
+| --------------------  | ------------------ |
+| Logs-API              | Alpha*             |
+| Logs-SDK              | Alpha              |
+| Logs-OTLP Exporter    | Alpha              |
+| Logs-Appender-Tracing | Alpha              |
+| Metrics-API           | Alpha              |
+| Metrics-SDK           | Alpha              |
+| Metrics-OTLP Exporter | Alpha              |
+| Traces-API            | Beta               |
+| Traces-SDK            | Beta               |
+| Traces-OTLP Exporter  | Beta               |
 
 *OpenTelemetry Rust is not introducing a new end user callable Logging API.
 Instead, it provides [Logs Bridge

RELEASING.md

@@ -16,7 +16,7 @@ A draft PR can be created, but before releasing consider the following:
 
 * Are there any pending pull requests which should be included in the next release?
   * Are they blockers?
-* Are there any unresolved issues which should be resolved before the next release?
+* Are there any unresolved issues which should be resolved before the next release? Check the release [blockers milestone](https://github.com/open-telemetry/opentelemetry-rust/milestones) for every release
 * Bring it up at a SIG meeting, this can usually get some of these questions answered sooner than later. It will also
   help establish a person to perform the release. Ideally this can be someone different each time to ensure that the
   process is documented.

examples/metrics-basic/src/main.rs

@@ -43,23 +43,21 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     );
 
     // Create a ObservableCounter instrument and register a callback that reports the measurement.
-    let observable_counter = meter
+    let _observable_counter = meter
         .u64_observable_counter("my_observable_counter")
         .with_description("My observable counter example description")
         .with_unit(Unit::new("myunit"))
+        .with_callback(|observer| {
+            observer.observe(
+                100,
+                &[
+                    KeyValue::new("mykey1", "myvalue1"),
+                    KeyValue::new("mykey2", "myvalue2"),
+                ],
+            )
+        })
         .init();
 
-    meter.register_callback(&[observable_counter.as_any()], move |observer| {
-        observer.observe_u64(
-            &observable_counter,
-            100,
-            &[
-                KeyValue::new("mykey1", "myvalue1"),
-                KeyValue::new("mykey2", "myvalue2"),
-            ],
-        )
-    })?;
-
     // Create a UpCounter Instrument.
     let updown_counter = meter.i64_up_down_counter("my_updown_counter").init();
 
@@ -73,23 +71,21 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     );
 
     // Create a Observable UpDownCounter instrument and register a callback that reports the measurement.
-    let observable_up_down_counter = meter
+    let _observable_up_down_counter = meter
         .i64_observable_up_down_counter("my_observable_updown_counter")
         .with_description("My observable updown counter example description")
         .with_unit(Unit::new("myunit"))
+        .with_callback(|observer| {
+            observer.observe(
+                100,
+                &[
+                    KeyValue::new("mykey1", "myvalue1"),
+                    KeyValue::new("mykey2", "myvalue2"),
+                ],
+            )
+        })
         .init();
 
-    meter.register_callback(&[observable_up_down_counter.as_any()], move |observer| {
-        observer.observe_i64(
-            &observable_up_down_counter,
-            100,
-            &[
-                KeyValue::new("mykey1", "myvalue1"),
-                KeyValue::new("mykey2", "myvalue2"),
-            ],
-        )
-    })?;
-
     // Create a Histogram Instrument.
     let histogram = meter
         .f64_histogram("my_histogram")
@@ -108,43 +104,36 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     // Note that there is no ObservableHistogram instrument.
 
     // Create a Gauge Instrument.
-    // Note that the Gauge instrument is experimental, and can be changed/removed in the future releases.
-    #[cfg(feature = "otel_unstable")]
-    {
-        let gauge = meter
-            .f64_gauge("my_gauge")
-            .with_description("A gauge set to 1.0")
-            .with_unit(Unit::new("myunit"))
-            .init();
-
-        gauge.record(
-            1.0,
-            &[
-                KeyValue::new("mykey1", "myvalue1"),
-                KeyValue::new("mykey2", "myvalue2"),
-            ],
-        );
-    }
+    let gauge = meter
+        .f64_gauge("my_gauge")
+        .with_description("A gauge set to 1.0")
+        .with_unit(Unit::new("myunit"))
+        .init();
+
+    gauge.record(
+        1.0,
+        &[
+            KeyValue::new("mykey1", "myvalue1"),
+            KeyValue::new("mykey2", "myvalue2"),
+        ],
+    );
 
     // Create a ObservableGauge instrument and register a callback that reports the measurement.
-    let observable_gauge = meter
+    let _observable_gauge = meter
         .f64_observable_gauge("my_observable_gauge")
         .with_description("An observable gauge set to 1.0")
         .with_unit(Unit::new("myunit"))
+        .with_callback(|observer| {
+            observer.observe(
+                1.0,
+                &[
+                    KeyValue::new("mykey1", "myvalue1"),
+                    KeyValue::new("mykey2", "myvalue2"),
+                ],
+            )
+        })
         .init();
 
-    // Register a callback that reports the measurement.
-    meter.register_callback(&[observable_gauge.as_any()], move |observer| {
-        observer.observe_f64(
-            &observable_gauge,
-            1.0,
-            &[
-                KeyValue::new("mykey1", "myvalue1"),
-                KeyValue::new("mykey2", "myvalue2"),
-            ],
-        )
-    })?;
-
     // Metrics are exported by default every 30 seconds when using stdout exporter,
     // however shutting down the MeterProvider here instantly flushes
     // the metrics, instead of waiting for the 30 sec interval.

opentelemetry-appender-log/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## vNext
 
+- Add log key-values as attributes [#1628](https://github.com/open-telemetry/opentelemetry-rust/pull/1628)
+
 ## v0.3.0
 
 ## v0.2.0

opentelemetry-appender-log/Cargo.toml

@@ -12,12 +12,17 @@ edition = "2021"
 
 [dependencies]
 opentelemetry = { version = "0.22", path = "../opentelemetry", features = ["logs"]}
-log = { workspace = true, features = ["kv_unstable", "std"]}
+log = { workspace = true, features = ["kv", "std"]}
+serde = { workspace = true, optional = true, features = ["std"] }
 
 [features]
 logs_level_enabled = ["opentelemetry/logs_level_enabled"]
+with-serde = ["log/kv_serde", "serde"]
 default = ["logs_level_enabled"]
 
 [dev-dependencies]
 opentelemetry_sdk = { path = "../opentelemetry-sdk", features = [ "testing", "logs_level_enabled" ] }
+opentelemetry-stdout = { path = "../opentelemetry-stdout", features = ["logs"]}
+log = { workspace = true, features = ["kv_serde"] }
 tokio = { workspace = true }
+serde = { workspace = true, features = ["std", "derive"] }

opentelemetry-appender-log/examples/logs-basic-in-memory.rs opentelemetry-appender-log/examples/logs-basic.rs

@@ -1,4 +1,4 @@
-//! run with `$ cargo run --example logs-basic-in-memory
+//! run with `$ cargo run --example logs-basic`
 
 /// This example shows how to use in_memory_exporter for logs. This uses opentelemetry-appender-log crate, which is a
 /// [logging appender](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/glossary.md#log-appender--bridge) that bridges logs from the [log crate](https://docs.rs/log/latest/log/) to OpenTelemetry.
@@ -8,15 +8,15 @@ use log::{error, info, warn, Level};
 use opentelemetry_appender_log::OpenTelemetryLogBridge;
 use opentelemetry_sdk::logs::{BatchLogProcessor, LoggerProvider};
 use opentelemetry_sdk::runtime;
-use opentelemetry_sdk::testing::logs::InMemoryLogsExporter;
+use opentelemetry_stdout::LogExporter;
 
 #[tokio::main]
 async fn main() {
-    //Create an InMemoryLogsExporter
-    let exporter: InMemoryLogsExporter = InMemoryLogsExporter::default();
+    //Create an exporter that writes to stdout
+    let exporter = LogExporter::default();
     //Create a LoggerProvider and register the exporter
     let logger_provider = LoggerProvider::builder()
-        .with_log_processor(BatchLogProcessor::builder(exporter.clone(), runtime::Tokio).build())
+        .with_log_processor(BatchLogProcessor::builder(exporter, runtime::Tokio).build())
         .build();
 
     // Setup Log Appender for the log crate.
@@ -25,14 +25,12 @@ async fn main() {
     log::set_max_level(Level::Info.to_level_filter());
 
     // Emit logs using macros from the log crate.
-    error!("hello from {}. My price is {}", "apple", 2.99);
+    let fruit = "apple";
+    let price = 2.99;
+
+    error!(fruit, price; "hello from {fruit}. My price is {price}");
     warn!("warn!");
     info!("test log!");
 
     logger_provider.force_flush();
-
-    let emitted_logs = exporter.get_emitted_logs().unwrap();
-    for log in emitted_logs {
-        println!("{:?}", log);
-    }
 }