Merge branch 'main' into otel-json

Author: ramgdev

.github/workflows/ci.yml

@@ -53,7 +53,7 @@ jobs:
   external-types:
     strategy:
       matrix:
-        example: [opentelemetry, opentelemetry-sdk]
+        example: [opentelemetry, opentelemetry-sdk, opentelemetry-otlp, opentelemetry-zipkin]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4

.github/workflows/markdown-link-check.yml

@@ -15,7 +15,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: Install markdown-link-check
-        run: npm install -g markdown-link-check
+        run: npm install -g markdown-link-check@3.11.2
 
       - name: Run markdown-link-check
         run: |

RELEASING.md

@@ -0,0 +1,52 @@
+# Releasing OpenTelemetry Rust
+
+The primary audience for this is the SIG Maintainers. It provides the list of steps for how to release the crates and the
+considerations to make before releasing the crate. It may provide use to consumers of the crate if/when we develop a
+release cadence.
+
+## Release cadence
+
+As of Feb 2024, there is no established cadence for the OpenTelemetry crates. The balance is required between too many
+breaking changes in a single release, and since we have instability flipping between implementations across 0.x
+releases. Perhaps once we've established a 1.0 we can consider adopting a consistent release cadence.
+
+## Considerations
+
+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?
+* 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.
+
+## Steps to Release
+
+1. Create a release PR
+  - For each crate
+    - Bump appropriate version
+    - Update change logs to reflect release version.
+    - Update API/SDK version as necessary
+    - Attach `integration test` label to the PR to run integration tests
+  - If there's a large enough set of changes, consider writing a migration guide.
+2. Merge the PR
+  - Get reviews from other Maintainers
+  - Ensure that there haven't been any interfering PRs
+3. Tag the release commit based on the [tagging convention](#tagging-convention). It should usually be a bump on minor version before 1.0
+4. Create Github Release
+5. [Publish](#publishing-crates) to crates.io using the version as of the release commit
+6. Post to [#otel-rust](https://cloud-native.slack.com/archives/C03GDP0H023) on CNCF Slack.
+
+
+## Tagging Convention
+
+For each crate: it should be `<crate-name>-<version>` `<version>` being the simple `X.Y.Z`.
+
+## Publishing Crates
+
+For now we use the [basic procedure](https://doc.rust-lang.org/cargo/reference/publishing.html) from crates.io.
+
+Follow this for each crate as necessary.
+
+For any new crates remember to add open-telemetry/rust-maintainers to the list.

opentelemetry-otlp/allowed-external-types.toml

@@ -0,0 +1,22 @@
+# Copyright The OpenTelemetry Authors
+# SPDX-License-Identifier: Apache-2.0
+# This is used with cargo-check-external-types to reduce the surface area of downstream crates from
+# the public API. Ideally this can have a few exceptions as possible.
+allowed_external_types = [
+    "opentelemetry::*",
+    "opentelemetry_http::*",
+    "opentelemetry_sdk::*",
+    # http is a pre 1.0 crate
+    "http::uri::InvalidUri",
+    "http::header::name::InvalidHeaderName",
+    "http::header::value::InvalidHeaderValue",
+    # prost is a pre 1.0 crate
+    "prost::error::EncodeError",
+    # tonic is a pre 1.0 crate
+    "tonic::status::Code",
+    "tonic::status::Status",
+    "tonic::metadata::map::MetadataMap",
+    "tonic::transport::channel::Channel",
+    "tonic::transport::error::Error",
+    "tonic::service::interceptor::Interceptor",
+]

opentelemetry-sdk/src/metrics/mod.rs

@@ -590,6 +590,115 @@ mod tests {
         );
     }
 
+    // "multi_thread" tokio flavor must be used else flush won't
+    // be able to make progress!
+    #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+    #[ignore = "Known bug: https://github.com/open-telemetry/opentelemetry-rust/issues/1598"]
+    async fn delta_memory_efficiency_test() {
+        // Run this test with stdout enabled to see output.
+        // cargo test delta_memory_efficiency_test --features=metrics,testing -- --nocapture
+
+        // Arrange
+        let exporter = InMemoryMetricsExporterBuilder::new()
+            .with_temporality_selector(DeltaTemporalitySelector())
+            .build();
+        let reader = PeriodicReader::builder(exporter.clone(), runtime::Tokio).build();
+        let meter_provider = SdkMeterProvider::builder().with_reader(reader).build();
+
+        // Act
+        let meter = meter_provider.meter("test");
+        let counter = meter
+            .u64_counter("my_counter")
+            .with_unit(Unit::new("my_unit"))
+            .init();
+        counter.add(1, &[KeyValue::new("key1", "value1")]);
+        counter.add(1, &[KeyValue::new("key1", "value1")]);
+        counter.add(1, &[KeyValue::new("key1", "value1")]);
+        counter.add(1, &[KeyValue::new("key1", "value1")]);
+        counter.add(1, &[KeyValue::new("key1", "value1")]);
+
+        counter.add(1, &[KeyValue::new("key1", "value2")]);
+        counter.add(1, &[KeyValue::new("key1", "value2")]);
+        counter.add(1, &[KeyValue::new("key1", "value2")]);
+
+        meter_provider.force_flush().unwrap();
+
+        // Assert
+        let resource_metrics = exporter
+            .get_finished_metrics()
+            .expect("metrics are expected to be exported.");
+        assert!(!resource_metrics.is_empty());
+        let metric = &resource_metrics[0].scope_metrics[0].metrics[0];
+        assert_eq!(metric.name, "my_counter");
+        assert_eq!(metric.unit.as_str(), "my_unit");
+        let sum = metric
+            .data
+            .as_any()
+            .downcast_ref::<data::Sum<u64>>()
+            .expect("Sum aggregation expected for Counter instruments by default");
+
+        // Expecting 2 time-series.
+        assert_eq!(sum.data_points.len(), 2);
+        assert!(sum.is_monotonic, "Counter should produce monotonic.");
+        assert_eq!(
+            sum.temporality,
+            data::Temporality::Delta,
+            "Should produce Delta as configured"
+        );
+
+        // find and validate key1=value1 datapoint
+        let mut data_point1 = None;
+        for datapoint in &sum.data_points {
+            if datapoint
+                .attributes
+                .iter()
+                .any(|(k, v)| k.as_str() == "key1" && v.as_str() == "value1")
+            {
+                data_point1 = Some(datapoint);
+            }
+        }
+        assert_eq!(
+            data_point1
+                .expect("datapoint with key1=value1 expected")
+                .value,
+            5
+        );
+
+        // find and validate key1=value2 datapoint
+        let mut data_point1 = None;
+        for datapoint in &sum.data_points {
+            if datapoint
+                .attributes
+                .iter()
+                .any(|(k, v)| k.as_str() == "key1" && v.as_str() == "value2")
+            {
+                data_point1 = Some(datapoint);
+            }
+        }
+        assert_eq!(
+            data_point1
+                .expect("datapoint with key1=value2 expected")
+                .value,
+            3
+        );
+
+        // flush again, and validate that nothing is flushed
+        // as delta temporality.
+        meter_provider.force_flush().unwrap();
+        let resource_metrics = exporter
+            .get_finished_metrics()
+            .expect("metrics are expected to be exported.");
+        println!("resource_metrics: {:?}", resource_metrics);
+        assert!(resource_metrics.is_empty(), "No metrics should be exported as no new measurements were recorded since last collect.");
+    }
+
+    struct DeltaTemporalitySelector();
+    impl TemporalitySelector for DeltaTemporalitySelector {
+        fn temporality(&self, _kind: InstrumentKind) -> Temporality {
+            Temporality::Delta
+        }
+    }
+
     struct TestContext {
         exporter: InMemoryMetricsExporter,
         meter_provider: SdkMeterProvider,

opentelemetry-semantic-conventions/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## vNext
 
+### Changed
+
+- Update to [v1.24.0](https://github.com/open-telemetry/semantic-conventions/releases/tag/v1.24.0) of the semantic conventions.
+  [#1596](https://github.com/open-telemetry/opentelemetry-rust/pull/1596)
+
 ## v0.14.0
 
 ### Changed

opentelemetry-semantic-conventions/scripts/generate-consts-from-spec.sh

@@ -5,8 +5,8 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 CRATE_DIR="${SCRIPT_DIR}/../"
 
 # freeze the spec version and generator version to make generation reproducible
-SPEC_VERSION=1.21.0
-SEMCOVGEN_VERSION=0.19.0
+SPEC_VERSION=1.24.0
+SEMCOVGEN_VERSION=0.23.0
 
 cd "$CRATE_DIR"
 

opentelemetry-semantic-conventions/src/lib.rs

@@ -20,4 +20,4 @@ pub mod trace;
 
 /// The schema URL that matches the version of the semantic conventions that
 /// this crate defines.
-pub const SCHEMA_URL: &str = "https://opentelemetry.io/schemas/1.21.0";
+pub const SCHEMA_URL: &str = "https://opentelemetry.io/schemas/1.24.0";

opentelemetry-semantic-conventions/src/resource.rs

@@ -0,0 +1,12 @@
+# Copyright The OpenTelemetry Authors
+# SPDX-License-Identifier: Apache-2.0
+# This is used with cargo-check-external-types to reduce the surface area of downstream crates from
+# the public API. Ideally this can have a few exceptions as possible.
+allowed_external_types = [
+    "opentelemetry::*",
+    "opentelemetry_http::*",
+    "opentelemetry_sdk::*",
+    # http is a pre 1.0 crate
+    "http::error::Error",
+    "http::uri::InvalidUri",
+]

opentelemetry-semantic-conventions/src/trace.rs

@@ -42,3 +42,13 @@ otel_unstable = []
 
 [dev-dependencies]
 opentelemetry_sdk = { path = "../opentelemetry-sdk" } # for documentation tests
+criterion = { version = "0.3" }
+
+[[bench]]
+name = "metrics"
+harness = false
+required-features = ["metrics"]
+
+[[bench]]
+name = "attributes"
+harness = false

opentelemetry-zipkin/allowed-external-types.toml

@@ -0,0 +1,51 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use opentelemetry::KeyValue;
+
+// Run this benchmark with:
+// cargo bench --bench attributes
+
+fn criterion_benchmark(c: &mut Criterion) {
+    attributes_creation(c);
+}
+
+fn attributes_creation(c: &mut Criterion) {
+    c.bench_function("CreateOTelKeyValue", |b| {
+        b.iter(|| {
+            let _v1 = black_box(KeyValue::new("attribute1", "value1"));
+        });
+    });
+
+    c.bench_function("CreateKeyValueTuple", |b| {
+        b.iter(|| {
+            let _v1 = black_box(("attribute1", "value1"));
+        });
+    });
+
+    #[allow(clippy::useless_vec)]
+    c.bench_function("CreateVector_KeyValue", |b| {
+        b.iter(|| {
+            let _v1 = black_box(vec![
+                KeyValue::new("attribute1", "value1"),
+                KeyValue::new("attribute2", "value2"),
+                KeyValue::new("attribute3", "value3"),
+                KeyValue::new("attribute4", "value4"),
+            ]);
+        });
+    });
+
+    #[allow(clippy::useless_vec)]
+    c.bench_function("CreateVector_StringPairs", |b| {
+        b.iter(|| {
+            let _v1 = black_box(vec![
+                ("attribute1", "value1"),
+                ("attribute2", "value2"),
+                ("attribute3", "value3"),
+                ("attribute4", "value4"),
+            ]);
+        });
+    });
+}
+
+criterion_group!(benches, criterion_benchmark);
+
+criterion_main!(benches);

opentelemetry/Cargo.toml

@@ -0,0 +1,73 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use opentelemetry::{
+    metrics::{noop::NoopMeterProvider, Counter, MeterProvider as _},
+    KeyValue,
+};
+
+// Run this benchmark with:
+// cargo bench --bench metrics --features=metrics
+
+fn create_counter() -> Counter<u64> {
+    let meter_provider: NoopMeterProvider = NoopMeterProvider::default();
+    let meter = meter_provider.meter("benchmarks");
+    let counter = meter.u64_counter("counter_bench").init();
+    counter
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    counter_add(c);
+}
+
+fn counter_add(c: &mut Criterion) {
+    let counter = create_counter();
+
+    c.bench_function("Counter_NoAttributes", |b| {
+        b.iter(|| {
+            counter.add(1, &[]);
+        });
+    });
+
+    c.bench_function("Counter_AddWithInlineStaticAttributes", |b| {
+        b.iter(|| {
+            counter.add(
+                1,
+                &[
+                    KeyValue::new("attribute1", "value1"),
+                    KeyValue::new("attribute2", "value2"),
+                    KeyValue::new("attribute3", "value3"),
+                    KeyValue::new("attribute4", "value4"),
+                ],
+            );
+        });
+    });
+
+    c.bench_function("Counter_AddWithStaticArray", |b| {
+        b.iter(|| {
+            let kv = [
+                KeyValue::new("attribute1", "value1"),
+                KeyValue::new("attribute2", "value2"),
+                KeyValue::new("attribute3", "value3"),
+                KeyValue::new("attribute4", "value4"),
+            ];
+
+            counter.add(1, &kv);
+        });
+    });
+
+    c.bench_function("Counter_AddWithDynamicAttributes", |b| {
+        b.iter(|| {
+            let kv = vec![
+                KeyValue::new("attribute1", "value1"),
+                KeyValue::new("attribute2", "value2"),
+                KeyValue::new("attribute3", "value3"),
+                KeyValue::new("attribute4", "value4"),
+            ];
+
+            counter.add(1, &kv);
+        });
+    });
+}
+
+criterion_group!(benches, criterion_benchmark);
+
+criterion_main!(benches);