Merge branch 'main' into fix/split-lint-ci-for-faster-feedback

Author: bryantbiggs

.github/workflows/benchmark.yml

@@ -1,37 +1,35 @@
-# This workflow runs a Criterion benchmark on a PR and compares the results against the base branch.
-# It is triggered on a PR or a push to main.
+# This workflow has two jobs:
+# 1. compareBenchmark: Runs on PRs with the "performance" label, comparing Criterion
+#    benchmark results against the base branch using criterion-compare-action.
+# 2. continuousBenchmark: Runs daily on main via schedule, storing benchmark results
+#    in the gh-pages branch and publishing a dashboard via github-action-benchmark.
+#    Skips runs where the HEAD commit has already been benchmarked.
 #
-# The workflow is gated on the presence of the "performance" label on the PR.
-#
-# The workflow runs on a self-hosted runner pool. We can't use the shared runners for this,
-# because they are only permitted to run on the default branch to preserve resources. 
-#
-# In the future, we might like to consider using bencher.dev or the framework used by otel-golang here. 
-on: 
+# The PR job runs on shared GitHub runners to save resources.
+# The continuous job runs on a self-hosted bare-metal runner for consistent, accurate results.
+on:
   pull_request:
     types: [labeled, synchronize]
-  push:
-    branches:
-      - main
-name: benchmark pull requests
+  schedule:
+    - cron: '0 6 * * *' # daily at 06:00 UTC
+  workflow_dispatch:
+name: benchmark
 permissions:
   contents: read
 jobs:
-  runBenchmark:
-    name: run benchmark
+  # ---------------------------------------------------------------------------
+  # PR benchmark comparison
+  # ---------------------------------------------------------------------------
+  compareBenchmark:
+    name: compare benchmarks (PR)
+    if: github.event_name == 'pull_request' && contains(github.event.pull_request.labels.*.name, 'performance')
+    runs-on: ubuntu-latest
     permissions:
       pull-requests: write
-
-    # If we're running on main, use our oracle bare-metal runner for accuracy. 
-    # If we're running on a PR, use github's shared workers to save resources.
-    runs-on: ${{ github.event_name == 'pull_request' && 'ubuntu-latest' || 'oracle-bare-metal-64cpu-512gb-x86-64' }}
-    if: ${{ (github.event_name == 'pull_request' && contains(github.event.pull_request.labels.*.name, 'performance')) || github.event_name == 'push' }}
     container:
       image: rust:slim-bullseye
     env:
-      # For PRs, compare against the base branch - e.g., 'main'. 
-      # For pushes to main, compare against the previous commit
-      BRANCH_NAME: ${{ github.event_name == 'pull_request' && github.base_ref || github.event.before }}
+      BRANCH_NAME: ${{ github.base_ref }}
       GIT_DISCOVERY_ACROSS_FILESYSTEM: 1
     steps:
       - name: Harden the runner (Audit all outbound calls)
@@ -41,15 +39,15 @@ jobs:
 
       - name: Setup container environment
         run: |
-          apt-get update && apt-get install --fix-missing -y unzip cmake build-essential pkg-config curl git
+          apt-get update && apt-get install --fix-missing -y unzip cmake build-essential pkg-config curl git libssl-dev
           cargo install cargo-criterion
 
       - name: Make repo safe for Git inside container
         run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
 
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
-          fetch-depth: 10 # Fetch a bit of history so we can do perf diffs
+          fetch-depth: 10
 
       - uses: arduino/setup-protoc@c65c819552d16ad3c9b72d9dfd5ba5237b9c906b # v3.0.0
         with:
@@ -58,3 +56,67 @@ jobs:
       - uses: boa-dev/criterion-compare-action@adfd3a94634fe2041ce5613eb7df09d247555b87 # v3.2.4
         with:
           branchName: ${{ env.BRANCH_NAME }}
