feat(otlp-tracing): enable to export traces with grpc export with tracing-otlp and tracing-otlp-protocol arg

crates/ethereum/cli/Cargo.toml

@@ -23,11 +23,13 @@ reth-node-ethereum.workspace = true
 reth-node-metrics.workspace = true
 reth-rpc-server-types.workspace = true
 reth-tracing.workspace = true
+reth-tracing-otlp.workspace = true
 reth-node-api.workspace = true
 
 # misc
 clap.workspace = true
 eyre.workspace = true
+url.workspace = true
 tracing.workspace = true
 
 [dev-dependencies]

crates/ethereum/cli/src/app.rs

@@ -14,8 +14,10 @@ use reth_node_ethereum::{consensus::EthBeaconConsensus, EthEvmConfig, EthereumNo
 use reth_node_metrics::recorder::install_prometheus_recorder;
 use reth_rpc_server_types::RpcModuleValidator;
 use reth_tracing::{FileWorkerGuard, Layers};
+use reth_tracing_otlp::OtlpProtocol;
 use std::{fmt, sync::Arc};
 use tracing::info;
+use url::Url;
 
 /// A wrapper around a parsed CLI that handles command execution.
 #[derive(Debug)]
@@ -96,7 +98,8 @@ where
                 self.cli.logs.log_file_directory.join(chain_spec.chain().to_string());
         }
 
-        self.init_tracing()?;
+        self.init_tracing(&runner)?;
+
         // Install the prometheus recorder to be sure to record all metrics
         let _ = install_prometheus_recorder();
 
@@ -106,25 +109,55 @@ where
     /// Initializes tracing with the configured options.
     ///
     /// If file logging is enabled, this function stores guard to the struct.
