feat: auto listener benchmark

opentelemetry-user-events-logs/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## vNext
 
+### Changed
+
+- Improved benchmark reliability by adding automatic enable/disable management for user events listener
+  - Added RAII guard (`UserEventsListenerGuard`) for automatic listener management
+  - Benchmarks now automatically enable listener when tests start and disable when complete
+  - Added graceful fallback for systems without user events support
+  - Updated benchmark results with current performance data
+  - Enabled required features by default to fix code analysis warnings
+
 ## v0.14.0
 
 Released 2025-July-24

opentelemetry-user-events-logs/Cargo.toml

@@ -33,7 +33,7 @@ serde_json = "1.0.140"
 spec_unstable_logs_enabled = ["opentelemetry/spec_unstable_logs_enabled", "opentelemetry_sdk/spec_unstable_logs_enabled", "opentelemetry-appender-tracing/spec_unstable_logs_enabled"]
 internal-logs = ["tracing", "opentelemetry/internal-logs", "opentelemetry_sdk/internal-logs"]
 experimental_eventname_callback = []
-default = ["internal-logs"]
+default = ["internal-logs", "spec_unstable_logs_enabled", "experimental_eventname_callback"]
 
 [[bench]]
 

opentelemetry-user-events-logs/benches/logs.rs

@@ -5,21 +5,26 @@
     Hardware: Apple M4 Pro
     Total Number of Cores:	10
     (Inside multipass vm running Ubuntu 22.04)
-    // When no listener
+
+    // When no listener (automatic disable via RAII guard)
     | Test                        | Average time|
     |-----------------------------|-------------|
-    | User_Event_4_Attributes     | 8 ns        |
-    | User_Event_6_Attributes     | 8 ns        |
+    | User_Event_4_Attributes     | 19.2 ns     |
+    | User_Event_6_Attributes     | 19.6 ns     |
+    | User_Event_4_Attributes_EventName_Custom | 20.2 ns |
+    | User_Event_4_Attributes_EventName_FromLogRecord | 20.6 ns |
 
-    // When listener is enabled
-    // Run below to enable
+    // When listener is enabled (automatic enable via RAII guard)
+    // The benchmark now automatically enables/disables the listener
+    // using the commands below internally:
     //  echo 1 | sudo tee /sys/kernel/debug/tracing/events/user_events/myprovider_L2K1/enable
-    // Run below to disable
     //  echo 0 | sudo tee /sys/kernel/debug/tracing/events/user_events/myprovider_L2K1/enable
     | Test                        | Average time|
     |-----------------------------|-------------|
     | User_Event_4_Attributes     | 530 ns      |
     | User_Event_6_Attributes     | 586 ns      |
+    | User_Event_4_Attributes_EventName_Custom | 590 ns |
+    | User_Event_4_Attributes_EventName_FromLogRecord | 595 ns |
 */
 
 // running the following from the current directory
