From 118dd477501cb37d8eebfb4c6685da8f8d039290 Mon Sep 17 00:00:00 2001 From: Chris Cassano Date: Tue, 25 Nov 2025 15:51:52 -0800 Subject: [PATCH 1/7] feat: privacy mode first pass --- rust/lit-actions/cli/main.rs | 2 + rust/lit-node/lit-node/src/git_info.rs | 2 +- rust/lit-node/lit-node/src/main.rs | 8 ++ .../lit-node/lit-node/src/utils/rocket/mod.rs | 1 + .../lit-node/src/utils/rocket/privacy_mode.rs | 85 +++++++++++++++++++ .../lit-attestation-service/src/main.rs | 2 + rust/lit-os/lit-os-metrics/src/main.rs | 2 + 7 files changed, 101 insertions(+), 1 deletion(-) create mode 100644 rust/lit-node/lit-node/src/utils/rocket/privacy_mode.rs diff --git a/rust/lit-actions/cli/main.rs b/rust/lit-actions/cli/main.rs index f95bb0a..65d0cda 100644 --- a/rust/lit-actions/cli/main.rs +++ b/rust/lit-actions/cli/main.rs @@ -83,6 +83,8 @@ async fn init_observability(args: &Args) -> Result { &cfg, otel_resource.clone(), sdktrace::Config::default().with_resource(otel_resource.clone()), + #[cfg(feature = "proxy-collector")] + "lit-actions", ) .await .map_err(|e| anyhow::anyhow!("Failed to create OTEL providers: {}", e))?; diff --git a/rust/lit-node/lit-node/src/git_info.rs b/rust/lit-node/lit-node/src/git_info.rs index e7d0e87..ceeeca7 100644 --- a/rust/lit-node/lit-node/src/git_info.rs +++ b/rust/lit-node/lit-node/src/git_info.rs @@ -1 +1 @@ -pub const GIT_COMMIT_HASH: &str = "5caf4cb4b70f0ec3b5094e71785ce78421027805"; +pub const GIT_COMMIT_HASH: &str = "bc3891668f8441a1217a20343088e5067aa42188"; diff --git a/rust/lit-node/lit-node/src/main.rs b/rust/lit-node/lit-node/src/main.rs index 7b33938..a60caed 100644 --- a/rust/lit-node/lit-node/src/main.rs +++ b/rust/lit-node/lit-node/src/main.rs @@ -409,6 +409,7 @@ pub fn main() { }) })) .attach(metrics_fairings) + .attach(crate::utils::rocket::privacy_mode::privacy_mode_fairing()) .manage(cfg.clone()) .manage(resolver) .manage(tss_state.peer_state.clone()) @@ -487,10 +488,17 @@ async fn init_observability( cfg, otel_resource.clone(), sdktrace::Config::default().with_resource(otel_resource.clone()), + #[cfg(feature = "proxy-collector")] + PKG_NAME, ) .await .map_err(|e| unexpected_err(e, Some("failed to create OTEL providers: {:?}".into())))?; + // Add privacy mode layer to disable tracing when privacy_mode is enabled + // The privacy mode layer checks thread-local state set by the fairing + use tracing_subscriber::layer::SubscriberExt; + let subscriber = subscriber.with(crate::utils::rocket::privacy_mode::PrivacyModeLayer); + // Set globals global::set_text_map_propagator(TraceContextPropagator::new()); global::set_tracer_provider(tracing_provider); diff --git a/rust/lit-node/lit-node/src/utils/rocket/mod.rs b/rust/lit-node/lit-node/src/utils/rocket/mod.rs index 873678b..8f2ca59 100644 --- a/rust/lit-node/lit-node/src/utils/rocket/mod.rs +++ b/rust/lit-node/lit-node/src/utils/rocket/mod.rs @@ -1 +1,2 @@ pub mod guards; +pub mod privacy_mode; diff --git a/rust/lit-node/lit-node/src/utils/rocket/privacy_mode.rs b/rust/lit-node/lit-node/src/utils/rocket/privacy_mode.rs new file mode 100644 index 0000000..8939a82 --- /dev/null +++ b/rust/lit-node/lit-node/src/utils/rocket/privacy_mode.rs @@ -0,0 +1,85 @@ +use rocket::Request; +use rocket::fairing::AdHoc; +use tracing::info; + +thread_local! { + static PRIVACY_MODE: std::cell::Cell = std::cell::Cell::new(false); +} + +/// Extract privacy_mode from query parameters or headers +fn extract_privacy_mode(req: &Request<'_>) -> bool { + // Check query parameters first + if let Some(privacy_mode) = req.query_value::("privacy_mode") { + if let Ok(true) = privacy_mode { + return true; + } + } + + // Check headers + if let Some(privacy_mode_header) = req.headers().get_one("X-Privacy-Mode") { + if privacy_mode_header.eq_ignore_ascii_case("true") || privacy_mode_header == "1" { + return true; + } + } + + false +} + +/// Check if privacy mode is enabled for the current request +pub fn is_privacy_mode_enabled() -> bool { + PRIVACY_MODE.with(|cell| cell.get()) +} + +/// Create a fairing that sets privacy mode state for the request +pub fn privacy_mode_fairing() -> impl rocket::fairing::Fairing { + AdHoc::on_request("Privacy Mode", |req, _| { + Box::pin(async move { + let privacy_enabled = extract_privacy_mode(req); + + // If privacy mode is enabled, log just the endpoint path for metrics + // This must happen before we set privacy mode, otherwise the log will be filtered + if privacy_enabled { + let method = req.method().as_str(); + let path = req.uri().path().as_str(); + info!(method = method, path = path, "privacy_mode_request"); + } + + // Store in thread-local state so the tracing layer can check it + PRIVACY_MODE.with(|cell| cell.set(privacy_enabled)); + }) + }) +} + +/// A tracing layer that filters out all events and spans when privacy mode is enabled +pub struct PrivacyModeLayer; + +impl tracing_subscriber::Layer for PrivacyModeLayer +where + S: tracing::Subscriber, +{ + fn enabled( + &self, + _metadata: &tracing::Metadata<'_>, + _ctx: tracing_subscriber::layer::Context<'_, S>, + ) -> bool { + // Disable all tracing when privacy mode is enabled + !is_privacy_mode_enabled() + } + + fn on_event( + &self, + _event: &tracing::Event<'_>, + _ctx: tracing_subscriber::layer::Context<'_, S>, + ) { + // Events are filtered by enabled() above + } + + fn on_new_span( + &self, + _attrs: &tracing::span::Attributes<'_>, + _id: &tracing::span::Id, + _ctx: tracing_subscriber::layer::Context<'_, S>, + ) { + // Spans are filtered by enabled() above + } +} diff --git a/rust/lit-os/lit-attestation-service/src/main.rs b/rust/lit-os/lit-attestation-service/src/main.rs index 55efa62..c9ae988 100644 --- a/rust/lit-os/lit-attestation-service/src/main.rs +++ b/rust/lit-os/lit-attestation-service/src/main.rs @@ -51,6 +51,8 @@ async fn init_observability(cfg: &LitConfig) -> Result<(SdkMeterProvider, Logger cfg, otel_resource.clone(), sdktrace::Config::default().with_resource(otel_resource.clone()), + #[cfg(feature = "proxy-collector")] + PKG_NAME, ) .await .map_err(|e| unexpected_err(e, Some("failed to create OTEL providers: {:?}".into())))?; diff --git a/rust/lit-os/lit-os-metrics/src/main.rs b/rust/lit-os/lit-os-metrics/src/main.rs index 264fe2e..5a55cd6 100644 --- a/rust/lit-os/lit-os-metrics/src/main.rs +++ b/rust/lit-os/lit-os-metrics/src/main.rs @@ -177,6 +177,8 @@ async fn init_observability( cfg, otel_resource.clone(), sdktrace::Config::default().with_resource(otel_resource.clone()), + #[cfg(feature = "proxy-collector")] + PKG_NAME, ) .await .map_err(|e| unexpected_err(e, Some("Failed to create observability providers".into())))?; From f86a48436eead3c3afee9fde2c1f2d87d249e8ba Mon Sep 17 00:00:00 2001 From: Chris Cassano Date: Tue, 25 Nov 2025 16:08:57 -0800 Subject: [PATCH 2/7] add privacy mode test --- rust/lit-node/lit-node/src/git_info.rs | 2 +- .../lit-node/tests/integration/mod.rs | 1 + .../lit-node/tests/integration/tracing.rs | 256 ++++++++++++++++++ 3 files changed, 258 insertions(+), 1 deletion(-) create mode 100644 rust/lit-node/lit-node/tests/integration/tracing.rs diff --git a/rust/lit-node/lit-node/src/git_info.rs b/rust/lit-node/lit-node/src/git_info.rs index ceeeca7..5316eb1 100644 --- a/rust/lit-node/lit-node/src/git_info.rs +++ b/rust/lit-node/lit-node/src/git_info.rs @@ -1 +1 @@ -pub const GIT_COMMIT_HASH: &str = "bc3891668f8441a1217a20343088e5067aa42188"; +pub const GIT_COMMIT_HASH: &str = "118dd477501cb37d8eebfb4c6685da8f8d039290"; diff --git a/rust/lit-node/lit-node/tests/integration/mod.rs b/rust/lit-node/lit-node/tests/integration/mod.rs index 4fd75da..87a0bda 100644 --- a/rust/lit-node/lit-node/tests/integration/mod.rs +++ b/rust/lit-node/lit-node/tests/integration/mod.rs @@ -8,3 +8,4 @@ pub mod integration_tests; pub mod lit_actions; pub mod session_sigs; pub mod shadow; +pub mod tracing; diff --git a/rust/lit-node/lit-node/tests/integration/tracing.rs b/rust/lit-node/lit-node/tests/integration/tracing.rs new file mode 100644 index 0000000..6020597 --- /dev/null +++ b/rust/lit-node/lit-node/tests/integration/tracing.rs @@ -0,0 +1,256 @@ +use crate::common::auth_sig::get_session_sigs_for_auth; +use crate::common::lit_actions::execute_lit_action_session_sigs; +use lit_node_core::request::JsonExecutionRequest; +use lit_node_core::response::{GenericResponse, JsonExecutionResponse}; +use lit_node_core::{ + Invocation, LitAbility, LitResourceAbilityRequest, LitResourceAbilityRequestResource, + LitResourcePrefix, NodeSet, +}; +use lit_node_testnet::TestSetupBuilder; +use lit_node_testnet::node_collection::get_identity_pubkeys_from_node_set; +use rand::Rng; +use rand_core::OsRng; +use std::fs::File; +use std::io::{BufRead, BufReader, Seek}; +use tracing::info; + +#[tokio::test] +pub async fn test_privacy_mode_logging() { + crate::common::setup_logging(); + + info!("Starting privacy mode test"); + + // Setup testnet + let (_testnet, validator_collection, end_user) = TestSetupBuilder::default().build().await; + + let node_set = validator_collection.random_threshold_nodeset().await; + let node_set_map = get_identity_pubkeys_from_node_set(&node_set).await; + + let realm_id = ethers::types::U256::from(1); + let epoch = validator_collection + .actions() + .get_current_epoch(realm_id) + .await + .as_u64(); + + // Read the lit action script + let lit_action_code = + std::fs::read_to_string("./tests/lit_action_scripts/broadcast_and_collect.js") + .expect("failed to read broadcast_and_collect.js"); + let lit_action_code = data_encoding::BASE64.encode(lit_action_code.as_bytes()); + + let (pubkey, _token_id, _eth_address) = end_user.first_pkp().info(); + let mut js_params = serde_json::Map::new(); + js_params.insert("publicKey".to_string(), pubkey.into()); + + // Generate session sigs + let session_sigs_and_node_set = get_session_sigs_for_auth( + &node_set_map, + vec![LitResourceAbilityRequest { + resource: LitResourceAbilityRequestResource { + resource: "*".to_string(), + resource_prefix: LitResourcePrefix::LA.to_string(), + }, + ability: LitAbility::LitActionExecution.to_string(), + }], + Some(end_user.wallet.clone()), + None, + None, + ); + + // Get log readers for the nodes + let mut log_readers = validator_collection.log_readers(); + + // Test 1: Execute without privacy mode + info!("=== TEST 1: Executing lit action WITHOUT privacy mode ==="); + + // Get initial log positions + let initial_log_positions: Vec = log_readers + .iter_mut() + .map(|reader| reader.stream_position().unwrap_or(0)) + .collect(); + + let execute_resp_no_privacy = execute_lit_action_session_sigs( + Some(lit_action_code.clone()), + None, + Some(serde_json::Value::Object(js_params.clone())), + None, + &session_sigs_and_node_set, + epoch, + ) + .await + .expect("failed to execute lit action without privacy mode"); + + assert!(!execute_resp_no_privacy.is_empty()); + assert!(execute_resp_no_privacy[0].ok); + + // Wait a bit for logs to be written + tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await; + + // Read new logs from all nodes + let logs_no_privacy: Vec = log_readers + .iter_mut() + .enumerate() + .flat_map(|(idx, reader)| { + let start_pos = initial_log_positions.get(idx).copied().unwrap_or(0); + read_logs_from_reader(reader, start_pos) + }) + .collect(); + + info!("Logs without privacy mode: {} lines", logs_no_privacy.len()); + + // Verify we have some logs + assert!( + !logs_no_privacy.is_empty(), + "Should have logs without privacy mode" + ); + + // Check for some expected log content (like endpoint paths, execution info, etc.) + let has_endpoint_log = logs_no_privacy + .iter() + .any(|line| line.contains("/web/execute") || line.contains("POST /web/execute")); + assert!(has_endpoint_log, "Should have endpoint logs"); + + // Test 2: Execute WITH privacy mode using header + info!("=== TEST 2: Executing lit action WITH privacy mode (header) ==="); + + // Get log positions before privacy mode request + let log_positions_before_privacy: Vec = log_readers + .iter_mut() + .map(|reader| reader.stream_position().unwrap_or(0)) + .collect(); + + // Execute with privacy mode using custom header + // We need to manually construct the request with the privacy mode header + let nodes: Vec = session_sigs_and_node_set + .iter() + .map(|sig_and_nodeset| sig_and_nodeset.node.clone()) + .collect(); + + let my_private_key = OsRng.r#gen(); + let mut execute_request = lit_sdk::ExecuteFunctionRequest::new() + .url_prefix(lit_sdk::UrlPrefix::Http) + .add_custom_header("X-Privacy-Mode", "true") + .node_set( + session_sigs_and_node_set + .iter() + .map(|sig_and_nodeset| { + let execute_request = JsonExecutionRequest { + auth_sig: lit_node_core::AuthSigItem::Single( + sig_and_nodeset.session_sig.clone(), + ), + code: Some(lit_action_code.clone()), + ipfs_id: None, + js_params: Some(serde_json::Value::Object(js_params.clone())), + auth_methods: None, + epoch, + node_set: nodes.clone(), + invocation: Invocation::Sync, + }; + lit_sdk::EndpointRequest { + node_set: sig_and_nodeset.node.clone(), + identity_key: sig_and_nodeset.identity_key, + body: execute_request, + } + }) + .collect::>(), + ) + .build() + .expect("failed to build execute request"); + + let execute_resp_privacy = execute_request + .send(&my_private_key) + .await + .expect("failed to execute lit action with privacy mode"); + + let results: Vec> = + execute_resp_privacy.results().to_owned(); + assert!(!results.is_empty()); + assert!(results[0].ok); + + // Wait a bit for logs to be written + tokio::time::sleep(tokio::time::Duration::from_millis(1000)).await; + + // Read new logs from all nodes + let logs_with_privacy: Vec = log_readers + .iter_mut() + .enumerate() + .flat_map(|(idx, reader)| { + let start_pos = log_positions_before_privacy.get(idx).copied().unwrap_or(0); + read_logs_from_reader(reader, start_pos) + }) + .collect(); + + info!("Logs with privacy mode: {} lines", logs_with_privacy.len()); + + // Verify we have the privacy mode endpoint log + let has_privacy_endpoint_log = logs_with_privacy.iter().any(|line| { + line.contains("privacy_mode_request") + || (line.contains("method") && line.contains("path") && line.contains("POST")) + }); + assert!( + has_privacy_endpoint_log, + "Should have privacy_mode_request log" + ); + + // Verify that detailed logs are filtered out + // Check that we don't have detailed execution logs that were present without privacy mode + let has_detailed_execution_logs = logs_with_privacy.iter().any(|line| { + // Look for logs that would contain sensitive execution details + // Exclude the privacy_mode_request log from this check + !line.contains("privacy_mode_request") + && (line.contains("executing lit action") + || line.contains("POST /web/execute/v2") + || (line.contains("execute") && (line.contains("debug") || line.contains("trace")))) + }); + + // We should NOT have detailed execution logs when privacy mode is on + assert!( + !has_detailed_execution_logs, + "Should not have detailed execution logs when privacy mode is enabled" + ); + + // Filter out privacy_mode_request logs for content comparison + let non_privacy_logs: Vec<_> = logs_with_privacy + .iter() + .filter(|line| !line.contains("privacy_mode_request")) + .collect(); + + info!("Non-privacy logs count: {}", non_privacy_logs.len()); + + // Compare: logs without privacy should have more content than logs with privacy + // (excluding the privacy_mode_request log) + let no_privacy_content: usize = logs_no_privacy.iter().map(|l| l.len()).sum(); + let with_privacy_content: usize = non_privacy_logs.iter().map(|l| l.len()).sum(); + + info!("Content length without privacy: {}", no_privacy_content); + info!( + "Content length with privacy (excluding privacy_mode_request): {}", + with_privacy_content + ); + + assert!( + no_privacy_content > with_privacy_content, + "Logs with privacy mode should have less content than without privacy mode. \ + No privacy: {}, With privacy: {}", + no_privacy_content, + with_privacy_content + ); + + info!("Privacy mode test completed successfully"); +} + +fn read_logs_from_reader(reader: &mut BufReader, start_position: u64) -> Vec { + // Seek to start position + if reader + .seek(std::io::SeekFrom::Start(start_position)) + .is_err() + { + return Vec::new(); + } + + reader + .lines() + .map(|line| line.unwrap_or_default()) + .collect() +} From 0732c2dbea89200037de01e6e9dd859b8494cbd3 Mon Sep 17 00:00:00 2001 From: Chris Cassano Date: Tue, 25 Nov 2025 16:24:07 -0800 Subject: [PATCH 3/7] clippy fix --- rust/lit-node/lit-node/src/git_info.rs | 2 +- rust/lit-node/lit-node/src/utils/rocket/privacy_mode.rs | 8 +++----- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/rust/lit-node/lit-node/src/git_info.rs b/rust/lit-node/lit-node/src/git_info.rs index 5316eb1..17c33ab 100644 --- a/rust/lit-node/lit-node/src/git_info.rs +++ b/rust/lit-node/lit-node/src/git_info.rs @@ -1 +1 @@ -pub const GIT_COMMIT_HASH: &str = "118dd477501cb37d8eebfb4c6685da8f8d039290"; +pub const GIT_COMMIT_HASH: &str = "9fa058d074c49194725a75b99f23a40cbd072474"; diff --git a/rust/lit-node/lit-node/src/utils/rocket/privacy_mode.rs b/rust/lit-node/lit-node/src/utils/rocket/privacy_mode.rs index 8939a82..781ebbd 100644 --- a/rust/lit-node/lit-node/src/utils/rocket/privacy_mode.rs +++ b/rust/lit-node/lit-node/src/utils/rocket/privacy_mode.rs @@ -3,16 +3,14 @@ use rocket::fairing::AdHoc; use tracing::info; thread_local! { - static PRIVACY_MODE: std::cell::Cell = std::cell::Cell::new(false); + static PRIVACY_MODE: std::cell::Cell = const { std::cell::Cell::new(false) }; } /// Extract privacy_mode from query parameters or headers fn extract_privacy_mode(req: &Request<'_>) -> bool { // Check query parameters first - if let Some(privacy_mode) = req.query_value::("privacy_mode") { - if let Ok(true) = privacy_mode { - return true; - } + if let Some(Ok(true)) = req.query_value::("privacy_mode") { + return true; } // Check headers From 1d7c31f763786f38d01ed9a660ec2c96d7028a52 Mon Sep 17 00:00:00 2001 From: Chris Cassano Date: Tue, 25 Nov 2025 16:32:03 -0800 Subject: [PATCH 4/7] no need to mint a pkp, removed that --- rust/lit-node/lit-node/tests/integration/tracing.rs | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/rust/lit-node/lit-node/tests/integration/tracing.rs b/rust/lit-node/lit-node/tests/integration/tracing.rs index 6020597..8d77b90 100644 --- a/rust/lit-node/lit-node/tests/integration/tracing.rs +++ b/rust/lit-node/lit-node/tests/integration/tracing.rs @@ -38,10 +38,7 @@ pub async fn test_privacy_mode_logging() { std::fs::read_to_string("./tests/lit_action_scripts/broadcast_and_collect.js") .expect("failed to read broadcast_and_collect.js"); let lit_action_code = data_encoding::BASE64.encode(lit_action_code.as_bytes()); - - let (pubkey, _token_id, _eth_address) = end_user.first_pkp().info(); - let mut js_params = serde_json::Map::new(); - js_params.insert("publicKey".to_string(), pubkey.into()); + let js_params = serde_json::Map::new(); // Generate session sigs let session_sigs_and_node_set = get_session_sigs_for_auth( @@ -128,7 +125,7 @@ pub async fn test_privacy_mode_logging() { .collect(); let my_private_key = OsRng.r#gen(); - let mut execute_request = lit_sdk::ExecuteFunctionRequest::new() + let execute_request = lit_sdk::ExecuteFunctionRequest::new() .url_prefix(lit_sdk::UrlPrefix::Http) .add_custom_header("X-Privacy-Mode", "true") .node_set( From 4bd5c2353a3cbae2be1d9c18f8b9b23bc51cfa91 Mon Sep 17 00:00:00 2001 From: Chris Cassano Date: Tue, 25 Nov 2025 16:42:59 -0800 Subject: [PATCH 5/7] remove proxy-collector cfg flag in lit-node since it doesn't make sense there --- rust/lit-node/lit-node/src/main.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/rust/lit-node/lit-node/src/main.rs b/rust/lit-node/lit-node/src/main.rs index a60caed..6bb7a93 100644 --- a/rust/lit-node/lit-node/src/main.rs +++ b/rust/lit-node/lit-node/src/main.rs @@ -488,8 +488,6 @@ async fn init_observability( cfg, otel_resource.clone(), sdktrace::Config::default().with_resource(otel_resource.clone()), - #[cfg(feature = "proxy-collector")] - PKG_NAME, ) .await .map_err(|e| unexpected_err(e, Some("failed to create OTEL providers: {:?}".into())))?; From 54b46e7cc07c3798584b61d79ea3175ed51d89e9 Mon Sep 17 00:00:00 2001 From: Chris Cassano Date: Tue, 25 Nov 2025 16:50:55 -0800 Subject: [PATCH 6/7] remove proxy-collector feature flagging from lit-actions --- rust/lit-actions/cli/main.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/rust/lit-actions/cli/main.rs b/rust/lit-actions/cli/main.rs index 65d0cda..f95bb0a 100644 --- a/rust/lit-actions/cli/main.rs +++ b/rust/lit-actions/cli/main.rs @@ -83,8 +83,6 @@ async fn init_observability(args: &Args) -> Result { &cfg, otel_resource.clone(), sdktrace::Config::default().with_resource(otel_resource.clone()), - #[cfg(feature = "proxy-collector")] - "lit-actions", ) .await .map_err(|e| anyhow::anyhow!("Failed to create OTEL providers: {}", e))?; From 6aba6dae718f0d7f1393f2524d7929fb96bc64a9 Mon Sep 17 00:00:00 2001 From: Chris Cassano Date: Tue, 25 Nov 2025 16:52:00 -0800 Subject: [PATCH 7/7] remove proxy-collector feature flag from more projects --- rust/lit-os/lit-attestation-service/src/main.rs | 2 -- rust/lit-os/lit-os-metrics/src/main.rs | 2 -- 2 files changed, 4 deletions(-) diff --git a/rust/lit-os/lit-attestation-service/src/main.rs b/rust/lit-os/lit-attestation-service/src/main.rs index c9ae988..55efa62 100644 --- a/rust/lit-os/lit-attestation-service/src/main.rs +++ b/rust/lit-os/lit-attestation-service/src/main.rs @@ -51,8 +51,6 @@ async fn init_observability(cfg: &LitConfig) -> Result<(SdkMeterProvider, Logger cfg, otel_resource.clone(), sdktrace::Config::default().with_resource(otel_resource.clone()), - #[cfg(feature = "proxy-collector")] - PKG_NAME, ) .await .map_err(|e| unexpected_err(e, Some("failed to create OTEL providers: {:?}".into())))?; diff --git a/rust/lit-os/lit-os-metrics/src/main.rs b/rust/lit-os/lit-os-metrics/src/main.rs index 5a55cd6..264fe2e 100644 --- a/rust/lit-os/lit-os-metrics/src/main.rs +++ b/rust/lit-os/lit-os-metrics/src/main.rs @@ -177,8 +177,6 @@ async fn init_observability( cfg, otel_resource.clone(), sdktrace::Config::default().with_resource(otel_resource.clone()), - #[cfg(feature = "proxy-collector")] - PKG_NAME, ) .await .map_err(|e| unexpected_err(e, Some("Failed to create observability providers".into())))?;