-    pub fn init_tracing(&mut self) -> Result<()> {
+    /// For gRPC OTLP, it requires tokio runtime context.
+    pub fn init_tracing(&mut self, runner: &CliRunner) -> Result<()> {
         if self.guard.is_none() {
             let mut layers = self.layers.take().unwrap_or_default();
 
             #[cfg(feature = "otlp")]
-            if let Some(output_type) = &self.cli.traces.otlp {
-                info!(target: "reth::cli", "Starting OTLP tracing export to {:?}", output_type);
-                layers.with_span_layer(
-                    "reth".to_string(),
-                    output_type.clone(),
-                    self.cli.traces.otlp_filter.clone(),
-                )?;
+            {
+                self.cli.traces.validate()?;
+
+                if let Some(endpoint) = &self.cli.traces.otlp {
+                    info!(target: "reth::cli", "Starting OTLP tracing export to {:?}", endpoint);
+                    self.init_otlp_export(&mut layers, endpoint, runner)?;
+                }
             }
 
             self.guard = self.cli.logs.init_tracing_with_layers(layers)?;
             info!(target: "reth::cli", "Initialized tracing, debug log directory: {}", self.cli.logs.log_file_directory);
         }
         Ok(())
     }
+
+    /// Initialize OTLP tracing export based on protocol type.
+    ///
+    /// For gRPC, `block_on` is required because tonic's channel initialization needs
+    /// a tokio runtime context, even though `with_span_layer` itself is not async.
+    #[cfg(feature = "otlp")]
+    fn init_otlp_export(
+        &self,
+        layers: &mut Layers,
+        endpoint: &Url,
+        runner: &CliRunner,
+    ) -> Result<()> {
+        let endpoint = endpoint.clone();
+        let protocol = self.cli.traces.protocol;
+        let filter_level = self.cli.traces.otlp_filter.clone();
+
+        match protocol {
+            OtlpProtocol::Grpc => {
+                runner.block_on(async {
+                    layers.with_span_layer("reth".to_string(), endpoint, filter_level, protocol)
+                })?;
+            }
+            OtlpProtocol::Http => {
+                layers.with_span_layer("reth".to_string(), endpoint, filter_level, protocol)?;
+            }
+        }
+
+        Ok(())
+    }
 }
 
 /// Run CLI commands with the provided runner, components and launcher.

crates/node/core/Cargo.toml

@@ -59,8 +59,9 @@ url.workspace = true
 dirs-next.workspace = true
 shellexpand.workspace = true
 
-# tracing
+# obs
 tracing.workspace = true
+reth-tracing-otlp.workspace = true
 
 # crypto
 secp256k1 = { workspace = true, features = ["global-context", "std", "recovery"] }

crates/node/core/src/args/trace.rs

@@ -1,17 +1,19 @@
 //! Opentelemetry tracing configuration through CLI args.
 
 use clap::Parser;
-use eyre::{ensure, WrapErr};
+use eyre::WrapErr;
 use reth_tracing::tracing_subscriber::EnvFilter;
+use reth_tracing_otlp::OtlpProtocol;
 use url::Url;
 
 /// CLI arguments for configuring `Opentelemetry` trace and span export.
 #[derive(Debug, Clone, Parser)]
 pub struct TraceArgs {
-    /// Enable `Opentelemetry` tracing export to an OTLP endpoint. Currently
-    /// only http exporting is supported.
+    /// Enable `Opentelemetry` tracing export to an OTLP endpoint.
     ///
-    /// If no value provided, defaults to `http://localhost:4318/v1/traces`.
+    /// If no value provided, defaults based on protocol:
+    /// - HTTP: `http://localhost:4318/v1/traces`
+    /// - gRPC: `http://localhost:4317`
     ///
     /// Example: --tracing-otlp=http://collector:4318/v1/traces
     #[arg(
@@ -28,6 +30,22 @@ pub struct TraceArgs {
     )]
     pub otlp: Option<Url>,
 
+    /// OTLP transport protocol to use for exporting traces.
+    ///
+    /// - `http`: expects endpoint path to end with `/v1/traces`
+    /// - `grpc`: expects endpoint without a path
+    ///
+    /// Defaults to HTTP if not specified.
+    #[arg(
+        long = "tracing-otlp-protocol",
+        env = "OTEL_EXPORTER_OTLP_PROTOCOL",
+        global = true,
+        value_name = "PROTOCOL",
+        default_value = "http",
+        help_heading = "Tracing"
+    )]
+    pub protocol: OtlpProtocol,
+
     /// Set a filter directive for the OTLP tracer. This controls the verbosity
     /// of spans and events sent to the OTLP endpoint. It follows the same
     /// syntax as the `RUST_LOG` environment variable.