+
+  # ---------------------------------------------------------------------------
+  # Continuous benchmark tracking (daily schedule)
+  # ---------------------------------------------------------------------------
+  continuousBenchmark:
+    name: continuous benchmark tracking
+    if: github.event_name == 'schedule' || github.event_name == 'workflow_dispatch'
+    # Use bare-metal runner on the upstream repo for consistent results; fall back to shared runners elsewhere
+    runs-on: ${{ github.repository == 'open-telemetry/opentelemetry-rust' && 'oracle-bare-metal-64cpu-512gb-x86-64' || 'ubuntu-latest' }}
+    permissions:
+      contents: write
+    container:
+      image: rust:slim-bullseye
+    env:
+      GIT_DISCOVERY_ACROSS_FILESYSTEM: 1
+    steps:
+      - name: Harden the runner (Audit all outbound calls)
+        uses: step-security/harden-runner@a90bcbc6539c36a85cdfeb73f7e2f433735f215b # v2.15.0
+        with:
+          egress-policy: audit
+
+      - name: Setup container environment
+        run: |
+          apt-get update && apt-get install --fix-missing -y unzip cmake build-essential pkg-config curl git libssl-dev
+
+      - name: Make repo safe for Git inside container
+        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
+
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Check if commit already benchmarked
+        id: check_duplicate
+        run: |
+          # Fetch the benchmark data file from gh-pages and see if this commit is already recorded
+          DATA_URL="https://raw.githubusercontent.com/${{ github.repository }}/gh-pages/dev/bench/data.js"
+          if curl -sf "$DATA_URL" | grep -q "${{ github.sha }}"; then
+            echo "skip=true" >> "$GITHUB_OUTPUT"
+            echo "Commit ${{ github.sha }} already benchmarked, skipping."
+          else
+            echo "skip=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      - uses: arduino/setup-protoc@c65c819552d16ad3c9b72d9dfd5ba5237b9c906b # v3.0.0
+        if: steps.check_duplicate.outputs.skip != 'true'
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Run benchmarks
+        if: steps.check_duplicate.outputs.skip != 'true'
+        run: cargo bench --workspace --all-features -- --output-format bencher | tee output.txt
+
+      - name: Store benchmark result
+        if: steps.check_duplicate.outputs.skip != 'true'
+        uses: benchmark-action/github-action-benchmark@a7bc2366eda11037936ea57d811a43b3418d3073 # v1.21.0
+        with:
+          tool: 'cargo'
+          output-file-path: output.txt
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          auto-push: true
+          benchmark-data-dir-path: dev/bench
+          # Alert if a benchmark regresses by more than 20%
+          alert-threshold: '120%'
+          comment-on-alert: true
+          fail-on-alert: false

CONTRIBUTING.md

@@ -324,9 +324,14 @@ All such features should adhere to naming convention  `<signal>_<feature_name>`
 - Run `cargo test --all` - this will execute code and doc tests for all
 projects in this workspace.
 - Run `cargo bench` - this will run benchmarks to show performance
-- Run `cargo bench` - this will run benchmarks to show performance
 regressions
 
+Benchmarks are run daily against `main` and results are tracked over time.
+The continuous benchmark dashboard is published at
+<https://open-telemetry.github.io/opentelemetry-rust/dev/bench/>.
+PRs with the `performance` label will also get a benchmark comparison
+comment showing any regressions or improvements.
+
 ## FAQ
 
 ### Where should I put third party propagators/exporters, contrib or standalone crates?

docs/metrics.md

@@ -730,10 +730,12 @@ Follow these guidelines when deciding where to attach metric attributes:
 
     ```rust
     // Example: Setting resource-level attributes
-    let resource = Resource::new(vec![
-        KeyValue::new("service.name", "payment-processor"),
-        KeyValue::new("deployment.environment", "production"),
-    ]);
+    // Use Resource::builder() to preserve SDK-provided defaults
+    // (telemetry.sdk.*, service.name).
+    let resource = Resource::builder()
+        .with_service_name("payment-processor")
+        .with_attributes([KeyValue::new("deployment.environment.name", "production")])
+        .build();
     ```
 
   * **Meter-level attributes**: If the dimension applies only to a subset of

opentelemetry-appender-log/Cargo.toml

@@ -28,7 +28,7 @@ experimental_metadata_attributes = ["dep:opentelemetry-semantic-conventions"]
 opentelemetry_sdk = { workspace = true, features = ["testing"] }
 opentelemetry-stdout = { workspace = true, features = ["logs"] }
 log = { workspace = true, features = ["kv_serde"] }
-tokio = { workspace = true }
+tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
 serde = { workspace = true, features = ["std", "derive"] }
 
 [lints]

opentelemetry-otlp/src/exporter/tonic/mod.rs

