Merge branch 'main' into cijothomas/metricsdk-add-moretesetes

Author: cijothomas

.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-zipkin/allowed-external-types.toml

@@ -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/Cargo.toml

@@ -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/benches/attributes.rs

@@ -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/benches/metrics.rs

@@ -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);