test(metrics): cover view filter and histogram empty-attr mixing

Tests:
  * bound_histogram_empty_attributes_shares_with_unbound mirrors the
    existing counter version for histograms.
  * bound_counter_view_filters_attributes_at_bind_time and a histogram
    analog confirm a view filters attributes at bind() time, with bound
    and unbound recordings collapsing onto the same filtered data point.

Bench:
  * Counter_Bound_With_View_Delta confirms view filtering happens at bind
    time, leaving the hot path at unfiltered-bound speed. Updated bench
    required-features and added a note that criterion does not enforce
    regression on its own.

CHANGELOG entries for both crates updated to mention Clone, the noop
trait default, and the converged bound/unbound semantics.

Author: bryantbiggs

opentelemetry-sdk/CHANGELOG.md

@@ -8,10 +8,14 @@
 - **Added** `Counter::bind()` and `Histogram::bind()` SDK implementations that
   return pre-bound measurement handles (`BoundCounter<T>`, `BoundHistogram<T>`).
   Bound instruments resolve the attribute-to-aggregator mapping once at bind time
-  and cache the result, eliminating per-call HashMap lookups. Bound entries are
-  never evicted during delta collection — idle cycles produce no export but the
-  tracker persists. If `bind()` is called at the cardinality limit, the handle
-  transparently falls back to the unbound measurement path. Gated behind the
+  and cache the result, eliminating per-call HashMap lookups. View attribute
+  filtering is applied at bind time so the hot path stays free of per-call
+  attribute processing. Bound and unbound recordings with the same (post-view)
+  attribute set always aggregate into the same data point, including the empty
+  attribute set. Bound entries are never evicted during delta collection while
+  a handle exists — idle cycles produce no export but the tracker persists. If
+  `bind()` is called at the cardinality limit, the handle transparently falls
+  back to the unbound measurement path. Gated behind the
   `experimental_metrics_bound_instruments` feature flag. Benchmarks show ~28x
   speedup for counter operations and ~9x for histograms.
 - Delta metrics collection now uses in-place eviction instead of draining the

opentelemetry-sdk/Cargo.toml

@@ -127,7 +127,7 @@ required-features = ["logs"]
 [[bench]]
 name = "bound_instruments"
 harness = false
-required-features = ["metrics", "experimental_metrics_custom_reader", "experimental_metrics_bound_instruments"]
+required-features = ["metrics", "experimental_metrics_custom_reader", "experimental_metrics_bound_instruments", "spec_unstable_metrics_views"]
 
 [lib]
 bench = false

opentelemetry-sdk/benches/bound_instruments.rs

@@ -1,20 +1,25 @@
 use criterion::{criterion_group, criterion_main, Criterion};
-use opentelemetry::{metrics::MeterProvider as _, KeyValue};
-use opentelemetry_sdk::metrics::{ManualReader, SdkMeterProvider, Temporality};
+use opentelemetry::{metrics::MeterProvider as _, Key, KeyValue};
+use opentelemetry_sdk::metrics::{ManualReader, SdkMeterProvider, Stream, Temporality};
 
 // Run this benchmark with:
-// cargo bench --bench bound_instruments --features metrics,experimental_metrics_custom_reader,experimental_metrics_bound_instruments
+// cargo bench --bench bound_instruments --features metrics,experimental_metrics_custom_reader,experimental_metrics_bound_instruments,spec_unstable_metrics_views
 //
 // Apple M4 Max, 16 cores (12 performance + 4 efficiency), macOS 15.4
 //
 // Results (3 attributes: method, status, path):
 // Counter_Unbound_Delta             time:   [53.20 ns]
 // Counter_Bound_Delta               time:   [1.87 ns]    ~28x faster
+// Counter_Bound_With_View_Delta     time:   [~1.9 ns]    view filter applied at bind, not on hot path
 // Histogram_Unbound_Delta           time:   [58.58 ns]
 // Histogram_Bound_Delta             time:   [6.57 ns]    ~8.9x faster
 // Counter_Bound_Multithread/2       time:   [22.19 µs]   (100 adds/thread)
 // Counter_Bound_Multithread/4       time:   [35.32 µs]   (100 adds/thread)
 // Counter_Bound_Multithread/8       time:   [66.49 µs]   (100 adds/thread)
