[Logs] Initial draft to handle batch export into background thread

examples/self-diagnostics/src/main.rs

@@ -58,7 +58,7 @@ fn init_logger_provider() -> opentelemetry_sdk::logs::LoggerProvider {
                 .http()
                 .with_endpoint("http://localhost:4318/v1/logs"),
         )
-        .install_batch(opentelemetry_sdk::runtime::Tokio)
+        .install_batch()
         .unwrap();
     let cloned_provider = provider.clone();
 

opentelemetry-appender-log/examples/logs-basic.rs

@@ -16,7 +16,7 @@ async fn main() {
     let exporter = LogExporter::default();
     //Create a LoggerProvider and register the exporter
     let logger_provider = LoggerProvider::builder()
-        .with_log_processor(BatchLogProcessor::builder(exporter, runtime::Tokio).build())
+        .with_log_processor(BatchLogProcessor::builder(exporter).build())
         .build();
 
     // Setup Log Appender for the log crate.

opentelemetry-appender-tracing/src/layer.rs

@@ -296,7 +296,7 @@ mod tests {
     async fn batch_processor_no_deadlock() {
         let exporter: ReentrantLogExporter = ReentrantLogExporter;
         let logger_provider = LoggerProvider::builder()
-            .with_batch_exporter(exporter.clone(), opentelemetry_sdk::runtime::Tokio)
+            .with_batch_exporter(exporter.clone())
             .build();
 
         let layer = layer::OpenTelemetryTracingBridge::new(&logger_provider);

opentelemetry-otlp/examples/basic-otlp-http/src/main.rs

@@ -44,7 +44,7 @@ fn init_logs() -> Result<sdklogs::LoggerProvider, opentelemetry::logs::LogError>
                 .with_protocol(Protocol::HttpBinary) //can be changed to `Protocol::HttpJson` to export in JSON format
                 .with_endpoint("http://localhost:4318/v1/logs"),
         )
-        .install_batch(opentelemetry_sdk::runtime::Tokio)
+        .install_batch()
 }
 
 fn init_tracer_provider() -> Result<sdktrace::TracerProvider, TraceError> {

opentelemetry-otlp/examples/basic-otlp/src/main.rs

@@ -60,7 +60,7 @@ fn init_logs() -> Result<opentelemetry_sdk::logs::LoggerProvider, LogError> {
                 .tonic()
                 .with_endpoint("http://localhost:4317"),
         )
-        .install_batch(runtime::Tokio)
+        .install_batch()
 }
 
 #[tokio::main]

opentelemetry-otlp/src/logs.rs

@@ -12,10 +12,10 @@ use crate::{NoExporterConfig, OtlpPipeline};
 use async_trait::async_trait;
 use std::fmt::Debug;
 
-use opentelemetry::logs::{LogError, LogResult};
+use opentelemetry::logs::LogError;
 
 use opentelemetry_sdk::export::logs::LogBatch;
-use opentelemetry_sdk::{runtime::RuntimeChannel, Resource};
+use opentelemetry_sdk::Resource;
 
 /// Compression algorithm to use, defaults to none.
 pub const OTEL_EXPORTER_OTLP_LOGS_COMPRESSION: &str = "OTEL_EXPORTER_OTLP_LOGS_COMPRESSION";
@@ -99,7 +99,10 @@ impl LogExporter {
 
 #[async_trait]
 impl opentelemetry_sdk::export::logs::LogExporter for LogExporter {
-    async fn export(&mut self, batch: LogBatch<'_>) -> LogResult<()> {
+    async fn export(
+        &mut self,
+        batch: LogBatch<'_>,
+    ) -> opentelemetry::logs::LogResult<()> {
         self.client.export(batch).await
     }
 
@@ -165,14 +168,12 @@ impl OtlpLogPipeline<LogExporterBuilder> {
     /// Returns a [`LoggerProvider`].
     ///
     /// [`LoggerProvider`]: opentelemetry_sdk::logs::LoggerProvider
-    pub fn install_batch<R: RuntimeChannel>(
+    pub fn install_batch(
         self,
-        runtime: R,
     ) -> Result<opentelemetry_sdk::logs::LoggerProvider, LogError> {
         Ok(build_batch_with_exporter(
             self.exporter_builder.build_log_exporter()?,
             self.resource,
-            runtime,
             self.batch_config,
         ))
     }
@@ -192,14 +193,13 @@ fn build_simple_with_exporter(
     provider_builder.build()
 }
 
-fn build_batch_with_exporter<R: RuntimeChannel>(
+fn build_batch_with_exporter(
     exporter: LogExporter,
     resource: Option<Resource>,
-    runtime: R,
     batch_config: Option<opentelemetry_sdk::logs::BatchConfig>,
 ) -> opentelemetry_sdk::logs::LoggerProvider {
     let mut provider_builder = opentelemetry_sdk::logs::LoggerProvider::builder();
-    let batch_processor = opentelemetry_sdk::logs::BatchLogProcessor::builder(exporter, runtime)
+    let batch_processor = opentelemetry_sdk::logs::BatchLogProcessor::builder(exporter)
         .with_batch_config(batch_config.unwrap_or_default())
         .build();
     provider_builder = provider_builder.with_log_processor(batch_processor);

opentelemetry-otlp/tests/integration_test/tests/logs.rs

@@ -5,7 +5,7 @@ use log::{info, Level};
 use opentelemetry::logs::LogError;
 use opentelemetry::KeyValue;
 use opentelemetry_appender_log::OpenTelemetryLogBridge;
-use opentelemetry_sdk::{logs as sdklogs, runtime, Resource};
+use opentelemetry_sdk::{logs as sdklogs, Resource};
 use std::error::Error;
 use std::fs::File;
 use std::os::unix::fs::MetadataExt;
@@ -18,7 +18,7 @@ fn init_logs() -> Result<sdklogs::LoggerProvider, LogError> {
             opentelemetry_semantic_conventions::resource::SERVICE_NAME,
             "logs-integration-test",
         )]))
-        .install_batch(runtime::Tokio)
+        .install_batch()
 }
 
 pub async fn logs() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {

opentelemetry-sdk/src/logs/log_emitter.rs

@@ -1,5 +1,5 @@
 use super::{BatchLogProcessor, LogProcessor, LogRecord, SimpleLogProcessor, TraceContext};
-use crate::{export::logs::LogExporter, runtime::RuntimeChannel, Resource};
+use crate::{export::logs::LogExporter, Resource};
 use opentelemetry::otel_warn;
 use opentelemetry::{
     global,
@@ -189,12 +189,11 @@ impl Builder {
     }
 
     /// The `LogExporter` setup using a default `BatchLogProcessor` that this provider should use.
-    pub fn with_batch_exporter<T: LogExporter + 'static, R: RuntimeChannel>(
+    pub fn with_batch_exporter<T: LogExporter + 'static>(
         self,
         exporter: T,
-        runtime: R,
     ) -> Self {
-        let batch = BatchLogProcessor::builder(exporter, runtime).build();
+        let batch = BatchLogProcessor::builder(exporter).build();
         self.with_log_processor(batch)
     }