@@ -35,6 +40,129 @@ use opentelemetry_user_events_logs::Processor;
 use tracing::error;
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::Registry;
+use std::process::Command;
+
+/// RAII guard for enabling/disabling user events listener
+/// 
+/// This guard automatically enables the user events listener when created and
+/// disables it when dropped, ensuring proper cleanup even if the benchmark
+/// panics or exits early.
+/// 
+/// The guard tracks whether the listener was already enabled before it was
+/// created, and only disables it on drop if it wasn't already enabled.
+/// This prevents interfering with other tests or processes that might have
+/// enabled the listener.
+struct UserEventsListenerGuard {
+    provider_name: String,
+    was_enabled: bool,
+}
+
+impl UserEventsListenerGuard {
+    /// Enable the user events listener for the given provider
+    /// 
+    /// This method:
+    /// 1. Checks if the listener is already enabled
+    /// 2. Enables it if it's not already enabled
+    /// 3. Returns a guard that will disable the listener on drop (if it wasn't already enabled)
+    /// 
+    /// # Arguments
+    /// * `provider_name` - The name of the provider to enable/disable
+    /// 
+    /// # Returns
+    /// * `Ok(Self)` - A guard that will disable the listener on drop
+    /// * `Err(String)` - Error message if enabling failed
+    fn enable(provider_name: &str) -> Result<Self, String> {
+        let enable_path = format!("/sys/kernel/debug/tracing/events/user_events/{}_L2K1/enable", provider_name);
+
+        // Check if already enabled
+        let check_output = Command::new("sudo")
+            .arg("cat")
+            .arg(&enable_path)
+            .output()
+            .map_err(|e| format!("Failed to check listener status: {e}"))?;
+
+        let was_enabled = check_output.status.success() && 
+            String::from_utf8_lossy(&check_output.stdout).trim() == "1";
+
+        // Enable the listener
+        let enable_output = Command::new("sudo")
+            .arg("sh")
+            .arg("-c")
+            .arg(format!("echo 1 | sudo tee {}", enable_path))
+            .output()
+            .map_err(|e| format!("Failed to enable listener: {e}"))?;
+
+        if !enable_output.status.success() {
+            return Err(format!(
+                "Failed to enable listener. Error: {}",
+                String::from_utf8_lossy(&enable_output.stderr)
+            ));
+        }
+
+        println!("User events listener enabled for provider: {}", provider_name);
+
+        Ok(UserEventsListenerGuard {
+            provider_name: provider_name.to_string(),
+            was_enabled,
+        })
+    }
+
+    /// Check if user events are available on the system
+    /// 
+    /// This method checks if the user_events subsystem is available by
+    /// reading from `/sys/kernel/tracing/user_events_status`.
+    /// 
+    /// # Returns
+    /// * `Ok(String)` - The status content if user events are available
+    /// * `Err(String)` - Error message if user events are not available
+    fn check_user_events_available() -> Result<String, String> {
+        let output = Command::new("sudo")
+            .arg("cat")
+            .arg("/sys/kernel/tracing/user_events_status")
+            .output()
+            .map_err(|e| format!("Failed to execute command: {e}"))?;
+
+        if output.status.success() {
+            let status = String::from_utf8_lossy(&output.stdout);
+            Ok(status.to_string())
+        } else {
+            Err(format!(
+                "Command executed with failing error code: {}",
+                String::from_utf8_lossy(&output.stderr)
+            ))
+        }
+    }
+}
+
+impl Drop for UserEventsListenerGuard {
+    fn drop(&mut self) {
+        let disable_path = format!("/sys/kernel/debug/tracing/events/user_events/{}_L2K1/enable", self.provider_name);
+
+        // Only disable if it wasn't already enabled
+        if !self.was_enabled {
+            let disable_output = Command::new("sudo")
+                .arg("sh")
+                .arg("-c")
+                .arg(format!("echo 0 | sudo tee {}", disable_path))
+                .output();
+
+            match disable_output {
+                Ok(output) if output.status.success() => {
+                    println!("User events listener disabled for provider: {}", self.provider_name);
+                }
+                Ok(output) => {
+                    eprintln!("Failed to disable listener. Error: {}", 
+                        String::from_utf8_lossy(&output.stderr));
+                }
+                Err(e) => {
+                    eprintln!("Failed to disable listener: {}", e);
+                }
+            }
+        } else {
+            println!("User events listener was already enabled, leaving enabled for provider: {}", self.provider_name);
+        }
+    }
+}
 
 #[cfg(feature = "experimental_eventname_callback")]
 struct EventNameFromLogRecordEventName;