@@ -962,4 +962,96 @@ mod tests {
             result.unwrap_err()
         );
     }
+
+    #[test]
+    #[cfg(not(feature = "gzip-tonic"))]
+    fn test_gzip_compression_errors_without_feature() {
+        use crate::exporter::ExporterBuildError;
+        use crate::SpanExporter;
+        use crate::WithTonicConfig;
+
+        let result = SpanExporter::builder()
+            .with_tonic()
+            .with_compression(crate::Compression::Gzip)
+            .build();
+
+        assert!(result.is_err());
+        let err = result.unwrap_err();
+        assert!(
+            matches!(
+                err,
+                ExporterBuildError::FeatureRequiredForCompressionAlgorithm(..)
+            ),
+            "expected FeatureRequiredForCompressionAlgorithm error, got: {err:?}"
+        );
+        let msg = err.to_string();
+        assert!(
+            msg.contains("gzip-tonic"),
+            "error message should mention 'gzip-tonic' feature, got: {msg}"
+        );
+    }
+
+    #[tokio::test]
+    #[cfg(feature = "gzip-tonic")]
+    async fn test_gzip_compression_succeeds_with_feature() {
+        use crate::SpanExporter;
+        use crate::WithTonicConfig;
+
+        let result = SpanExporter::builder()
+            .with_tonic()
+            .with_compression(crate::Compression::Gzip)
+            .build();
+
+        assert!(
+            result.is_ok(),
+            "gzip compression should succeed when gzip-tonic feature is enabled, got: {:?}",
+            result.unwrap_err()
+        );
+    }
+
+    #[test]
+    #[cfg(not(feature = "zstd-tonic"))]
+    fn test_zstd_compression_errors_without_feature() {
+        use crate::exporter::ExporterBuildError;
+        use crate::SpanExporter;
+        use crate::WithTonicConfig;
+
+        let result = SpanExporter::builder()
+            .with_tonic()
+            .with_compression(crate::Compression::Zstd)
+            .build();
+
+        assert!(result.is_err());
+        let err = result.unwrap_err();
+        assert!(
+            matches!(
+                err,
+                ExporterBuildError::FeatureRequiredForCompressionAlgorithm(..)
+            ),
+            "expected FeatureRequiredForCompressionAlgorithm error, got: {err:?}"
+        );
+        let msg = err.to_string();
+        assert!(
+            msg.contains("zstd-tonic"),
+            "error message should mention 'zstd-tonic' feature, got: {msg}"
+        );
+    }
+
+    #[tokio::test]
+    #[cfg(feature = "zstd-tonic")]
+    async fn test_zstd_compression_succeeds_with_feature() {
+        use crate::SpanExporter;
+        use crate::WithTonicConfig;
+
+        let result = SpanExporter::builder()
+            .with_tonic()
+            .with_compression(crate::Compression::Zstd)
+            .build();
+
+        assert!(
+            result.is_ok(),
+            "zstd compression should succeed when zstd-tonic feature is enabled, got: {:?}",
+            result.unwrap_err()
+        );
+    }
 }

opentelemetry-sdk/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## vNext
 