+//
+// Note: criterion does not fail CI on regression by itself. These numbers are
+// reference values for human review; use `cargo criterion --baseline` locally
+// if you need automated comparison against a saved baseline.
 
 fn create_provider(temporality: Temporality) -> SdkMeterProvider {
     let reader = ManualReader::builder()
@@ -53,6 +58,38 @@ fn bench_bound_instruments(c: &mut Criterion) {
         });
     }
 
+    // Counter: Bound with a View filter — confirms the filter is applied at
+    // bind() time and the hot path stays free of attribute processing.
+    {
+        let view = |i: &opentelemetry_sdk::metrics::Instrument| {
+            if i.name() == "bound_with_view" {
+                Stream::builder()
+                    .with_allowed_attribute_keys(vec![
+                        Key::new("method"),
+                        Key::new("status"),
+                        Key::new("path"),
+                    ])
+                    .build()
+                    .ok()
+            } else {
+                None
+            }
+        };
+        let reader = ManualReader::builder()
+            .with_temporality(Temporality::Delta)
+            .build();
+        let provider = SdkMeterProvider::builder()
+            .with_reader(reader)
+            .with_view(view)
+            .build();
+        let meter = provider.meter("bench");
+        let counter = meter.u64_counter("bound_with_view").build();
+        let bound = counter.bind(&attrs);
+        group.bench_function("Counter_Bound_With_View_Delta", |b| {
+            b.iter(|| bound.add(1));
+        });
+    }
+
     // Histogram: Unbound vs Bound (Delta)
     {
         let provider = create_provider(Temporality::Delta);

opentelemetry-sdk/src/metrics/mod.rs

@@ -5364,4 +5364,168 @@ mod tests {
         );
         assert_eq!(sum.data_points[0].value, 100);
     }