@@ -97,6 +225,24 @@ where
 }
 
 fn benchmark_4_attributes(c: &mut Criterion) {
+    // Check if user events are available
+    if let Err(e) = UserEventsListenerGuard::check_user_events_available() {
+        eprintln!("Warning: User events not available: {}", e);
+        eprintln!("Benchmarks will run without listener enabled");
+    }
+
+    // Enable listener with RAII guard
+    let _guard = UserEventsListenerGuard::enable("myprovider")
+        .unwrap_or_else(|e| {
+            eprintln!("Warning: Failed to enable listener: {}", e);
+            eprintln!("Benchmarks will run without listener enabled");
+            // Return a dummy guard that does nothing on drop
+            UserEventsListenerGuard {
+                provider_name: "dummy".to_string(),
+                was_enabled: true,
+            }
+        });
+
     let provider = setup_provider_default();
     let ot_layer = tracing_layer::OpenTelemetryTracingBridge::new(&provider);
     let subscriber = Registry::default().with(ot_layer);
@@ -119,6 +265,24 @@ fn benchmark_4_attributes(c: &mut Criterion) {
 
 #[cfg(feature = "experimental_eventname_callback")]
 fn benchmark_4_attributes_event_name_custom(c: &mut Criterion) {
+    // Check if user events are available
+    if let Err(e) = UserEventsListenerGuard::check_user_events_available() {
+        eprintln!("Warning: User events not available: {}", e);
+        eprintln!("Benchmarks will run without listener enabled");
+    }
+
+    // Enable listener with RAII guard
+    let _guard = UserEventsListenerGuard::enable("myprovider")
+        .unwrap_or_else(|e| {
+            eprintln!("Warning: Failed to enable listener: {}", e);
+            eprintln!("Benchmarks will run without listener enabled");
+            // Return a dummy guard that does nothing on drop
+            UserEventsListenerGuard {
+                provider_name: "dummy".to_string(),
+                was_enabled: true,
+            }
+        });
+
     let provider = setup_provider_with_callback(EventNameFromLogRecordCustom);
     let ot_layer = tracing_layer::OpenTelemetryTracingBridge::new(&provider);
     let subscriber = Registry::default().with(ot_layer);
@@ -141,6 +305,24 @@ fn benchmark_4_attributes_event_name_custom(c: &mut Criterion) {
 
 #[cfg(feature = "experimental_eventname_callback")]
 fn benchmark_4_attributes_event_name_from_log_record(c: &mut Criterion) {
+    // Check if user events are available
+    if let Err(e) = UserEventsListenerGuard::check_user_events_available() {
+        eprintln!("Warning: User events not available: {}", e);
+        eprintln!("Benchmarks will run without listener enabled");
+    }
+
+    // Enable listener with RAII guard
+    let _guard = UserEventsListenerGuard::enable("myprovider")
+        .unwrap_or_else(|e| {
+            eprintln!("Warning: Failed to enable listener: {}", e);
+            eprintln!("Benchmarks will run without listener enabled");
+            // Return a dummy guard that does nothing on drop
+            UserEventsListenerGuard {
+                provider_name: "dummy".to_string(),
+                was_enabled: true,
+            }
+        });
+
     let provider = setup_provider_with_callback(EventNameFromLogRecordEventName);
     let ot_layer = tracing_layer::OpenTelemetryTracingBridge::new(&provider);
     let subscriber = Registry::default().with(ot_layer);
@@ -162,6 +344,24 @@ fn benchmark_4_attributes_event_name_from_log_record(c: &mut Criterion) {
 }
 
 fn benchmark_6_attributes(c: &mut Criterion) {
+    // Check if user events are available
+    if let Err(e) = UserEventsListenerGuard::check_user_events_available() {
+        eprintln!("Warning: User events not available: {}", e);
+        eprintln!("Benchmarks will run without listener enabled");
+    }
+
+    // Enable listener with RAII guard
+    let _guard = UserEventsListenerGuard::enable("myprovider")
+        .unwrap_or_else(|e| {
+            eprintln!("Warning: Failed to enable listener: {}", e);
+            eprintln!("Benchmarks will run without listener enabled");
+            // Return a dummy guard that does nothing on drop
+            UserEventsListenerGuard {
+                provider_name: "dummy".to_string(),
+                was_enabled: true,
+            }
+        });
+
     let provider = setup_provider_default();
     let ot_layer = tracing_layer::OpenTelemetryTracingBridge::new(&provider);
     let subscriber = Registry::default().with(ot_layer);