perf(suppression): stabilize results

Author: bantonsson

opentelemetry-sdk/benches/context.rs

@@ -23,6 +23,7 @@ fn criterion_benchmark(c: &mut Criterion) {
         Environment::NoContext,
         Environment::NoSdk,
     ] {
+        let _restore_guard = Context::new().attach();
         let (_provider, _tracer, _guard) = env.setup();
 
         for api in [Api::Alt, Api::Spec] {

opentelemetry/benches/context_suppression.rs

@@ -1,5 +1,5 @@
 use criterion::{criterion_group, criterion_main, Criterion};
-use opentelemetry::Context;
+use opentelemetry::{Context, ContextGuard};
 use std::hint::black_box;
 
 // Run this benchmark with:
@@ -21,41 +21,56 @@ fn criterion_benchmark(c: &mut Criterion) {
 
     // Benchmark the cost of entering a suppressed scope
     group.bench_function("enter_telemetry_suppressed_scope", |b| {
+        let _restore_ctx = Context::default().attach();
         b.iter(|| {
-            let _guard = black_box(Context::enter_telemetry_suppressed_scope());
+            let _guard = black_box(enter_telemetry_suppressed_scope());
         });
     });
 
     // For comparison - normal context attach
     group.bench_function("normal_attach", |b| {
+        let _restore_ctx = Context::default().attach();
         b.iter(|| {
-            let _guard = black_box(Context::current().attach());
+            let _guard = black_box(normal_attach());
         });
     });
 
     // Benchmark checking if current is suppressed (when not suppressed)
     group.bench_function("is_current_telemetry_suppressed_false", |b| {
         // Make sure we're in a non-suppressed context
-        let _restore_ctx = Context::current().attach();
+        let _restore_ctx = Context::default().attach();
         b.iter(|| {
-            let is_suppressed = black_box(Context::is_current_telemetry_suppressed());
-            black_box(is_suppressed);
+            let _is_suppressed = black_box(is_current_telemetry_suppressed());
         });
     });
 
     // Benchmark checking if current is suppressed (when suppressed)
     group.bench_function("is_current_telemetry_suppressed_true", |b| {
         // Enter suppressed context for the duration of the benchmark
-        let _suppressed_guard = Context::enter_telemetry_suppressed_scope();
+        let _suppressed_guard = Context::default().with_telemetry_suppressed().attach();
         b.iter(|| {
-            let is_suppressed = black_box(Context::is_current_telemetry_suppressed());
-            black_box(is_suppressed);
+            let _is_suppressed = black_box(is_current_telemetry_suppressed());
         });
     });
 
     group.finish();
 }
 
+#[inline(never)]
+fn enter_telemetry_suppressed_scope() -> ContextGuard {
+    Context::enter_telemetry_suppressed_scope()
+}
+
+#[inline(never)]
+fn normal_attach() -> ContextGuard {
+    Context::current().attach()
+}
+
+#[inline(never)]
+fn is_current_telemetry_suppressed() -> bool {
+    Context::is_current_telemetry_suppressed()
+}
+
 criterion_group! {
     name = benches;
     config = Criterion::default()