+
+    #[cfg(feature = "experimental_metrics_bound_instruments")]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+    async fn bound_histogram_empty_attributes_shares_with_unbound() {
+        let mut test_context = TestContext::new(Temporality::Cumulative);
+        let histogram = test_context
+            .meter()
+            .u64_histogram("my_histogram")
+            .with_boundaries(vec![5.0, 10.0, 25.0])
+            .build();
+        let bound = histogram.bind(&[]);
+
+        histogram.record(3, &[]);
+        bound.record(7);
+        histogram.record(20, &[]);
+        test_context.flush_metrics();
+
+        let MetricData::Histogram(hist) = test_context.get_aggregation::<u64>("my_histogram", None)
+        else {
+            unreachable!()
+        };
+
+        assert_eq!(
+            hist.data_points.len(),
+            1,
+            "Bound and unbound with empty attributes must share the same data point"
+        );
+        let dp = &hist.data_points[0];
+        assert!(dp.attributes.is_empty());
+        assert_eq!(dp.count, 3);
+        assert_eq!(dp.sum, 30);
+    }
+
+    #[cfg(feature = "experimental_metrics_bound_instruments")]
+    #[cfg(feature = "spec_unstable_metrics_views")]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+    async fn bound_counter_view_filters_attributes_at_bind_time() {
+        use opentelemetry::Key;
+
+        let exporter = InMemoryMetricExporter::default();
+        let view = |i: &Instrument| {
+            if i.name() == "my_counter" {
+                Stream::builder()
+                    .with_allowed_attribute_keys(vec![Key::new("k1"), Key::new("k2")])
+                    .build()
+                    .ok()
+            } else {
+                None
+            }
+        };
+        let meter_provider = SdkMeterProvider::builder()
+            .with_periodic_exporter(exporter.clone())
+            .with_view(view)
+            .build();
+        let meter = meter_provider.meter("test");
+        let counter = meter.u64_counter("my_counter").build();
+
+        // bind with k3 included — view should drop it at bind time
+        let bound = counter.bind(&[
+            KeyValue::new("k1", "v1"),
+            KeyValue::new("k2", "v2"),
+            KeyValue::new("k3", "v3"),
+        ]);
+        bound.add(10);
+        bound.add(20);
+
+        // unbound call with a *different* k3 value: after view filtering both
+        // bound and unbound must collapse into the same data point.
+        counter.add(
+            7,
+            &[
+                KeyValue::new("k1", "v1"),
+                KeyValue::new("k2", "v2"),
+                KeyValue::new("k3", "different"),
+            ],
+        );
+
+        meter_provider.force_flush().unwrap();
+        let resource_metrics = exporter
+            .get_finished_metrics()
+            .expect("metrics are expected to be exported.");
+        let metric = &resource_metrics[0].scope_metrics[0].metrics[0];
+        let data::AggregatedMetrics::U64(MetricData::Sum(sum)) = &metric.data else {
+            unreachable!()
+        };
+
+        assert_eq!(
+            sum.data_points.len(),
+            1,
+            "view should filter k3, leaving bound+unbound to aggregate together"
+        );
+        assert_eq!(sum.data_points[0].value, 37);
+        let attrs = &sum.data_points[0].attributes;
+        assert_eq!(attrs.len(), 2);
+        assert!(attrs.iter().any(|kv| kv.key.as_str() == "k1"));
+        assert!(attrs.iter().any(|kv| kv.key.as_str() == "k2"));
+        assert!(!attrs.iter().any(|kv| kv.key.as_str() == "k3"));
+    }
+
+    #[cfg(feature = "experimental_metrics_bound_instruments")]
+    #[cfg(feature = "spec_unstable_metrics_views")]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+    async fn bound_histogram_view_filters_attributes_at_bind_time() {
+        use opentelemetry::Key;
+
+        let exporter = InMemoryMetricExporter::default();
+        let view = |i: &Instrument| {
+            if i.name() == "my_hist" {
+                Stream::builder()
+                    .with_allowed_attribute_keys(vec![Key::new("k1"), Key::new("k2")])
+                    .build()
+                    .ok()
+            } else {
+                None
+            }
+        };
+        let meter_provider = SdkMeterProvider::builder()
+            .with_periodic_exporter(exporter.clone())
+            .with_view(view)
+            .build();
+        let meter = meter_provider.meter("test");
+        let histogram = meter
+            .u64_histogram("my_hist")
+            .with_boundaries(vec![5.0, 10.0, 25.0])
+            .build();
+
+        let bound = histogram.bind(&[
+            KeyValue::new("k1", "v1"),
+            KeyValue::new("k2", "v2"),
+            KeyValue::new("k3", "v3"),
+        ]);
+        bound.record(3);
+        bound.record(20);
+        histogram.record(
+            7,
+            &[
+                KeyValue::new("k1", "v1"),
+                KeyValue::new("k2", "v2"),
+                KeyValue::new("k3", "different"),
+            ],
+        );
+
+        meter_provider.force_flush().unwrap();
+        let resource_metrics = exporter
+            .get_finished_metrics()
+            .expect("metrics are expected to be exported.");
+        let metric = &resource_metrics[0].scope_metrics[0].metrics[0];
+        let data::AggregatedMetrics::U64(MetricData::Histogram(hist)) = &metric.data else {
+            unreachable!()
+        };
+
+        assert_eq!(
+            hist.data_points.len(),
+            1,
+            "view should filter k3, leaving bound+unbound to aggregate together"
+        );
+        let dp = &hist.data_points[0];
+        assert_eq!(dp.count, 3);
+        assert_eq!(dp.sum, 30);
+        assert_eq!(dp.attributes.len(), 2);
+        assert!(dp.attributes.iter().any(|kv| kv.key.as_str() == "k1"));
+        assert!(dp.attributes.iter().any(|kv| kv.key.as_str() == "k2"));
+        assert!(!dp.attributes.iter().any(|kv| kv.key.as_str() == "k3"));
+    }
 }

opentelemetry/CHANGELOG.md

@@ -6,9 +6,12 @@
   aggregator references for a fixed attribute set. Created via `Counter::bind()`
   and `Histogram::bind()`, bound instruments bypass per-call attribute lookup,
   providing significant performance improvements for hot paths where the same
-  attributes are used repeatedly. Also adds the `SyncInstrument::bind()` trait
-  method and `BoundSyncInstrument<T>` trait for SDK implementors. Gated behind
-  the `experimental_metrics_bound_instruments` feature flag.
+  attributes are used repeatedly. Both types implement `Clone` so a single bound
+  state can be shared across threads or modules without re-binding. Also adds
+  the `SyncInstrument::bind()` trait method and `BoundSyncInstrument<T>` trait
+  for SDK implementors; the trait method has a no-op default so custom
+  `SyncInstrument` impls degrade gracefully without panicking. Gated behind the
+  `experimental_metrics_bound_instruments` feature flag.
 - Add `reserve` method to `opentelemetry::propagation::Injector` to hint at the number of elements that will be added to avoid multiple resize operations of the underlying data structure. Has an empty default implementation.
 - **Breaking** Removed the following public fields and methods from the `SpanBuilder` [#3227][3227]:
   - `trace_id`, `span_id`, `end_time`, `status`, `sampling_result`