[DOCs/operators]: Release notes for v2025.19 kase (#6157)

* add release and operators notes

* bump up version

* fix location in csv to USA

* bump up stats

* typo fix

Cargo.toml

@@ -215,7 +215,6 @@ base64 = "0.22.1"
 base85rs = "0.1.3"
 bincode = "1.3.3"
 bip39 = { version = "2.0.0", features = ["zeroize"] }
-bit-vec = "0.7.0"                                     # can we unify those?
 bitvec = "1.0.0"
 blake3 = "1.7.0"
 bloomfilter = "3.0.1"
@@ -243,13 +242,11 @@ criterion = "0.5"
 csv = "1.3.1"
 ctr = "0.9.1"
 cupid = "0.6.1"
-curve25519-dalek = "4.1"
 dashmap = "5.5.3"
 # We want https://github.com/DefGuard/wireguard-rs/pull/64 , but there's no crates.io release being pushed out anymore
 defguard_wireguard_rs = { git = "https://github.com/DefGuard/wireguard-rs.git", rev = "v0.4.7" }
 digest = "0.10.7"
 dirs = "6.0"
-doc-comment = "0.3"
 dotenvy = "0.15.6"
 dyn-clone = "1.0.19"
 ecdsa = "0.16"
@@ -265,11 +262,8 @@ futures = "0.3.31"
 futures-util = "0.3"
 generic-array = "0.14.7"
 getrandom = "0.2.10"
-getset = "0.1.5"
 handlebars = "3.5.5"
-headers = "0.4.0"
 hex = "0.4.3"
-hex-literal = "0.3.3"
 hickory-resolver = "0.25"
 hkdf = "0.12.3"
 hmac = "0.12.1"
@@ -293,24 +287,18 @@ lazy_static = "1.5.0"
 ledger-transport = "0.10.0"
 ledger-transport-hid = "0.10.0"
 log = "0.4"
-maxminddb = "0.23.0"
 mime = "0.3.17"
 moka = { version = "0.12", features = ["future"] }
 nix = "0.27.1"
 notify = "5.1.0"
-okapi = "0.7.0"
 once_cell = "1.21.3"
-opentelemetry = "0.30.0"
-opentelemetry-otlp = "0.30.0"
-opentelemetry-semantic-conventions = "0.30.0"
-opentelemetry_sdk = "0.30.0"
-opentelemetry-stdout = "0.30.0"
+opentelemetry = "0.19.0"
+opentelemetry-jaeger = "0.18.0"
 parking_lot = "0.12.3"
 pem = "0.8"
 petgraph = "0.6.5"
 pin-project = "1.1"
 pnet_packet = "0.35.0"
-pin-project-lite = "0.2.16"
 publicsuffix = "2.3.0"
 proc_pidinfo = "0.1.3"
 quote = "1"
@@ -318,13 +306,10 @@ rand = "0.8.5"
 rand_chacha = "0.3"
 rand_core = "0.6.3"
 rand_distr = "0.4"
-rand_pcg = "0.3.1"
-rand_seeder = "0.2.3"
 rayon = "1.5.1"
 regex = "1.10.6"
 reqwest = { version = "0.12.15", default-features = false }
 rs_merkle = "1.5.0"
-safer-ffi = "0.1.13"
 schemars = "0.8.22"
 semver = "1.0.26"
 serde = "1.0.219"
@@ -363,16 +348,15 @@ toml = "0.8.22"
 tower = "0.5.2"
 tower-http = "0.5.2"
 tracing = "0.1.41"
-tracing-core = "0.1.33"
 tracing-log = "0.2"
-tracing-opentelemetry = "0.31.0"
-tracing-serde = "0.2.0"
+tracing-opentelemetry = "0.19.0"
 tracing-subscriber = "0.3.19"
 tracing-tree = "0.2.2"
 tracing-indicatif = "0.3.9"
 tracing-test = "0.2.5"
 ts-rs = "10.1.0"
 tungstenite = { version = "0.20.1", default-features = false }
+typed-builder = "0.23.0"
 uniffi = "0.29.2"
 uniffi_build = "0.29.0"
 url = "2.5"

clients/native/Cargo.toml

@@ -46,6 +46,7 @@ nym-bandwidth-controller = { path = "../../common/bandwidth-controller" }
 nym-bin-common = { path = "../../common/bin-common", features = [
     "output_format",
     "clap",
+    "basic_tracing",
 ] }
 nym-client-core = { path = "../../common/client-core", features = [
     "fs-credentials-storage",
@@ -70,11 +71,3 @@ nym-client-websocket-requests = { path = "websocket-requests" }
 nym-id = { path = "../../common/nym-id" }
 
 [dev-dependencies]
-
-[features]
-default = []
-otel = [
-    "nym-client-core/otel",
-    "nym-bin-common/otel",
-    "nym-gateway-requests/otel",
-]

clients/native/src/main.rs

@@ -4,7 +4,7 @@
 use std::error::Error;
 
 use clap::{crate_name, crate_version, Parser};
-use nym_bin_common::logging::{maybe_print_banner, setup_no_otel_logger};
+use nym_bin_common::logging::{maybe_print_banner, setup_tracing_logger};
 use nym_network_defaults::setup_env;
 
 pub mod client;
@@ -20,7 +20,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     if !args.no_banner {
         maybe_print_banner(crate_name!(), crate_version!());
     }
-    setup_no_otel_logger().expect("failed to initialize logging");
+    setup_tracing_logger();
 
     if let Err(err) = commands::execute(args).await {
         log::error!("{err}");

clients/native/src/websocket/handler.rs

@@ -184,14 +184,7 @@ impl Handler {
         });
 
         // the ack control is now responsible for chunking, etc.
-        let input_msg = InputMessage::new_regular(
-            recipient,
-            message,
-            lane,
-            self.packet_type,
-            #[cfg(feature = "otel")]
-            None,
-        );
+        let input_msg = InputMessage::new_regular(recipient, message, lane, self.packet_type);
         if let Err(err) = self.msg_input.send(input_msg).await {
             if !self.shutdown_token.is_cancelled() {
                 error!("Failed to send message to the input buffer: {err}");
@@ -223,15 +216,8 @@ impl Handler {
             TransmissionLane::ConnectionId(id)
         });
 
-        let input_msg = InputMessage::new_anonymous(
-            recipient,
-            message,
-            reply_surbs,
-            lane,
-            self.packet_type,
-            #[cfg(feature = "otel")]
-            None,
-        );
+        let input_msg =
+            InputMessage::new_anonymous(recipient, message, reply_surbs, lane, self.packet_type);
         if let Err(err) = self.msg_input.send(input_msg).await {
             if !self.shutdown_token.is_cancelled() {
                 error!("Failed to send anonymous message to the input buffer: {err}");

clients/socks5/Cargo.toml

@@ -27,6 +27,7 @@ zeroize = { workspace = true }
 nym-bin-common = { path = "../../common/bin-common", features = [
     "output_format",
     "clap",
+    "basic_tracing",
 ] }
 nym-client-core = { path = "../../common/client-core", features = [
     "fs-credentials-storage",
@@ -53,7 +54,3 @@ nym-validator-client = { path = "../../common/client-libs/validator-client", fea
 [features]
 default = []
 eth = []
-otel = [
-    "nym-socks5-client-core/otel",
-    "nym-bin-common/otel",
-]

clients/socks5/src/main.rs

@@ -4,7 +4,7 @@
 use std::error::Error;
 
 use clap::{crate_name, crate_version, Parser};
-use nym_bin_common::logging::{maybe_print_banner, setup_no_otel_logger};
+use nym_bin_common::logging::{maybe_print_banner, setup_tracing_logger};
 use nym_network_defaults::setup_env;
 
 mod commands;
@@ -19,7 +19,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     if !args.no_banner {
         maybe_print_banner(crate_name!(), crate_version!());
     }
-    setup_no_otel_logger().expect("failed to initialize logging");
+    setup_tracing_logger();
 
     if let Err(err) = commands::execute(args).await {
         log::error!("{err}");

common/bin-common/Cargo.toml

@@ -8,30 +8,24 @@ license = { workspace = true }
 repository = { workspace = true }
 
 [dependencies]
-chrono = { workspace = true, optional = true }
-cfg-if = { workspace = true }
 clap = { workspace = true, features = ["derive"], optional = true }
 clap_complete = { workspace = true, optional = true }
 clap_complete_fig = { workspace = true, optional = true }
 const-str = { workspace = true }
-opentelemetry = { workspace = true, optional = true }
-opentelemetry-otlp = { workspace = true,features=["metrics", "grpc-tonic", "tls",
-    "tls-webpki-roots"], optional = true }
-opentelemetry-semantic-conventions = { workspace = true, features = ["semconv_experimental"], optional = true }
-opentelemetry-stdout = { workspace = true, features = ["trace", "metrics"], optional = true }
-opentelemetry_sdk = { workspace = true, optional = true }
-rand = { workspace = true, optional = true }
+log = { workspace = true }
 schemars = { workspace = true, features = ["preserve_order"], optional = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true, optional = true }
-thiserror = { workspace = true }
-tracing = { workspace = true }
-tracing-core = { workspace = true }
+
+## tracing
+tracing-subscriber = { workspace = true, features = ["env-filter"], optional = true }
+tracing-tree = { workspace = true, optional = true }
+tracing = { workspace = true, optional = true }
+opentelemetry-jaeger = { workspace = true, features = ["rt-tokio", "collector_client", "isahc_collector_client"], optional = true }
 tracing-opentelemetry = { workspace = true, optional = true }
-tracing-serde = { workspace = true }
-tracing-subscriber = { workspace = true, features = ["env-filter", "json"] }
-tracing-tree = { workspace = true }
 utoipa = { workspace = true, optional = true }
+opentelemetry = { workspace = true, features = ["rt-tokio"], optional = true }
+
 
 [build-dependencies]
 vergen = { workspace = true, features = ["build", "git", "gitcl", "rustc", "cargo"] }
@@ -41,17 +35,13 @@ default = []
 openapi = ["utoipa"]
 output_format = ["serde_json", "dep:clap"]
 bin_info_schema = ["schemars"]
-tokio-console = ["otel"]
-otel = [
-    "chrono",
+basic_tracing = ["dep:tracing", "tracing-subscriber"]
+tracing = [
+    "basic_tracing",
+    "tracing-tree",
+    "opentelemetry-jaeger",
     "tracing-opentelemetry",
     "opentelemetry",
-    "opentelemetry-otlp",
-    "opentelemetry-semantic-conventions",
-    "opentelemetry-stdout",
-    "opentelemetry_sdk",
-    "serde_json",
-    "rand",
 ]
 clap = ["dep:clap", "dep:clap_complete", "dep:clap_complete_fig"]
 models = []

common/bin-common/src/lib.rs

@@ -4,9 +4,6 @@
 pub mod build_information;
 pub mod logging;
 
-#[cfg(feature = "otel")]
-pub mod opentelemetry;
-
 #[cfg(feature = "clap")]
 pub mod completions;
 

common/bin-common/src/logging/error.rs

@@ -1,20 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-#[cfg(feature = "otel")]
-use opentelemetry_otlp::ExporterBuildError;
-
-#[derive(thiserror::Error, Debug)]
-pub enum TracingError {
-    #[error("tracing logger already initialised")]
-    TracingLoggerAlreadyInitialised,
-
-    #[error("Logging error: {0}")]
-    TracingTryInitError(tracing_subscriber::util::TryInitError),
-
-    #[cfg(feature = "otel")]
-    #[error("{0}")]
-    TracingExporterBuildError(#[from] ExporterBuildError),
-
-    #[error("{0}")]
-    TracingFilterParseError(#[from] tracing_subscriber::filter::ParseError),
-}

common/bin-common/src/logging/mod.rs

@@ -1,12 +1,19 @@
 // Copyright 2022-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-pub mod error;
-
-use error::TracingError;
 use serde::{Deserialize, Serialize};
 use std::io::IsTerminal;
-use tracing_subscriber::{filter::Directive, layer::SubscriberExt, util::SubscriberInitExt};
+
+#[cfg(feature = "tracing")]
+pub use opentelemetry;
+#[cfg(feature = "tracing")]
+pub use opentelemetry_jaeger;
+#[cfg(feature = "tracing")]
+pub use tracing_opentelemetry;
+#[cfg(feature = "tracing")]
+pub use tracing_subscriber;
+#[cfg(feature = "tracing")]
+pub use tracing_tree;
 
 #[derive(Debug, Default, Copy, Clone, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
@@ -15,6 +22,7 @@ pub struct LoggingSettings {
 }
 
 // don't call init so that we could attach additional layers
+#[cfg(feature = "basic_tracing")]
 pub fn build_tracing_logger() -> impl tracing_subscriber::layer::SubscriberExt {
     use tracing_subscriber::prelude::*;
 
@@ -23,6 +31,7 @@ pub fn build_tracing_logger() -> impl tracing_subscriber::layer::SubscriberExt {
         .with(default_tracing_env_filter())
 }
 
+#[cfg(feature = "basic_tracing")]
 pub fn default_tracing_env_filter() -> tracing_subscriber::filter::EnvFilter {
     if ::std::env::var("RUST_LOG").is_ok() {
         tracing_subscriber::filter::EnvFilter::from_default_env()
@@ -34,6 +43,7 @@ pub fn default_tracing_env_filter() -> tracing_subscriber::filter::EnvFilter {
     }
 }
 
+#[cfg(feature = "basic_tracing")]
 pub fn default_tracing_fmt_layer<S, W>(
     writer: W,
 ) -> impl tracing_subscriber::Layer<S> + Sync + Send + 'static
@@ -53,47 +63,45 @@ where
         .with_target(false)
 }
 
-/// Creates a tracing filter that sets more granular log levels for specific crates.
-/// This allows for finer control over logging verbosity.
-pub(crate) fn granual_filtered_env() -> Result<tracing_subscriber::filter::EnvFilter, TracingError>
-{
-    fn directive_checked(directive: impl Into<String>) -> Result<Directive, TracingError> {
-        directive.into().parse().map_err(From::from)
-    }
-
-    let mut filter = default_tracing_env_filter();
-
-    // these crates are more granularly filtered
-    let filter_crates = ["defguard_wireguard_rs"];
-    for crate_name in filter_crates {
-        filter = filter.add_directive(directive_checked(format!("{crate_name}=warn"))?);
-    }
-    Ok(filter)
-}
-
-pub fn setup_no_otel_logger() -> Result<(), TracingError> {
-    // Only set up if not already initialized
-    if tracing::dispatcher::has_been_set() {
-        // It shouldn't be - this is really checking that it is torn down between async command executions
-        return Err(TracingError::TracingLoggerAlreadyInitialised);
-    }
-
-    let registry = tracing_subscriber::registry()
-        .with(default_tracing_fmt_layer(std::io::stderr))
-        .with(granual_filtered_env()?);
-
-    registry
-        .try_init()
-        .map_err(|e| TracingError::TracingTryInitError(e))?;
-
-    Ok(())
+#[cfg(feature = "basic_tracing")]
+pub fn setup_tracing_logger() {
+    use tracing_subscriber::util::SubscriberInitExt;
+    build_tracing_logger().init()
 }
 
 // TODO: This has to be a macro, running it as a function does not work for the file_appender for some reason
+#[cfg(feature = "tracing")]
 #[macro_export]
 macro_rules! setup_tracing {
     ($service_name: expr) => {
-        setup_no_otel_logger()
+        use nym_bin_common::logging::tracing_subscriber::layer::SubscriberExt;
+        use nym_bin_common::logging::tracing_subscriber::util::SubscriberInitExt;
+
+        let registry = nym_bin_common::logging::tracing_subscriber::Registry::default()
+            .with(nym_bin_common::logging::tracing_subscriber::EnvFilter::from_default_env())
+            .with(
+                nym_bin_common::logging::tracing_tree::HierarchicalLayer::new(4)
+                    .with_targets(true)
+                    .with_bracketed_fields(true),
+            );
+
+        let tracer = nym_bin_common::logging::opentelemetry_jaeger::new_collector_pipeline()
+            .with_endpoint("http://44.199.230.10:14268/api/traces")
+            .with_service_name($service_name)
+            .with_isahc()
+            .with_trace_config(
+                nym_bin_common::logging::opentelemetry::sdk::trace::config().with_sampler(
+                    nym_bin_common::logging::opentelemetry::sdk::trace::Sampler::TraceIdRatioBased(
+                        0.1,
+                    ),
+                ),
+            )
+            .install_batch(nym_bin_common::logging::opentelemetry::runtime::Tokio)
+            .expect("Could not init tracer");
+
+        let telemetry = nym_bin_common::logging::tracing_opentelemetry::layer().with_tracer(tracer);
+
+        registry.with(telemetry).init();
     };
 }
 

common/bin-common/src/opentelemetry/compact_id_generator.rs

@@ -1,47 +0,0 @@
-use opentelemetry::trace::{SpanId, TraceId};
-use opentelemetry_sdk::trace::IdGenerator;
-use rand::RngCore;
-
-#[derive(Clone, Debug)]
-pub struct Compact13BytesIdGenerator;
-
-impl IdGenerator for Compact13BytesIdGenerator {
-    fn new_trace_id(&self) -> TraceId {
-        let mut rng = rand::thread_rng();
-        let mut bytes = [0u8; 16];
-
-        // Fill the first 13 bytes with random data
-        rng.fill_bytes(&mut bytes[0..12]);
-        // Set the last 4 bytes to zero
-        bytes[12] = 0;
-        bytes[13] = 0;
-        bytes[14] = 0;
-        bytes[15] = 0;
-
-        TraceId::from_bytes(bytes)
-    }
-
-    fn new_span_id(&self) -> SpanId {
-        let mut rng = rand::thread_rng();
-        let mut bytes = [0u8; 8];
-        rng.fill_bytes(&mut bytes);
-
-        SpanId::from_bytes(bytes)
-    }
-}
-
-pub fn compress_trace_id(trace_id: &TraceId) -> [u8; 12] {
-    let bytes = trace_id.to_bytes();
-
-    let mut compressed = [0u8; 12];
-    compressed.copy_from_slice(&bytes[0..12]);
-
-    compressed
-}
-
-pub fn decompress_trace_id(compressed: &[u8; 12]) -> [u8; 16] {
-    let mut bytes = [0u8; 16];
-    bytes[0..12].copy_from_slice(compressed);
-    bytes[12..].copy_from_slice(&[0u8; 4]);
-    bytes
-}

common/bin-common/src/opentelemetry/context.rs

@@ -1,155 +0,0 @@
-use opentelemetry::propagation::{Extractor, Injector, TextMapPropagator};
-use opentelemetry::trace::{SpanContext, TraceContextExt, TraceId};
-use opentelemetry::{Context, TraceFlags};
-use opentelemetry_sdk::{propagation::TraceContextPropagator, trace::IdGenerator};
-use std::collections::HashMap;
-use std::fmt::Display;
-use tracing::instrument;
-use tracing_opentelemetry::OpenTelemetrySpanExt;
-
-/// Make a Carrier for context propagation
-pub struct ContextCarrier {
-    data: HashMap<String, String>,
-}
-
-impl ContextCarrier {
-    pub fn new_empty() -> Self {
-        ContextCarrier {
-            data: HashMap::new(),
-        }
-    }
-
-    pub fn new_with_data(data: HashMap<String, String>) -> Self {
-        if data.is_empty() {
-            return ContextCarrier::new_empty();
-        }
-
-        ContextCarrier { data }
-    }
-
-    pub fn new_with_current_context(context: Context) -> Self {
-        let mut carrier = ContextCarrier::new_empty();
-        let propagator = TraceContextPropagator::new();
-        propagator.inject_context(&context, &mut carrier);
-        carrier
-    }
-
-    pub fn iter(&self) -> impl Iterator<Item = (&String, &String)> {
-        self.data.iter()
-    }
-
-    pub fn from_map(data: HashMap<String, String>) -> Self {
-        ContextCarrier { data }
-    }
-
-    pub fn into_map(self) -> HashMap<String, String> {
-        self.data
-    }
-
-    pub fn extract_trace_id(&self) -> Option<TraceId> {
-        self.get("traceparent").and_then(|tp| {
-            let parts: Vec<&str> = tp.split('-').collect();
-            if parts.len() == 4 {
-                TraceId::from_hex(parts[1]).ok()
-            } else {
-                None
-            }
-        })
-    }
-
-    pub fn extract_trace_id_into_bytes(&self) -> Option<[u8; 16]> {
-        self.extract_trace_id().map(|id| id.to_bytes())
-    }
-
-    pub fn extract_traceparent(&self) -> Option<String> {
-        self.get("traceparent").map(|s| s.to_string())
-    }
-}
-
-impl Injector for ContextCarrier {
-    fn set(&mut self, key: &str, value: String) {
-        self.data.insert(key.to_string(), value);
-    }
-}
-
-impl Extractor for ContextCarrier {
-    fn get(&self, key: &str) -> Option<&str> {
-        self.data.get(key).map(|s| s.as_str())
-    }
-
-    fn keys(&self) -> Vec<&str> {
-        self.data.keys().map(|k| k.as_str()).collect()
-    }
-}
-
-impl Display for ContextCarrier {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{:?}", self.data)
-    }
-}
-
-pub struct ManualContextPropagator {
-    pub root_span: tracing::Span,
-    pub trace_id: TraceId,
-}
-
-impl ManualContextPropagator {
-    #[instrument(skip_all, level = "debug")]
-    pub fn new(name: &str, context: HashMap<String, String>) -> Self {
-        let carrier = ContextCarrier::new_with_data(context);
-        let trace_id = match carrier.extract_trace_id() {
-            Some(id) => id,
-            None => Context::current().span().span_context().trace_id(),
-        };
-
-        let root_span_builder = new_span_context_with_id(trace_id.clone());
-
-        let root_span = tracing::info_span!("trace_root", name = %name, trace_id = %trace_id);
-        root_span.set_parent(root_span_builder);
-
-        ManualContextPropagator {
-            root_span,
-            trace_id,
-        }
-    }
-
-    #[instrument(skip_all, level = "debug")]
-    pub fn new_from_tid(name: &str, trace_id: TraceId) -> Self {
-        let root_span_builder = new_span_context_with_id(trace_id.clone());
-
-        let root_span = tracing::info_span!("trace_root", name = %name, trace_id = %trace_id);
-        root_span.set_parent(root_span_builder);
-
-        ManualContextPropagator {
-            root_span,
-            trace_id,
-        }
-    }
-
-    pub fn root_span(&self) -> &tracing::Span {
-        &self.root_span
-    }
-}
-
-#[instrument(skip_all, level = "debug")]
-pub fn new_span_context_with_id(trace_id: TraceId) -> Context {
-    let id_gen = opentelemetry_sdk::trace::RandomIdGenerator::default();
-    let span_id = id_gen.new_span_id();
-    let span_context = SpanContext::new(
-        trace_id,
-        span_id,
-        TraceFlags::SAMPLED,
-        true,
-        Default::default(),
-    );
-
-    Context::current().with_remote_span_context(span_context)
-}
-
-#[instrument(skip_all, level = "debug")]
-pub fn extract_trace_id_from_tracing_cx() -> TraceId {
-    let cx = tracing::Span::current().context();
-    let binding = cx.span();
-    let trace_id = binding.span_context().trace_id();
-    trace_id
-}

common/bin-common/src/opentelemetry/mod.rs

@@ -1,186 +0,0 @@
-pub mod compact_id_generator;
-pub mod context;
-mod trace_id_format;
-
-use tracing::{Level, info};
-use tracing_subscriber::filter::Directive;
-use tracing_subscriber::fmt;
-use tracing_subscriber::layer::SubscriberExt;
-use tracing_subscriber::util::SubscriberInitExt;
-
-use crate::logging::default_tracing_env_filter;
-use crate::logging::error::TracingError;
-use crate::opentelemetry::compact_id_generator::Compact13BytesIdGenerator;
-use opentelemetry::trace::TracerProvider;
-use opentelemetry::{KeyValue, global};
-use opentelemetry_otlp::tonic_types::metadata::MetadataMap;
-use opentelemetry_otlp::tonic_types::transport::ClientTlsConfig;
-use opentelemetry_otlp::{WithExportConfig, WithTonicConfig};
-use opentelemetry_sdk::metrics::{MeterProviderBuilder, PeriodicReader, SdkMeterProvider};
-use opentelemetry_sdk::trace::SdkTracerProvider;
-use opentelemetry_sdk::{Resource, trace::Sampler};
-use opentelemetry_semantic_conventions::SCHEMA_URL;
-use opentelemetry_semantic_conventions::resource::{DEPLOYMENT_ENVIRONMENT_NAME, SERVICE_VERSION};
-use tracing_opentelemetry::{MetricsLayer, OpenTelemetryLayer};
-use tracing_subscriber::fmt::format::FmtSpan;
-
-pub struct TracerProviderGuard(Option<SdkTracerProvider>);
-
-impl Drop for TracerProviderGuard {
-    fn drop(&mut self) {
-        if let Some(tracer_provider) = self.0.take() {
-            // Ensure all spans are flushed before exit
-            if let Err(e) = tracer_provider.shutdown() {
-                eprintln!("Error shutting down tracer provider: {:?}", e);
-            }
-        }
-    }
-}
-
-pub(crate) fn granual_filtered_env() -> Result<tracing_subscriber::filter::EnvFilter, TracingError>
-{
-    fn directive_checked(directive: impl Into<String>) -> Result<Directive, TracingError> {
-        directive.into().parse().map_err(From::from)
-    }
-
-    let mut filter = default_tracing_env_filter();
-
-    // these crates are more granularly filtered
-    let filter_crates = ["defguard_wireguard_rs"];
-    for crate_name in filter_crates {
-        filter = filter.add_directive(directive_checked(format!("{crate_name}=warn"))?);
-    }
-    Ok(filter)
-}
-
-pub fn setup_tracing_logger(service_name: String) -> Result<TracerProviderGuard, TracingError> {
-    if tracing::dispatcher::has_been_set() {
-        // It shouldn't be - this is really checking that it is torn down between async command executions
-        return Err(TracingError::TracingLoggerAlreadyInitialised);
-    }
-
-    // define ingestion points
-    let endpoint = std::env::var("SIGNOZ_ENDPOINT").expect("SIGNOZ_ENDPOINT not set");
-    let key = std::env::var("SIGNOZ_INGESTION_KEY").expect("SIGNOZ_INGESTION_KEY not set");
-    let mut metadata = MetadataMap::new();
-    metadata.insert(
-        "signoz-ingestion-key",
-        key.parse().expect("Could not parse signoz ingestion key"),
-    );
-
-    // Build resources
-    let resource = build_resource(&service_name);
-
-    // Initialize tracer and meter providers
-    let tracer_provider = init_tracer_provider(&endpoint, metadata.clone(), resource.clone())?;
-    let meter_provider = init_meter_provider(&endpoint, metadata.clone(), resource.clone())?;
-
-    // Bridge tracing and opentelemetry
-    let tracer = tracer_provider.tracer("otel-subscriber");
-    let fmt_layer = fmt::layer()
-        .json()
-        .with_writer(std::io::stderr)
-        .with_span_events(FmtSpan::NEW | FmtSpan::CLOSE)
-        .with_span_list(false)
-        .with_current_span(true)
-        .event_format(trace_id_format::TraceIdFormat);
-
-    let registry = tracing_subscriber::registry()
-        .with(fmt_layer)
-        .with(granual_filtered_env()?)
-        .with(tracing_subscriber::filter::LevelFilter::from_level(
-            Level::INFO,
-        ))
-        .with(MetricsLayer::new(meter_provider.clone()))
-        .with(OpenTelemetryLayer::new(tracer));
-
-    registry
-        .try_init()
-        .map_err(TracingError::TracingTryInitError)?;
-
-    global::set_tracer_provider(tracer_provider.clone());
-    global::set_meter_provider(meter_provider.clone());
-
-    info!("Tracing initialized with service name: {}", service_name);
-
-    Ok(TracerProviderGuard(Some(tracer_provider)))
-}
-
-fn build_resource(service_name: &str) -> Resource {
-    Resource::builder()
-        .with_service_name(service_name.to_string())
-        .with_schema_url(
-            [
-                KeyValue::new(SERVICE_VERSION, env!("CARGO_PKG_VERSION")),
-                KeyValue::new(DEPLOYMENT_ENVIRONMENT_NAME, "develop"),
-            ],
-            SCHEMA_URL,
-        )
-        .build()
-}
-
-fn init_tracer_provider(
-    endpoint: &str,
-    metadata: MetadataMap,
-    resource: Resource,
-) -> Result<SdkTracerProvider, TracingError> {
-    let mut exporter_builder = opentelemetry_otlp::SpanExporter::builder()
-        .with_tonic()
-        .with_metadata(metadata)
-        .with_endpoint(endpoint);
-
-    if endpoint.starts_with("https://") {
-        exporter_builder =
-            exporter_builder.with_tls_config(ClientTlsConfig::new().with_enabled_roots());
-    }
-
-    let exporter = exporter_builder.build()?;
-
-    let tracer = SdkTracerProvider::builder()
-        .with_sampler(Sampler::ParentBased(Box::new(Sampler::TraceIdRatioBased(
-            1.0,
-        ))))
-        .with_id_generator(Compact13BytesIdGenerator)
-        .with_resource(resource)
-        .with_batch_exporter(exporter)
-        .build();
-
-    global::set_tracer_provider(tracer.clone());
-    Ok(tracer)
-}
-
-fn init_meter_provider(
-    endpoint: &str,
-    metadata: MetadataMap,
-    resource: Resource,
-) -> Result<SdkMeterProvider, TracingError> {
-    let mut exporter_builder = opentelemetry_otlp::MetricExporter::builder()
-        .with_tonic()
-        .with_metadata(metadata)
-        .with_endpoint(endpoint)
-        .with_temporality(opentelemetry_sdk::metrics::Temporality::default());
-
-    if endpoint.starts_with("https://") {
-        exporter_builder =
-            exporter_builder.with_tls_config(ClientTlsConfig::new().with_enabled_roots());
-    }
-
-    let exporter = exporter_builder.build()?;
-
-    let reader = PeriodicReader::builder(exporter)
-        .with_interval(std::time::Duration::from_secs(30))
-        .build();
-
-    let stdout_reader =
-        PeriodicReader::builder(opentelemetry_stdout::MetricExporter::default()).build();
-
-    let meter_provider = MeterProviderBuilder::default()
-        .with_resource(resource)
-        .with_reader(reader)
-        .with_reader(stdout_reader)
-        .build();
-
-    global::set_meter_provider(meter_provider.clone());
-
-    Ok(meter_provider)
-}

common/bin-common/src/opentelemetry/trace_id_format.rs

@@ -1,88 +0,0 @@
-use chrono::Utc;
-use opentelemetry::trace::TraceContextExt;
-use opentelemetry::{SpanId, TraceId};
-use serde::ser::{SerializeMap, Serializer as _};
-use std::io;
-use tracing::{Event, Subscriber};
-use tracing_opentelemetry::OpenTelemetrySpanExt;
-use tracing_serde::AsSerde;
-use tracing_serde::fields::AsMap;
-use tracing_subscriber::fmt::format::Writer;
-use tracing_subscriber::fmt::{FmtContext, FormatEvent, FormatFields};
-use tracing_subscriber::registry::LookupSpan;
-
-pub struct WriteAdaptor<'a> {
-    fmt_write: &'a mut dyn std::fmt::Write,
-}
-
-impl<'a> WriteAdaptor<'a> {
-    pub fn new(fmt_write: &'a mut dyn std::fmt::Write) -> Self {
-        Self { fmt_write }
-    }
-}
-
-impl<'a> io::Write for WriteAdaptor<'a> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        let s =
-            std::str::from_utf8(buf).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
-
-        self.fmt_write
-            .write_str(s)
-            .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
-
-        Ok(s.as_bytes().len())
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-pub struct TraceIdFormat;
-
-impl<S, N> FormatEvent<S, N> for TraceIdFormat
-where
-    S: Subscriber + for<'lookup> LookupSpan<'lookup>,
-    N: for<'writer> FormatFields<'writer> + 'static,
-{
-    fn format_event(
-        &self,
-        _ctx: &FmtContext<'_, S, N>,
-        mut writer: Writer<'_>,
-        event: &Event<'_>,
-    ) -> std::fmt::Result
-    where
-        S: Subscriber + for<'a> LookupSpan<'a>,
-    {
-        let meta = event.metadata();
-
-        let mut visit = || {
-            let mut serializer = serde_json::Serializer::new(WriteAdaptor::new(&mut writer));
-            let mut serializer = serializer.serialize_map(None)?;
-            serializer.serialize_entry("timestamp", &Utc::now().to_rfc3339())?;
-            serializer.serialize_entry("level", &meta.level().as_serde())?;
-            serializer.serialize_entry("fields", &event.field_map())?;
-            serializer.serialize_entry("target", meta.target())?;
-
-            let current_span = tracing::Span::current();
-            let context = current_span.context();
-            let span_ref = context.span();
-            let span_context = span_ref.span_context();
-
-            let trace_id = span_context.trace_id();
-            if trace_id != TraceId::INVALID {
-                serializer.serialize_entry("trace_id", &trace_id.to_string())?;
-
-                let span_id = span_context.span_id();
-                if span_id != SpanId::INVALID {
-                    serializer.serialize_entry("span_id", &span_id.to_string())?;
-                }
-            }
-
-            serializer.end()
-        };
-
-        visit().map_err(|_| std::fmt::Error)?;
-        writeln!(writer)
-    }
-}

common/client-core/Cargo.toml

@@ -36,7 +36,7 @@ nym-bandwidth-controller = { path = "../bandwidth-controller" }
 nym-crypto = { path = "../crypto" }
 nym-gateway-client = { path = "../client-libs/gateway-client" }
 nym-gateway-requests = { path = "../gateway-requests" }
-nym-http-api-client = { path = "../http-api-client" }
+nym-http-api-client = { path = "../http-api-client", features = ["network-defaults"] }
 nym-nonexhaustive-delayqueue = { path = "../nonexhaustive-delayqueue" }
 nym-sphinx = { path = "../nymsphinx" }
 nym-statistics-common = { path = "../statistics" }
@@ -126,7 +126,6 @@ cli = ["clap", "comfy-table"]
 fs-credentials-storage = ["nym-credential-storage/persistent-storage"]
 fs-surb-storage = ["nym-client-core-surb-storage/fs-surb-storage"]
 fs-gateways-storage = ["nym-client-core-gateways-storage/fs-gateways-storage"]
-otel = ["nym-sphinx/otel"]
 wasm = ["nym-gateway-client/wasm"]
 metrics-server = []
 

common/client-core/src/client/base_client/mod.rs

@@ -67,13 +67,16 @@ use std::path::Path;
 use std::sync::Arc;
 use time::OffsetDateTime;
 use tokio::sync::mpsc::Sender;
-use tracing::instrument;
 use url::Url;
 
 #[cfg(target_arch = "wasm32")]
 #[cfg(debug_assertions)]
 use wasm_utils::console_log;
 
+/// Default number of retries for Nym API requests when using network details with domain fronting.
+/// This allows the client to try alternative URLs if the primary endpoint is unavailable.
+const DEFAULT_NYM_API_RETRIES: usize = 3;
+
 #[cfg(all(
     not(target_arch = "wasm32"),
     feature = "fs-surb-storage",
@@ -122,7 +125,6 @@ pub struct ClientOutput {
 }
 
 impl ClientOutput {
-    #[instrument(name = "ClientOutput::register_receiver", skip_all)]
     pub fn register_receiver(
         &mut self,
     ) -> Result<mpsc::UnboundedReceiver<Vec<ReconstructedMessage>>, ClientCoreError> {
@@ -214,6 +216,9 @@ pub struct BaseClientBuilder<C, S: MixnetClientStorage> {
     client_store: S,
     dkg_query_client: Option<C>,
 
+    // Optional API URLs for domain fronting support
+    nym_api_urls: Option<Vec<nym_network_defaults::ApiUrl>>,
+
     wait_for_gateway: bool,
     custom_topology_provider: Option<Box<dyn TopologyProvider + Send + Sync>>,
     custom_gateway_transceiver: Option<Box<dyn GatewayTransceiver + Send>>,
@@ -243,6 +248,7 @@ where
             config: base_config,
             client_store,
             dkg_query_client,
+            nym_api_urls: None,
             wait_for_gateway: false,
             custom_topology_provider: None,
             custom_gateway_transceiver: None,
@@ -265,6 +271,16 @@ where
         self
     }
 
+    /// Set Nym API URLs for domain fronting support.
+    ///
+    /// When provided, the client will use these API URLs (which include front_hosts)
+    /// to construct HTTP clients with domain fronting enabled.
+    #[must_use]
+    pub fn with_nym_api_urls(mut self, nym_api_urls: Vec<nym_network_defaults::ApiUrl>) -> Self {
+        self.nym_api_urls = Some(nym_api_urls);
+        self
+    }
+
     #[must_use]
     pub fn with_forget_me(mut self, forget_me: &ForgetMe) -> Self {
         self.config.debug.forget_me = *forget_me;
@@ -386,7 +402,6 @@ where
     }
 
     #[allow(clippy::too_many_arguments)]
-    #[instrument(skip_all)]
     fn start_real_traffic_controller(
         controller_config: real_messages_control::Config,
         key_rotation_config: KeyRotationConfig,
@@ -478,7 +493,6 @@ where
 
     // buffer controlling all messages fetched from provider
     // required so that other components would be able to use them (say the websocket)
-    #[instrument(skip_all)]
     fn start_received_messages_buffer_controller(
         local_encryption_keypair: Arc<x25519::KeyPair>,
         query_receiver: ReceivedBufferRequestReceiver,
@@ -511,7 +525,6 @@ where
     }
 
     #[allow(clippy::too_many_arguments)]
-    #[instrument(skip_all)]
     async fn start_gateway_client(
         config: &Config,
         initialisation_result: InitialisationResult,
@@ -618,7 +631,6 @@ where
     }
 
     #[allow(clippy::too_many_arguments)]
-    #[instrument(skip_all)]
     async fn setup_gateway_transceiver(
         custom_gateway_transceiver: Option<Box<dyn GatewayTransceiver + Send>>,
         config: &Config,
@@ -776,7 +788,7 @@ where
             shutdown_tracker,
         )
     }
-    #[instrument(skip_all)]
+
     fn start_mix_traffic_controller(
         gateway_transceiver: Box<dyn GatewayTransceiver + Send>,
         shutdown_tracker: &ShutdownTracker,
@@ -789,7 +801,7 @@ where
             event_tx,
         );
 
-        let mix_tx = mix_traffic_controller.mix_rx();
+        let mix_tx = mix_traffic_controller.mix_tx();
         let client_tx = mix_traffic_controller.client_tx();
 
         shutdown_tracker.try_spawn_named(
@@ -869,21 +881,67 @@ where
     }
 
     fn construct_nym_api_client(
+        nym_api_urls: Option<&Vec<nym_network_defaults::ApiUrl>>,
         config: &Config,
         user_agent: Option<UserAgent>,
     ) -> Result<nym_http_api_client::Client, ClientCoreError> {
+        tracing::debug!(
+            "construct_nym_api_client called with nym_api_urls: {}",
+            nym_api_urls.is_some()
+        );
+
+        // If API URLs are provided, use new_with_fronted_urls() which handles domain fronting
+        if let Some(nym_api_urls) = nym_api_urls {
+            if nym_api_urls.is_empty() {
+                tracing::warn!("Provided nym_api_urls is empty, falling back to config endpoints");
+            } else {
+                tracing::info!(
+                    "Building nym-api client from provided URLs (with domain fronting support): {} URLs",
+                    nym_api_urls.len()
+                );
+
+                let mut builder =
+                    nym_http_api_client::ClientBuilder::new_with_fronted_urls(nym_api_urls.clone())
+                        .map_err(ClientCoreError::from)?
+                        .with_retries(DEFAULT_NYM_API_RETRIES);
+
+                if let Some(user_agent) = user_agent {
+                    builder = builder.with_user_agent(user_agent);
+                }
+
+                return builder.build().map_err(ClientCoreError::from);
+            }
+        }
+
+        // Fallback to basic client for backwards compatibility
+        tracing::debug!("Building basic nym-api HTTP client from config endpoints");
+
         let mut nym_api_urls = config.get_nym_api_endpoints();
+        if nym_api_urls.is_empty() {
+            tracing::warn!("No API endpoints configured in config, this may cause issues");
+        }
         nym_api_urls.shuffle(&mut thread_rng());
 
-        let mut builder = nym_http_api_client::Client::builder(nym_api_urls[0].clone())
-            .map_err(ClientCoreError::from)?;
+        // Convert config URLs to ApiUrl format for consistency
+        let api_urls: Vec<nym_network_defaults::ApiUrl> = nym_api_urls
+            .into_iter()
+            .map(|url| nym_network_defaults::ApiUrl {
+                url: url.to_string(),
+                front_hosts: None,
+            })
+            .collect();
+
+        tracing::debug!("Using {} config API endpoints", api_urls.len());
+
+        let mut builder = nym_http_api_client::ClientBuilder::new_with_fronted_urls(api_urls)
+            .map_err(ClientCoreError::from)?
+            .with_retries(DEFAULT_NYM_API_RETRIES)
+            .with_bincode();
 
         if let Some(user_agent) = user_agent {
             builder = builder.with_user_agent(user_agent);
         }
 
-        builder = builder.with_bincode();
-
         builder.build().map_err(ClientCoreError::from)
     }
 
@@ -893,7 +951,6 @@ where
         Ok(client.get_key_rotation_info().await?.into())
     }
 
-    #[instrument(skip_all)]
     pub async fn start_base(mut self) -> Result<BaseClient, ClientCoreError>
     where
         S::ReplyStore: Send + Sync,
@@ -947,8 +1004,8 @@ where
         // Create a shutdown tracker for this client - either as a child of provided tracker
         // or get one from the registry
         let shutdown_tracker = match self.shutdown {
-            Some(parent_tracker) => parent_tracker.child_tracker(),
-            None => nym_task::get_sdk_shutdown_tracker()?,
+            Some(parent_tracker) => parent_tracker.clone(),
+            None => nym_task::create_sdk_shutdown_tracker()?,
         };
 
         Self::start_event_control(self.event_tx, event_receiver, &shutdown_tracker);
@@ -968,7 +1025,11 @@ where
             .dkg_query_client
             .map(|client| BandwidthController::new(credential_store, client));
 
-        let nym_api_client = Self::construct_nym_api_client(&self.config, self.user_agent.clone())?;
+        let nym_api_client = Self::construct_nym_api_client(
+            self.nym_api_urls.as_ref(),
+            &self.config,
+            self.user_agent.clone(),
+        )?;
         let key_rotation_config = Self::determine_key_rotation_state(&nym_api_client).await?;
 
         let topology_provider = Self::setup_topology_provider(
@@ -983,7 +1044,7 @@ where
             self.user_agent.clone(),
             generate_client_stats_id(*self_address.identity()),
             input_sender.clone(),
-            &shutdown_tracker.child_tracker(),
+            &shutdown_tracker.clone(),
         );
 
         // needs to be started as the first thing to block if required waiting for the gateway
@@ -993,7 +1054,7 @@ where
             shared_topology_accessor.clone(),
             self_address.gateway(),
             self.wait_for_gateway,
-            &shutdown_tracker.child_tracker(),
+            &shutdown_tracker.clone(),
         )
         .await?;
 
@@ -1013,7 +1074,7 @@ where
             stats_reporter.clone(),
             #[cfg(unix)]
             self.connection_fd_callback,
-            &shutdown_tracker.child_tracker(),
+            &shutdown_tracker.clone(),
         )
         .await?;
         let gateway_ws_fd = gateway_transceiver.ws_fd();
@@ -1021,7 +1082,7 @@ where
         let reply_storage = Self::setup_persistent_reply_storage(
             reply_storage_backend,
             key_rotation_config,
-            &shutdown_tracker.child_tracker(),
+            &shutdown_tracker.clone(),
         )
         .await?;
 
@@ -1032,7 +1093,7 @@ where
             reply_storage.key_storage(),
             reply_controller_sender.clone(),
             stats_reporter.clone(),
-            &shutdown_tracker.child_tracker(),
+            &shutdown_tracker.clone(),
         );
 
         // The message_sender is the transmitter for any component generating sphinx packets
@@ -1042,7 +1103,7 @@ where
 
         let (message_sender, client_request_sender) = Self::start_mix_traffic_controller(
             gateway_transceiver,
-            &shutdown_tracker.child_tracker(),
+            &shutdown_tracker.clone(),
             EventSender(event_sender),
         );
 
@@ -1073,7 +1134,7 @@ where
             shared_lane_queue_lengths.clone(),
             client_connection_rx,
             stats_reporter.clone(),
-            &shutdown_tracker.child_tracker(),
+            &shutdown_tracker.clone(),
         );
 
         if !self
@@ -1089,7 +1150,7 @@ where
                 shared_topology_accessor.clone(),
                 message_sender,
                 stats_reporter.clone(),
-                &shutdown_tracker.child_tracker(),
+                &shutdown_tracker.clone(),
             );
         }
 
@@ -1143,3 +1204,53 @@ pub struct BaseClient {
     pub forget_me: ForgetMe,
     pub remember_me: RememberMe,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use nym_network_defaults::{ApiUrl, NymNetworkDetails};
+
+    #[test]
+    fn test_network_details_with_multiple_urls() {
+        // Verify that network details can be configured with multiple API URLs
+        let mut network_details = NymNetworkDetails::new_empty();
+        network_details.nym_api_urls = Some(vec![
+            ApiUrl {
+                url: "https://validator.nymtech.net/api/".to_string(),
+                front_hosts: None,
+            },
+            ApiUrl {
+                url: "https://nym-frontdoor.vercel.app/api/".to_string(),
+                front_hosts: Some(vec!["vercel.app".to_string(), "vercel.com".to_string()]),
+            },
+        ]);
+
+        assert_eq!(network_details.nym_api_urls.as_ref().unwrap().len(), 2);
+        assert!(network_details.nym_api_urls.as_ref().unwrap()[1]
+            .front_hosts
+            .is_some());
+    }
+
+    #[test]
+    fn test_network_details_with_front_hosts() {
+        // Verify that ApiUrl can store domain fronting configuration
+        let api_url = ApiUrl {
+            url: "https://nym-frontdoor.vercel.app/api/".to_string(),
+            front_hosts: Some(vec!["vercel.app".to_string(), "vercel.com".to_string()]),
+        };
+
+        assert_eq!(api_url.url, "https://nym-frontdoor.vercel.app/api/");
+        assert_eq!(api_url.front_hosts.as_ref().unwrap().len(), 2);
+        assert!(api_url
+            .front_hosts
+            .as_ref()
+            .unwrap()
+            .contains(&"vercel.app".to_string()));
+    }
+
+    #[test]
+    fn test_default_nym_api_retries_constant() {
+        // Verify the retry constant is set correctly
+        assert_eq!(DEFAULT_NYM_API_RETRIES, 3);
+    }
+}

common/client-core/src/client/cover_traffic_stream.rs

@@ -205,7 +205,7 @@ impl LoopCoverTrafficStream<OsRng> {
                 TrySendError::Full(_) => {
                     // This isn't a problem, if the channel is full means we're already sending the
                     // max amount of messages downstream can handle.
-                    tracing::debug!("Failed to send cover message - channel full");
+                    tracing::trace!("Failed to send cover message - channel full");
                 }
                 TrySendError::Closed(_) => {
                     tracing::warn!("Failed to send cover message - channel closed");

common/client-core/src/client/inbound_messages.rs

@@ -29,8 +29,6 @@ pub enum InputMessage {
         data: Vec<u8>,
         lane: TransmissionLane,
         max_retransmissions: Option<u32>,
-        #[cfg(feature = "otel")]
-        trace_id: Option<[u8; 12]>,
     },
 
     /// Creates a message used for a duplex anonymous communication where the recipient
@@ -47,8 +45,6 @@ pub enum InputMessage {
         reply_surbs: u32,
         lane: TransmissionLane,
         max_retransmissions: Option<u32>,
-        #[cfg(feature = "otel")]
-        trace_id: Option<[u8; 12]>,
     },
 
     /// Attempt to use our internally received and stored `ReplySurb` to send the message back
@@ -94,16 +90,12 @@ impl InputMessage {
         data: Vec<u8>,
         lane: TransmissionLane,
         packet_type: Option<PacketType>,
-        #[cfg(feature = "otel")]
-        trace_id: Option<[u8; 12]>,
     ) -> Self {
         let message = InputMessage::Regular {
             recipient,
             data,
             lane,
             max_retransmissions: None,
-            #[cfg(feature = "otel")]
-            trace_id,
         };
         if let Some(packet_type) = packet_type {
             InputMessage::new_wrapper(message, packet_type)
@@ -118,8 +110,6 @@ impl InputMessage {
         reply_surbs: u32,
         lane: TransmissionLane,
         packet_type: Option<PacketType>,
-        #[cfg(feature = "otel")]
-        trace_id: Option<[u8; 12]>,
     ) -> Self {
         let message = InputMessage::Anonymous {
             recipient,
@@ -127,8 +117,6 @@ impl InputMessage {
             reply_surbs,
             lane,
             max_retransmissions: None,
-            #[cfg(feature = "otel")]
-            trace_id,
         };
         if let Some(packet_type) = packet_type {
             InputMessage::new_wrapper(message, packet_type)
@@ -197,14 +185,4 @@ impl InputMessage {
         self.set_max_retransmissions(max_retransmissions);
         self
     }
-
-    #[cfg(feature = "otel")]
-    pub fn trace_id(&self) -> Option<[u8; 12]> {
-        match self {
-            InputMessage::Regular { trace_id, .. } => *trace_id,
-            InputMessage::Anonymous { trace_id, .. } => *trace_id,
-            InputMessage::Premade { .. } | InputMessage::Reply { .. } => None,
-            InputMessage::MessageWrapper { message, .. } => message.trace_id(),
-        }
-    }
 }

common/client-core/src/client/mix_traffic/mod.rs

@@ -20,7 +20,10 @@ pub mod transceiver;
 
 // We remind ourselves that 32 x 32kb = 1024kb, a reasonable size for a network buffer.
 pub const MIX_MESSAGE_RECEIVER_BUFFER_SIZE: usize = 32;
-const MAX_FAILURE_COUNT: usize = 100;
+
+/// Reduced from 100 to 20 to fail fast (~1-2 seconds instead of ~6 seconds).
+/// If we can't send 20 packets in a row, the gateway is unreachable.
+const MAX_FAILURE_COUNT: usize = 20;
 
 // that's also disgusting.
 pub struct Empty;
@@ -84,7 +87,7 @@ impl MixTrafficController {
         self.client_tx.clone()
     }
 
-    pub fn mix_rx(&self) -> BatchMixMessageSender {
+    pub fn mix_tx(&self) -> BatchMixMessageSender {
         self.mix_tx.clone()
     }
 
@@ -156,6 +159,11 @@ impl MixTrafficController {
                             // Do we need to handle the embedded mixnet client case
                             // separately?
                             self.event_tx.send(MixnetClientEvent::Traffic(MixTrafficEvent::FailedSendingSphinx));
+                            // IMO it shouldn't be signalled from there but it is how it is
+                            // TODO : report the failure upwards and shutdown from upwards
+                            // Gateway is dead, we have to shut down currently
+                            error!("Signalling shutdown from the MixTrafficController");
+                            self.shutdown_token.cancel();
                             break;
                         }
                     }

common/client-core/src/client/real_messages_control/acknowledgement_control/input_message_listener.rs

@@ -70,7 +70,6 @@ where
                 .send_reply(recipient_tag, data, lane, max_retransmissions);
     }
 
-    #[instrument(skip_all)]
     async fn handle_plain_message(
         &mut self,
         recipient: Recipient,
@@ -78,27 +77,16 @@ where
         lane: TransmissionLane,
         packet_type: PacketType,
         max_retransmissions: Option<u32>,
-        #[cfg(feature = "otel")]
-        trace_id: Option<[u8; 12]>,
     ) {
         if let Err(err) = self
             .message_handler
-            .try_send_plain_message(
-                recipient,
-                content,
-                lane,
-                packet_type,
-                max_retransmissions,
-                #[cfg(feature = "otel")]
-                trace_id,
-            )
+            .try_send_plain_message(recipient, content, lane, packet_type, max_retransmissions)
             .await
         {
             warn!("failed to send a plain message - {err}")
         }
     }
 
-    #[instrument(skip_all)]
     async fn handle_repliable_message(
         &mut self,
         recipient: Recipient,
@@ -107,8 +95,6 @@ where
         lane: TransmissionLane,
         packet_type: PacketType,
         max_retransmissions: Option<u32>,
-        #[cfg(feature = "otel")]
-        trace_id: Option<[u8; 12]>,
     ) {
         if let Err(err) = self
             .message_handler
@@ -119,8 +105,6 @@ where
                 lane,
                 packet_type,
                 max_retransmissions,
-                #[cfg(feature = "otel")]
-                trace_id,
             )
             .await
         {
@@ -129,36 +113,20 @@ where
     }
 
     #[allow(clippy::panic)]
-    #[instrument(skip_all)]
     async fn on_input_message(&mut self, msg: InputMessage) {
-        #[cfg(feature = "otel")]
-        let trace_id = msg.trace_id();
-        #[cfg(feature = "otel")]
-        if let Some(tid) = trace_id {
-            tracing::info!("Processing input message with trace_id: {:?}", tid);
-        }
-
         match msg {
             InputMessage::Regular {
                 recipient,
                 data,
                 lane,
                 max_retransmissions,
-                ..
             } => {
-                #[cfg(feature = "otel")]
-                info!(
-                    "Handling regular input message with trace_id: {:?}",
-                    trace_id
-                );
                 self.handle_plain_message(
                     recipient,
                     data,
                     lane,
                     PacketType::Mix,
                     max_retransmissions,
-                    #[cfg(feature = "otel")]
-                    trace_id,
                 )
                 .await
             }
@@ -168,13 +136,7 @@ where
                 reply_surbs,
                 lane,
                 max_retransmissions,
-                ..
             } => {
-                #[cfg(feature = "otel")]
-                tracing::info!(
-                    "Handling anonymous input message with trace_id: {:?}",
-                    trace_id
-                );
                 self.handle_repliable_message(
                     recipient,
                     data,
@@ -182,8 +144,6 @@ where
                     lane,
                     PacketType::Mix,
                     max_retransmissions,
-                    #[cfg(feature = "otel")]
-                    trace_id,
                 )
                 .await
             }
@@ -193,8 +153,6 @@ where
                 lane,
                 max_retransmissions,
             } => {
-                #[cfg(feature = "otel")]
-                info!("Handling reply input message with trace_id: {:?}", trace_id);
                 self.handle_reply(recipient_tag, data, lane, max_retransmissions)
                     .await;
             }
@@ -208,21 +166,13 @@ where
                     data,
                     lane,
                     max_retransmissions,
-                    ..
                 } => {
-                    #[cfg(feature = "otel")]
-                    tracing::info!(
-                        "Handling regular input message with trace_id: {:?}",
-                        trace_id
-                    );
                     self.handle_plain_message(
                         recipient,
                         data,
                         lane,
                         packet_type,
                         max_retransmissions,
-                        #[cfg(feature = "otel")]
-                        trace_id,
                     )
                     .await
                 }
@@ -232,7 +182,6 @@ where
                     reply_surbs,
                     lane,
                     max_retransmissions,
-                    ..
                 } => {
                     self.handle_repliable_message(
                         recipient,
@@ -241,8 +190,6 @@ where
                         lane,
                         packet_type,
                         max_retransmissions,
-                        #[cfg(feature = "otel")]
-                        trace_id,
                     )
                     .await
                 }
@@ -266,7 +213,6 @@ where
         };
     }
 
-    #[instrument(skip_all)]
     pub(crate) async fn run(&mut self, shutdown_token: ShutdownToken) {
         debug!("Started InputMessageListener with graceful shutdown support");
 

common/client-core/src/client/real_messages_control/acknowledgement_control/retransmission_request_listener.rs

@@ -60,13 +60,7 @@ where
 
         // TODO: Figure out retransmission packet type signaling
         self.message_handler
-            .try_prepare_single_chunk_for_sending(
-                packet_recipient,
-                chunk_data,
-                packet_type,
-                #[cfg(feature = "otel")]
-                None
-            )
+            .try_prepare_single_chunk_for_sending(packet_recipient, chunk_data, packet_type)
             .await
     }
 

common/client-core/src/client/real_messages_control/message_handler.rs

@@ -27,7 +27,7 @@ use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;
 use thiserror::Error;
-use tracing::{debug, error, info, instrument, trace, warn};
+use tracing::{debug, error, info, trace, warn};
 
 // TODO: move that error elsewhere since it seems to be contaminating different files
 #[derive(Debug, Error)]
@@ -476,7 +476,6 @@ where
         self.forward_messages(msgs, lane).await;
     }
 
-    #[instrument(skip_all)]
     pub(crate) async fn try_send_plain_message(
         &mut self,
         recipient: Recipient,
@@ -484,8 +483,6 @@ where
         lane: TransmissionLane,
         packet_type: PacketType,
         max_retransmissions: Option<u32>,
-        #[cfg(feature = "otel")]
-        trace_id: Option<[u8; 12]>,
     ) -> Result<(), PreparationError> {
         let message = NymMessage::new_plain(message);
         self.try_split_and_send_non_reply_message(
@@ -494,13 +491,10 @@ where
             lane,
             packet_type,
             max_retransmissions,
-            #[cfg(feature = "otel")]
-            trace_id,
         )
         .await
     }
 
-    #[instrument(skip_all)]
     pub(crate) async fn try_split_and_send_non_reply_message(
         &mut self,
         message: NymMessage,
@@ -508,8 +502,6 @@ where
         lane: TransmissionLane,
         packet_type: PacketType,
         max_retransmissions: Option<u32>,
-        #[cfg(feature = "otel")]
-        trace_id: Option<[u8; 12]>,
     ) -> Result<(), PreparationError> {
         debug!("Sending non-reply message with packet type {packet_type}");
         // TODO: I really dislike existence of this assertion, it implies code has to be re-organised
@@ -542,8 +534,6 @@ where
                 &self.config.ack_key,
                 &recipient,
                 packet_type,
-                #[cfg(feature = "otel")]
-                trace_id,
             )?;
 
             let real_message = RealMessage::new(
@@ -595,8 +585,6 @@ where
             TransmissionLane::AdditionalReplySurbs,
             packet_type,
             max_retransmissions,
-            #[cfg(feature = "otel")]
-            None,
         )
         .await?;
 
@@ -614,8 +602,6 @@ where
         lane: TransmissionLane,
         packet_type: PacketType,
         max_retransmissions: Option<u32>,
-        #[cfg(feature = "otel")]
-        trace_id: Option<[u8; 12]>,
     ) -> Result<(), SurbWrappedPreparationError> {
         debug!("Sending message with reply SURBs with packet type {packet_type}");
         let sender_tag = self.get_or_create_sender_tag(&recipient);
@@ -639,8 +625,6 @@ where
             lane,
             packet_type,
             max_retransmissions,
-            #[cfg(feature = "otel")]
-            trace_id,
         )
         .await?;
 
@@ -655,8 +639,6 @@ where
         recipient: Recipient,
         chunk: Fragment,
         packet_type: PacketType,
-        #[cfg(feature = "otel")]
-        trace_id: Option<[u8; 12]>,
     ) -> Result<PreparedFragment, PreparationError> {
         debug!("Sending single chunk with packet type {packet_type}");
         let topology_permit = self.topology_access.get_read_permit().await;
@@ -668,8 +650,6 @@ where
             &self.config.ack_key,
             &recipient,
             packet_type,
-            #[cfg(feature = "otel")]
-            trace_id,
         )?;
 
         Ok(prepared_fragment)

common/client-core/src/client/real_messages_control/real_traffic_stream.rs

@@ -298,6 +298,8 @@ where
                         "failed to send mixnet packet due to closed channel (outside of shutdown!)"
                     );
                 }
+                // Early return to avoid further processing when channel is closed
+                return;
             }
             Ok(_) => {
                 let event = if fragment_id.is_some() {

common/client-core/src/client/statistics_control.rs

@@ -80,8 +80,6 @@ impl StatisticsControl {
             stats_report.into(),
             TransmissionLane::General,
             None,
-            #[cfg(feature = "otel")]
-            None,
         );
         if let Err(err) = self.report_tx.send(report_message).await {
             tracing::error!("Failed to report client stats: {err:?}");

common/client-core/src/init/helpers.rs

@@ -151,7 +151,7 @@ pub async fn gateways_for_init(
     }
 
     let retry_count = retry_count.unwrap_or(DEFAULT_NYM_API_RETRIES);
-    let mut builder = nym_http_api_client::ClientBuilder::new_with_urls(nym_api_urls.clone())
+    let mut builder = nym_http_api_client::ClientBuilder::new_with_urls(nym_api_urls.clone())?
         .with_retries(retry_count)
         .with_bincode();
 

common/client-libs/gateway-client/src/client/mod.rs

@@ -1043,12 +1043,6 @@ impl<C, St> GatewayClient<C, St> {
     }
 
     // Note: this requires prior authentication
-    #[instrument(skip_all,
-        fields(
-            gateway = %self.gateway_identity,
-            gateway_address = %self.gateway_address
-        )
-    )]
     pub fn start_listening_for_mixnet_messages(&mut self) -> Result<(), GatewayClientError> {
         if !self.authenticated {
             return Err(GatewayClientError::NotAuthenticated);

common/client-libs/mixnet-client/src/client.rs

@@ -267,7 +267,6 @@ impl Client {
 }
 
 impl SendWithoutResponse for Client {
-    #[instrument(skip(self, packet))]
     fn send_without_response(&self, packet: MixPacket) -> io::Result<()> {
         let address = packet.next_hop_address();
         trace!("Sending packet to {address}");

common/gateway-requests/Cargo.toml

@@ -19,11 +19,11 @@ serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 strum = { workspace = true }
 thiserror = { workspace = true }
+tracing = { workspace = true, features = ["log"] }
 time = { workspace = true }
 subtle = { workspace = true }
 zeroize = { workspace = true }
 
-nym-bin-common = { path = "../bin-common" }
 nym-crypto = { path = "../crypto", features = ["aead", "hashing"] }
 nym-pemstore = { path = "../pemstore" }
 nym-sphinx = { path = "../nymsphinx" }
@@ -34,11 +34,6 @@ nym-task = { path = "../task" }
 nym-credentials = { path = "../credentials" }
 nym-credentials-interface = { path = "../credentials-interface" }
 
-opentelemetry = { workspace = true, features = ["trace"], optional = true }
-opentelemetry_sdk = { workspace = true, optional = true }
-tracing-opentelemetry = { workspace = true, optional = true }
-tracing = { workspace = true, features = ["std", "attributes", "tracing-attributes"] }
-
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio]
 workspace = true
 features = ["time"]
@@ -56,12 +51,3 @@ anyhow = { workspace = true }
 nym-compact-ecash = { path = "../nym_offline_compact_ecash" } # we need specific imports in tests
 nym-test-utils = { path = "../test-utils" }
 tokio = { workspace = true, features = ["full"] }
-
-[features]
-default = []
-otel = [
-    "nym-bin-common/otel",
-    "opentelemetry",
-    "opentelemetry_sdk",
-    "tracing-opentelemetry",
-]

common/gateway-requests/src/types/text_request/authenticate.rs

@@ -4,7 +4,6 @@
 use crate::{AuthenticationFailure, GatewayRequestsError, SharedGatewayKey};
 use nym_crypto::asymmetric::ed25519;
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
 use std::iter;
 use std::time::Duration;
 use subtle::ConstantTimeEq;
@@ -17,9 +16,6 @@ pub struct AuthenticateRequest {
     pub content: AuthenticateRequestContent,
 
     pub request_signature: ed25519::Signature,
-
-    #[serde(default)]
-    pub otel_context: Option<HashMap<String, String>>,
 }
 
 impl AuthenticateRequest {
@@ -27,7 +23,6 @@ impl AuthenticateRequest {
         protocol_version: u8,
         shared_key: &SharedGatewayKey,
         identity_keys: &ed25519::KeyPair,
-        otel_context: Option<HashMap<String, String>>,
     ) -> Result<AuthenticateRequest, GatewayRequestsError> {
         let content = AuthenticateRequestContent::new(
             protocol_version,
@@ -40,7 +35,6 @@ impl AuthenticateRequest {
         Ok(AuthenticateRequest {
             content,
             request_signature,
-            otel_context,
         })
     }
 

common/gateway-requests/src/types/text_request/mod.rs

@@ -8,16 +8,12 @@ use crate::{
     AUTHENTICATE_V2_PROTOCOL_VERSION, CREDENTIAL_UPDATE_V2_PROTOCOL_VERSION,
     INITIAL_PROTOCOL_VERSION,
 };
-#[cfg(feature = "otel")]
-use nym_bin_common::opentelemetry::context::ContextCarrier;
 use nym_credentials_interface::CredentialSpendingData;
 use nym_crypto::asymmetric::ed25519;
 use nym_sphinx::DestinationAddressBytes;
 use nym_statistics_common::types::SessionType;
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
 use std::str::FromStr;
-use tracing::{instrument, warn};
 use tungstenite::Message;
 
 pub mod authenticate;
@@ -80,10 +76,6 @@ pub enum ClientControlRequest {
         address: String,
         enc_address: String,
         iv: String,
-        /// this is a trace id that is used in testing and performance verification
-        /// in mainnet, this will always be set to None
-        #[serde(default)]
-        otel_context: Option<HashMap<String, String>>,
     },
 
     AuthenticateV2(Box<AuthenticateRequest>),
@@ -135,25 +127,14 @@ impl ClientControlRequest {
         let nonce = shared_key.random_nonce_or_iv();
         let ciphertext = shared_key.encrypt_naive(address.as_bytes_ref(), Some(&nonce))?;
 
-        #[cfg(feature = "otel")]
-        let context_carrier = {
-            let context = opentelemetry::Context::current();
-            ContextCarrier::new_with_current_context(context).into_map()
-        };
-
         Ok(ClientControlRequest::Authenticate {
             protocol_version,
             address: address.as_base58_string(),
             enc_address: bs58::encode(&ciphertext).into_string(),
             iv: bs58::encode(&nonce).into_string(),
-            #[cfg(feature = "otel")]
-            otel_context: Some(context_carrier),
-            #[cfg(not(feature = "otel"))]
-            otel_context: None,
         })
     }
 
-    #[instrument(skip_all)]
     pub fn new_authenticate_v2(
         shared_key: &SharedGatewayKey,
         identity_keys: &ed25519::KeyPair,
@@ -161,25 +142,8 @@ impl ClientControlRequest {
         // if we're using v2 authentication, we must announce at least that protocol version
         let protocol_version = AUTHENTICATE_V2_PROTOCOL_VERSION;
 
-        #[cfg(feature = "otel")]
-        let context_carrier = {
-            use nym_bin_common::opentelemetry::context::extract_trace_id_from_tracing_cx;
-            use tracing_opentelemetry::OpenTelemetrySpanExt;
-
-            let current_span = tracing::Span::current();
-            let otel_context = current_span.context();
-            ContextCarrier::new_with_current_context(otel_context).into_map()
-        };
-        #[cfg(not(feature = "otel"))]
-        let context_carrier: HashMap<String, String> = HashMap::new();
-
         Ok(ClientControlRequest::AuthenticateV2(Box::new(
-            AuthenticateRequest::new(
-                protocol_version,
-                shared_key,
-                identity_keys,
-                Some(context_carrier),
-            )?,
+            AuthenticateRequest::new(protocol_version, shared_key, identity_keys)?,
         )))
     }
 

common/http-api-client/Cargo.toml

@@ -11,11 +11,9 @@ license.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [features]
-# TODO: Remove otel from default before release
 default=["tunneling"]
 tunneling=[]
 network-defaults = ["dep:nym-network-defaults"]
-otel = ["nym-bin-common/otel", "opentelemetry", "opentelemetry_sdk"]
 debug-inventory = ["nym-http-api-client-macro/debug-inventory"]
 
 [dependencies]
@@ -26,8 +24,6 @@ reqwest = { workspace = true, features = ["json", "gzip", "deflate", "brotli", "
 http.workspace = true
 url = { workspace = true }
 once_cell = { workspace = true }
-opentelemetry = { workspace = true, optional = true }
-opentelemetry_sdk = { workspace = true, optional = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 serde_yaml = { workspace = true}
@@ -57,3 +53,4 @@ features = ["tokio"]
 
 [dev-dependencies]
 tokio = { workspace = true, features = ["rt", "macros"] }
+

common/http-api-client/src/lib.rs

@@ -296,6 +296,9 @@ impl std::error::Error for ReqwestErrorWrapper {}
 #[derive(Debug, Error)]
 #[allow(missing_docs)]
 pub enum HttpClientError {
+    #[error("did not provide any valid client URLs")]
+    NoUrlsProvided,
+
     #[error("failed to construct inner reqwest client: {source}")]
     ReqwestBuildError {
         #[source]
@@ -582,24 +585,29 @@ impl ClientBuilder {
             Self::new(alt)
         } else {
             let url = url.to_url()?;
-            Ok(Self::new_with_urls(vec![url]))
+            Self::new_with_urls(vec![url])
         }
     }
 
     /// Create a client builder from network details with sensible defaults
     #[cfg(feature = "network-defaults")]
+    // deprecating function since it's not clear from its signature whether the client
+    // would be constructed using `nym_api_urls` or `nym_vpn_api_urls`
+    #[deprecated(note = "use explicit Self::new_with_fronted_urls instead")]
     pub fn from_network(
         network: &nym_network_defaults::NymNetworkDetails,
     ) -> Result<Self, HttpClientError> {
-        let urls = network
-            .nym_api_urls
-            .as_ref()
-            .ok_or_else(|| {
-                HttpClientError::GenericRequestFailure(
-                    "No API URLs configured in network details".to_string(),
-                )
-            })?
-            .iter()
+        let urls = network.nym_api_urls.as_ref().cloned().unwrap_or_default();
+        Self::new_with_fronted_urls(urls.clone())
+    }
+
+    /// Create a client builder using the provided set of domain-fronted URLs
+    #[cfg(feature = "network-defaults")]
+    pub fn new_with_fronted_urls(
+        urls: Vec<nym_network_defaults::ApiUrl>,
+    ) -> Result<Self, HttpClientError> {
+        let urls = urls
+            .into_iter()
             .map(|api_url| {
                 // Convert ApiUrl to our Url type with fronting support
                 let mut url = Url::parse(&api_url.url)?;
@@ -611,15 +619,19 @@ impl ClientBuilder {
                         .iter()
                         .map(|host| format!("https://{}", host))
                         .collect();
-                    url = Url::new(api_url.url.clone(), Some(fronts))
-                        .map_err(|e| HttpClientError::GenericRequestFailure(e.to_string()))?;
+                    url = Url::new(api_url.url.clone(), Some(fronts)).map_err(|source| {
+                        HttpClientError::MalformedUrl {
+                            raw: api_url.url.clone(),
+                            source,
+                        }
+                    })?;
                 }
 
                 Ok(url)
             })
             .collect::<Result<Vec<_>, HttpClientError>>()?;
 
-        let mut builder = Self::new_with_urls(urls);
+        let mut builder = Self::new_with_urls(urls)?;
 
         // Enable domain fronting by default (on retry)
         #[cfg(feature = "tunneling")]
@@ -631,7 +643,11 @@ impl ClientBuilder {
     }
 
     /// Constructs a new http `ClientBuilder` from a valid url.
-    pub fn new_with_urls(urls: Vec<Url>) -> Self {
+    pub fn new_with_urls(urls: Vec<Url>) -> Result<Self, HttpClientError> {
+        if urls.is_empty() {
+            return Err(HttpClientError::NoUrlsProvided);
+        }
+
         let urls = Self::check_urls(urls);
 
         #[cfg(target_arch = "wasm32")]
@@ -640,7 +656,7 @@ impl ClientBuilder {
         #[cfg(not(target_arch = "wasm32"))]
         let reqwest_client_builder = default_builder();
 
-        ClientBuilder {
+        Ok(ClientBuilder {
             urls,
             timeout: None,
             custom_user_agent: false,
@@ -651,7 +667,7 @@ impl ClientBuilder {
 
             retry_limit: 0,
             serialization: SerializationFormat::Json,
-        }
+        })
     }
 
     /// Add an additional URL to the set usable by this constructed `Client`
@@ -948,13 +964,13 @@ impl Client {
 
                     return (url.as_str(), url.front_str());
                 } else {
-                    warn!(
-                        "Domain fronting is enabled, but no host_url is defined! Domain fronting WILL NOT WORK"
+                    tracing::debug!(
+                        "Domain fronting is enabled, but no host_url is defined for current URL"
                     )
                 }
             } else {
-                warn!(
-                    "Domain fronting is enabled, but no front_url is defined! Domain fronting WILL NOT WORK"
+                tracing::debug!(
+                    "Domain fronting is enabled, but current URL has no front_hosts configured"
                 )
             }
         }
@@ -986,21 +1002,6 @@ impl ApiClientCore for Client {
 
         self.apply_hosts_to_req(&mut req);
 
-        // if opentelemetry is activated add the current trace context to the request
-        #[cfg(feature = "otel")]
-        {
-            use nym_bin_common::opentelemetry::context::ContextCarrier;
-            use opentelemetry::Context;
-
-            let carrier = ContextCarrier::new_with_current_context(Context::current());
-
-            if let Some(traceparent) = carrier.extract_traceparent() {
-                if let Ok(header_value) = HeaderValue::from_str(&traceparent) {
-                    req.headers_mut().insert("traceparent", header_value);
-                }
-            }
-        }
-
         let mut rb = RequestBuilder::from_parts(self.reqwest_client.clone(), req);
 
         rb = rb

common/http-api-client/src/registry.rs

@@ -21,6 +21,10 @@ inventory::collect!(ConfigRecord);
 /// Returns the default builder with all registered configurations applied.
 pub fn default_builder() -> ReqwestClientBuilder {
     let mut b = ReqwestClientBuilder::new();
+
+    #[cfg(feature = "debug-inventory")]
+    let mut test_client = ReqwestClientBuilder::new();
+
     let mut records: Vec<&'static ConfigRecord> =
         inventory::iter::<ConfigRecord>.into_iter().collect();
     records.sort_by_key(|r| r.priority); // lower runs first
@@ -35,6 +39,10 @@ pub fn default_builder() -> ReqwestClientBuilder {
 
     for r in records {
         b = (r.apply)(b);
+        #[cfg(feature = "debug-inventory")]
+        {
+            test_client = (r.apply)(test_client);
+        }
     }
 
     #[cfg(feature = "debug-inventory")]
@@ -47,7 +55,7 @@ pub fn default_builder() -> ReqwestClientBuilder {
         eprintln!("[HTTP-INVENTORY] Building test client to verify configuration...");
 
         // Try to build a client to see if it works
-        match b.try_clone().unwrap().build() {
+        match test_client.build() {
             Ok(client) => {
                 eprintln!("[HTTP-INVENTORY] ✓ Client built successfully");
                 eprintln!("[HTTP-INVENTORY] Client debug info: {:#?}", client);

common/http-api-client/src/tests.rs

@@ -2,77 +2,77 @@ use super::*;
 
 #[test]
 fn sanitizing_urls() {
-    let base_url: Url = "http://foomp.com".parse().unwrap();
+    let base_url: Url = "http://api.test".parse().unwrap();
 
     // works with a full string
     assert_eq!(
-        "http://foomp.com/foo/bar",
+        "http://api.test/foo/bar",
         sanitize_url(&base_url, "/foo//bar/", NO_PARAMS).as_str()
     );
 
     // (and leading slash doesn't matter)
     assert_eq!(
-        "http://foomp.com/foo/bar",
+        "http://api.test/foo/bar",
         sanitize_url(&base_url, "foo//bar/", NO_PARAMS).as_str()
     );
 
     // works with 1 segment
     assert_eq!(
-        "http://foomp.com/foo",
+        "http://api.test/foo",
         sanitize_url(&base_url, &["foo"], NO_PARAMS).as_str()
     );
 
     // works with 2 segments
     assert_eq!(
-        "http://foomp.com/foo/bar",
+        "http://api.test/foo/bar",
         sanitize_url(&base_url, &["foo", "bar"], NO_PARAMS).as_str()
     );
 
     // works with leading slash
     assert_eq!(
-        "http://foomp.com/foo",
+        "http://api.test/foo",
         sanitize_url(&base_url, &["/foo"], NO_PARAMS).as_str()
     );
     assert_eq!(
-        "http://foomp.com/foo/bar",
+        "http://api.test/foo/bar",
         sanitize_url(&base_url, &["/foo", "bar"], NO_PARAMS).as_str()
     );
     assert_eq!(
-        "http://foomp.com/foo/bar",
+        "http://api.test/foo/bar",
         sanitize_url(&base_url, &["foo", "/bar"], NO_PARAMS).as_str()
     );
 
     // works with trailing slash
     assert_eq!(
-        "http://foomp.com/foo",
+        "http://api.test/foo",
         sanitize_url(&base_url, &["foo/"], NO_PARAMS).as_str()
     );
     assert_eq!(
-        "http://foomp.com/foo/bar",
+        "http://api.test/foo/bar",
         sanitize_url(&base_url, &["foo/", "bar"], NO_PARAMS).as_str()
     );
     assert_eq!(
-        "http://foomp.com/foo/bar",
+        "http://api.test/foo/bar",
         sanitize_url(&base_url, &["foo", "bar/"], NO_PARAMS).as_str()
     );
 
     // works with both leading and trailing slash
     assert_eq!(
-        "http://foomp.com/foo",
+        "http://api.test/foo",
         sanitize_url(&base_url, &["/foo/"], NO_PARAMS).as_str()
     );
     assert_eq!(
-        "http://foomp.com/foo/bar",
+        "http://api.test/foo/bar",
         sanitize_url(&base_url, &["/foo/", "/bar/"], NO_PARAMS).as_str()
     );
 
     // adds params
     assert_eq!(
-        "http://foomp.com/foo/bar?foomp=baz",
+        "http://api.test/foo/bar?foomp=baz",
         sanitize_url(&base_url, &["foo", "bar"], &[("foomp", "baz")]).as_str()
     );
     assert_eq!(
-        "http://foomp.com/foo/bar?arg1=val1&arg2=val2",
+        "http://api.test/foo/bar?arg1=val1&arg2=val2",
         sanitize_url(
             &base_url,
             &["/foo/", "/bar/"],
@@ -91,83 +91,87 @@ fn sanitizing_urls() {
 #[tokio::test]
 async fn api_client_retry() -> Result<(), Box<dyn std::error::Error>> {
     let client = ClientBuilder::new_with_urls(vec![
-        "http://broken.nym.badurl".parse()?,
-        "http://example.com/".parse()?,
-    ])
+        "http://broken.nym.test".parse()?,         // This will fail
+        "https://httpbin.org/status/200".parse()?, // This will succeed
+    ])?
     .with_retries(3)
     .build()?;
 
-    let req = client.create_get_request(&["/"], NO_PARAMS).unwrap();
+    let req = client.create_get_request(&[], NO_PARAMS).unwrap();
     let resp = client.send(req).await?;
 
-    assert_eq!(resp.status(), 200);
+    // The main test is that we successfully retried and switched to the working URL
+    // We accept any response from the working endpoint since external services can be unreliable
+    assert_eq!(
+        client.current_url().as_str(),
+        "https://httpbin.org/status/200"
+    );
 
-    // check that the url was updated
-    assert_eq!(client.current_url().as_str(), "http://example.com/");
+    println!("Response status: {}", resp.status());
 
     Ok(())
 }
 
 #[test]
 fn host_updating() {
-    let url = Url::new("http://example.com", None).unwrap();
+    let url = Url::new("http://nym-api1.test", None).unwrap();
     let mut client = ClientBuilder::new(url).unwrap().build().unwrap();
 
     // check that the url is set correctly
     let current_url = client.current_url();
-    assert_eq!(current_url.as_str(), "http://example.com/");
+    assert_eq!(current_url.as_str(), "http://nym-api1.test/");
     assert_eq!(current_url.front_str(), None);
 
     // update the url
     client.update_host();
 
     // check that the url is still the same since there is one URL
-    assert_eq!(client.current_url().as_str(), "http://example.com/");
+    assert_eq!(client.current_url().as_str(), "http://nym-api1.test/");
 
     // =======================================
     // we rotate through urls when available
 
     let new_urls = vec![
-        Url::new("http://example.com", None).unwrap(),
-        Url::new("http://example.org", None).unwrap(),
+        Url::new("http://nym-api1.test", None).unwrap(),
+        Url::new("http://nym-api2.test", None).unwrap(),
     ];
     client.change_base_urls(new_urls);
-    assert_eq!(client.current_url().as_str(), "http://example.com/");
+    assert_eq!(client.current_url().as_str(), "http://nym-api1.test/");
 
     client.update_host();
 
     // check that the url got updated now that there are multiple URLs
-    assert_eq!(client.current_url().as_str(), "http://example.org/");
+    assert_eq!(client.current_url().as_str(), "http://nym-api2.test/");
     assert_eq!(client.current_url().front_str(), None);
 
     client.update_host();
-    assert_eq!(client.current_url().as_str(), "http://example.com/");
+    assert_eq!(client.current_url().as_str(), "http://nym-api1.test/");
 
     // =======================================
     // we rotate through urls when available if fronting is disabled
 
     let new_urls = vec![
         Url::new(
-            "http://example.com",
-            Some(vec!["http://front1.com", "http://front2.com"]),
+            "http://nym-api1.test",
+            Some(vec!["http://cdn1.test", "http://cdn2.test"]),
         )
         .unwrap(),
-        Url::new("http://example.org", None).unwrap(),
+        Url::new("http://nym-api2.test", None).unwrap(),
     ];
     client.change_base_urls(new_urls);
 
-    assert_eq!(client.current_url().as_str(), "http://example.com/");
+    assert_eq!(client.current_url().as_str(), "http://nym-api1.test/");
 
     client.update_host();
 
     // check that the url got updated now that there are multiple URLs
-    assert_eq!(client.current_url().as_str(), "http://example.org/");
+    assert_eq!(client.current_url().as_str(), "http://nym-api2.test/");
 }
 
 #[test]
 #[cfg(feature = "tunneling")]
 fn fronted_host_updating() {
-    let url = Url::new("http://example.com", Some(vec!["http://front1.com"])).unwrap();
+    let url = Url::new("http://nym-api.test", Some(vec!["http://cdn1.test"])).unwrap();
     let mut client = ClientBuilder::new(url)
         .unwrap()
         .with_fronting(crate::fronted::FrontPolicy::Always)
@@ -176,46 +180,103 @@ fn fronted_host_updating() {
 
     // check that the url is set correctly
     let current_url = client.current_url();
-    assert_eq!(current_url.as_str(), "http://example.com/");
-    assert_eq!(current_url.front_str(), Some("front1.com"));
+    assert_eq!(current_url.as_str(), "http://nym-api.test/");
+    assert_eq!(current_url.front_str(), Some("cdn1.test"));
 
     // update the url
     client.update_host();
 
     // check that the url is still the same since there is one URL and one front
     let current_url = client.current_url();
-    assert_eq!(current_url.as_str(), "http://example.com/");
-    assert_eq!(current_url.front_str(), Some("front1.com"));
+    assert_eq!(current_url.as_str(), "http://nym-api.test/");
+    assert_eq!(current_url.front_str(), Some("cdn1.test"));
 
     // =======================================
     // we rotate through front urls when available if fronting is enabled
 
     let new_urls = vec![
         Url::new(
-            "http://example.com",
-            Some(vec!["http://front1.com", "http://front2.com"]),
+            "http://nym-api.test",
+            Some(vec!["http://cdn1.test", "http://cdn2.test"]),
         )
         .unwrap(),
-        Url::new("http://example.org", None).unwrap(),
+        Url::new("http://nym-api2.test", None).unwrap(),
     ];
     client.change_base_urls(new_urls);
 
     let current_url = client.current_url();
-    assert_eq!(current_url.as_str(), "http://example.com/");
-    assert_eq!(current_url.front_str(), Some("front1.com"));
+    assert_eq!(current_url.as_str(), "http://nym-api.test/");
+    assert_eq!(current_url.front_str(), Some("cdn1.test"));
 
     // update the url - this should keep the same host but change the front
     client.update_host();
 
     let current_url = client.current_url();
     // check that the url is still the same since there is one URL
-    assert_eq!(current_url.as_str(), "http://example.com/");
-    assert_eq!(current_url.front_str(), Some("front2.com"));
+    assert_eq!(current_url.as_str(), "http://nym-api.test/");
+    assert_eq!(current_url.front_str(), Some("cdn2.test"));
 
     // update the url - this should wrap around to the first front as the second url is not fronted
     client.update_host();
 
     let current_url = client.current_url();
-    assert_eq!(current_url.as_str(), "http://example.com/");
-    assert_eq!(current_url.front_str(), Some("front1.com"));
+    assert_eq!(current_url.as_str(), "http://nym-api.test/");
+    assert_eq!(current_url.front_str(), Some("cdn1.test"));
+}
+
+#[test]
+#[cfg(feature = "network-defaults")]
+fn from_network_configures_multiple_urls_and_retries() {
+    use nym_network_defaults::{ApiUrl, NymNetworkDetails};
+
+    // Create network details with multiple URLs and fronting
+    let mut network_details = NymNetworkDetails::new_empty();
+    network_details.nym_api_urls = Some(vec![
+        ApiUrl {
+            url: "https://validator.nymtech.net/api/".to_string(),
+            front_hosts: None,
+        },
+        ApiUrl {
+            url: "https://nym-frontdoor.vercel.app/api/".to_string(),
+            front_hosts: Some(vec!["vercel.app".to_string(), "vercel.com".to_string()]),
+        },
+        ApiUrl {
+            url: "https://nym-frontdoor.global.ssl.fastly.net/api/".to_string(),
+            front_hosts: Some(vec!["yelp.global.ssl.fastly.net".to_string()]),
+        },
+    ]);
+
+    // Build client from network details
+    let client = ClientBuilder::new_with_fronted_urls(
+        network_details.nym_api_urls.clone().unwrap_or_default(),
+    )
+    .expect("Failed to create client from network")
+    .build()
+    .expect("Failed to build client");
+
+    // Verify all URLs were configured
+    assert_eq!(
+        client.base_urls().len(),
+        3,
+        "Expected 3 URLs to be configured from network details"
+    );
+
+    // Verify the URLs have fronting configured where appropriate
+    assert_eq!(
+        client.base_urls()[0].as_str(),
+        "https://validator.nymtech.net/api/"
+    );
+    assert!(client.base_urls()[0].front_str().is_none());
+
+    assert_eq!(
+        client.base_urls()[1].as_str(),
+        "https://nym-frontdoor.vercel.app/api/"
+    );
+    assert!(client.base_urls()[1].front_str().is_some());
+
+    assert_eq!(
+        client.base_urls()[2].as_str(),
+        "https://nym-frontdoor.global.ssl.fastly.net/api/"
+    );
+    assert!(client.base_urls()[2].front_str().is_some());
 }

common/http-api-common/Cargo.toml

@@ -18,7 +18,6 @@ bytes = { workspace = true, optional = true }
 colored = { workspace = true, optional = true }
 futures = { workspace = true, optional = true }
 mime = { workspace = true, optional = true }
-nym-bin-common = { path = "../bin-common" }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 serde_yaml = { workspace = true, optional = true }
@@ -50,8 +49,6 @@ middleware = [
     "zeroize"
 ]
 
-otel = ["nym-bin-common/otel"]
-
 utoipa = ["dep:utoipa"]
 
 [lints]

common/http-api-common/src/middleware/logging.rs

@@ -56,16 +56,6 @@ async fn log_request(
 
     let host = header_map(request.headers().get(HOST), "Unknown Host".to_string());
 
-    // Extract traceparent from headers if it exists
-    #[cfg(feature = "otel")]
-    let traceparent = request
-        .headers()
-        .get("traceparent")
-        .and_then(|h| h.to_str().ok())
-        .map(|s| s.to_string());
-    #[cfg(not(feature = "otel"))]
-    let traceparent: Option<String> = None;
-
     let start = Instant::now();
     // run request through all middleware, incl. extractors
     let res = next.run(request).await;
@@ -92,10 +82,10 @@ async fn log_request(
 
     match level {
         LogLevel::Debug => debug!(
-            "[{addr} -> {host}] {method} '{uri}': {print_status} {time_taken} {agent_str}: {agent} traceparent: {traceparent:?}",
+            "[{addr} -> {host}] {method} '{uri}': {print_status} {time_taken} {agent_str}: {agent}"
         ),
         LogLevel::Info => info!(
-            "[{addr} -> {host}] {method} '{uri}': {print_status} {time_taken} {agent_str}: {agent} traceparent: {traceparent:?}"
+            "[{addr} -> {host}] {method} '{uri}': {print_status} {time_taken} {agent_str}: {agent}"
         ),
     }
 

common/network-defaults/src/network.rs

@@ -124,6 +124,8 @@ impl NymNetworkDetails {
             }
         }
 
+        let nym_api = var(var_names::NYM_API).expect("nym api not set");
+
         NymNetworkDetails::new_empty()
             .with_network_name(var(var_names::NETWORK_NAME).expect("network name not set"))
             .with_bech32_account_prefix(
@@ -149,7 +151,7 @@ impl NymNetworkDetails {
             })
             .with_additional_validator_endpoint(ValidatorDetails::new(
                 var(var_names::NYXD).expect("nyxd validator not set"),
-                Some(var(var_names::NYM_API).expect("nym api not set")),
+                Some(nym_api.clone()),
                 get_optional_env(var_names::NYXD_WEBSOCKET),
             ))
             .with_mixnet_contract(get_optional_env(var_names::MIXNET_CONTRACT_ADDRESS))
@@ -159,6 +161,10 @@ impl NymNetworkDetails {
             .with_multisig_contract(get_optional_env(var_names::MULTISIG_CONTRACT_ADDRESS))
             .with_coconut_dkg_contract(get_optional_env(var_names::COCONUT_DKG_CONTRACT_ADDRESS))
             .with_nym_vpn_api_url(get_optional_env(var_names::NYM_VPN_API))
+            .with_nym_api_urls(Some(vec![ApiUrl {
+                url: nym_api,
+                front_hosts: None,
+            }]))
     }
 
     pub fn new_mainnet() -> Self {
@@ -348,6 +354,12 @@ impl NymNetworkDetails {
         self
     }
 
+    #[must_use]
+    pub fn with_nym_api_urls(mut self, urls: Option<Vec<ApiUrl>>) -> Self {
+        self.nym_api_urls = urls;
+        self
+    }
+
     pub fn nym_vpn_api_url(&self) -> Option<Url> {
         self.nym_vpn_api_url.as_ref().map(|url| {
             url.parse()

common/node-tester-utils/Cargo.toml

@@ -30,7 +30,3 @@ workspace = true
 ## wasm-only dependencies
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-utils]
 path = "../wasm/utils"
-
-[ features ]
-default = []
-otel = ["nym-sphinx/otel"]

common/node-tester-utils/src/tester.rs

@@ -231,8 +231,6 @@ where
             &address,
             &address,
             PacketType::Mix,
-            #[cfg(feature = "otel")]
-            None,
         )?)
     }
 

common/nymsphinx/Cargo.toml

@@ -8,14 +8,12 @@ license = { workspace = true }
 repository = { workspace = true }
 
 [dependencies]
-sphinx-packet = { workspace = true }
 tracing = { workspace = true }
 rand = { workspace = true }
 rand_distr = { workspace = true }
 rand_chacha = { workspace = true }
 thiserror = { workspace = true }
 
-nym-bin-common = { path = "../bin-common" }
 nym-sphinx-acknowledgements = { path = "acknowledgements" }
 nym-sphinx-addressing = { path = "addressing" }
 nym-sphinx-anonymous-replies = { path = "anonymous-replies" }
@@ -57,11 +55,3 @@ outfox = [
     "nym-sphinx-params/outfox",
     "nym-sphinx-types/outfox",
 ]
-
-otel = [
-    "nym-bin-common/otel",
-    "nym-sphinx-acknowledgements/otel",
-    "nym-sphinx-addressing/otel",
-    "nym-sphinx-cover/otel",
-    "nym-sphinx-anonymous-replies/otel",
-] 

common/nymsphinx/acknowledgements/Cargo.toml

@@ -24,4 +24,3 @@ nym-topology = { path = "../../topology" }
 
 [features]
 serde = ["dep:serde", "generic-array"]
-otel = ["nym-sphinx-addressing/otel"]

common/nymsphinx/acknowledgements/src/surb_ack.rs

@@ -61,10 +61,7 @@ impl SurbAck {
         };
 
         let delays = nym_sphinx_routing::generate_hop_delays(average_delay, route.len());
-        #[cfg(not(feature = "otel"))]
         let destination = recipient.as_sphinx_destination();
-        #[cfg(feature = "otel")]
-        let destination = recipient.as_sphinx_destination(None);
 
         let surb_ack_payload = prepare_identifier(rng, ack_key, marshaled_fragment_id);
         let packet_size = match packet_type {

common/nymsphinx/addressing/Cargo.toml

@@ -8,20 +8,14 @@ license = { workspace = true }
 repository = { workspace = true }
 
 [dependencies]
-nym-bin-common = { path = "../../bin-common", features = ["opentelemetry"] } # for trace id compression/decompression
 nym-crypto = { path = "../../crypto", features = ["asymmetric", "sphinx"] } # all addresses are expressed in terms on their crypto keys
 nym-sphinx-types = { path = "../types", features = ["sphinx"] } # we need to be able to refer to some types defined inside sphinx crate
 serde = { workspace = true } # implementing serialization/deserialization for some types, like `Recipient`
 thiserror = { workspace = true }
-tracing = { workspace = true }
 
 [dev-dependencies]
 rand = { workspace = true }
 nym-crypto = { path = "../../crypto", features = ["rand"] }
 bincode = { workspace = true }
 serde_json = { workspace = true }
-serde = { workspace = true, features = ["derive"] }
-
-[features]
-default = []
-otel = ["nym-bin-common/otel"]
+serde = { workspace = true, features = ["derive"] }

common/nymsphinx/addressing/src/clients.rs

@@ -153,28 +153,12 @@ impl Recipient {
     // TODO: Currently the `DestinationAddress` is equivalent to `ClientIdentity`, but perhaps
     // it shouldn't be? Maybe it should be (for example) H(`ClientIdentity || ClientEncryptionKey`)
     // instead? That is an open question.
-    pub fn as_sphinx_destination(
-        &self,
-        #[cfg(feature = "otel")]
-        trace_id: Option<[u8; 12]>
-    ) -> Destination {
-        #[cfg(feature = "otel")]
-        use nym_bin_common::opentelemetry::compact_id_generator::decompress_trace_id;
-        #[cfg(feature = "otel")]
-        let trace_id_16 = if let Some(trace_id) = trace_id {
-            decompress_trace_id(&trace_id)
-        } else {
-            decompress_trace_id(&[0u8; 12])
-        };
-
+    pub fn as_sphinx_destination(&self) -> Destination {
         // since the nym mix network differs slightly in design from loopix, we do not care
         // about "surb_id" field at all and just use the default value.
         Destination::new(
             self.client_identity.derive_destination_address(),
-            #[cfg(not(feature = "otel"))]
-            [0u8; 16],
-            #[cfg(feature = "otel")]
-            trace_id_16
+            Default::default(),
         )
     }
 

common/nymsphinx/anonymous-replies/Cargo.toml

@@ -25,7 +25,3 @@ workspace = true
 
 [dev-dependencies]
 rand_chacha = { workspace = true }
-
-[ features ]
-default = []
-otel = ["nym-sphinx-addressing/otel"]

common/nymsphinx/anonymous-replies/src/reply_surb.rs

@@ -82,9 +82,6 @@ impl ReplySurb {
             topology.random_route_to_egress(rng, recipient.gateway())?
         };
         let delays = nym_sphinx_routing::generate_hop_delays(average_delay, route.len());
-        #[cfg(feature = "otel")]
-        let destination = recipient.as_sphinx_destination(None);
-        #[cfg(not(feature = "otel"))]
         let destination = recipient.as_sphinx_destination();
 
         let mut surb_material = SURBMaterial::new(route, delays, destination);

common/nymsphinx/cover/Cargo.toml

@@ -20,6 +20,3 @@ nym-sphinx-params = { path = "../params" }
 nym-sphinx-routing = { path = "../routing" }
 nym-sphinx-types = { path = "../types" }
 nym-topology = { path = "../../topology" }
-
-[features]
-otel = ["nym-sphinx-addressing/otel"]

common/nymsphinx/cover/src/lib.rs

@@ -125,10 +125,7 @@ where
 
     let route = topology.random_route_to_egress(rng, full_address.gateway())?;
     let delays = nym_sphinx_routing::generate_hop_delays(average_packet_delay, route.len());
-    #[cfg(not(feature = "otel"))]
     let destination = full_address.as_sphinx_destination();
-    #[cfg(feature = "otel")]
-    let destination = full_address.as_sphinx_destination(None);
 
     let rotation_id = topology.current_key_rotation();
     let sphinx_key_rotation = SphinxKeyRotation::from(rotation_id);

common/nymsphinx/framing/Cargo.toml

@@ -11,10 +11,8 @@ repository = { workspace = true }
 bytes = { workspace = true }
 tokio-util = { workspace = true, features = ["codec"] }
 thiserror = { workspace = true }
-opentelemetry = { workspace = true }
 tracing = { workspace = true }
 
-nym-bin-common = { path = "../../bin-common" }
 nym-sphinx-types = { path = "../types", features = ["sphinx", "outfox"] }
 nym-sphinx-params = { path = "../params", features = ["sphinx", "outfox"] }
 nym-sphinx-forwarding = { path = "../forwarding" }
@@ -23,7 +21,3 @@ nym-sphinx-acknowledgements = { path = "../acknowledgements" }
 
 [dev-dependencies]
 tokio = { workspace = true, features = ["full"] }
-
-[features]
-default = []
-otel = ["nym-bin-common/otel"]

common/nymsphinx/framing/src/processing.rs

@@ -2,11 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::packet::FramedNymPacket;
-#[cfg(feature = "otel")]
-use nym_bin_common::opentelemetry::{
-    compact_id_generator::decompress_trace_id, context::ManualContextPropagator,
-};
-
 use nym_sphinx_acknowledgements::surb_ack::{SurbAck, SurbAckRecoveryError};
 use nym_sphinx_addressing::nodes::{NymNodeRoutingAddress, NymNodeRoutingAddressError};
 use nym_sphinx_forwarding::packet::MixPacket;
@@ -19,9 +14,7 @@ use nym_sphinx_types::{
 };
 use std::fmt::Display;
 use thiserror::Error;
-#[cfg(feature = "otel")]
-use tracing::warn_span;
-use tracing::{debug, error, info, instrument, trace, warn};
+use tracing::{debug, error, info, trace};
 
 #[derive(Debug)]
 pub enum MixProcessingResultData {
@@ -161,7 +154,6 @@ impl PartiallyUnwrappedPacket {
         })
     }
 
-    #[instrument(skip_all)]
     pub fn finalise_unwrapping(self) -> Result<MixProcessingResult, PacketProcessingError> {
         let packet_size = self.received_data.packet_size();
         let packet_type = self.received_data.packet_type();
@@ -244,7 +236,6 @@ fn perform_framed_packet_processing(
     })
 }
 
-#[instrument(skip_all)]
 fn wrap_processed_sphinx_packet(
     packet: nym_sphinx_types::ProcessedPacket,
     packet_size: PacketSize,
@@ -267,38 +258,15 @@ fn wrap_processed_sphinx_packet(
         // sphinx all together?
         ProcessedPacketData::FinalHop {
             destination,
-            #[cfg(feature = "otel")]
-            identifier,
-            #[cfg(not(feature = "otel"))]
-                identifier: _,
+            identifier: _,
             payload,
-        } => {
-            // if we have a trace id in the destination, we log it for easier correlation later on
-            #[cfg(feature = "otel")]
-            let span = match identifier[0..12].try_into().map(|b: [u8; 12]| b) {
-                Ok(trace_bytes) if !trace_bytes.iter().all(|b| *b == 0) => {
-                    let full_trace_id_bytes = decompress_trace_id(&trace_bytes);
-                    let full_trace_id =
-                        opentelemetry::trace::TraceId::from_bytes(full_trace_id_bytes);
-                    let context_propagator =
-                        ManualContextPropagator::new_from_tid("final_hop", full_trace_id);
-                    tracing::info_span!(parent: &context_propagator.root_span, "final_hop_processing", trace_id=%full_trace_id)
-                }
-                _ => {
-                    tracing::debug_span!("final_hop_processing")
-                }
-            };
-            #[cfg(feature = "otel")]
-            let _entered_span = span.enter();
-
-            process_final_hop(
-                destination,
-                payload.recover_plaintext()?,
-                packet_size,
-                packet_type,
-                key_rotation,
-            )
-        }
+        } => process_final_hop(
+            destination,
+            payload.recover_plaintext()?,
+            packet_size,
+            packet_type,
+            key_rotation,
+        ),
     }?;
 
     Ok(MixProcessingResult {
@@ -344,7 +312,6 @@ fn wrap_processed_outfox_packet(
     }
 }
 
-#[instrument(skip_all)]
 fn perform_final_processing(
     packet: NymProcessedPacket,
     packet_size: PacketSize,

common/nymsphinx/src/preparer/mod.rs

@@ -163,6 +163,19 @@ pub trait FragmentPreparer {
         })
     }
 
+    /// Tries to convert this [`Fragment`] into a [`SphinxPacket`] that can be sent through the Nym mix-network,
+    /// such that it contains required SURB-ACK and public component of the ephemeral key used to
+    /// derive the shared key.
+    /// Also all the data, apart from the said public component, is encrypted with an ephemeral shared key.
+    /// This method can fail if the provided network topology is invalid.
+    /// It returns total expected delay as well as the [`SphinxPacket`] (including first hop address)
+    /// to be sent through the network.
+    ///
+    /// The procedure is as follows:
+    /// For each fragment:
+    /// - compute SURB_ACK
+    /// - generate (x, g^x)
+    /// - compute k = KDF(remote encryption key ^ x) this is equivalent to KDF( dh(remote, x) )
     /// - compute v_b = AES-128-CTR(k, serialized_fragment)
     /// - compute vk_b = g^x || v_b
     /// - compute sphinx_plaintext = SURB_ACK || g^x || v_b
@@ -176,8 +189,6 @@ pub trait FragmentPreparer {
         packet_sender: &Recipient,
         packet_recipient: &Recipient,
         packet_type: PacketType,
-        #[cfg(feature = "otel")]
-        trace_id: Option<[u8; 12]>,
     ) -> Result<PreparedFragment, NymTopologyError> {
         debug!("Preparing chunk for sending");
         // each plain or repliable packet (i.e. not a reply) attaches an ephemeral public key so that the recipient
@@ -238,16 +249,6 @@ pub trait FragmentPreparer {
             topology.random_route_to_egress(&mut rng, destination)?
         };
 
-        #[cfg(feature = "otel")]
-        let destination = packet_recipient.as_sphinx_destination(trace_id);
-
-        #[cfg(feature = "otel")]
-        tracing::info!(
-            "Packet destination with trace id: {:?}",
-            &destination.identifier
-        );
-        
-        #[cfg(not(feature = "otel"))]
         let destination = packet_recipient.as_sphinx_destination();
 
         // including set of delays
@@ -273,7 +274,6 @@ pub trait FragmentPreparer {
             )?,
         };
 
-        // - compute k = KDF(remote encryption key ^ x) this is equivalent to KDF( dh(remote, x) )
         // from the previously constructed route extract the first hop
         let first_hop_address =
             NymNodeRoutingAddress::try_from(route.first().unwrap().address).unwrap();
@@ -428,8 +428,6 @@ where
         ack_key: &AckKey,
         packet_recipient: &Recipient,
         packet_type: PacketType,
-        #[cfg(feature = "otel")]
-        trace_id: Option<[u8; 12]>,
     ) -> Result<PreparedFragment, NymTopologyError> {
         let sender = self.sender_address;
 
@@ -441,8 +439,6 @@ where
             &sender,
             packet_recipient,
             packet_type,
-            #[cfg(feature = "otel")]
-            trace_id,
         )
     }
 

common/nymsphinx/types/Cargo.toml

@@ -10,8 +10,6 @@ repository = { workspace = true }
 [dependencies]
 sphinx-packet = { workspace = true, optional = true }
 nym-outfox = { path = "../../../nym-outfox", optional = true }
-# TODO add optional
-nym-bin-common = { path = "../../../common/bin-common" }
 thiserror = { workspace = true }
 
 [features]

common/nyxd-scraper/Cargo.toml

@@ -32,6 +32,8 @@ tracing.workspace = true
 url.workspace = true
 
 
+# TEMP
+#nym-bin-common = { path = "../bin-common", features = ["basic_tracing"]}
 
 
 [build-dependencies]

common/socks5-client-core/Cargo.toml

@@ -37,4 +37,3 @@ nym-validator-client = { path = "../client-libs/validator-client" }
 
 [features]
 default = []
-otel = ["nym-sphinx/otel"]

common/socks5-client-core/src/socks/client.rs

@@ -350,8 +350,6 @@ impl SocksClient {
             self.config.connection_start_surbs,
             TransmissionLane::ConnectionId(self.connection_id),
             self.packet_type,
-            #[cfg(feature = "otel")]
-            None,
         );
         self.input_sender
             .send(input_message)
@@ -375,8 +373,6 @@ impl SocksClient {
             msg.into_bytes(),
             TransmissionLane::ConnectionId(self.connection_id),
             self.packet_type,
-            #[cfg(feature = "otel")]
-            None,
         );
         self.input_sender
             .send(input_message)
@@ -443,8 +439,6 @@ impl SocksClient {
                     per_request_surbs,
                     lane,
                     packet_type,
-                    #[cfg(feature = "otel")]
-                    None,
                 )
             } else {
                 InputMessage::new_regular(
@@ -452,8 +446,6 @@ impl SocksClient {
                     provider_message.into_bytes(),
                     lane,
                     packet_type,
-                    #[cfg(feature = "otel")]
-                    None,
                 )
             }
         })

common/task/src/lib.rs

@@ -24,6 +24,6 @@ pub use crate::runtime_registry::RegistryAccessError;
 
 /// Get or create a ShutdownTracker for SDK use.
 /// This provides automatic task management without requiring manual setup.
-pub fn get_sdk_shutdown_tracker() -> Result<ShutdownTracker, RegistryAccessError> {
-    Ok(runtime_registry::RuntimeRegistry::get_or_create_sdk()?.shutdown_tracker_owned())
+pub fn create_sdk_shutdown_tracker() -> Result<ShutdownTracker, RegistryAccessError> {
+    Ok(runtime_registry::RuntimeRegistry::create_sdk()?.shutdown_tracker_owned())
 }

common/task/src/runtime_registry.rs

@@ -19,30 +19,45 @@ pub(crate) struct RuntimeRegistry {
 pub enum RegistryAccessError {
     #[error("the runtime registry is poisoned")]
     Poisoned,
+
+    #[error("The SDK ShutdownManager already exists")]
+    ExistingShutdownManager,
+
+    #[error("No existing SDK ShutdownManager")]
+    MissingShutdownManager,
 }
 
 impl RuntimeRegistry {
-    /// Get or create a ShutdownManager for SDK use.
+    /// Create a ShutdownManager for SDK use.
     /// This manager doesn't listen to OS signals, making it suitable for library use.
-    pub(crate) fn get_or_create_sdk() -> Result<Arc<ShutdownManager>, RegistryAccessError> {
+    /// This function overwrite any existing manager!
+    pub(crate) fn create_sdk() -> Result<Arc<ShutdownManager>, RegistryAccessError> {
+        let mut guard = REGISTRY
+            .sdk_manager
+            .write()
+            .map_err(|_| RegistryAccessError::Poisoned)?;
+
+        Ok(guard
+            .insert(Arc::new(
+                ShutdownManager::new_without_signals().with_cancel_on_panic(),
+            ))
+            .clone())
+    }
+
+    /// Get the  ShutdownManager for SDK use.
+    /// This manager doesn't listen to OS signals, making it suitable for library use.
+    /// Not yet used, but maybe in the future
+    #[allow(dead_code)]
+    pub(crate) fn get_sdk() -> Result<Arc<ShutdownManager>, RegistryAccessError> {
         let guard = REGISTRY
             .sdk_manager
             .read()
             .map_err(|_| RegistryAccessError::Poisoned)?;
         if let Some(manager) = guard.as_ref() {
-            return Ok(manager.clone());
+            Ok(manager.clone())
+        } else {
+            Err(RegistryAccessError::MissingShutdownManager)
         }
-        drop(guard);
-
-        let mut guard = REGISTRY
-            .sdk_manager
-            .write()
-            .map_err(|_| RegistryAccessError::Poisoned)?;
-        Ok(guard
-            .get_or_insert_with(|| {
-                Arc::new(ShutdownManager::new_without_signals().with_cancel_on_panic())
-            })
-            .clone())
     }
 
     /// Check if an SDK manager has been created.
@@ -85,10 +100,13 @@ mod tests {
 
         assert!(!RuntimeRegistry::has_sdk_manager().unwrap());
 
-        let manager1 = RuntimeRegistry::get_or_create_sdk().unwrap();
+        // Error if nothing was created
+        assert!(RuntimeRegistry::get_sdk().is_err());
+
+        let manager1 = RuntimeRegistry::create_sdk().unwrap();
         assert!(RuntimeRegistry::has_sdk_manager().unwrap());
 
-        let manager2 = RuntimeRegistry::get_or_create_sdk().unwrap();
+        let manager2 = RuntimeRegistry::get_sdk().unwrap();
         // Should return the same instance
         assert!(Arc::ptr_eq(&manager1, &manager2));
 

common/types/Cargo.toml

@@ -29,7 +29,6 @@ x25519-dalek = { workspace = true, features = ["static_secrets"] }
 cosmwasm-std = { workspace = true }
 cosmrs = { workspace = true }
 
-nym-bin-common = { path = "../../common/bin-common" }
 nym-validator-client = { path = "../../common/client-libs/validator-client" }
 nym-mixnet-contract-common = { path = "../../common/cosmwasm-smart-contracts/mixnet-contract" }
 nym-vesting-contract-common = { path = "../../common/cosmwasm-smart-contracts/vesting-contract" }

contracts/coconut-dkg/src/dealers/transactions.rs

@@ -110,7 +110,7 @@ pub fn try_transfer_ownership(
     DEALERS_INDICES.save(deps.storage, &transfer_to, &current_index)?;
     DEALERS_INDICES.remove(deps.storage, &info.sender);
 
-    // update registration detail for every epoch the current dealer has participated in the protocol
+    // update registration detail and share information for every epoch the current dealer has participated in the protocol
     // ideally, we'd have only updated the current epoch, but the way the contract is constructed
     // forbids that otherwise we'd have introduced inconsistency
     for epoch_id in 0..=epoch.epoch_id {
@@ -118,6 +118,11 @@ pub fn try_transfer_ownership(
             EPOCH_DEALERS_MAP.remove(deps.storage, (epoch_id, &info.sender));
             EPOCH_DEALERS_MAP.save(deps.storage, (epoch_id, &transfer_to), &details)?;
         }
+        if let Some(mut vk_share) = vk_shares().may_load(deps.storage, (&info.sender, epoch_id))? {
+            vk_shares().remove(deps.storage, (&info.sender, epoch_id))?;
+            vk_share.owner = transfer_to.clone();
+            vk_shares().save(deps.storage, (&transfer_to, epoch_id), &vk_share)?;
+        }
     }
 
     let Some(transaction_info) = env.transaction else {
@@ -262,6 +267,7 @@ mod tests_with_mock {
         contract.run_initial_dummy_dkg();
         let old_index = DEALERS_INDICES.load(&contract, &group_member)?;
         let old_details = EPOCH_DEALERS_MAP.load(&contract, (0, &group_member))?;
+        let old_share = vk_shares().load(&contract, (&group_member, 0))?;
 
         let not_group_member = contract.addr_make("not_group_member");
         let (deps, env) = contract.deps_mut_env();
@@ -291,13 +297,20 @@ mod tests_with_mock {
         assert!(EPOCH_DEALERS_MAP
             .may_load(&contract, (0, &group_member))?
             .is_none());
+        assert!(vk_shares()
+            .may_load(&contract, (&group_member, 0))?
+            .is_none());
 
         let new_index = DEALERS_INDICES.load(&contract, &new_group_member)?;
         let new_details = EPOCH_DEALERS_MAP.load(&contract, (0, &new_group_member))?;
+        let new_share = vk_shares().load(&contract, (&new_group_member, 0))?;
 
         // the underlying info hasn't changed
         assert_eq!(old_index, new_index);
         assert_eq!(old_details, new_details);
+        assert_ne!(old_share, new_share);
+        assert_eq!(old_share.owner, group_member);
+        assert_eq!(new_share.owner, new_group_member);
 
         assert_eq!(
             OWNERSHIP_TRANSFER_LOG.load(

documentation/docs/components/operators/snippets/quic-bridge-deployment-script-setup.mdx

@@ -15,6 +15,7 @@ Operators can use [Nym Bridge Configuration Tool](https://github.com/nymtech/nym
 <Steps>
 ###### 1. Download [`quic_bridge_deployment.sh`](https://github.com/nymtech/nym/blob/develop/scripts/nym-node-setup/quic_bridge_deployment.sh) script
 - SSH to your server
+- **Run as root**
 - Download the script and make executable
 ```sh
 wget https://raw.githubusercontent.com/nymtech/nym/refs/heads/develop/scripts/nym-node-setup/quic_bridge_deployment.sh && \
@@ -26,7 +27,7 @@ chmod +x quic_bridge_deployment.sh
 - Optional: open `tmux` in case you will need to run another commands on the VPS
 - Run the script with a command `full_bridge_setup`
 ```sh
-./nym-node-setup/quic_bridge_deployment.sh full_bridge_setup
+./quic_bridge_deployment.sh full_bridge_setup
 ```
 
 ###### 3. Follow the interactive prompts

documentation/docs/components/outputs/api-scraping-outputs/time-now.md

@@ -1 +1 @@
-Tuesday, October 14th 2025, 11:34:14 UTC
+Thursday, October 30th 2025, 13:00:59 UTC

documentation/docs/components/outputs/command-outputs/node-api-check-query-help.md

@@ -11,7 +11,7 @@ options:
   --no_routing_history  Display node stats without routing history
   --no_verloc_metrics   Display node stats without verloc metrics
   -m, --markdown        Display results in markdown format
-  -o, --output [OUTPUT]
+  -o [OUTPUT], --output [OUTPUT]
                         Save results to file (in current dir or supply with
                         path without filename)
 ```

documentation/docs/components/outputs/csv2md-outputs/isp-sheet.md

@@ -18,23 +18,23 @@
 | [Hostslick](https://hostslick.com)                                                                                   | Netherlands, Germany                                                                                                                                | Yes, on by default                   | Yes                                                | Good amount of bandwidth for the price. Make sure you open the ticket if you want to run Exit node                                                                                                                  | 07/2024            |
 | [Incognet](https://incognet.io)                                                                                      | Netherlands and USA                                                                                                                                 | Yes, on by default                   | Yes                                                | They allow Tor exit nodes but you must adhere to their rules https://incognet.io/tor-exits                                                                                                                          | 07/2024            |
 | [Incognet](https://incognet.io/kansas-city-dedicated-servers)                                                        | USA, Netherlands                                                                                                                                    | Yes                                  | nan                                                | nan                                                                                                                                                                                                                 | 07/2025            |
-| [Ionos](https://www.ionos.com/servers/amd-servers)                                                                   | US, DE, UK, ESP, FR                                                                                                                                 | nan                                  | No                                                 | nan                                                                                                                                                                                                                 | 07/2025            |
+| [Ionos](https://www.ionos.com/servers/amd-servers)                                                                   | USA, DE, UK, ESP, FR                                                                                                                                | nan                                  | No                                                 | nan                                                                                                                                                                                                                 | 07/2025            |
 | [IsHosting](https://ishosting.com/en)                                                                                | Brazil, Netherlands                                                                                                                                 | Yes, based on ticket                 | Yes                                                | Expensive                                                                                                                                                                                                           | 05/2024            |
-| [Leaseweb](https://www.leaseweb.com/en/configure/vc/product/entityKey/DEDSER02_NEW_ORDER_BUSINESS_R740XD-24SFF-6134) | US, NL, DE, UK, CA, SG, JP, AUS, HK                                                                                                                 | nan                                  | No                                                 | KYC mandatory                                                                                                                                                                                                       | 07/2025            |
+| [Leaseweb](https://www.leaseweb.com/en/configure/vc/product/entityKey/DEDSER02_NEW_ORDER_BUSINESS_R740XD-24SFF-6134) | USA, NL, DE, UK, CA, SG, JP, AUS, HK                                                                                                                | nan                                  | No                                                 | KYC mandatory                                                                                                                                                                                                       | 07/2025            |
 | [Linode](https://linode.com)                                                                                         | USA, Canada, Japan, India, Indonesia, Sweden, Netherlands, Germany, Brazil, France, UK, Australia, Italy                                            | Yes out of the box                   | No, only through [BitLAunch](https://bitlaunch.io) | IPv6 sometimes need to be re-added in Networking tab, no reboot needed                                                                                                                                              | 05/2024            |
 | [LiteServer](https://liteserver.nl)                                                                                  | Netherlands                                                                                                                                         | Yes, on by default                   | Yes                                                | Very reliable Dutch provider. They do allow Relay nodes but for Exit nodes you need to contact them. Always check T&C https://liteserver.nl/legal                                                                   | 07/2024            |
 | [Lowendbox](https://lowendbox.com/category/dedicated-servers)                                                        |                                                                                                                                                     |                                      |                                                    | Just an aggregator with good offers                                                                                                                                                                                 | 07/2025            |
 | [M247](https://m247.com/eu/services/host/dedicated-servers/)                                                         | UK, Austria, Br, Sw, Jp, Poland, Fr, USA, Netherlands                                                                                               | Yes                                  | No                                                 | nan                                                                                                                                                                                                                 | 07/2025            |
-| [Mebilcom](https://www.melbicom.net/dedicatedserver/)                                                                | NL, US, DE, UAE, NG, ESP, IN, IT, FR, LT, SG, BG, LV, PL                                                                                            | nan                                  | No                                                 | nan                                                                                                                                                                                                                 | 07/2025            |
+| [Mebilcom](https://www.melbicom.net/dedicatedserver/)                                                                | NL, USA, DE, UAE, NG, ESP, IN, IT, FR, LT, SG, BG, LV, PL                                                                                           | nan                                  | No                                                 | nan                                                                                                                                                                                                                 | 07/2025            |
 | [Mevspace](https://mevspace.com)                                                                                     | Poland                                                                                                                                              | Yes, on by default                   | Yes                                                | Flexible Polish providers with 3 DCs in Poland. They do allow Tor Exit nodes but you may need a dedicated server for this. Make sure you open a ticket to check. As of today's date, they have 48h for 1 EUR tariff | 07/2024            |
 | [Misaka](https://www.misaka.io/)                                                                                     | South Africa                                                                                                                                        | Yes, native support                  | No                                                 | Very Expensive                                                                                                                                                                                                      | 05/2024            |
 | [NiceVPS](https://nicevps.net/)                                                                                      | Netherlands                                                                                                                                         | Yes                                  | nan                                                | nan                                                                                                                                                                                                                 | 07/2025            |
 | [Njalla](https://nja.la)                                                                                             | Sweden                                                                                                                                              | Yes                                  | Yes                                                | Privacy vandguards! The biggest VPS 45 is 3 cores only, but it works better than many “larger” servers on the market.                                                                                               | 05/2024            |
 | [OVH](https://us.ovhcloud.com/bare-metal/rise/rise-3/)                                                               | USA, DE, FR, UK, PL, CA                                                                                                                             |                                      | No                                                 | Not all locations always available                                                                                                                                                                                  | 07/2025            |
-| [Oneprovider](https://oneprovider.com/en/dedicated-servers/ipv6)                                                     | PL, FR, NL, UA, US, BG, RO, DK, ESP, NO, CZ, RS, IE, IT, UK, HU, CH, SK, AT, BE, BA, HK, JP, SG, LU, AU, SWE, UAE, BR, CR, MX, GR, CL, MA, AR       | Yes                                  | No                                                 | nan                                                                                                                                                                                                                 | 07/2025            |
+| [Oneprovider](https://oneprovider.com/en/dedicated-servers/ipv6)                                                     | PL, FR, NL, UA, USA, BG, RO, DK, ESP, NO, CZ, RS, IE, IT, UK, HU, CH, SK, AT, BE, BA, HK, JP, SG, LU, AU, SWE, UAE, BR, CR, MX, GR, CL, MA, AR      | Yes                                  | No                                                 | nan                                                                                                                                                                                                                 | 07/2025            |
 | [PrivateLayer](https://privatelayer.com)                                                                             | Swiss                                                                                                                                               | Yes                                  | Yes                                                | Slow customer response                                                                                                                                                                                              | 07/2025            |
 | [Privex](https://www.privex.io/tor-exit-policy/)                                                                     | USA, Germany, Sweden                                                                                                                                | Yes                                  | Yes                                                | nan                                                                                                                                                                                                                 | 07/2025            |
-| [Psychz](https://www.psychz.net)                                                                                     | US, UK, Brazil, Japan, Russia, South Africa and many more                                                                                           | Yes                                  | nan                                                | nan                                                                                                                                                                                                                 | 07/2025            |
+| [Psychz](https://www.psychz.net)                                                                                     | USA, UK, Brazil, Japan, Russia, South Africa and many more                                                                                          | Yes                                  | nan                                                | nan                                                                                                                                                                                                                 | 07/2025            |
 | [RDP](https://rdp.sh)                                                                                                | Netherlands, USA, Poland                                                                                                                            | Yes, on by default                   | Yes                                                | German provider. Exit nodes are allowed, policy is here https://rdp.sh/docs/faq/tor ports 25,465,587 must be closed. Make sure you open a ticket before running an exit node.                                       | 07/2024            |
 | [Servermania](https://www.servermania.com/dedicated-servers-hosting.htm)                                             | USA, Canada                                                                                                                                         | nan                                  | No                                                 | nan                                                                                                                                                                                                                 | 07/2025            |
 | [Svea](https://svea.net/vps)                                                                                         | Sweden                                                                                                                                              | Yes                                  | nan                                                | nan                                                                                                                                                                                                                 | 07/2025            |

documentation/docs/data/csv/isp-sheet.csv

@@ -21,11 +21,11 @@
 [Lowendbox](https://lowendbox.com/category/dedicated-servers), , , ,Just an aggregator with good offers,07/2025
 [Thundervm](https://thundervm.com/en/hosting/dedicated-server),"USA, UK, France, Italy, Switzerland, Netherlands",,Yes, ,07/2025
 [OVH](https://us.ovhcloud.com/bare-metal/rise/rise-3/),"USA, DE, FR, UK, PL, CA", ,No,Not all locations always available,07/2025
-[Mebilcom](https://www.melbicom.net/dedicatedserver/),"NL, US, DE, UAE, NG, ESP, IN, IT, FR, LT, SG, BG, LV, PL",,No,,07/2025
+[Mebilcom](https://www.melbicom.net/dedicatedserver/),"NL, USA, DE, UAE, NG, ESP, IN, IT, FR, LT, SG, BG, LV, PL",,No,,07/2025
 [Servermania](https://www.servermania.com/dedicated-servers-hosting.htm),"USA, Canada",,No,,07/2025
-[Oneprovider](https://oneprovider.com/en/dedicated-servers/ipv6),"PL, FR, NL, UA, US, BG, RO, DK, ESP, NO, CZ, RS, IE, IT, UK, HU, CH, SK, AT, BE, BA, HK, JP, SG, LU, AU, SWE, UAE, BR, CR, MX, GR, CL, MA, AR",Yes,No,,07/2025
-[Ionos](https://www.ionos.com/servers/amd-servers),"US, DE, UK, ESP, FR",,No,,07/2025
-[Leaseweb](https://www.leaseweb.com/en/configure/vc/product/entityKey/DEDSER02_NEW_ORDER_BUSINESS_R740XD-24SFF-6134),"US, NL, DE, UK, CA, SG, JP, AUS, HK",,No,KYC mandatory,07/2025
+[Oneprovider](https://oneprovider.com/en/dedicated-servers/ipv6),"PL, FR, NL, UA, USA, BG, RO, DK, ESP, NO, CZ, RS, IE, IT, UK, HU, CH, SK, AT, BE, BA, HK, JP, SG, LU, AU, SWE, UAE, BR, CR, MX, GR, CL, MA, AR",Yes,No,,07/2025
+[Ionos](https://www.ionos.com/servers/amd-servers),"USA, DE, UK, ESP, FR",,No,,07/2025
+[Leaseweb](https://www.leaseweb.com/en/configure/vc/product/entityKey/DEDSER02_NEW_ORDER_BUSINESS_R740XD-24SFF-6134),"USA, NL, DE, UK, CA, SG, JP, AUS, HK",,No,KYC mandatory,07/2025
 [M247](https://m247.com/eu/services/host/dedicated-servers/),"UK, Austria, Br, Sw, Jp, Poland, Fr, USA, Netherlands",Yes,No,,07/2025
 [Hostroyale](https://hostroyale.com/hosting/dedicated-server/),Various countries with different pricing,, Yes,,07/2025
 [DataPacket](https://www.datapacket.com/pricing),"NL, GR, SK, BE, RO, HU, DK, IE, DE, UA, PT, GB, ES, FR, IT, NO, CZ, BG, SE, AT, PL, HR, CH, USA, CO, AR, PE, MX, CL, TR, ZA, NG, IL, HK, AU, SG, JP",Yes,,,07/2025
@@ -35,7 +35,7 @@
 [Colocall](https://www.colocall.net/),Ukraine,Yes,,,07/2025
 [Incognet](https://incognet.io/kansas-city-dedicated-servers),"USA, Netherlands",Yes,,,07/2025
 [FranTech](https://my.frantech.ca),USA,Yes,,,07/2025
-[Psychz](https://www.psychz.net),"US, UK, Brazil, Japan, Russia, South Africa and many more",Yes,,,07/2025
+[Psychz](https://www.psychz.net),"USA, UK, Brazil, Japan, Russia, South Africa and many more",Yes,,,07/2025
 [Fsit](https://www.fsit.com/server/vps-vserver-kvm),Swiss,Yes,Yes,,07/2025
 [NiceVPS](https://nicevps.net/),Netherlands,Yes,,,07/2025
 [Dataclub](https://www.dataclub.eu/),"Latvia, Sweden, Netherlands",Yes,,,07/2027

documentation/docs/pages/operators/changelog.mdx

@@ -49,6 +49,90 @@ This page displays a full list of all the changes during our release cycle from
 
 <VarInfo />
 
+## `v2025.19-kase`
+
+- [Release Binaries](https://github.com/nymtech/nym/releases/tag/nym-binaries-v2025.19-kase)
+- [`nym-node`](nodes/nym-node.mdx) version `1.20.0`
+
+```sh
+nym-node
+Binary Name:        nym-node
+Build Timestamp:    2025-10-30T12:43:37.933354749Z
+Build Version:      1.20.0
+Commit SHA:         75a6d3426bd18dca600ad1cfa39b0a3c4f319c69
+Commit Date:        2025-10-30T11:59:32.000000000+01:00
+Commit Branch:      HEAD
+rustc Version:      1.88.0
+rustc Channel:      stable
+cargo Profile:      release
+```
+
+### Operators Updates & Tools
+
+<Callout type="info" emoji="ℹ️">
+**When this platform release becomes latest, we would like to ask operators ruuning any Gateway mode of `nym-node`, to use new version of [QUIC brige deployment tool](https://github.com/nymtech/nym/blob/develop/scripts/nym-node-setup/quic_bridge_deployment.sh)and install QUIC `nym-bridge` on their server, following [these steps](#quic-transport-bridge-deployment).**
+</Callout>
+
+Alongside this platform release we are happy to introduce several improvements and new tools for node operators.
+
+- [Updated version of QUIC brige deployment tool](https://github.com/nymtech/nym/blob/develop/scripts/nym-node-setup/quic_bridge_deployment.sh), **if you run a `nym-node` in any Gateway mode, please install QUIC on your server, following [these steps](#quic-transport-bridge-deployment)**
+
+- [New **Nym Node Status Dashboard**](https://node-status.nym.com)
+
+- [New **Harbourmaster** aka ***Nym Node Status Observatory***](https://harbourmaster.nymtech.net)
+
+
+
+### Features
+
+- [Propagate cancel token to mixnet client](https://github.com/nymtech/nym/pull/6105): Ensures cancellation token propagation to mixnet client
+
+- [[DOCs/operators] QUIC deployment script & docs](https://github.com/nymtech/nym/pull/6098): Script and documentation for QUIC deployment, referencing `nym-bridges` repository  
+
+- [Move gateway probe to monorepo (Rust edition 2024)](https://github.com/nymtech/nym/pull/6094): Moves `nym-gateway-probe` and related packages into monorepo, updates to Rust 2024 edition
+
+- [Expose reference to Mnemonic from `DirectSecp256k1HdWallet`](https://github.com/nymtech/nym/pull/6083): Adds safer accessors for mnemonic references and deprecates unsafe cloning
+
+### Bugfix
+
+- [Cherry pick - request #6143 from nymtech/bugfix/mix-tx-closed-v2](https://github.com/nymtech/nym/pull/6153): Add circuit breaker  
+<AccordionTemplate name={<TestingSteps/>}>
+ **Summary:**
+- Network-requester started successfully  
+- SOCKS5 client started successfully  
+- Traffic was proxied through the mixnet  
+- Shutdown was clean  
+- No 'channel closed (outside of shutdown!)' errors  
+</AccordionTemplate>
+
+- [`nym-credential-proxy` query params parsing regression](https://github.com/nymtech/nym/pull/6121): Fix query deserialization issue with `serde_urlencoded` breaking compatibility with VPN API
+
+- [Revert some dep updates introduced in #6043](https://github.com/nymtech/nym/pull/6120): Revert dependency updates that broke ANSI escape characters within tracing output
+
+- [Skip IPv6 metadata endpoint request](https://github.com/nymtech/nym/pull/6118): Skip querying IPv4-only metadata endpoints during IPv6 probing tests
+
+- [Revert "Propagate cancel token to mixnet client"](https://github.com/nymtech/nym/pull/6115): Reverts earlier change due to premature mixnet exit issues
+
+- [Retrieve and update ticketbook in the same query](https://github.com/nymtech/nym/pull/6101): Fix concurrency issue with multiple agents retrieving ticketbooks simultaneously
+
+- [Include network name in default gateway probe config path](https://github.com/nymtech/nym/pull/6100): Prevents reuse of credentials across different networks
+
+- [Incompatibility fixes](https://github.com/nymtech/nym/pull/6099): Fixes several incompatibilities, including initialization and build mismatches
+
+- [Testnet manager `02sql` migration](https://github.com/nymtech/nym/pull/6096): Fix invalid FK constraint blocking SQL migration
+
+- [Use custom topology provider for list of init gateways](https://github.com/nymtech/nym/pull/6092): Fixes SDK bug where clients ignored custom topology provider on registration
+
+- [Fix `WASM` client + build commands](https://github.com/nymtech/nym/pull/6043): Fixes WASM client hang and runtime time-related issues; improves internal dev testing stability
+
+### Refactors & Maintenance
+
+- [Update to no longer use 1mb files](https://github.com/nymtech/nym/pull/6117)
+
+- [Restore pending DKG contract state migration](https://github.com/nymtech/nym/pull/6116)
+
+- [Update `dirs` to `6.0`](https://github.com/nymtech/nym/pull/6109): Minor dependency update, safe for compatibility
+
 ## `v2025.18-jarlsberg`
 
 - [Release Binaries](https://github.com/nymtech/nym/releases/tag/nym-binaries-v2025.18-jarlsberg)

documentation/docs/pages/operators/nodes/nym-node/setup.mdx

@@ -21,13 +21,13 @@ This documentation page provides a guide on how to set up and run a [NYM NODE](.
 ```sh
 nym-node
 Binary Name:        nym-node
-Build Timestamp:    2025-10-15T09:04:32.043934599Z
-Build Version:      1.19.0
-Commit SHA:         2235a6e1477bea7368ee5443a298f544deb63504
-Commit Date:        2025-10-15T10:22:16.000000000+02:00
-Commit Branch:      master
-rustc Version:      1.92.0-nightly
-rustc Channel:      nightly
+Build Timestamp:    2025-10-30T12:43:37.933354749Z
+Build Version:      1.20.0
+Commit SHA:         75a6d3426bd18dca600ad1cfa39b0a3c4f319c69
+Commit Date:        2025-10-30T11:59:32.000000000+01:00
+Commit Branch:      HEAD
+rustc Version:      1.88.0
+rustc Channel:      stable
 cargo Profile:      release
 ```
 

gateway/Cargo.toml

@@ -50,7 +50,6 @@ zeroize = { workspace = true }
 
 # internal
 nym-api-requests = { path = "../nym-api/nym-api-requests" }
-nym-bin-common = { path = "../common/bin-common" }
 nym-credentials = { path = "../common/credentials" }
 nym-credentials-interface = { path = "../common/credentials-interface" }
 nym-credential-verification = { path = "../common/credential-verification" }
@@ -83,25 +82,9 @@ nym-service-provider-requests-common = { path = "../common/service-provider-requ
 
 
 defguard_wireguard_rs = { workspace = true }
-opentelemetry = { workspace = true, optional = true }
-opentelemetry_sdk = { workspace = true, optional = true }
-tracing-opentelemetry = { workspace = true, optional = true }
 
 [dev-dependencies]
 nym-gateway-storage = { path = "../common/gateway-storage", features = ["mock"] }
 nym-wireguard = { path = "../common/wireguard", features = ["mock"] }
 mock_instant = "0.6.0"
 time = { workspace = true }
-
-[features]
-default = []
-otel = [
-    "nym-bin-common/otel",
-    "nym-client-core/otel",
-    "nym-gateway-requests/otel",
-    "nym-sphinx/otel",
-    "nym-sdk/otel",
-    "opentelemetry",
-    "opentelemetry_sdk",
-    "tracing-opentelemetry",
-]

gateway/src/node/client_handling/websocket/connection_handler/authenticated.rs

@@ -14,8 +14,6 @@ use futures::{
     future::{FusedFuture, OptionFuture},
     FutureExt, StreamExt,
 };
-#[cfg(feature = "otel")]
-use nym_bin_common::opentelemetry::context::ManualContextPropagator;
 use nym_credential_verification::CredentialVerifier;
 use nym_credential_verification::{
     bandwidth_storage_manager::BandwidthStorageManager, ClientBandwidth,
@@ -33,8 +31,6 @@ use nym_sphinx::forwarding::packet::MixPacket;
 use nym_statistics_common::{gateways::GatewaySessionEvent, types::SessionType};
 use nym_validator_client::coconut::EcashApiError;
 use rand::{random, CryptoRng, Rng};
-#[cfg(feature = "otel")]
-use std::collections::HashMap;
 use std::{process, time::Duration};
 use thiserror::Error;
 use tokio::io::{AsyncRead, AsyncWrite};
@@ -151,8 +147,6 @@ pub(crate) struct AuthenticatedHandler<R, S> {
     // senders that are used to return the result of the ping to the handler requesting the ping.
     is_active_request_receiver: IsActiveRequestReceiver,
     is_active_ping_pending_reply: Option<(u64, IsActiveResultSender)>,
-    #[cfg(feature = "otel")]
-    pub otel_propagator: Option<ManualContextPropagator>,
 }
 
 // explicitly remove handle from the global store upon being dropped
@@ -195,24 +189,6 @@ impl<R, S> AuthenticatedHandler<R, S> {
                 client_address: client.address.as_base58_string(),
             })?;
 
-        #[cfg(feature = "otel")]
-        let manual_ctx_propagator = {
-            let context = match client.otel_context {
-                Some(ref ctx) => ctx.clone(),
-                None => HashMap::new(),
-            };
-
-            let manual_ctx_propagator = if !context.is_empty() {
-                Some(ManualContextPropagator::new(
-                    "upgrading_fresh_to_authenticated",
-                    context,
-                ))
-            } else {
-                None
-            };
-            manual_ctx_propagator
-        };
-
         let handler = AuthenticatedHandler {
             bandwidth_storage_manager: BandwidthStorageManager::new(
                 Box::new(fresh.shared_state.storage.clone()),
@@ -226,8 +202,6 @@ impl<R, S> AuthenticatedHandler<R, S> {
             mix_receiver,
             is_active_request_receiver,
             is_active_ping_pending_reply: None,
-            #[cfg(feature = "otel")]
-            otel_propagator: manual_ctx_propagator,
         };
         handler.send_metrics(GatewaySessionEvent::new_session_start(
             handler.client.address,
@@ -253,19 +227,7 @@ impl<R, S> AuthenticatedHandler<R, S> {
     /// # Arguments
     ///
     /// * `mix_packet`: packet received from the client that should get forwarded into the network.
-    #[instrument(skip_all)]
     fn forward_packet(&self, mix_packet: MixPacket) {
-        #[cfg(feature = "otel")]
-        {
-            let span = match &self.otel_propagator {
-                Some(propagator) => {
-                    info_span!(parent: &propagator.root_span, "forwarding_mix_packet")
-                }
-                None => info_span!("forwarding_mix_packet_no_otel"),
-            };
-            let _enter = span.enter();
-        }
-
         if let Err(err) = self
             .inner
             .shared_state
@@ -325,26 +287,11 @@ impl<R, S> AuthenticatedHandler<R, S> {
         &mut self,
         mix_packet: MixPacket,
     ) -> Result<ServerResponse, RequestHandlingError> {
-        trace!("forwarding sphinx packet");
-        #[cfg(feature = "otel")]
-        let span = {
-            let span = match &self.otel_propagator {
-                Some(propagator) => {
-                    info_span!(parent: &propagator.root_span, "handling_forward_sphinx")
-                }
-                None => debug_span!("handling_forward_sphinx_no_otel"),
-            };
-            span
-        };
-        #[cfg(feature = "otel")]
-        let _enter = span.enter();
-
         let required_bandwidth = mix_packet.packet().len() as i64;
 
         let remaining_bandwidth = self
             .bandwidth_storage_manager
             .try_use_bandwidth(required_bandwidth)
-            .in_current_span()
             .await?;
         self.forward_packet(mix_packet);
 
@@ -358,22 +305,8 @@ impl<R, S> AuthenticatedHandler<R, S> {
     /// # Arguments
     ///
     /// * `bin_msg`: raw message to handle.
-    #[instrument(skip_all)]
     async fn handle_binary(&mut self, bin_msg: Vec<u8>) -> Message {
         trace!("binary request");
-        #[cfg(feature = "otel")]
-        let span = {
-            let span = match &self.otel_propagator {
-                Some(propagator) => {
-                    info_span!(parent: &propagator.root_span, "handling_binary_request")
-                }
-                None => info_span!("handling_binary_request_no_otel"),
-            };
-            span
-        };
-        #[cfg(feature = "otel")]
-        let _enter = span.enter();
-
         // this function decrypts the request and checks the MAC
         match BinaryRequest::try_from_encrypted_tagged_bytes(bin_msg, &self.client.shared_keys) {
             Err(e) => {
@@ -383,11 +316,9 @@ impl<R, S> AuthenticatedHandler<R, S> {
             Ok(request) => match request {
                 // currently only a single type exists
                 BinaryRequest::ForwardSphinx { packet }
-                | BinaryRequest::ForwardSphinxV2 { packet } => self
-                    .handle_forward_sphinx(packet)
-                    .in_current_span()
-                    .await
-                    .into_ws_message(),
+                | BinaryRequest::ForwardSphinxV2 { packet } => {
+                    self.handle_forward_sphinx(packet).await.into_ws_message()
+                }
                 _ => RequestHandlingError::UnknownBinaryRequest.into_error_message(),
             },
         }
@@ -448,7 +379,6 @@ impl<R, S> AuthenticatedHandler<R, S> {
         Ok(SensitiveServerResponse::KeyUpgradeAck {}.encrypt(&self.client.shared_keys)?)
     }
 
-    #[instrument(skip_all)]
     async fn handle_encrypted_text_request(
         &mut self,
         ciphertext: Vec<u8>,
@@ -478,7 +408,6 @@ impl<R, S> AuthenticatedHandler<R, S> {
     /// # Arguments
     ///
     /// * `raw_request`: raw message to handle.
-    #[instrument(skip_all)]
     async fn handle_text(&mut self, raw_request: String) -> Message
     where
         R: Rng + CryptoRng,
@@ -623,7 +552,6 @@ impl<R, S> AuthenticatedHandler<R, S> {
         }
     }
 
-    #[instrument(skip_all)]
     async fn handle_is_active_request(
         &mut self,
         reply_tx: IsActiveResultSender,
@@ -654,37 +582,20 @@ impl<R, S> AuthenticatedHandler<R, S> {
     /// Simultaneously listens for incoming client requests, which realistically should only be
     /// binary requests to forward sphinx packets or increase bandwidth
     /// and for sphinx packets received from the mix network that should be sent back to the client.
-    #[instrument(level = "debug", skip_all,
-        fields(
-            client = %self.client.address.as_base58_string()
-        )
-    )]
     pub(crate) async fn listen_for_requests(mut self)
     where
         R: Rng + CryptoRng,
         S: AsyncRead + AsyncWrite + Unpin,
     {
         trace!("Started listening for ALL incoming requests...");
+
         // Ping timeout future used to check if the client responded to our ping request
         let mut ping_timeout: OptionFuture<_> = None.into();
 
-        #[cfg(feature = "otel")]
-        let from_client_span = {
-            let span = match &self.otel_propagator {
-                Some(propagator) => {
-                    info_span!(parent: &propagator.root_span, "authenticated_client_handler_listen")
-                }
-                None => tracing::debug_span!("authenticated_client_handler_listen_no_otel"),
-            };
-            span
-        };
-        #[cfg(feature = "otel")]
-        let _enter = from_client_span.enter();
-
         loop {
             tokio::select! {
                 // Received a request to ping the client to check if it's still active
-                tx = self.is_active_request_receiver.next().in_current_span() => {
+                tx = self.is_active_request_receiver.next() => {
                     match tx {
                         None => break,
                         Some(reply_tx) => {
@@ -698,10 +609,10 @@ impl<R, S> AuthenticatedHandler<R, S> {
                 },
                 // The ping timeout expired, meaning the client didn't respond to our ping request
                 _ = &mut ping_timeout, if !ping_timeout.is_terminated() => {
-                    ping_timeout = None.into();
-                    self.handle_ping_timeout().await;
+                   ping_timeout = None.into();
+                   self.handle_ping_timeout().await;
                 },
-                socket_msg = self.inner.read_websocket_message().in_current_span() => {
+                socket_msg = self.inner.read_websocket_message() => {
                     let socket_msg = match socket_msg {
                         None => break,
                         Some(Ok(socket_msg)) => socket_msg,
@@ -716,7 +627,7 @@ impl<R, S> AuthenticatedHandler<R, S> {
                     }
 
                     if let Some(response) = self.handle_request(socket_msg).await {
-                        if let Err(err) = self.inner.send_websocket_message(response).in_current_span().await {
+                        if let Err(err) = self.inner.send_websocket_message(response).await {
                             debug!(
                                 "Failed to send message over websocket: {err}. Assuming the connection is dead.",
                             );
@@ -724,7 +635,7 @@ impl<R, S> AuthenticatedHandler<R, S> {
                         }
                     }
                 },
-                mix_messages = self.mix_receiver.next().in_current_span() => {
+                mix_messages = self.mix_receiver.next() => {
                     let mix_messages = match mix_messages {
                         None => {
                             debug!("mix receiver was closed! Assuming the connection is dead.");

gateway/src/node/client_handling/websocket/connection_handler/fresh.rs

@@ -13,8 +13,6 @@ use futures::{
     channel::{mpsc, oneshot},
     SinkExt, StreamExt,
 };
-#[cfg(feature = "otel")]
-use nym_bin_common::opentelemetry::context::ManualContextPropagator;
 use nym_credentials_interface::AvailableBandwidth;
 use nym_crypto::aes::cipher::crypto_common::rand_core::RngCore;
 use nym_crypto::asymmetric::ed25519;
@@ -36,8 +34,6 @@ use nym_node_metrics::events::MetricsEvent;
 use nym_sphinx::DestinationAddressBytes;
 use nym_task::ShutdownToken;
 use rand::CryptoRng;
-#[cfg(feature = "otel")]
-use std::collections::HashMap;
 use std::net::SocketAddr;
 use std::time::Duration;
 use thiserror::Error;
@@ -45,9 +41,7 @@ use time::OffsetDateTime;
 use tokio::io::{AsyncRead, AsyncWrite};
 use tokio::time::timeout;
 use tokio_tungstenite::tungstenite::{protocol::Message, Error as WsError};
-#[cfg(feature = "otel")]
-use tracing::info_span;
-use tracing::{debug, error, info, instrument, warn, Instrument};
+use tracing::*;
 
 #[derive(Debug, Error)]
 pub(crate) enum InitialAuthenticationError {
@@ -169,7 +163,6 @@ impl<R, S> FreshHandler<R, S> {
 
     /// Attempts to perform websocket handshake with the remote and upgrades the raw TCP socket
     /// to the framed WebSocket.
-    #[instrument(skip_all)]
     pub(crate) async fn perform_websocket_handshake(&mut self) -> Result<(), WsError>
     where
         S: AsyncRead + AsyncWrite + Unpin,
@@ -193,7 +186,6 @@ impl<R, S> FreshHandler<R, S> {
     /// # Arguments
     ///
     /// * `init_msg`: a client handshake init message which should contain its identity public key as well as an ephemeral key.
-    #[instrument(skip_all)]
     async fn perform_registration_handshake(
         &mut self,
         init_msg: Vec<u8>,
@@ -219,7 +211,6 @@ impl<R, S> FreshHandler<R, S> {
     }
 
     /// Attempts to read websocket message from the associated socket.
-    #[instrument(skip_all)]
     pub(crate) async fn read_websocket_message(&mut self) -> Option<Result<Message, WsError>>
     where
         S: AsyncRead + AsyncWrite + Unpin,
@@ -235,7 +226,6 @@ impl<R, S> FreshHandler<R, S> {
     /// # Arguments
     ///
     /// * `msg`: WebSocket message to write back to the client.
-    #[instrument(skip_all)]
     pub(crate) async fn send_websocket_message(
         &mut self,
         msg: impl Into<Message>,
@@ -252,7 +242,6 @@ impl<R, S> FreshHandler<R, S> {
         }
     }
 
-    #[instrument(skip_all)]
     pub(crate) async fn send_error_response(
         &mut self,
         err: impl std::error::Error,
@@ -280,7 +269,6 @@ impl<R, S> FreshHandler<R, S> {
     ///
     /// * `shared_keys`: keys derived between the client and gateway.
     /// * `packets`: unwrapped packets that are to be pushed back to the client.
-    #[instrument(skip_all)]
     pub(crate) async fn push_packets_to_client(
         &mut self,
         shared_keys: &SharedGatewayKey,
@@ -338,7 +326,6 @@ impl<R, S> FreshHandler<R, S> {
     ///
     /// * `client_address`: address of the client that is going to receive the messages.
     /// * `shared_keys`: shared keys derived between the client and the gateway used to encrypt and tag the messages.
-    #[instrument(skip_all)]
     async fn push_stored_messages_to_client(
         &mut self,
         client_address: DestinationAddressBytes,
@@ -645,8 +632,6 @@ impl<R, S> FreshHandler<R, S> {
                 address,
                 shared_keys.key,
                 session_request_start,
-                #[cfg(feature = "otel")]
-                None,
             )),
             ServerResponse::Authenticate {
                 protocol_version: Some(negotiated_protocol),
@@ -656,13 +641,9 @@ impl<R, S> FreshHandler<R, S> {
         ))
     }
 
-    #[instrument(skip_all, fields(
-        address = %request.content.client_identity.derive_destination_address(),
-    ))]
     async fn handle_authenticate_v2(
         &mut self,
         request: Box<AuthenticateRequest>,
-        #[cfg(feature = "otel")] otel_context: Option<HashMap<String, String>>,
     ) -> Result<InitialAuthResult, InitialAuthenticationError>
     where
         S: AsyncRead + AsyncWrite + Unpin,
@@ -737,8 +718,6 @@ impl<R, S> FreshHandler<R, S> {
                 address,
                 shared_key.key,
                 session_request_start,
-                #[cfg(feature = "otel")]
-                otel_context,
             )),
             ServerResponse::Authenticate {
                 protocol_version: Some(negotiated_protocol),
@@ -837,8 +816,6 @@ impl<R, S> FreshHandler<R, S> {
             remote_address,
             shared_keys,
             OffsetDateTime::now_utc(),
-            #[cfg(feature = "otel")]
-            None,
         );
 
         Ok(InitialAuthResult::new(
@@ -869,7 +846,6 @@ impl<R, S> FreshHandler<R, S> {
         }
     }
 
-    #[instrument(skip_all)]
     pub(crate) async fn handle_initial_client_request(
         &mut self,
         request: ClientControlRequest,
@@ -878,58 +854,17 @@ impl<R, S> FreshHandler<R, S> {
         S: AsyncRead + AsyncWrite + Unpin + Send,
         R: CryptoRng + RngCore + Send,
     {
-        // extract and set up opentelemetry context if provided
-        #[cfg(feature = "otel")]
-        let (context_propagator, otel_ctx) =
-            if let ClientControlRequest::AuthenticateV2(ref auth_req) = request {
-                if let Some(otel_context) = &auth_req.otel_context {
-                    info!(
-                        "=== OpenTelemetry context provided in the request: {otel_context:?} ==="
-                    );
-                    (
-                        Some(ManualContextPropagator::new(
-                            "handling_initial_client_request_with_otel",
-                            otel_context.clone(),
-                        )),
-                        Some(otel_context.clone()),
-                    )
-                } else {
-                    debug!("No OpenTelemetry context provided in the request");
-                    (None, None)
-                }
-            } else {
-                debug!("No OpenTelemetry context provided in the request");
-                (None, None)
-            };
-        #[cfg(feature = "otel")]
-        let child_span = match context_propagator {
-            Some(ref propagator) => {
-                let span = info_span!(parent: &propagator.root_span, "=== Handling initial client request with otel context ===");
-                span
-            }
-            None => {
-                tracing::debug_span!("=== Handling initial client request without otel context ===")
-            }
-        };
-        #[cfg(feature = "otel")]
-        let _enter = child_span.enter();
-
+        // we can handle stateless client requests without prior authentication, like `ClientControlRequest::SupportedProtocol`
         let auth_result = match request {
             ClientControlRequest::Authenticate {
                 protocol_version,
                 address,
                 enc_address,
                 iv,
-                otel_context: _,
             } => {
                 self.handle_legacy_authenticate(protocol_version, address, enc_address, iv)
                     .await
             }
-            #[cfg(feature = "otel")]
-            ClientControlRequest::AuthenticateV2(req) => {
-                self.handle_authenticate_v2(req, otel_ctx).await
-            }
-            #[cfg(not(feature = "otel"))]
             ClientControlRequest::AuthenticateV2(req) => self.handle_authenticate_v2(req).await,
             ClientControlRequest::RegisterHandshakeInitRequest {
                 protocol_version,
@@ -954,6 +889,7 @@ impl<R, S> FreshHandler<R, S> {
                     }
                     other => debug!("authentication failure: {other}"),
                 }
+
                 self.send_and_forget_error_response(&err).await;
                 return Err(err);
             }
@@ -976,11 +912,9 @@ impl<R, S> FreshHandler<R, S> {
             warn!("could not establish client details");
             return Err(InitialAuthenticationError::EmptyClientDetails);
         };
-
         Ok(Some(client_details))
     }
 
-    #[instrument(skip_all)]
     pub(crate) async fn handle_until_authenticated_or_failure(
         mut self,
     ) -> Option<AuthenticatedHandler<R, S>>
@@ -1019,7 +953,7 @@ impl<R, S> FreshHandler<R, S> {
                     registration_details.session_request_timestamp,
                 );
 
-                let auth_handle = AuthenticatedHandler::upgrade(
+                return AuthenticatedHandler::upgrade(
                     self,
                     registration_details,
                     mix_receiver,
@@ -1028,12 +962,10 @@ impl<R, S> FreshHandler<R, S> {
                 .await
                 .inspect_err(|err| error!("failed to upgrade client handler: {err}"))
                 .ok();
-                return auth_handle;
             }
         }
     }
 
-    #[instrument(skip_all)]
     pub(crate) async fn wait_for_initial_message(
         &mut self,
     ) -> Result<ClientControlRequest, InitialAuthenticationError>
@@ -1084,7 +1016,6 @@ impl<R, S> FreshHandler<R, S> {
             .map_err(|_| InitialAuthenticationError::InvalidRequest)
     }
 
-    #[instrument(skip_all)]
     pub(crate) async fn start_handling(self)
     where
         S: AsyncRead + AsyncWrite + Unpin + Send,
@@ -1094,10 +1025,10 @@ impl<R, S> FreshHandler<R, S> {
         let shutdown = self.shutdown.clone();
         tokio::select! {
             _ = shutdown.cancelled() => {
-                tracing::trace!("received cancellation")
+                trace!("received cancellation")
             }
-            _ = super::handle_connection(self).instrument(tracing::debug_span!("connection_handler", remote = %remote)) => {
-                tracing::debug!("finished connection handler for {remote}")
+            _ = super::handle_connection(self) => {
+                debug!("finished connection handler for {remote}")
             }
         }
     }

gateway/src/node/client_handling/websocket/connection_handler/mod.rs

@@ -7,13 +7,10 @@ use nym_gateway_requests::shared_key::SharedGatewayKey;
 use nym_gateway_requests::ServerResponse;
 use nym_sphinx::DestinationAddressBytes;
 use rand::{CryptoRng, Rng};
-#[cfg(feature = "otel")]
-use std::collections::HashMap;
 use std::time::Duration;
 use time::OffsetDateTime;
 use tokio::io::{AsyncRead, AsyncWrite};
 use tokio_tungstenite::WebSocketStream;
-use tracing::Instrument;
 use tracing::{debug, instrument, trace, warn};
 
 pub(crate) use self::authenticated::AuthenticatedHandler;
@@ -51,8 +48,6 @@ pub(crate) struct ClientDetails {
     // note, this does **NOT ALWAYS** indicate timestamp of when client connected
     // it is (for v2 auth) timestamp the client **signed** when it created the request
     pub(crate) session_request_timestamp: OffsetDateTime,
-    #[cfg(feature = "otel")]
-    pub(crate) otel_context: Option<HashMap<String, String>>,
 }
 
 impl ClientDetails {
@@ -61,15 +56,12 @@ impl ClientDetails {
         address: DestinationAddressBytes,
         shared_keys: SharedGatewayKey,
         session_request_timestamp: OffsetDateTime,
-        #[cfg(feature = "otel")] otel_context: Option<HashMap<String, String>>,
     ) -> Self {
         ClientDetails {
             address,
             id,
             shared_keys,
             session_request_timestamp,
-            #[cfg(feature = "otel")]
-            otel_context,
         }
     }
 }
@@ -100,7 +92,7 @@ impl InitialAuthResult {
 }
 
 // imo there's no point in including the peer address in anything higher than debug
-#[instrument(skip_all)]
+#[instrument(level = "debug", skip_all, fields(peer = %handle.peer_address))]
 pub(crate) async fn handle_connection<R, S>(mut handle: FreshHandler<R, S>)
 where
     R: Rng + CryptoRng + Send,
@@ -125,25 +117,8 @@ where
 
     trace!("managed to perform websocket handshake!");
 
-    if let Some(auth_handle) = handle.handle_until_authenticated_or_failure().in_current_span().await {
-        #[cfg(feature = "otel")]
-        {
-            let from_client_span = {
-                let parent = match auth_handle.otel_propagator.as_ref() {
-                    Some(propagator) => propagator.root_span(),
-                    None => &tracing::Span::current(), // fallback to current span if no propagator
-                };
-                tracing::info_span!(parent: parent, "listening for requests")
-            };
-            auth_handle
-                .listen_for_requests()
-                .instrument(from_client_span)
-                .await
-        }
-        #[cfg(not(feature = "otel"))]
-        {
-            auth_handle.listen_for_requests().await;
-        }
+    if let Some(auth_handle) = handle.handle_until_authenticated_or_failure().await {
+        auth_handle.listen_for_requests().await
     }
 
     trace!("the handler is done!");

gateway/src/node/client_handling/websocket/listener.rs

@@ -53,7 +53,6 @@ impl Listener {
         )
     }
 
-    #[instrument(skip_all)]
     fn try_handle_accepted_connection(&self, accepted: io::Result<(TcpStream, SocketAddr)>) {
         match accepted {
             Ok((socket, remote_address)) => {
@@ -91,7 +90,7 @@ impl Listener {
                         let metrics_ref = handle.shared_state.metrics.clone();
 
                         // 4.1. handle all client requests until connection gets terminated
-                        handle.start_handling().in_current_span().await;
+                        handle.start_handling().await;
 
                         // 4.2. decrement the connection counter
                         metrics_ref.network.disconnected_ingress_websocket_client();
@@ -105,7 +104,6 @@ impl Listener {
 
     // TODO: change the signature to pub(crate) async fn run(&self, handler: Handler)
 
-    #[instrument(skip_all)]
     pub async fn run(&mut self) {
         info!("Starting websocket listener at {}", self.address);
         let tcp_listener = match tokio::net::TcpListener::bind(self.address).await {
@@ -124,7 +122,7 @@ impl Listener {
                     trace!("client_handling::Listener: received shutdown");
                     break
                 }
-                connection = tcp_listener.accept().in_current_span() => {
+                connection = tcp_listener.accept() => {
                     self.try_handle_accepted_connection(connection)
                 }
             }

gateway/src/node/internal_service_providers/authenticator/mixnet_listener.rs

@@ -977,8 +977,6 @@ fn create_input_message(
             response_packet,
             lane,
             packet_type,
-            #[cfg(feature = "otel")]
-            None,
         ))
     } else {
         tracing::error!("No nym-address or sender tag provided");

nym-api/Cargo.toml

@@ -95,7 +95,7 @@ nym-topology = { path = "../common/topology" }
 nym-api-requests = { path = "nym-api-requests" }
 nym-validator-client = { path = "../common/client-libs/validator-client" }
 nym-http-api-client = { path = "../common/http-api-client" }
-nym-bin-common = { path = "../common/bin-common", features = ["output_format", "openapi"] }
+nym-bin-common = { path = "../common/bin-common", features = ["output_format", "openapi", "basic_tracing"] }
 nym-node-tester-utils = { path = "../common/node-tester-utils" }
 nym-node-requests = { path = "../nym-node/nym-node-requests" }
 nym-types = { path = "../common/types" }
@@ -110,10 +110,6 @@ nym-ecash-signer-check = { path = "../common/ecash-signer-check" }
 no-reward = []
 v2-performance = []
 generate-ts = ["ts-rs"]
-otel = [
-    "nym-bin-common/otel",
-    "nym-node-tester-utils/otel",
-]
 
 [build-dependencies]
 anyhow = { workspace = true }

nym-api/src/main.rs

@@ -31,7 +31,7 @@ async fn main() -> Result<(), anyhow::Error> {
         // instrument tokio console subscriber needs RUSTFLAGS="--cfg tokio_unstable" at build time
         console_subscriber::init();
     } else {
-        nym_bin_common::logging::setup_no_otel_logger().expect("failed to initialize logging");
+        nym_bin_common::logging::setup_tracing_logger();
     }}
 
     info!("Starting nym api...");

nym-credential-proxy/nym-credential-proxy/Cargo.toml

@@ -45,7 +45,9 @@ utoipa = { workspace = true, features = ["axum_extras", "time"] }
 utoipa-swagger-ui = { workspace = true, features = ["axum"] }
 zeroize.workspace = true
 
-nym-bin-common = { path = "../../common/bin-common" }
+nym-bin-common = { path = "../../common/bin-common", features = [
+    "basic_tracing",
+] }
 nym-compact-ecash = { path = "../../common/nym_offline_compact_ecash" }
 nym-config = { path = "../../common/config" }
 nym-crypto = { path = "../../common/crypto", features = [

nym-credential-proxy/nym-credential-proxy/src/main.rs

@@ -6,7 +6,7 @@ cfg_if::cfg_if! {
         use crate::cli::Cli;
         use clap::Parser;
         use nym_bin_common::bin_info_owned;
-        use nym_bin_common::logging::setup_no_otel_logger;
+        use nym_bin_common::logging::setup_tracing_logger;
         use nym_network_defaults::setup_env;
         use tracing::{info, trace};
 
@@ -29,7 +29,7 @@ async fn main() -> anyhow::Result<()> {
     trace!("args: {cli:#?}");
 
     setup_env(cli.config_env_file.as_ref());
-    setup_no_otel_logger().expect("failed to initialize logging");
+    setup_tracing_logger();
 
     let bin_info = bin_info_owned!();
     info!("using the following version: {bin_info}");

nym-gateway-probe/Cargo.toml

@@ -73,7 +73,3 @@ vergen-gitcl = { workspace = true, default-features = false, features = [
 
 [package.metadata.cargo-machete]
 ignored = ["vergen", "nym-http-api-client"]
-
-[features]
-default = []
-otel = ["nym-sdk/otel", "nym-http-api-client/otel", "nym-bin-common/otel"]

nym-gateway-probe/src/icmp.rs

@@ -84,8 +84,6 @@ fn create_input_message(
         surbs,
         lane,
         packet_type,
-        #[cfg(feature = "otel")]
-        None
     ))
 }
 

nym-network-monitor/Cargo.toml

@@ -30,7 +30,7 @@ utoipa-swagger-ui = { workspace = true, features = ["axum"] }
 tokio-postgres = { workspace = true }
 
 # internal
-nym-bin-common = { path = "../common/bin-common" }
+nym-bin-common = { path = "../common/bin-common", features = ["basic_tracing"] }
 nym-client-core = { path = "../common/client-core" }
 nym-crypto = { path = "../common/crypto" }
 nym-network-defaults = { path = "../common/network-defaults" }

nym-network-monitor/src/main.rs

@@ -189,7 +189,7 @@ async fn nym_topology_from_env() -> anyhow::Result<NymTopology> {
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    nym_bin_common::logging::setup_no_otel_logger().expect("failed to initialize logging");
+    nym_bin_common::logging::setup_tracing_logger();
 
     let args = Args::parse();
 

nym-node-status-api/nym-node-status-api/.sqlx/query-0b51df277ed66c6553f66af9b135342dee177abc1c92e4a89147de3c22d3d1a5.json

@@ -1,6 +1,6 @@
 {
   "db_name": "PostgreSQL",
-  "query": "SELECT\n            node_id,\n            ed25519_identity_pubkey,\n            total_stake,\n            ip_addresses as \"ip_addresses!: serde_json::Value\",\n            mix_port,\n            x25519_sphinx_pubkey,\n            node_role as \"node_role: serde_json::Value\",\n            supported_roles as \"supported_roles: serde_json::Value\",\n            entry as \"entry: serde_json::Value\",\n            performance,\n            self_described as \"self_described: serde_json::Value\",\n            bond_info as \"bond_info: serde_json::Value\"\n        FROM\n            nym_nodes\n        ORDER BY\n            node_id\n        ",
+  "query": "SELECT\n            node_id,\n            ed25519_identity_pubkey,\n            total_stake,\n            ip_addresses as \"ip_addresses!: serde_json::Value\",\n            mix_port,\n            x25519_sphinx_pubkey,\n            node_role as \"node_role: serde_json::Value\",\n            supported_roles as \"supported_roles: serde_json::Value\",\n            entry as \"entry: serde_json::Value\",\n            performance,\n            self_described as \"self_described: serde_json::Value\",\n            bond_info as \"bond_info: serde_json::Value\",\n            http_api_port\n        FROM\n            nym_nodes\n        WHERE\n            self_described IS NOT NULL\n        AND\n            bond_info IS NOT NULL\n        ",
   "describe": {
     "columns": [
       {
@@ -62,6 +62,11 @@
         "ordinal": 11,
         "name": "bond_info: serde_json::Value",
         "type_info": "Jsonb"
+      },
+      {
+        "ordinal": 12,
+        "name": "http_api_port",
+        "type_info": "Int4"
       }
     ],
     "parameters": {
@@ -79,8 +84,9 @@
       true,
       false,
       true,
+      true,
       true
     ]
   },
-  "hash": "c48d04fc3de59dd484f0a63d40336ced54e08785f77e9ef85f3157d004ec85dc"
+  "hash": "0b51df277ed66c6553f66af9b135342dee177abc1c92e4a89147de3c22d3d1a5"
 }

nym-node-status-api/nym-node-status-api/.sqlx/query-3ddc12cc4e1796b787a50c40560d2bd71d1cfe5f5265e6f161b3122d1317a421.json

@@ -1,6 +1,6 @@
 {
   "db_name": "PostgreSQL",
-  "query": "SELECT\n            node_id,\n            ed25519_identity_pubkey,\n            total_stake,\n            ip_addresses as \"ip_addresses!: serde_json::Value\",\n            mix_port,\n            x25519_sphinx_pubkey,\n            node_role as \"node_role: serde_json::Value\",\n            supported_roles as \"supported_roles: serde_json::Value\",\n            entry as \"entry: serde_json::Value\",\n            performance,\n            self_described as \"self_described: serde_json::Value\",\n            bond_info as \"bond_info: serde_json::Value\"\n        FROM\n            nym_nodes\n        WHERE\n            self_described IS NOT NULL\n        AND\n            bond_info IS NOT NULL\n        ",
+  "query": "SELECT\n            node_id,\n            ed25519_identity_pubkey,\n            total_stake,\n            ip_addresses as \"ip_addresses!: serde_json::Value\",\n            mix_port,\n            x25519_sphinx_pubkey,\n            node_role as \"node_role: serde_json::Value\",\n            supported_roles as \"supported_roles: serde_json::Value\",\n            entry as \"entry: serde_json::Value\",\n            performance,\n            self_described as \"self_described: serde_json::Value\",\n            bond_info as \"bond_info: serde_json::Value\",\n            http_api_port\n        FROM\n            nym_nodes\n        ORDER BY\n            node_id\n        ",
   "describe": {
     "columns": [
       {
@@ -62,6 +62,11 @@
         "ordinal": 11,
         "name": "bond_info: serde_json::Value",
         "type_info": "Jsonb"
+      },
+      {
+        "ordinal": 12,
+        "name": "http_api_port",
+        "type_info": "Int4"
       }
     ],
     "parameters": {
@@ -79,8 +84,9 @@
       true,
       false,
       true,
+      true,
       true
     ]
   },
-  "hash": "283f49a65c7d70bf271702ff6a5c7ad6e68c81932d295ff18ed198c54706a57c"
+  "hash": "3ddc12cc4e1796b787a50c40560d2bd71d1cfe5f5265e6f161b3122d1317a421"
 }

nym-node-status-api/nym-node-status-api/.sqlx/query-b010fb91828f7e4f0b72bdfe3b58b2abb437cccdb6ebd2e1087cc822ed737b0e.json

@@ -1,26 +0,0 @@
-{
-  "db_name": "PostgreSQL",
-  "query": "INSERT INTO nym_nodes\n                (node_id, ed25519_identity_pubkey,\n                    total_stake,\n                    ip_addresses, mix_port,\n                    x25519_sphinx_pubkey, node_role,\n                    supported_roles, entry,\n                    self_described,\n                    bond_info,\n                    performance, last_updated_utc\n                )\n                VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)\n                ON CONFLICT(node_id) DO UPDATE SET\n                ed25519_identity_pubkey=excluded.ed25519_identity_pubkey,\n                ip_addresses=excluded.ip_addresses,\n                mix_port=excluded.mix_port,\n                x25519_sphinx_pubkey=excluded.x25519_sphinx_pubkey,\n                node_role=excluded.node_role,\n                supported_roles=excluded.supported_roles,\n                entry=excluded.entry,\n                self_described=excluded.self_described,\n                bond_info=excluded.bond_info,\n                performance=excluded.performance,\n                last_updated_utc=excluded.last_updated_utc\n                ;",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Left": [
-        "Int4",
-        "Varchar",
-        "Int8",
-        "Jsonb",
-        "Int4",
-        "Varchar",
-        "Jsonb",
-        "Jsonb",
-        "Jsonb",
-        "Jsonb",
-        "Jsonb",
-        "Varchar",
-        "Int4"
-      ]
-    },
-    "nullable": []
-  },
-  "hash": "b010fb91828f7e4f0b72bdfe3b58b2abb437cccdb6ebd2e1087cc822ed737b0e"
-}

nym-node-status-api/nym-node-status-api/.sqlx/query-dde9aff827c34086077927bbe33fa3d5c939e7122ba7c88b78a353f00b271ec2.json

@@ -0,0 +1,27 @@
+{
+  "db_name": "PostgreSQL",
+  "query": "INSERT INTO nym_nodes\n                (node_id, ed25519_identity_pubkey,\n                    total_stake,\n                    ip_addresses, mix_port,\n                    x25519_sphinx_pubkey, node_role,\n                    supported_roles, entry,\n                    self_described,\n                    bond_info,\n                    performance, last_updated_utc, http_api_port\n                )\n                VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)\n                ON CONFLICT(node_id) DO UPDATE SET\n                ed25519_identity_pubkey=excluded.ed25519_identity_pubkey,\n                ip_addresses=excluded.ip_addresses,\n                mix_port=excluded.mix_port,\n                x25519_sphinx_pubkey=excluded.x25519_sphinx_pubkey,\n                node_role=excluded.node_role,\n                supported_roles=excluded.supported_roles,\n                entry=excluded.entry,\n                self_described=excluded.self_described,\n                bond_info=excluded.bond_info,\n                performance=excluded.performance,\n                last_updated_utc=excluded.last_updated_utc,\n                http_api_port=excluded.http_api_port\n                ;",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Left": [
+        "Int4",
+        "Varchar",
+        "Int8",
+        "Jsonb",
+        "Int4",
+        "Varchar",
+        "Jsonb",
+        "Jsonb",
+        "Jsonb",
+        "Jsonb",
+        "Jsonb",
+        "Varchar",
+        "Int4",
+        "Int4"
+      ]
+    },
+    "nullable": []
+  },
+  "hash": "dde9aff827c34086077927bbe33fa3d5c939e7122ba7c88b78a353f00b271ec2"
+}

nym-node-status-api/nym-node-status-api/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "nym-node-status-api"
-version = "4.0.10"
+version = "4.0.11-rc1"
 authors.workspace = true
 repository.workspace = true
 homepage.workspace = true

nym-node-status-api/nym-node-status-api/migrations_pg/20251008000000_nym_nodes_add_http_api_port.sql

@@ -0,0 +1,2 @@
+ALTER TABLE nym_nodes
+    ADD COLUMN IF NOT EXISTS http_api_port INTEGER;

nym-node-status-api/nym-node-status-api/src/cli/mod.rs

@@ -1,5 +1,5 @@
 use crate::ticketbook_manager::TicketbookManagerConfig;
-use clap::Parser;
+use clap::{Parser, Subcommand};
 use nym_bin_common::bin_info;
 use nym_credential_proxy_lib::shared_state::ecash_state::TicketType;
 use reqwest::Url;
@@ -105,6 +105,19 @@ pub(crate) struct Cli {
 
     #[clap(flatten)]
     pub(crate) ticketbook: TicketbookArgs,
+
+    #[command(subcommand)]
+    pub(crate) command: Option<Commands>,
+}
+
+#[derive(Subcommand, Debug)]
+pub(crate) enum Commands {
+    /// Scrape a single node and output detailed debug logs
+    ScrapeNode {
+        /// The id of the node to scrape
+        #[arg(long)]
+        node_id: i64,
+    },
 }
 
 #[derive(Debug, Parser)]

nym-node-status-api/nym-node-status-api/src/db/models.rs

@@ -381,7 +381,7 @@ impl ScrapeNodeKind {
 pub(crate) struct ScraperNodeInfo {
     pub node_kind: ScrapeNodeKind,
     pub hosts: Vec<String>,
-    pub http_api_port: i64,
+    pub http_api_port: Option<u16>,
 }
 
 impl ScraperNodeInfo {
@@ -395,8 +395,21 @@ impl ScraperNodeInfo {
                 format!("http://{}", host),
             ]);
 
-            if self.http_api_port != DEFAULT_NYM_NODE_HTTP_PORT as i64 {
-                urls.insert(0, format!("http://{}:{}", host, self.http_api_port));
+            if let Some(custom_http_api_port) = self.http_api_port {
+                urls = Vec::new();
+                for host in &self.hosts {
+                    urls.append(&mut vec![format!(
+                        "http://{}:{}",
+                        host, custom_http_api_port
+                    )]);
+                }
+
+                // do not fall back to default ports, if the operator sets a custom http api port
+                // in their bond, use it and error out if it's not available
+                // this will correctly handle cases where some operators run multiple nodes
+                // on a single IP address and assign different custom http port apis at bond time
+
+                // urls.insert(0, format!("http://{}:{}", host, custom_http_api_port));
             }
         }
 
@@ -423,6 +436,7 @@ pub(crate) struct NymNodeDto {
     pub performance: String,
     pub self_described: Option<serde_json::Value>,
     pub bond_info: Option<serde_json::Value>,
+    pub http_api_port: Option<i32>,
 }
 
 #[allow(dead_code)] // it's not dead code but clippy doesn't detect usage in sqlx macros
@@ -440,6 +454,7 @@ pub(crate) struct NymNodeInsertRecord {
     pub entry: Option<serde_json::Value>,
     pub self_described: Option<serde_json::Value>,
     pub bond_info: Option<serde_json::Value>,
+    pub http_api_port: Option<i32>,
     pub last_updated_utc: i64,
 }
 
@@ -456,6 +471,12 @@ impl NymNodeInsertRecord {
             .map(|info| decimal_to_i64(info.total_stake()))
             .unwrap_or(0);
         let entry = serialize_opt_to_value!(skimmed_node.entry)?;
+        let http_api_port = bond_info.and_then(|bond| {
+            bond.bond_information
+                .node
+                .custom_http_port
+                .map(|port| port as i32)
+        });
         let bond_info = serialize_opt_to_value!(bond_info)?;
         let self_described = serialize_opt_to_value!(self_described)?;
 
@@ -472,6 +493,7 @@ impl NymNodeInsertRecord {
             entry,
             self_described,
             bond_info,
+            http_api_port,
             last_updated_utc: now,
         };
 

nym-node-status-api/nym-node-status-api/src/db/queries/nym_nodes.rs

@@ -35,7 +35,8 @@ pub(crate) async fn get_all_nym_nodes(pool: &DbPool) -> anyhow::Result<Vec<NymNo
             entry as "entry: serde_json::Value",
             performance,
             self_described as "self_described: serde_json::Value",
-            bond_info as "bond_info: serde_json::Value"
+            bond_info as "bond_info: serde_json::Value",
+            http_api_port
         FROM
             nym_nodes
         ORDER BY
@@ -72,7 +73,8 @@ pub(crate) async fn get_described_bonded_nym_nodes(
             entry as "entry: serde_json::Value",
             performance,
             self_described as "self_described: serde_json::Value",
-            bond_info as "bond_info: serde_json::Value"
+            bond_info as "bond_info: serde_json::Value",
+            http_api_port
         FROM
             nym_nodes
         WHERE
@@ -115,9 +117,9 @@ pub(crate) async fn update_nym_nodes(
                     supported_roles, entry,
                     self_described,
                     bond_info,
-                    performance, last_updated_utc
+                    performance, last_updated_utc, http_api_port
                 )
-                VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
+                VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)
                 ON CONFLICT(node_id) DO UPDATE SET
                 ed25519_identity_pubkey=excluded.ed25519_identity_pubkey,
                 ip_addresses=excluded.ip_addresses,
@@ -129,7 +131,8 @@ pub(crate) async fn update_nym_nodes(
                 self_described=excluded.self_described,
                 bond_info=excluded.bond_info,
                 performance=excluded.performance,
-                last_updated_utc=excluded.last_updated_utc
+                last_updated_utc=excluded.last_updated_utc,
+                http_api_port=excluded.http_api_port
                 ;",
             record.node_id,
             record.ed25519_identity_pubkey,
@@ -144,6 +147,7 @@ pub(crate) async fn update_nym_nodes(
             record.bond_info,
             record.performance,
             record.last_updated_utc as i32,
+            record.http_api_port,
         )
         .execute(&mut *tx)
         .await

nym-node-status-api/nym-node-status-api/src/db/queries/scraper.rs

@@ -21,10 +21,11 @@ pub(crate) async fn get_nodes_for_scraping(pool: &DbPool) -> Result<Vec<ScraperN
     let skimmed_nodes = queries::get_described_bonded_nym_nodes(pool)
         .await
         .map(|nodes_dto| {
-            nodes_dto.into_iter().filter_map(|node| {
-                let node_id = node.node_id;
-                match SkimmedNode::try_from(node) {
-                    Ok(node) => Some(node),
+            nodes_dto.into_iter().filter_map(|node_dto| {
+                let node_id = node_dto.node_id;
+                let http_api_port = node_dto.http_api_port;
+                match SkimmedNode::try_from(node_dto) {
+                    Ok(node) => Some((node, http_api_port)),
                     Err(e) => {
                         tracing::error!("Failed to decode node_id={}: {}", node_id, e);
                         None
@@ -33,7 +34,7 @@ pub(crate) async fn get_nodes_for_scraping(pool: &DbPool) -> Result<Vec<ScraperN
             })
         })?;
 
-    skimmed_nodes.for_each(|node| {
+    skimmed_nodes.for_each(|(node, http_api_port)| {
         // TODO: relies on polyfilling: Nym nodes table might contain legacy mixnodes
         // as well. Categorize them here.
         let node_kind = if gateway_keys.contains(&node.ed25519_identity_pubkey.to_base58_string()) {
@@ -54,7 +55,7 @@ pub(crate) async fn get_nodes_for_scraping(pool: &DbPool) -> Result<Vec<ScraperN
                 .into_iter()
                 .map(|ip| ip.to_string())
                 .collect::<Vec<_>>(),
-            http_api_port: node.mix_port.into(),
+            http_api_port: http_api_port.map(|port| port as u16),
         })
     });
 

nym-node-status-api/nym-node-status-api/src/db/tests.rs

@@ -138,6 +138,7 @@ mod db_tests {
             performance: "1.0".to_string(),
             self_described: None,
             bond_info: None,
+            http_api_port: None,
         };
 
         let skimmed_node: nym_validator_client::nym_api::SkimmedNode =
@@ -362,22 +363,42 @@ fn test_scraper_node_info_contact_addresses() {
     let node_info = ScraperNodeInfo {
         node_kind: ScrapeNodeKind::MixingNymNode { node_id: 123 },
         hosts: vec!["1.1.1.1".to_string(), "example.com".to_string()],
-        http_api_port: 8080,
+        http_api_port: None,
     };
 
     let addresses = node_info.contact_addresses();
 
     // Should generate multiple URLs for each host
-    // Custom port (8080) should be inserted at the beginning
+    // When no custom port is specified only default ports should be used
     assert!(addresses.contains(&"http://1.1.1.1:8080".to_string()));
-    assert!(addresses.contains(&"http://example.com:8080".to_string()));
     assert!(addresses.contains(&"http://1.1.1.1:8000".to_string()));
     assert!(addresses.contains(&"https://1.1.1.1".to_string()));
+    assert!(addresses.contains(&"http://1.1.1.1".to_string()));
     assert!(addresses.contains(&"http://example.com:8000".to_string()));
     // Check that URLs follow the expected pattern
     assert!(addresses.len() >= 8); // At least 4 URLs per host
 }
 
+#[test]
+fn test_scraper_node_info_contact_addresses_with_custom_http_api_port() {
+    use crate::db::models::{ScrapeNodeKind, ScraperNodeInfo};
+
+    let node_info = ScraperNodeInfo {
+        node_kind: ScrapeNodeKind::MixingNymNode { node_id: 123 },
+        hosts: vec!["1.1.1.1".to_string(), "example.com".to_string()],
+        http_api_port: Some(4444),
+    };
+
+    let addresses = node_info.contact_addresses();
+
+    // Should generate multiple URLs for each host
+    // Custom port (4444) should be the only port in the list
+    assert!(addresses.contains(&"http://1.1.1.1:4444".to_string()));
+    assert!(addresses.contains(&"http://example.com:4444".to_string()));
+    // Check that URLs follow the expected pattern
+    assert!(addresses.len() >= 2); // At least 4 URLs per host
+}
+
 #[test]
 fn test_scrape_node_kind_node_id() {
     use crate::db::models::ScrapeNodeKind;
@@ -414,6 +435,7 @@ fn test_nym_node_dto_with_invalid_keys() {
         performance: "1.0".to_string(),
         self_described: None,
         bond_info: None,
+        http_api_port: None,
     };
 
     let result: Result<nym_validator_client::nym_api::SkimmedNode, _> = nym_node_dto.try_into();
@@ -451,6 +473,7 @@ fn test_nym_node_dto_with_invalid_performance() {
         performance: "invalid_percent".to_string(),
         self_described: None,
         bond_info: None,
+        http_api_port: None,
     };
 
     let result: Result<nym_validator_client::nym_api::SkimmedNode, _> = nym_node_dto.try_into();

nym-node-status-api/nym-node-status-api/src/main.rs

@@ -1,4 +1,6 @@
+use crate::cli::Commands;
 use crate::monitor::DelegationsCache;
+use crate::node_scraper::helpers::scrape_and_store_description_by_node_id;
 use crate::ticketbook_manager::TicketbookManager;
 use crate::ticketbook_manager::state::TicketbookManagerState;
 use clap::Parser;
@@ -40,11 +42,49 @@ async fn main() -> anyhow::Result<()> {
     tracing::info!("Registered {} agent keys", agent_key_list.len());
 
     let connection_url = args.database_url.clone();
-    tracing::debug!("Using config:\n{:#?}", args);
+    if std::env::var("SHOW_CONFIG").ok().is_some() {
+        tracing::debug!("Using config:\n{:#?}", args);
+    }
 
     let storage = db::Storage::init(connection_url, args.sqlx_busy_timeout_s).await?;
     let db_pool = storage.pool_owned();
 
+    // node geocache is shared between node monitor and HTTP server
+    let geocache = moka::future::Cache::builder()
+        .time_to_live(args.geodata_ttl)
+        .build();
+    let delegations_cache = DelegationsCache::new();
+
+    let client_config = nym_validator_client::nyxd::Config::try_from_nym_network_details(
+        &nym_network_defaults::NymNetworkDetails::new_from_env(),
+    )?;
+    let nyxd_client = NyxdClient::connect(client_config.clone(), args.nyxd_addr.as_str())
+        .map_err(|err| anyhow::anyhow!("Couldn't connect: {}", err))?;
+
+    match args.command {
+        Some(Commands::ScrapeNode { node_id }) => {
+            if std::env::var("RUN_ONCE_INIT_NODES").ok().is_some() {
+                let geocache_clone = geocache.clone();
+                let delegations_cache_clone = Arc::clone(&delegations_cache);
+                monitor::run_once(
+                    db_pool.clone(),
+                    args.nym_api_client_timeout,
+                    nyxd_client,
+                    args.ipinfo_api_token,
+                    geocache_clone,
+                    delegations_cache_clone,
+                )
+                .await?;
+            }
+            tracing::info!("Scraping node with id {node_id}...");
+            scrape_and_store_description_by_node_id(&db_pool, node_id).await?;
+            return Ok(());
+        }
+        None => {
+            // default behaviour
+        }
+    }
+
     // Start the node scraper
     let scraper = node_scraper::DescriptionScraper::new(storage.pool_owned());
     shutdown_manager.spawn_with_shutdown(async move {
@@ -58,20 +98,9 @@ async fn main() -> anyhow::Result<()> {
         scraper.start().await;
     });
 
-    // node geocache is shared between node monitor and HTTP server
-    let geocache = moka::future::Cache::builder()
-        .time_to_live(args.geodata_ttl)
-        .build();
-    let delegations_cache = DelegationsCache::new();
-
     // Start the monitor
     let geocache_clone = geocache.clone();
     let delegations_cache_clone = Arc::clone(&delegations_cache);
-    let client_config = nym_validator_client::nyxd::Config::try_from_nym_network_details(
-        &nym_network_defaults::NymNetworkDetails::new_from_env(),
-    )?;
-    let nyxd_client = NyxdClient::connect(client_config.clone(), args.nyxd_addr.as_str())
-        .map_err(|err| anyhow::anyhow!("Couldn't connect: {}", err))?;
 
     shutdown_manager.spawn_with_shutdown(async move {
         monitor::run_in_background(

nym-node-status-api/nym-node-status-api/src/metrics_scraper/mod.rs

@@ -57,7 +57,7 @@ async fn run(
         .clone()
         .expect("rust sdk mainnet default missing api_url");
 
-    let nym_api = nym_http_api_client::ClientBuilder::new_with_urls(vec![default_api_url.into()])
+    let nym_api = nym_http_api_client::ClientBuilder::new_with_urls(vec![default_api_url.into()])?
         .no_hickory_dns()
         .with_timeout(nym_api_client_timeout)
         .build()?;

nym-node-status-api/nym-node-status-api/src/monitor/mod.rs

@@ -68,7 +68,7 @@ pub(crate) async fn run_in_background(
     loop {
         tracing::info!("Refreshing node info...");
 
-        if let Err(e) = monitor.run().await {
+        if let Err(e) = monitor.run(false).await {
             tracing::error!(
                 "Monitor run failed: {e}, retrying in {}s...",
                 MONITOR_FAILURE_RETRY_DELAY.as_secs()
@@ -84,8 +84,33 @@ pub(crate) async fn run_in_background(
     }
 }
 
+#[instrument(level = "debug", name = "data_monitor", skip_all)]
+pub(crate) async fn run_once(
+    db_pool: DbPool,
+    nym_api_client_timeout: Duration,
+    nyxd_client: nym_validator_client::QueryHttpRpcNyxdClient,
+    ipinfo_api_token: String,
+    geocache: NodeGeoCache,
+    node_delegations: Arc<RwLock<DelegationsCache>>,
+) -> anyhow::Result<()> {
+    let ipinfo = IpInfoClient::new(ipinfo_api_token.clone());
+
+    let mut monitor = Monitor {
+        db_pool,
+        network_details: nym_network_defaults::NymNetworkDetails::new_from_env(),
+        nym_api_client_timeout,
+        nyxd_client,
+        ipinfo,
+        geocache,
+        node_delegations,
+    };
+
+    tracing::info!("Refreshing node info...");
+    monitor.run(true).await
+}
+
 impl Monitor {
-    async fn run(&mut self) -> anyhow::Result<()> {
+    async fn run(&mut self, exit_early: bool) -> anyhow::Result<()> {
         self.check_ipinfo_bandwidth().await;
 
         let default_api_url = self
@@ -98,7 +123,7 @@ impl Monitor {
             .expect("rust sdk mainnet default missing api_url");
 
         let nym_api =
-            nym_http_api_client::ClientBuilder::new_with_urls(vec![default_api_url.into()])
+            nym_http_api_client::ClientBuilder::new_with_urls(vec![default_api_url.into()])?
                 .no_hickory_dns()
                 .with_timeout(self.nym_api_client_timeout)
                 .build()?;
@@ -153,6 +178,11 @@ impl Monitor {
                 tracing::debug!("{} nym nodes written to DB!", inserted);
             })?;
 
+        // stop here if running once
+        if exit_early {
+            return Ok(());
+        }
+
         // refresh geodata for all nodes
         for node_description in described_nodes.values() {
             self.location_cached(node_description).await;

nym-node-status-api/nym-node-status-api/src/node_scraper/helpers.rs

@@ -118,6 +118,17 @@ pub fn sanitize_description(
     }
 }
 
+pub async fn scrape_and_store_description_by_node_id(pool: &DbPool, node_id: i64) -> Result<()> {
+    let nodes = crate::db::queries::get_nodes_for_scraping(pool).await?;
+    match nodes.iter().find(|n| *n.node_kind.node_id() == node_id) {
+        Some(node) => Ok(scrape_and_store_description(pool, node.clone()).await?),
+        None => {
+            error!("Could not find node with id {node_id}");
+            Err(anyhow!("Could not find node with id {node_id}"))
+        }
+    }
+}
+
 pub async fn scrape_and_store_description(pool: &DbPool, node: ScraperNodeInfo) -> Result<()> {
     let client = build_client()?;
     let urls = node.contact_addresses();
@@ -152,7 +163,13 @@ pub async fn scrape_and_store_description(pool: &DbPool, node: ScraperNodeInfo)
         anyhow::anyhow!("Failed to fetch description from any URL: {}", err_msg)
     })?;
 
-    let sanitized_description = sanitize_description(description, *node.node_id());
+    let sanitized_description = sanitize_description(description.clone(), *node.node_id());
+
+    trace!("tried_url_list = {tried_url_list:?}");
+    trace!("ndoe_id = {}", node.node_id());
+    trace!("description = {:?}", description);
+    trace!("sanitized_description = {:?}", sanitized_description);
+
     insert_scraped_node_description(pool, &node.node_kind, &sanitized_description).await?;
 
     Ok(())

nym-node/Cargo.toml

@@ -31,7 +31,6 @@ humantime-serde = { workspace = true }
 human-repr = { workspace = true }
 ipnetwork = { workspace = true }
 indicatif = { workspace = true }
-opentelemetry = { workspace = true, optional = true } # make it optional later
 rand = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json.workspace = true
@@ -51,6 +50,7 @@ cupid = { workspace = true }
 sysinfo = { workspace = true }
 
 nym-bin-common = { path = "../common/bin-common", features = [
+    "basic_tracing",
     "output_format",
 ] }
 nym-client-core-config-types = { path = "../common/client-core/config-types", features = [
@@ -130,17 +130,7 @@ criterion = { workspace = true, features = ["async_tokio"] }
 rand_chacha = { workspace = true }
 
 [features]
-default = []
-tokio-console = ["console-subscriber"]
-otel = [
-    "nym-bin-common/otel",
-    "nym-gateway/otel",
-    "nym-http-api-common/otel",
-    "nym-sphinx-framing/otel",
-    "nym-sphinx-addressing/otel",
-    "opentelemetry",
-]
-
+tokio-console = ["console-subscriber", "nym-task/tokio-tracing"]
 
 [lints]
 workspace = true

nym-node/src/cli/commands/run/mod.rs

@@ -8,7 +8,7 @@ use crate::node::bonding_information::BondingInformation;
 use crate::node::mixnet::packet_forwarding::global::is_global_ip;
 use std::fs;
 use std::net::IpAddr;
-use tracing::{debug, info, instrument, trace, warn};
+use tracing::{debug, info, trace, warn};
 
 mod args;
 
@@ -39,7 +39,6 @@ fn check_public_ips(ips: &[IpAddr], local: bool) -> Result<(), NymNodeError> {
     Ok(())
 }
 
-#[instrument(skip_all)]
 pub(crate) async fn execute(mut args: Args) -> Result<(), NymNodeError> {
     trace!("passed arguments: {args:#?}");
 

nym-node/src/cli/mod.rs

@@ -6,18 +6,10 @@ use crate::cli::commands::{
     test_throughput,
 };
 use crate::env::vars::{NYMNODE_CONFIG_ENV_FILE_ARG, NYMNODE_NO_BANNER_ARG};
-// use crate::error::NymNodeError;
 use clap::{Args, Parser, Subcommand};
-#[cfg(feature = "otel")]
-use nym_bin_common::logging::error::TracingError;
-#[cfg(feature = "otel")]
-use nym_bin_common::opentelemetry::setup_tracing_logger;
-use nym_bin_common::{bin_info, logging::setup_no_otel_logger};
+use nym_bin_common::bin_info;
 use std::future::Future;
 use std::sync::OnceLock;
-#[cfg(feature = "otel")]
-use tracing::Instrument;
-use tracing::instrument;
 
 pub(crate) mod commands;
 mod helpers;
@@ -60,134 +52,30 @@ impl Cli {
             .block_on(fut))
     }
 
-    #[instrument]
     pub(crate) fn execute(self) -> anyhow::Result<()> {
         // NOTE: `test_throughput` sets up its own logger as it has to include additional layers
-        // if !matches!(self.command, Commands::TestThroughput(..)) {
-        //     crate::logging::setup_tracing_logger()?;
-        // }
+        if !matches!(self.command, Commands::TestThroughput(..)) {
+            crate::logging::setup_tracing_logger()?;
+        }
 
         match self.command {
-            // Sync commands get logger w. no OTEL
-            Commands::BuildInfo(args) => {
-                setup_no_otel_logger()?;
-                build_info::execute(args)?
+            Commands::BuildInfo(args) => build_info::execute(args)?,
+            Commands::BondingInformation(args) => {
+                { Self::execute_async(bonding_information::execute(args))? }?
             }
-            Commands::Migrate(args) => {
-                setup_no_otel_logger()?;
-                migrate::execute(*args)?
+            Commands::NodeDetails(args) => { Self::execute_async(node_details::execute(args))? }?,
+            Commands::Run(args) => { Self::execute_async(run::execute(*args))? }?,
+            Commands::Migrate(args) => migrate::execute(*args)?,
+            Commands::Sign(args) => { Self::execute_async(sign::execute(args))? }?,
+            Commands::TestThroughput(args) => test_throughput::execute(args)?,
+            Commands::UnsafeResetSphinxKeys(args) => {
+                { Self::execute_async(reset_sphinx_keys::execute(args))? }?
             }
             Commands::Debug(debug) => match debug.command {
                 DebugCommands::ResetProvidersGatewayDbs(args) => {
-                    let _ = Self::execute_async(debug::reset_providers_dbs::execute(args))?;
+                    { Self::execute_async(debug::reset_providers_dbs::execute(args))? }?
                 }
             },
-            Commands::TestThroughput(args) => {
-                // Has its own logging setup
-                test_throughput::execute(args)?
-            }
-            // SigNoz/OTEL run in async context
-            Commands::BondingInformation(args) => Self::execute_async(async move {
-                #[cfg(feature = "otel")]
-                {
-                    let _guard =
-                        setup_tracing_logger("nym-node".to_string()).map_err(TracingError::from)?;
-                    let main_span = tracing::info_span!("startup", service = "nym-node");
-                    async {
-                        bonding_information::execute(args).await?;
-                        Ok::<(), anyhow::Error>(())
-                    }
-                    .instrument(main_span)
-                    .await
-                }
-                #[cfg(not(feature = "otel"))]
-                {
-                    setup_no_otel_logger().expect("failed to initialize logging");
-                    bonding_information::execute(args).await?;
-                    Ok::<(), anyhow::Error>(())
-                }
-            })??,
-            Commands::NodeDetails(args) => Self::execute_async(async move {
-                #[cfg(feature = "otel")]
-                {
-                    let _guard =
-                        setup_tracing_logger("nym-node".to_string()).map_err(TracingError::from)?;
-                    let main_span = tracing::info_span!("startup", service = "nym-node");
-                    async {
-                        node_details::execute(args).await?;
-                        Ok::<(), anyhow::Error>(())
-                    }
-                    .instrument(main_span)
-                    .await
-                }
-                #[cfg(not(feature = "otel"))]
-                {
-                    setup_no_otel_logger().expect("failed to initialize logging");
-                    node_details::execute(args).await?;
-                    Ok::<(), anyhow::Error>(())
-                }
-            })??,
-            Commands::Run(args) => Self::execute_async(async move {
-                #[cfg(feature = "otel")]
-                {
-                    let _guard =
-                        setup_tracing_logger("nym-node".to_string()).map_err(TracingError::from)?;
-                    tracing::warn!("OpenTelemetry is enabled for this nym-node instance.");
-                    let main_span = tracing::info_span!("startup", service = "nym-node");
-                    async {
-                        run::execute(*args).await?;
-                        Ok::<(), anyhow::Error>(())
-                    }
-                    .instrument(main_span)
-                    .await
-                }
-                #[cfg(not(feature = "otel"))]
-                {
-                    setup_no_otel_logger().expect("failed to initialize logging");
-                    run::execute(*args).await?;
-                    Ok::<(), anyhow::Error>(())
-                }
-            })??,
-            Commands::Sign(args) => Self::execute_async(async move {
-                #[cfg(feature = "otel")]
-                {
-                    let _guard =
-                        setup_tracing_logger("nym-node".to_string()).map_err(TracingError::from)?;
-                    let main_span = tracing::info_span!("startup", service = "nym-node");
-                    async {
-                        sign::execute(args).await?;
-                        Ok::<(), anyhow::Error>(())
-                    }
-                    .instrument(main_span)
-                    .await
-                }
-                #[cfg(not(feature = "otel"))]
-                {
-                    setup_no_otel_logger().expect("failed to initialize logging");
-                    sign::execute(args).await?;
-                    Ok::<(), anyhow::Error>(())
-                }
-            })??,
-            Commands::UnsafeResetSphinxKeys(args) => Self::execute_async(async move {
-                #[cfg(feature = "otel")]
-                {
-                    let _guard =
-                        setup_tracing_logger("nym-node".to_string()).map_err(TracingError::from)?;
-                    let main_span = tracing::info_span!("startup", service = "nym-node");
-                    async {
-                        reset_sphinx_keys::execute(args).await?;
-                        Ok::<(), anyhow::Error>(())
-                    }
-                    .instrument(main_span)
-                    .await
-                }
-                #[cfg(not(feature = "otel"))]
-                {
-                    setup_no_otel_logger().expect("failed to initialize logging");
-                    reset_sphinx_keys::execute(args).await?;
-                    Ok::<(), anyhow::Error>(())
-                }
-            })??,
         }
         Ok(())
     }

nym-node/src/config/mod.rs

@@ -428,20 +428,20 @@ impl Config {
     pub fn validate(&self) -> Result<(), NymNodeError> {
         self.mixnet.validate()?;
 
-        // // it's not allowed to run mixnode mode alongside entry mode
-        // if self.modes.mixnode && self.modes.entry {
-        //     return Err(NymNodeError::config_validation_failure(
-        //         "illegal modes configuration - node cannot run as a mixnode and an entry gateway",
-        //     ));
-        // }
-        //
-        // // nor it's allowed to run mixnode mode alongside exit mode
-        // // (use two separate checks for better error messages)
-        // if self.modes.mixnode && self.modes.exit {
-        //     return Err(NymNodeError::config_validation_failure(
-        //         "illegal modes configuration - node cannot run as a mixnode and an exit gateway",
-        //     ));
-        // }
+        // it's not allowed to run mixnode mode alongside entry mode
+        if self.modes.mixnode && self.modes.entry {
+            return Err(NymNodeError::config_validation_failure(
+                "illegal modes configuration - node cannot run as a mixnode and an entry gateway",
+            ));
+        }
+
+        // nor it's allowed to run mixnode mode alongside exit mode
+        // (use two separate checks for better error messages)
+        if self.modes.mixnode && self.modes.exit {
+            return Err(NymNodeError::config_validation_failure(
+                "illegal modes configuration - node cannot run as a mixnode and an exit gateway",
+            ));
+        }
 
         Ok(())
     }