feat: auto listener benchmark

opentelemetry-user-events-logs/CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## vNext
 
+
 ## v0.14.0
 
 Released 2025-July-24

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,161 @@ use opentelemetry_user_events_logs::Processor;
 use tracing::error;
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::Registry;
+use std::process::Command;
+
+const PROVIDER_NAME: &str = "myprovider";
+/// Suffix used by the kernel user_events provider naming in these benchmarks.
+/// Documented to avoid magic strings in path construction.
+const USER_EVENTS_PROVIDER_SUFFIX: &str = "_L2K1";
+
+/// 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/{}{}//enable",
+            provider_name, USER_EVENTS_PROVIDER_SUFFIX
+        ).replacen("//enable", "/enable", 1);
+
+        // 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 using a safe approach (no shell interpretation)
+        let mut enable_cmd = Command::new("sudo");
+        enable_cmd.arg("tee").arg(&enable_path);
+        enable_cmd.stdin(std::process::Stdio::piped());
+        let enable_output = enable_cmd
+            .spawn()
+            .and_then(|mut child| {
+                if let Some(stdin) = child.stdin.as_mut() {
+                    use std::io::Write;
+                    stdin.write_all(b"1\n")?;
+                }
+                child.wait_with_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)
+            ))
+        }
+    }
+
+    /// Create a dummy guard that performs no action on drop
+    ///
+    /// This is used when enabling the listener fails; it ensures the
+    /// benchmark can proceed without attempting to disable anything later.
+    fn dummy_guard() -> Self {
+        UserEventsListenerGuard {
+            provider_name: "dummy".to_string(),
+            was_enabled: true,
+        }
+    }
+}
+
+impl Drop for UserEventsListenerGuard {
+    fn drop(&mut self) {
+        let disable_path = format!(
+            "/sys/kernel/debug/tracing/events/user_events/{}{}//enable",
+            self.provider_name, USER_EVENTS_PROVIDER_SUFFIX
+        ).replacen("//enable", "/enable", 1);
+
+        // Only disable if it wasn't already enabled
+        if !self.was_enabled {
+            let mut disable_cmd = Command::new("sudo");
+            disable_cmd.arg("tee").arg(&disable_path);
+            disable_cmd.stdin(std::process::Stdio::piped());
+            match disable_cmd.spawn().and_then(|mut child| {
+                if let Some(stdin) = child.stdin.as_mut() {
+                    use std::io::Write;
+                    stdin.write_all(b"0\n")?;
+                }
+                child.wait_with_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;
@@ -64,7 +224,7 @@ impl EventNameCallback for EventNameFromLogRecordCustom {
 }
 
 fn setup_provider_default() -> SdkLoggerProvider {
-    let user_event_processor = Processor::builder("myprovider").build().unwrap();
+    let user_event_processor = Processor::builder(PROVIDER_NAME).build().unwrap();
 
     SdkLoggerProvider::builder()
         .with_resource(
@@ -81,7 +241,7 @@ fn setup_provider_with_callback<C>(event_name_callback: C) -> SdkLoggerProvider
 where
     C: EventNameCallback + 'static,
 {
-    let user_event_processor = Processor::builder("myprovider")
+    let user_event_processor = Processor::builder(PROVIDER_NAME)
         .with_event_name_callback(event_name_callback)
         .build()
         .unwrap();
@@ -97,7 +257,21 @@ 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");
+    }
+
     let provider = setup_provider_default();
+    // Enable listener with RAII guard (after provider is built so tracepoints exist)
+    let _guard = UserEventsListenerGuard::enable(PROVIDER_NAME)
+        .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::dummy_guard()
+        });
     let ot_layer = tracing_layer::OpenTelemetryTracingBridge::new(&provider);
     let subscriber = Registry::default().with(ot_layer);
 
@@ -119,7 +293,21 @@ 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");
+    }
+
     let provider = setup_provider_with_callback(EventNameFromLogRecordCustom);
+    // Enable listener with RAII guard (after provider is built so tracepoints exist)
+    let _guard = UserEventsListenerGuard::enable(PROVIDER_NAME)
+        .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::dummy_guard()
+        });
     let ot_layer = tracing_layer::OpenTelemetryTracingBridge::new(&provider);
     let subscriber = Registry::default().with(ot_layer);
 
@@ -141,7 +329,21 @@ 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");
+    }
+
     let provider = setup_provider_with_callback(EventNameFromLogRecordEventName);
+    // Enable listener with RAII guard (after provider is built so tracepoints exist)
+    let _guard = UserEventsListenerGuard::enable(PROVIDER_NAME)
+        .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::dummy_guard()
+        });
     let ot_layer = tracing_layer::OpenTelemetryTracingBridge::new(&provider);
     let subscriber = Registry::default().with(ot_layer);
 
@@ -162,7 +364,21 @@ 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");
+    }
+
     let provider = setup_provider_default();
+    // Enable listener with RAII guard (after provider is built so tracepoints exist)
+    let _guard = UserEventsListenerGuard::enable(PROVIDER_NAME)
+        .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::dummy_guard()
+        });
     let ot_layer = tracing_layer::OpenTelemetryTracingBridge::new(&provider);
     let subscriber = Registry::default().with(ot_layer);