+- **Breaking** The SDK `testing` feature is now runtime agnostic. [#3407][3407]
+  - `TokioSpanExporter` and `new_tokio_test_exporter` have been renamed to `TestSpanExporter` and `new_test_exporter`.
+  - The following transitive dependencies and features have been removed: `tokio/rt`, `tokio/time`, `tokio/macros`, `tokio/rt-multi-thread`, `tokio-stream`, `experimental_async_runtime`
 - Add 32-bit platform support by using `portable-atomic` for `AtomicI64` and `AtomicU64` in the metrics module. This enables compilation on 32-bit ARM targets (e.g., `armv5te-unknown-linux-gnueabi`, `armv7-unknown-linux-gnueabihf`).
 - `Aggregation` enum and `StreamBuilder::with_aggregation()` are now stable and no longer require the `spec_unstable_metrics_views` feature flag.
 - Fix `service.name` Resource attribute fallback to follow OpenTelemetry
@@ -29,6 +32,7 @@
 [3312]: https://github.com/open-telemetry/opentelemetry-rust/pull/3312
 [3248]: https://github.com/open-telemetry/opentelemetry-rust/pull/3248
 [3262]: https://github.com/open-telemetry/opentelemetry-rust/pull/3262
+[3407]: https://github.com/open-telemetry/opentelemetry-rust/pull/3407
 
 - "spec_unstable_logs_enabled" feature flag is removed. The capability (and the
   backing specification) is now stable and is enabled by default.

opentelemetry-sdk/Cargo.toml

@@ -37,6 +37,7 @@ rustdoc-args = ["--cfg", "docsrs"]
 criterion = { workspace = true, features = ["html_reports"] }
 rstest = { workspace = true }
 temp-env = { workspace = true }
+tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
 
 [target.'cfg(not(target_os = "windows"))'.dev-dependencies]
 pprof = { workspace = true }
@@ -47,7 +48,7 @@ trace = ["opentelemetry/trace", "rand", "percent-encoding"]
 jaeger_remote_sampler = ["trace", "opentelemetry-http", "http", "serde", "serde_json", "url", "experimental_async_runtime"]
 logs = ["opentelemetry/logs"]
 metrics = ["opentelemetry/metrics"]
-testing = ["opentelemetry/testing", "trace", "metrics", "logs", "rt-tokio", "rt-tokio-current-thread", "tokio/macros", "tokio/rt-multi-thread"]
+testing = ["opentelemetry/testing", "trace", "metrics", "logs", "tokio/sync"]
 experimental_async_runtime = []
 rt-tokio = ["tokio/rt", "tokio/time", "tokio-stream", "experimental_async_runtime"]
 rt-tokio-current-thread = ["tokio/rt", "tokio/time", "tokio-stream", "experimental_async_runtime"]

opentelemetry-sdk/src/logs/batch_log_processor.rs

@@ -756,7 +756,7 @@ mod tests {
     use opentelemetry::logs::LogRecord;
     use opentelemetry::InstrumentationScope;
     use opentelemetry::KeyValue;
-    use std::sync::atomic::{AtomicUsize, Ordering};
+    use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
     use std::sync::{Arc, Mutex};
     use std::time::Duration;
 
@@ -839,6 +839,29 @@ mod tests {
         assert_eq!(config.max_queue_size, 4096);
         assert_eq!(config.max_export_batch_size, 1024);
     }
+    #[test]
+    fn test_force_flush_being_called() {
+        #[derive(Debug, Clone)]
+        struct MockExporter {
+            export_called: Arc<AtomicBool>,
+        }
+        impl LogExporter for MockExporter {
+            async fn export(&self, _batch: LogBatch<'_>) -> OTelSdkResult {
+                self.export_called.store(true, Ordering::SeqCst);
+                Ok(())
+            }
+        }
+        let exporter = MockExporter {
+            export_called: Arc::new(AtomicBool::new(false)),
+        };
+        let processor = BatchLogProcessor::new(exporter.clone(), BatchConfig::default());
+        let scope = opentelemetry::InstrumentationScope::builder("my-crate")
+            .with_schema_url("https://opentelemetry.io/schemas/1.17.0")
+            .build();
+        processor.emit(&mut SdkLogRecord::new(), &scope);
+        processor.force_flush().unwrap();
+        assert!(exporter.export_called.load(Ordering::SeqCst));
+    }
 
     #[test]
     fn test_batch_config_max_export_batch_size_validation() {

opentelemetry-sdk/src/logs/log_processor_with_async_runtime.rs

@@ -775,13 +775,17 @@ mod tests {
             BatchLogProcessor::new(exporter.clone(), BatchConfig::default(), runtime::Tokio);
         let provider = SdkLoggerProvider::builder()
             .with_log_processor(processor)
-            .with_resource(Resource::new(vec![
-                KeyValue::new("k1", "v1"),
-                KeyValue::new("k2", "v3"),
-                KeyValue::new("k3", "v3"),
-                KeyValue::new("k4", "v4"),
-                KeyValue::new("k5", "v5"),
-            ]))
+            .with_resource(
+                Resource::builder_empty()
+                    .with_attributes(vec![
+                        KeyValue::new("k1", "v1"),
+                        KeyValue::new("k2", "v3"),
+                        KeyValue::new("k3", "v3"),
+                        KeyValue::new("k4", "v4"),
+                        KeyValue::new("k5", "v5"),
+                    ])
+                    .build(),
+            )
             .build();
         provider.force_flush().unwrap();
         assert_eq!(exporter.get_resource().unwrap().into_iter().count(), 5);