@@ -47,25 +65,25 @@ pub struct TraceArgs {
 
 impl Default for TraceArgs {
     fn default() -> Self {
-        Self { otlp: None, otlp_filter: EnvFilter::from_default_env() }
+        Self {
+            otlp: None,
+            protocol: OtlpProtocol::Http,
+            otlp_filter: EnvFilter::from_default_env(),
+        }
     }
 }
 
-// Parses and validates an OTLP endpoint url.
-fn parse_otlp_endpoint(arg: &str) -> eyre::Result<Url> {
-    let mut url = Url::parse(arg).wrap_err("Invalid URL for OTLP trace output")?;
-
-    // If the path is empty, we set the path.
-    if url.path() == "/" {
-        url.set_path("/v1/traces")
+impl TraceArgs {
+    /// Validate the configuration
+    pub fn validate(&mut self) -> eyre::Result<()> {
+        if let Some(url) = &mut self.otlp {
+            self.protocol.validate_endpoint(url)?;
+        }
+        Ok(())
     }
+}
 
-    // OTLP url must end with `/v1/traces` per the OTLP specification.
-    ensure!(
-        url.path().ends_with("/v1/traces"),
-        "OTLP trace endpoint must end with /v1/traces, got path: {}",
-        url.path()
-    );
-
-    Ok(url)
+// Parses an OTLP endpoint url.
+fn parse_otlp_endpoint(arg: &str) -> eyre::Result<Url> {
+    Url::parse(arg).wrap_err("Invalid URL for OTLP trace output")
 }

crates/optimism/cli/Cargo.toml

@@ -44,6 +44,7 @@ reth-optimism-evm.workspace = true
 reth-cli-runner.workspace = true
 reth-node-builder = { workspace = true, features = ["op"] }
 reth-tracing.workspace = true
+reth-tracing-otlp.workspace = true
 
 # eth
 alloy-eips.workspace = true
@@ -55,6 +56,7 @@ alloy-rlp.workspace = true
 futures-util.workspace = true
 derive_more.workspace = true
 serde.workspace = true
+url.workspace = true
 clap = { workspace = true, features = ["derive", "env"] }
 
 tokio = { workspace = true, features = ["sync", "macros", "time", "rt-multi-thread"] }
@@ -105,4 +107,5 @@ serde = [
     "reth-optimism-primitives/serde",
     "reth-primitives-traits/serde",
     "reth-optimism-chainspec/serde",
+    "url/serde",
 ]

crates/optimism/cli/src/app.rs

@@ -9,8 +9,10 @@ use reth_optimism_consensus::OpBeaconConsensus;
 use reth_optimism_node::{OpExecutorProvider, OpNode};
 use reth_rpc_server_types::RpcModuleValidator;
 use reth_tracing::{FileWorkerGuard, Layers};
+use reth_tracing_otlp::OtlpProtocol;
 use std::{fmt, sync::Arc};
 use tracing::info;
+use url::Url;
 
 /// A wrapper around a parsed CLI that handles command execution.
 #[derive(Debug)]
@@ -63,7 +65,8 @@ where
                 self.cli.logs.log_file_directory.join(chain_spec.chain.to_string());
         }
 
-        self.init_tracing()?;
+        self.init_tracing(&runner)?;
+
         // Install the prometheus recorder to be sure to record all metrics
         let _ = install_prometheus_recorder();
 
@@ -114,23 +117,52 @@ where
     /// Initializes tracing with the configured options.
     ///
     /// If file logging is enabled, this function stores guard to the struct.
-    pub fn init_tracing(&mut self) -> Result<()> {
+    /// For gRPC OTLP, it requires tokio runtime context.
+    pub fn init_tracing(&mut self, runner: &CliRunner) -> Result<()> {
         if self.guard.is_none() {
             let mut layers = self.layers.take().unwrap_or_default();
 
             #[cfg(feature = "otlp")]
-            if let Some(output_type) = &self.cli.traces.otlp {
-                info!(target: "reth::cli", "Starting OTLP tracing export to {:?}", output_type);
-                layers.with_span_layer(
-                    "reth".to_string(),
-                    output_type.clone(),
-                    self.cli.traces.otlp_filter.clone(),
-                )?;
+            {
+                self.cli.traces.validate()?;
+                if let Some(endpoint) = &self.cli.traces.otlp {
+                    info!(target: "reth::cli", "Starting OTLP tracing export to {:?}", endpoint);
+                    self.init_otlp_export(&mut layers, endpoint, runner)?;
+                }
             }
 
             self.guard = self.cli.logs.init_tracing_with_layers(layers)?;
             info!(target: "reth::cli", "Initialized tracing, debug log directory: {}", self.cli.logs.log_file_directory);
         }
         Ok(())
     }
+
+    /// Initialize OTLP tracing export based on protocol type.
+    ///
+    /// For gRPC, `block_on` is required because tonic's channel initialization needs
+    /// a tokio runtime context, even though `with_span_layer` itself is not async.
+    #[cfg(feature = "otlp")]
+    fn init_otlp_export(
+        &self,
+        layers: &mut Layers,
+        endpoint: &Url,
+        runner: &CliRunner,
+    ) -> Result<()> {
+        let endpoint = endpoint.clone();
+        let protocol = self.cli.traces.protocol;
+        let level_filter = self.cli.traces.otlp_filter.clone();
+
+        match protocol {
+            OtlpProtocol::Grpc => {
+                runner.block_on(async {
+                    layers.with_span_layer("reth".to_string(), endpoint, level_filter, protocol)
+                })?;
+            }
+            OtlpProtocol::Http => {
+                layers.with_span_layer("reth".to_string(), endpoint, level_filter, protocol)?;
+            }
+        }
+
+        Ok(())
+    }
 }