update stress

Author: lalitb

stress/Cargo.toml

@@ -52,6 +52,7 @@ tracing-subscriber = { workspace = true, features = ["registry", "std"] }
 num-format = "0.4.4"
 sysinfo = { version = "0.32", optional = true }
 libc = "=0.2.164" # https://github.com/GuillaumeGomez/sysinfo/issues/1392
+futures-executor = { workspace = true }
 
 [features]
 stats = ["sysinfo"]

stress/src/logs.rs

@@ -11,36 +11,75 @@
 
 use opentelemetry::InstrumentationScope;
 use opentelemetry_appender_tracing::layer;
-use opentelemetry_sdk::logs::{LogProcessor, LoggerProvider};
+use opentelemetry_sdk::export::logs::{LogBatch, LogExporter};
+use opentelemetry_sdk::logs::{LogProcessor, LogResult, LoggerProvider};
+use std::{
+    os::unix::process,
+    sync::{Arc, Mutex},
+};
 use tracing::error;
 use tracing_subscriber::prelude::*;
 
 mod throughput;
 
+#[derive(Clone, Debug, Default)]
+pub struct SimpleExporter;
+
+impl LogExporter for SimpleExporter {
+    fn export<'a>(
+        &'a mut self,
+        _batch: &'a LogBatch<'a>,
+    ) -> impl std::future::Future<Output = LogResult<()>> + Send + 'a {
+        async { Ok(()) }
+    }
+}
+
 #[derive(Debug)]
-pub struct NoOpLogProcessor;
+pub struct NoOpLogProcessor {
+    exporter: Arc<Mutex<SimpleExporter>>,
+}
+
+impl NoOpLogProcessor {
+    pub fn new(exporter: SimpleExporter) -> Self {
+        Self {
+            exporter: Arc::new(Mutex::new(exporter)),
+        }
+    }
+}
 
 impl LogProcessor for NoOpLogProcessor {
-    fn emit(
-        &self,
-        _record: &mut opentelemetry_sdk::logs::LogRecord,
-        _scope: &InstrumentationScope,
-    ) {
+    fn emit(&self, record: &mut opentelemetry_sdk::logs::LogRecord, scope: &InstrumentationScope) {
+        let log_tuple = &[(record as &opentelemetry_sdk::logs::LogRecord, scope)];
+        let log_batch = LogBatch::new(log_tuple);
+
+        // Access the exporter using the Mutex
+        if let Ok(mut exporter) = self.exporter.lock() {
+            match futures_executor::block_on(exporter.export(&log_batch)) {
+                Err(err) => {
+                    eprintln!("Error: Export failed in NoOpLogProcessor. Error: {:?}", err);
+                }
+                _ => {}
+            }
+        } else {
+            eprintln!("Error: Failed to acquire lock on exporter.");
+        }
     }
 
-    fn force_flush(&self) -> opentelemetry_sdk::logs::LogResult<()> {
+    fn force_flush(&self) -> LogResult<()> {
         Ok(())
     }
 
-    fn shutdown(&self) -> opentelemetry_sdk::logs::LogResult<()> {
+    fn shutdown(&self) -> LogResult<()> {
         Ok(())
     }
 }
 
 fn main() {
+    let exporter = SimpleExporter::default();
+    let processor = NoOpLogProcessor::new(exporter);
     // LoggerProvider with a no-op processor.
     let provider: LoggerProvider = LoggerProvider::builder()
-        .with_log_processor(NoOpLogProcessor {})
+        .with_log_processor(processor)
         .build();
 
     // Use the OpenTelemetryTracingBridge to test the throughput of the appender-tracing.