Revert "handle_binary"

This reverts commit bc47fdfdfd.
Revert "missing span"
2025-09-02 15:25:21 +02:00 · 2025-09-02 15:25:20 +02:00 · 2025-09-02 15:25:19 +02:00 · 2025-09-02 15:25:18 +02:00 · 2025-09-02 15:25:16 +02:00 · 2025-09-02 15:25:15 +02:00
29 changed files with 979 additions and 103 deletions
@@ -1447,7 +1447,7 @@ checksum = "c2895653b4d9f1538a83970077cb01dfc77a4810524e51a110944688e916b18e"
 dependencies = [
 "prost 0.11.9",
 "prost-types",
- "tonic",
+ "tonic 0.9.2",
 "tracing-core",
 ]
@@ -1469,7 +1469,7 @@ dependencies = [
 "thread_local",
 "tokio",
 "tokio-stream",
- "tonic",
+ "tonic 0.9.2",
 "tracing",
 "tracing-core",
 "tracing-subscriber",
@@ -3580,6 +3580,7 @@ dependencies = [
 "bytes",
 "futures-channel",
 "futures-util",
 "h2 0.4.11",
 "http 1.3.1",
 "http-body 1.0.1",
 "httparse",
@@ -3634,6 +3635,19 @@ dependencies = [
 "tokio-io-timeout",
 ]
 [[package]]
 name = "hyper-timeout"
 version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b90d566bffbce6a75bd8b09a05aa8c2cb1fabb6cb348f8840c9e4c90a0d83b0"
 dependencies = [
 "hyper 1.6.0",
 "hyper-util",
 "pin-project-lite",
 "tokio",
 "tower-service",
 ]
 [[package]]
 name = "hyper-util"
 version = "0.1.15"
@@ -5157,7 +5171,7 @@ dependencies = [
 "clap_complete_fig",
 "const-str",
 "log",
- "opentelemetry",
+ "opentelemetry 0.30.0",
 "opentelemetry-jaeger",
 "schemars 0.8.22",
 "serde",
@@ -6001,6 +6015,10 @@ dependencies = [
 "nym-validator-client 0.1.0",
 "nym-wireguard",
 "nym-wireguard-types 0.1.0",
 "opentelemetry 0.30.0",
 "opentelemetry-otlp",
 "opentelemetry-stdout",
 "opentelemetry_sdk 0.30.0",
 "rand 0.8.5",
 "sha2 0.10.9",
 "sqlx",
@@ -6011,6 +6029,7 @@ dependencies = [
 "tokio-tungstenite",
 "tokio-util",
 "tracing",
 "tracing-opentelemetry",
 "url",
 "zeroize",
 ]
@@ -6069,6 +6088,7 @@ dependencies = [
 "nym-sphinx 0.1.0",
 "nym-statistics-common 0.1.0",
 "nym-task 0.1.0",
 "opentelemetry 0.30.0",
 "rand 0.8.5",
 "serde",
 "serde_json",
@@ -6620,6 +6640,7 @@ dependencies = [
 "cargo_metadata 0.19.2",
 "celes",
 "chacha",
 "chrono",
 "clap",
 "colored",
 "criterion",
@@ -6666,6 +6687,11 @@ dependencies = [
 "nym-verloc",
 "nym-wireguard",
 "nym-wireguard-types 0.1.0",
 "opentelemetry 0.30.0",
 "opentelemetry-otlp",
 "opentelemetry-semantic-conventions 0.30.0",
 "opentelemetry-stdout",
 "opentelemetry_sdk 0.30.0",
 "rand 0.8.5",
 "rand_chacha 0.3.1",
 "serde",
@@ -6679,7 +6705,10 @@ dependencies = [
 "toml 0.8.23",
 "tower-http 0.5.2",
 "tracing",
 "tracing-core",
 "tracing-indicatif",
 "tracing-opentelemetry",
 "tracing-serde",
 "tracing-subscriber",
 "url",
 "utoipa",
@@ -7060,6 +7089,11 @@ dependencies = [
 "nym-task 0.1.0",
 "nym-topology 0.1.0",
 "nym-validator-client 0.1.0",
 "opentelemetry 0.30.0",
 "opentelemetry-otlp",
 "opentelemetry-semantic-conventions 0.30.0",
 "opentelemetry-stdout",
 "opentelemetry_sdk 0.30.0",
 "parking_lot",
 "rand 0.8.5",
 "reqwest 0.12.22",
@@ -7073,6 +7107,8 @@ dependencies = [
 "tokio-util",
 "toml 0.8.23",
 "tracing",
 "tracing-core",
 "tracing-opentelemetry",
 "tracing-subscriber",
 "url",
 "uuid",
@@ -8234,90 +8270,164 @@ dependencies = [
 [[package]]
 name = "opentelemetry"
-version = "0.19.0"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f4b8347cc26099d3aeee044065ecc3ae11469796b4d65d065a23a584ed92a6f"
+checksum = "1b69a91d4893e713e06f724597ad630f1fa76057a5e1026c0ca67054a9032a76"
 dependencies = [
- "opentelemetry_api",
+ "futures-core",
- "opentelemetry_sdk",
+ "futures-sink",
 "js-sys",
 "once_cell",
 "pin-project-lite",
 "thiserror 1.0.69",
 ]
 [[package]]
 name = "opentelemetry"
 version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aaf416e4cb72756655126f7dd7bb0af49c674f4c1b9903e80c009e0c37e552e6"
 dependencies = [
 "futures-core",
 "futures-sink",
 "js-sys",
 "pin-project-lite",
 "thiserror 2.0.12",
 "tracing",
 ]
 [[package]]
 name = "opentelemetry-http"
-version = "0.8.0"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a819b71d6530c4297b49b3cae2939ab3a8cc1b9f382826a1bc29dd0ca3864906"
+checksum = "b0ba633e55c5ea6f431875ba55e71664f2fa5d3a90bd34ec9302eecc41c865dd"
 dependencies = [
 "async-trait",
 "bytes",
 "http 0.2.12",
 "isahc",
- "opentelemetry_api",
+ "opentelemetry 0.23.0",
 ]
 [[package]]
 name = "opentelemetry-http"
 version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "50f6639e842a97dbea8886e3439710ae463120091e2e064518ba8e716e6ac36d"
 dependencies = [
 "async-trait",
 "bytes",
 "http 1.3.1",
 "opentelemetry 0.30.0",
 "reqwest 0.12.22",
 ]
 [[package]]
 name = "opentelemetry-jaeger"
-version = "0.18.0"
+version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08e028dc9f4f304e9320ce38c80e7cf74067415b1ad5a8750a38bae54a4d450d"
+checksum = "501b471b67b746d9a07d4c29f8be00f952d1a2eca356922ede0098cbaddff19f"
 dependencies = [
 "async-trait",
- "futures",
+ "futures-core",
- "futures-executor",
+ "futures-util",
 "http 0.2.12",
 "isahc",
- "once_cell",
+ "opentelemetry 0.23.0",
- "opentelemetry",
+ "opentelemetry-http 0.12.0",
- "opentelemetry-http",
+ "opentelemetry-semantic-conventions 0.15.0",
- "opentelemetry-semantic-conventions",
+ "opentelemetry_sdk 0.23.0",
 "thiserror 1.0.69",
 "thrift",
 "tokio",
 ]
 [[package]]
-name = "opentelemetry-semantic-conventions"
+name = "opentelemetry-otlp"
-version = "0.11.0"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24e33428e6bf08c6f7fcea4ddb8e358fab0fe48ab877a87c70c6ebe20f673ce5"
+checksum = "dbee664a43e07615731afc539ca60c6d9f1a9425e25ca09c57bc36c87c55852b"
 dependencies = [
- "opentelemetry",
+ "http 1.3.1",
 "opentelemetry 0.30.0",
 "opentelemetry-http 0.30.0",
 "opentelemetry-proto",
 "opentelemetry_sdk 0.30.0",
 "prost 0.13.5",
 "reqwest 0.12.22",
 "thiserror 2.0.12",
 "tokio",
 "tonic 0.13.1",
 "tracing",
 ]
 [[package]]
-name = "opentelemetry_api"
+name = "opentelemetry-proto"
-version = "0.19.0"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed41783a5bf567688eb38372f2b7a8530f5a607a4b49d38dd7573236c23ca7e2"
+checksum = "2e046fd7660710fe5a05e8748e70d9058dc15c94ba914e7c4faa7c728f0e8ddc"
 dependencies = [
- "fnv",
+ "opentelemetry 0.30.0",
- "futures-channel",
+ "opentelemetry_sdk 0.30.0",
- "futures-util",
+ "prost 0.13.5",
- "indexmap 1.9.3",
+ "tonic 0.13.1",
- "once_cell",
+]
- "pin-project-lite",
+
- "thiserror 1.0.69",
+[[package]]
- "urlencoding",
+name = "opentelemetry-semantic-conventions"
 version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1869fb4bb9b35c5ba8a1e40c9b128a7b4c010d07091e864a29da19e4fe2ca4d7"
 [[package]]
 name = "opentelemetry-semantic-conventions"
 version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "83d059a296a47436748557a353c5e6c5705b9470ef6c95cfc52c21a8814ddac2"
 [[package]]
 name = "opentelemetry-stdout"
 version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "447191061af41c3943e082ea359ab8b64ff27d6d34d30d327df309ddef1eef6f"
 dependencies = [
 "chrono",
 "opentelemetry 0.30.0",
 "opentelemetry_sdk 0.30.0",
 ]
 [[package]]
 name = "opentelemetry_sdk"
-version = "0.19.0"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b3a2a91fdbfdd4d212c0dcc2ab540de2c2bcbbd90be17de7a7daf8822d010c1"
+checksum = "ae312d58eaa90a82d2e627fd86e075cf5230b3f11794e2ed74199ebbe572d4fd"
 dependencies = [
 "async-trait",
 "crossbeam-channel",
 "dashmap",
 "fnv",
 "futures-channel",
 "futures-executor",
 "futures-util",
 "lazy_static",
 "once_cell",
- "opentelemetry_api",
+ "opentelemetry 0.23.0",
 "ordered-float 4.6.0",
 "percent-encoding",
 "rand 0.8.5",
 "thiserror 1.0.69",
 ]
 [[package]]
 name = "opentelemetry_sdk"
 version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "11f644aa9e5e31d11896e024305d7e3c98a88884d9f8919dbf37a9991bc47a4b"
 dependencies = [
 "futures-channel",
 "futures-executor",
 "futures-util",
 "opentelemetry 0.30.0",
 "percent-encoding",
 "rand 0.9.2",
 "serde_json",
 "thiserror 2.0.12",
 "tokio",
 "tokio-stream",
 ]
@@ -8337,6 +8447,15 @@ dependencies = [
 "num-traits",
 ]
 [[package]]
 name = "ordered-float"
 version = "4.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7bb71e1b3fa6ca1c61f383464aaf2bb0e2f8e772a1f01d486832464de363b951"
 dependencies = [
 "num-traits",
 ]
 [[package]]
 name = "overload"
 version = "0.1.1"
@@ -9254,6 +9373,7 @@ dependencies = [
 "async-compression",
 "base64 0.22.1",
 "bytes",
 "futures-channel",
 "futures-core",
 "futures-util",
 "http 1.3.1",
@@ -11031,7 +11151,7 @@ dependencies = [
 "byteorder",
 "integer-encoding",
 "log",
- "ordered-float",
+ "ordered-float 2.10.1",
 "threadpool",
 ]
@@ -11337,7 +11457,7 @@ dependencies = [
 "http 0.2.12",
 "http-body 0.4.6",
 "hyper 0.14.32",
- "hyper-timeout",
+ "hyper-timeout 0.4.1",
 "percent-encoding",
 "pin-project",
 "prost 0.11.9",
@@ -11349,6 +11469,34 @@ dependencies = [
 "tracing",
 ]
 [[package]]
 name = "tonic"
 version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7e581ba15a835f4d9ea06c55ab1bd4dce26fc53752c69a04aac00703bfb49ba9"
 dependencies = [
 "async-trait",
 "base64 0.22.1",
 "bytes",
 "http 1.3.1",
 "http-body 1.0.1",
 "http-body-util",
 "hyper 1.6.0",
 "hyper-timeout 0.5.2",
 "hyper-util",
 "percent-encoding",
 "pin-project",
 "prost 0.13.5",
 "tokio",
 "tokio-rustls 0.26.2",
 "tokio-stream",
 "tower 0.5.2",
 "tower-layer",
 "tower-service",
 "tracing",
 "webpki-roots 0.26.11",
 ]
 [[package]]
 name = "tower"
 version = "0.4.13"
@@ -11377,9 +11525,12 @@ checksum = "d039ad9159c98b70ecfd540b2573b97f7f52c3e8d9f8ad57a24b916a536975f9"
 dependencies = [
 "futures-core",
 "futures-util",
 "indexmap 2.10.0",
 "pin-project-lite",
 "slab",
 "sync_wrapper 1.0.2",
 "tokio",
 "tokio-util",
 "tower-layer",
 "tower-service",
 "tracing",
@@ -11521,16 +11672,30 @@ dependencies = [
 [[package]]
 name = "tracing-opentelemetry"
-version = "0.19.0"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00a39dcf9bfc1742fa4d6215253b33a6e474be78275884c216fc2a06267b3600"
+checksum = "ddcf5959f39507d0d04d6413119c04f33b623f4f951ebcbdddddfad2d0623a9c"
 dependencies = [
 "js-sys",
 "once_cell",
- "opentelemetry",
+ "opentelemetry 0.30.0",
 "opentelemetry_sdk 0.30.0",
 "smallvec",
 "tracing",
 "tracing-core",
- "tracing-log 0.1.4",
+ "tracing-log 0.2.0",
 "tracing-subscriber",
 "web-time",
 ]
 [[package]]
 name = "tracing-serde"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "704b1aeb7be0d0a84fc9828cae51dab5970fee5088f83d1dd7ee6f6246fc6ff1"
 dependencies = [
 "serde",
 "tracing-core",
 ]
 [[package]]
@@ -11543,12 +11708,15 @@ dependencies = [
 "nu-ansi-term",
 "once_cell",
 "regex",
 "serde",
 "serde_json",
 "sharded-slab",
 "smallvec",
 "thread_local",
 "tracing",
 "tracing-core",
 "tracing-log 0.2.0",
 "tracing-serde",
 ]
 [[package]]
@@ -11946,12 +12114,6 @@ dependencies = [
 "serde",
 ]
 [[package]]
 name = "urlencoding"
 version = "2.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
 [[package]]
 name = "utf-8"
 version = "0.7.6"
@@ -281,8 +281,12 @@ nix = "0.27.1"
 notify = "5.1.0"
 okapi = "0.7.0"
 once_cell = "1.21.3"
-opentelemetry = "0.19.0"
+opentelemetry = "0.30.0"
-opentelemetry-jaeger = "0.18.0"
+opentelemetry-otlp = "0.30.0"
 opentelemetry-semantic-conventions = "0.30.0"
 opentelemetry_sdk = "0.30.0"
 opentelemetry-stdout = "0.30.0"
 opentelemetry-jaeger = "0.22.0"
 parking_lot = "0.12.3"
 pem = "0.8"
 petgraph = "0.6.5"
@@ -338,8 +342,10 @@ 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.19.0"
+tracing-opentelemetry = "0.31.0"
 tracing-serde = "0.2.0"
 tracing-subscriber = "0.3.19"
 tracing-tree = "0.2.2"
 tracing-indicatif = "0.3.9"
@@ -0,0 +1,11 @@
 find . -name "Cargo.toml" -not -path "./target/*" -exec grep -l "^name = " {} \; | xargs grep "^name = " | grep -v 'name = "nym-'
 find . -name "Cargo.toml" \
  -not -path "./nym-wallet/*" \
  -not -path "./contracts/*" \
  -not -path "./target/*" \
  -not -name "./Cargo.toml" \
  -exec sed -i 's/^version = ".*"/version.workspace = true/' {} \;
 find . -name "Cargo.toml" -not -path "./target/*" -exec awk '/^\[package\]/{flag=1; next} flag && /^name = /{print FILENAME ":" $0; flag=0} /^\[/{flag=0}' {} \; | grep -v 'name = "nym-'
@@ -21,10 +21,10 @@ serde_json = { workspace = true, optional = true }
 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 }
+opentelemetry-jaeger = { workspace = true, features = ["tokio", "collector_client", "isahc_collector_client"], optional = true }
 tracing-opentelemetry = { workspace = true, optional = true }
 utoipa = { workspace = true, optional = true }
-opentelemetry = { workspace = true, features = ["rt-tokio"], optional = true }
+opentelemetry = { workspace = true, optional = true }
 [build-dependencies]
@@ -65,7 +65,7 @@ pub trait MixnetClientStorage {
    fn gateway_details_store(&self) -> &Self::GatewaysDetailsStore;
 }
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct Ephemeral {
    key_store: InMemEphemeralKeys,
    reply_store: reply_storage::Empty,
@@ -22,7 +22,7 @@ mod test;
 // use the old key after new one was issued.
 // Remember that Arc<T> has Deref implementation for T
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct ClientKeys {
    /// identity key associated with the client instance.
    identity_keypair: Arc<ed25519::KeyPair>,
@@ -196,7 +196,7 @@ impl KeyStore for OnDiskKeys {
    }
 }
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct InMemEphemeralKeys {
    keys: Arc<Mutex<ClientKeys>>,
 }
@@ -53,7 +53,7 @@ pub enum Ed25519RecoveryError {
 }
 /// Keypair for usage in ed25519 EdDSA.
-#[derive(Debug, Zeroize, ZeroizeOnDrop)]
+#[derive(Zeroize, ZeroizeOnDrop)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct KeyPair {
    private_key: PrivateKey,
@@ -66,6 +66,12 @@ pub struct KeyPair {
    index: u32,
 }
 impl Debug for KeyPair {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        Display::fmt(&self.public_key.to_base58_string(), f)
    }
 }
 /// All keys will always have an index field populated this is to prevent anyone from figuring out if
 /// the keys are derived or random, and alter their behaviour based on that.
 impl KeyPair {
@@ -55,6 +55,12 @@ pub struct KeyPair {
    pub(crate) public_key: PublicKey,
 }
 impl Debug for KeyPair {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        Display::fmt(&self.public_key.to_base58_string(), f)
    }
 }
 impl KeyPair {
    #[cfg(feature = "rand")]
    pub fn new<R: RngCore + CryptoRng>(rng: &mut R) -> Self {
@@ -227,6 +233,12 @@ impl AsRef<[u8]> for PublicKey {
 #[derive(Zeroize, ZeroizeOnDrop)]
 pub struct PrivateKey(x25519_dalek::StaticSecret);
 impl Debug for PrivateKey {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.to_base58_string())
    }
 }
 impl Display for PrivateKey {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.to_base58_string())
@@ -19,7 +19,6 @@ 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 }
@@ -34,6 +33,9 @@ nym-task = { path = "../task" }
 nym-credentials = { path = "../credentials" }
 nym-credentials-interface = { path = "../credentials-interface" }
 opentelemetry = { workspace = true, features = ["trace"] }
 tracing = { workspace = true, features = ["std", "attributes", "tracing-attributes"] }
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio]
 workspace = true
 features = ["time"]
@@ -48,3 +50,4 @@ default-features = false
 [dev-dependencies]
 nym-compact-ecash = { path = "../nym_offline_compact_ecash" } # we need specific imports in tests
@@ -20,7 +20,7 @@ use rand::{thread_rng, CryptoRng, RngCore};
 use std::any::{type_name, Any};
 use std::str::FromStr;
 use std::time::Duration;
-use tracing::log::*;
+use tracing::{error, trace};
 use tungstenite::Message as WsMessage;
 #[cfg(not(target_arch = "wasm32"))]
@@ -16,6 +16,9 @@ pub struct AuthenticateRequest {
    pub content: AuthenticateRequestContent,
    pub request_signature: ed25519::Signature,
    #[serde(default)]
    pub debug_trace_id: Option<String>,
 }
 impl AuthenticateRequest {
@@ -23,6 +26,7 @@ impl AuthenticateRequest {
        protocol_version: u8,
        shared_key: &SharedGatewayKey,
        identity_keys: &ed25519::KeyPair,
        debug_trace_id: Option<String>,
    ) -> Result<AuthenticateRequest, GatewayRequestsError> {
        let content = AuthenticateRequestContent::new(
            protocol_version,
@@ -35,6 +39,7 @@ impl AuthenticateRequest {
        Ok(AuthenticateRequest {
            content,
            request_signature,
            debug_trace_id,
        })
    }
@@ -12,8 +12,10 @@ use nym_credentials_interface::CredentialSpendingData;
 use nym_crypto::asymmetric::ed25519;
 use nym_sphinx::DestinationAddressBytes;
 use nym_statistics_common::types::SessionType;
 use opentelemetry::trace::TraceContextExt;
 use serde::{Deserialize, Serialize};
 use std::str::FromStr;
 use tracing::{instrument, warn};
 use tungstenite::Message;
 pub mod authenticate;
@@ -76,6 +78,10 @@ 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)]
        debug_trace_id: Option<String>,
    },
    AuthenticateV2(Box<AuthenticateRequest>),
@@ -127,14 +133,24 @@ impl ClientControlRequest {
        let nonce = shared_key.random_nonce_or_iv();
        let ciphertext = shared_key.encrypt_naive(address.as_bytes_ref(), Some(&nonce))?;
        let otel_context = opentelemetry::Context::current();
        warn!("OTEL CONTEXT: {:?}", otel_context);
        let span = otel_context.span();
        let context = span.span_context();
        let trace_id = context.trace_id();
        warn!("TRACE_ID: {:?}", trace_id);
        // panic!();
        Ok(ClientControlRequest::Authenticate {
            protocol_version,
            address: address.as_base58_string(),
            enc_address: bs58::encode(&ciphertext).into_string(),
            iv: bs58::encode(&nonce).into_string(),
            debug_trace_id: Some(trace_id.to_string()),
        })
    }
    #[instrument]
    pub fn new_authenticate_v2(
        shared_key: &SharedGatewayKey,
        identity_keys: &ed25519::KeyPair,
@@ -142,8 +158,21 @@ impl ClientControlRequest {
        // if we're using v2 authentication, we must announce at least that protocol version
        let protocol_version = AUTHENTICATE_V2_PROTOCOL_VERSION;
        let otel_context = opentelemetry::Context::current();
        warn!("OTEL CONTEXT: {:?}", otel_context);
        let span = otel_context.span();
        let context = span.span_context();
        let trace_id = context.trace_id();
        warn!("TRACE_ID: {:?}", trace_id);
        // panic!();
        Ok(ClientControlRequest::AuthenticateV2(Box::new(
-            AuthenticateRequest::new(protocol_version, shared_key, identity_keys)?,
+            AuthenticateRequest::new(
                protocol_version,
                shared_key,
                identity_keys,
                Some(trace_id.to_string()),
            )?,
        )))
    }
@@ -12,7 +12,7 @@ use zeroize::{Zeroize, ZeroizeOnDrop};
 use serde::{Deserialize, Serialize};
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Zeroize, ZeroizeOnDrop)]
+#[derive(Debug, Zeroize, ZeroizeOnDrop)]
 pub struct AckKey(CipherKey<AckEncryptionAlgorithm>);
 #[derive(Debug)]
@@ -40,7 +40,7 @@ tokio = { workspace = true, features = [
 tokio-stream = { workspace = true, features = ["fs"] }
 tokio-tungstenite = { workspace = true }
 tokio-util = { workspace = true, features = ["codec"] }
-tracing = { workspace = true }
+#tracing = { workspace = true }
 url = { workspace = true, features = ["serde"] }
 zeroize = { workspace = true }
@@ -72,6 +72,26 @@ nym-wireguard = { path = "../common/wireguard" }
 nym-wireguard-types = { path = "../common/wireguard-types", default-features = false }
 defguard_wireguard_rs = { workspace = true }
 opentelemetry = { workspace = true, features = ["trace"] }
 tracing = { workspace = true, features = [
    "std",
    "attributes",
    "tracing-attributes",
 ] }
 tracing-opentelemetry = { workspace = true }
 opentelemetry_sdk = { version = "0.30.0", default-features = false, features = [
    "trace",
    "rt-tokio",
    "experimental_metrics_custom_reader",
 ] }
 opentelemetry-otlp = { workspace = true, features = [
    "metrics",
    "grpc-tonic",
    "tls",
    "tls-webpki-roots",
 ] }
 opentelemetry-stdout = { workspace = true, features = ["trace", "metrics"] }
 [build-dependencies]
 tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
@@ -33,6 +33,8 @@ use nym_gateway_storage::traits::SharedKeyGatewayStorage;
 use nym_node_metrics::events::MetricsEvent;
 use nym_sphinx::DestinationAddressBytes;
 use nym_task::TaskClient;
 use opentelemetry::trace::TraceContextExt;
 use opentelemetry_sdk::trace::{IdGenerator, RandomIdGenerator};
 use rand::CryptoRng;
 use std::net::SocketAddr;
 use std::time::Duration;
@@ -41,7 +43,8 @@ use time::OffsetDateTime;
 use tokio::io::{AsyncRead, AsyncWrite};
 use tokio::time::timeout;
 use tokio_tungstenite::tungstenite::{protocol::Message, Error as WsError};
-use tracing::*;
+use tracing::{debug, error, info, info_span, instrument, warn};
 use tracing_opentelemetry::OpenTelemetrySpanExt;
 #[derive(Debug, Error)]
 pub(crate) enum InitialAuthenticationError {
@@ -854,6 +857,92 @@ impl<R, S> FreshHandler<R, S> {
        S: AsyncRead + AsyncWrite + Unpin + Send,
        R: CryptoRng + RngCore + Send,
    {
        /*
        ┌───────────────────────────────────────────────────────┐
        │                 Incoming Request                      │
        │         trace_id: "abc123..." (from client)           │
        └────────────────────────┬──────────────────────────────┘
                                 ↓
        ┌───────────────────────────────────────────────────────┐
        │           1. Create SpanContext                       │
        │  ┌─────────────────────────────────────────────┐      │
        │  │ SpanContext::new(                           │      │
        │  │   trace_id: "abc123..." (preserved)         │      │
        │  │   span_id:  "new_random_id"                 │      │
        │  │   is_remote: true                           │      │
        │  │ )                                           │      │
        │  └─────────────────────────────────────────────┘      │
        └────────────────────────┬──────────────────────────────┘
                                 ↓
        ┌───────────────────────────────────────────────────────┐
        │           2. Convert to Context                       │
        │  Context::current().with_remote_span_context(...)     │
        └────────────────────────┬──────────────────────────────┘
                                 ↓
        ┌───────────────────────────────────────────────────────┐
        │           3. Create & Configure Span                  │
        │  span = info_span!("authenticate_v1")                 │
        │  span.set_parent(context)  // Before entering         │
        └────────────────────────┬─────────────────────────────-┘
                                 ↓
        ┌───────────────────────────────────────────────────────┐
        │           4. Enter Span                               │
        │  let _enter = span.enter()                            │
        │  // All child spans inherit trace_id "abc123..."      │
        └───────────────────────────────────────────────────────┘
        */
        let span = if let ClientControlRequest::AuthenticateV2(ref auth_req) = request {
            if let Some(ref trace_id) = auth_req.debug_trace_id {
                warn!("RAW TRACE ID: {trace_id:?}");
                let trace_id = opentelemetry::trace::TraceId::from_hex(&trace_id)
                    .expect("Invalid trace ID format");
                warn!("🫂TraceID: {trace_id}🫂");
                // We don't need to try and preserve the SpanID, just the TraceID (right?) so
                // just making a new SpanID for the moment
                let id_generator = RandomIdGenerator::default();
                let span_id = id_generator.new_span_id();
                let span_context = opentelemetry::trace::SpanContext::new(
                    trace_id,
                    span_id,
                    opentelemetry::trace::TraceFlags::SAMPLED,
                    true, // is_remote = true since this comes from another service
                    Default::default(),
                );
                let remote_context =
                    opentelemetry::Context::current().with_remote_span_context(span_context);
                let _context_guard = remote_context.clone().attach();
                let span = info_span!(
                    "authenticate_v2",
                    trace_id = %trace_id
                );
                span.set_parent(remote_context.clone());
                Some(span)
            } else {
                warn!("AuthenticateV2 request but no trace_id provided");
                None
            }
        } else {
            warn!("Not an AuthenticateV2 request");
            None
        };
        // Probably a nicer way to do this but for now just match
        let _guard = match &span {
            Some(s) => {
                warn!("ENTERED SPAN");
                Some(s.enter())
            }
            None => {
                warn!("COULDN'T ENTER SPAN");
                None
            }
        };
        // we can handle stateless client requests without prior authentication, like `ClientControlRequest::SupportedProtocol`
        let auth_result = match request {
            ClientControlRequest::Authenticate {
@@ -861,6 +950,7 @@ impl<R, S> FreshHandler<R, S> {
                address,
                enc_address,
                iv,
                debug_trace_id: _,
            } => {
                self.handle_legacy_authenticate(protocol_version, address, enc_address, iv)
                    .await
@@ -35,7 +35,7 @@ serde_json.workspace = true
 thiserror.workspace = true
 tracing.workspace = true
 tracing-indicatif = { workspace = true }
-tracing-subscriber.workspace = true
+tracing-subscriber = { workspace = true, features = ["json", "fmt"] }
 tokio = { workspace = true, features = ["macros", "sync", "rt-multi-thread"] }
 tokio-util = { workspace = true, features = ["codec"] }
 toml = { workspace = true }
@@ -114,6 +114,19 @@ blake2 = "=0.8.1"
 sha2 = { workspace = true }
 hkdf = { workspace = true }
 # signoz
 opentelemetry = { workspace = true }
 opentelemetry_sdk = { workspace = true }
 tracing-core = { workspace = true }
 tracing-opentelemetry = { workspace = true }
 tracing-serde = { workspace = true }
 opentelemetry-otlp = { version = "0.30.0" }
 opentelemetry-semantic-conventions = { workspace = true, features = [
    "semconv_experimental",
 ] }
 opentelemetry-stdout = { workspace = true, features = ["trace", "metrics"] }
 chrono = { workspace = true }
 [[bench]]
 name = "benchmarks"
 harness = false
@@ -6,11 +6,13 @@ use crate::cli::commands::{
    test_throughput,
 };
 use crate::env::vars::{NYMNODE_CONFIG_ENV_FILE_ARG, NYMNODE_NO_BANNER_ARG};
-use crate::logging::setup_tracing_logger;
+use crate::error::NymNodeError;
 use crate::logging::{setup_no_otel_logger, setup_tracing_logger};
 use clap::{Parser, Subcommand};
 use nym_bin_common::bin_info;
 use std::future::Future;
 use std::sync::OnceLock;
 use tracing::instrument;
 pub(crate) mod commands;
 mod helpers;
@@ -53,28 +55,73 @@ 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(..)) {
            setup_tracing_logger()?;
        }
        match self.command {
-            Commands::BuildInfo(args) => build_info::execute(args)?,
+            // Sync commands get logger w. no OTEL
-            Commands::BondingInformation(args) => {
+            Commands::BuildInfo(args) => {
-                { Self::execute_async(bonding_information::execute(args))? }?
+                setup_no_otel_logger()?;
                build_info::execute(args)?
            }
-            Commands::NodeDetails(args) => { Self::execute_async(node_details::execute(args))? }?,
+            Commands::Migrate(args) => {
-            Commands::Run(args) => { Self::execute_async(run::execute(*args))? }?,
+                setup_no_otel_logger()?;
-            Commands::Migrate(args) => migrate::execute(*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::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 {
                setup_tracing_logger().map_err(NymNodeError::TracingSetupFailure)?;
                bonding_information::execute(args).await
            })??,
            Commands::NodeDetails(args) => Self::execute_async(async move {
                setup_tracing_logger().map_err(NymNodeError::TracingSetupFailure)?;
                node_details::execute(args).await
            })??,
            Commands::Run(args) => Self::execute_async(async move {
                setup_tracing_logger().map_err(NymNodeError::TracingSetupFailure)?;
                run::execute(*args).await
            })??,
            Commands::Sign(args) => Self::execute_async(async move {
                setup_tracing_logger().map_err(NymNodeError::TracingSetupFailure)?;
                sign::execute(args).await
            })??,
            Commands::UnsafeResetSphinxKeys(args) => Self::execute_async(async move {
                setup_tracing_logger().map_err(NymNodeError::TracingSetupFailure)?;
                reset_sphinx_keys::execute(args).await
            })??,
            Commands::TestTracing => Self::execute_async(async move {
                setup_tracing_logger().map_err(NymNodeError::TracingSetupFailure)?;
                Ok::<(), crate::error::NymNodeError>(())
            })??,
        }
        Ok(())
    }
    // 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(..)) {
    //     //     setup_tracing_logger()?;
    //     // }
    //     match self.command {
    //         Commands::BuildInfo(args) => build_info::execute(args)?,
    //         Commands::BondingInformation(args) => {
    //             { Self::execute_async(bonding_information::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))? }?
    //         }
    //     }
    //     Ok(())
    // }
 }
 #[derive(Subcommand, Debug)]
@@ -104,6 +151,11 @@ pub(crate) enum Commands {
    /// was running on this machine in mixnet mode
    #[clap(hide = true)]
    TestThroughput(test_throughput::Args),
    /// Test local tracing for instrumentation and
    /// TraceID aligmnet
    // TODO this needs to just start and then wait for the shutdown signal - grab from run()
    TestTracing,
 }
 #[cfg(test)]
@@ -76,6 +76,9 @@ pub enum KeyIOFailure {
 #[derive(Debug, Error)]
 pub enum NymNodeError {
    #[error("Failed to setup tracing logger")]
    TracingSetupFailure(#[source] anyhow::Error),
    #[error("this binary version no longer supports migration from legacy mixnodes and gateways")]
    UnsupportedMigration,
@@ -2,9 +2,27 @@
 // SPDX-License-Identifier: GPL-3.0-only
 use nym_bin_common::logging::{default_tracing_env_filter, default_tracing_fmt_layer};
 use tracing::{info, warn};
 use tracing_subscriber::filter::Directive;
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::util::SubscriberInitExt;
 use tracing_subscriber::{fmt, Layer};
 // Signoz
 use crate::trace_id_format::TraceIdFormat;
 use opentelemetry::trace::TracerProvider;
 use opentelemetry::{global, KeyValue};
 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::{RandomIdGenerator, SdkTracerProvider};
 use opentelemetry_sdk::{trace::Sampler, Resource};
 use opentelemetry_semantic_conventions::resource::{DEPLOYMENT_ENVIRONMENT_NAME, SERVICE_VERSION};
 use opentelemetry_semantic_conventions::SCHEMA_URL;
 use tracing_core::Level;
 use tracing_opentelemetry::{MetricsLayer, OpenTelemetryLayer};
 use tracing_subscriber::fmt::format::FmtSpan;
 pub(crate) fn granual_filtered_env() -> anyhow::Result<tracing_subscriber::filter::EnvFilter> {
    fn directive_checked(directive: impl Into<String>) -> anyhow::Result<Directive> {
@@ -13,7 +31,6 @@ pub(crate) fn granual_filtered_env() -> anyhow::Result<tracing_subscriber::filte
    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"))?);
@@ -22,13 +39,127 @@ pub(crate) fn granual_filtered_env() -> anyhow::Result<tracing_subscriber::filte
 }
 pub(crate) fn build_tracing_logger() -> anyhow::Result<impl SubscriberExt> {
-    Ok(tracing_subscriber::registry()
+    let key = std::env::var("SIGNOZ_INGESTION_KEY").expect("SIGNOZ_INGESTION_KEY not set");
-        .with(default_tracing_fmt_layer(std::io::stderr))
+    println!("SIGNOZ_INGESTION_KEY = {}", key);
-        .with(granual_filtered_env()?))
+    let mut metadata = MetadataMap::new();
    metadata.insert(
        "signoz-ingestion-key",
        key.parse().expect("Could not parse key"),
    );
    let tracer_provider = init_tracer_provider(metadata)?;
    let meter_provider = init_meter_provider()?;
    let tracer = tracer_provider.tracer("tracing-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(TraceIdFormat);
    let registry = tracing_subscriber::registry()
        .with(fmt_layer)
        .with(granual_filtered_env()?)
        .with(tracing_subscriber::filter::LevelFilter::from_level(
            Level::DEBUG,
        ))
        .with(MetricsLayer::new(meter_provider))
        .with(OpenTelemetryLayer::new(tracer));
    Ok(registry)
 }
 pub(crate) fn setup_tracing_logger() -> anyhow::Result<()> {
    build_tracing_logger()?.init();
    Ok(())
 }
 // This is called outside of the async context where we can't use OTEL
 pub(crate) fn setup_no_otel_logger() -> anyhow::Result<()> {
    // 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(anyhow::anyhow!("Tracing logger already initialised"));
    }
    let registry = tracing_subscriber::registry()
        .with(default_tracing_fmt_layer(std::io::stderr))
        .with(granual_filtered_env()?)
        .with(tracing_subscriber::filter::LevelFilter::from_level(
            Level::INFO,
        ));
    registry
        .try_init()
        .map_err(|e| anyhow::anyhow!("Failed to set tracing subscriber: {}", e))?;
    Ok(())
 }
 // Signoz/OTEL
 fn resource() -> Resource {
    Resource::builder()
        .with_service_name("nym-node")
        .with_schema_url(
            [
                KeyValue::new(SERVICE_VERSION, env!("CARGO_PKG_VERSION")),
                KeyValue::new(DEPLOYMENT_ENVIRONMENT_NAME, "develop"),
            ],
            SCHEMA_URL,
        )
        .build()
 }
 fn init_tracer_provider(metadata: MetadataMap) -> anyhow::Result<SdkTracerProvider> {
    let endpoint = std::env::var("SIGNOZ_ENDPOINT").expect("SIGNOZ_ENDPOINT not set");
    info!("SIGNOZ_ENDPOINT = {}", endpoint);
    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(RandomIdGenerator::default())
        .with_resource(resource())
        .with_batch_exporter(exporter)
        .build();
    Ok(tracer)
 }
 fn init_meter_provider() -> anyhow::Result<SdkMeterProvider> {
    let exporter = opentelemetry_otlp::MetricExporter::builder()
        .with_tonic()
        .with_temporality(opentelemetry_sdk::metrics::Temporality::default())
        .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)
 }
@@ -16,6 +16,7 @@ pub(crate) mod error;
 mod logging;
 pub(crate) mod node;
 pub(crate) mod throughput_tester;
 mod trace_id_format;
 pub(crate) mod wireguard;
 fn main() -> anyhow::Result<()> {
@@ -0,0 +1,88 @@
 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::fields::AsMap;
 use tracing_serde::AsSerde;
 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)
    }
 }
@@ -70,10 +70,18 @@ tokio-util.workspace = true
 uuid = { workspace = true, features = ["v4", "serde"] }
 bincode = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
-tracing.workspace = true
+#tracing.workspace = true
-tracing-subscriber = { workspace = true, features = ["env-filter"] }
+#tracing-subscriber = { workspace = true, features = ["env-filter", "registry", "std"] }
 dirs.workspace = true
 opentelemetry = { workspace = true }
 opentelemetry_sdk = { workspace = true }
 tracing = { workspace = true, features = ["std"] }
 tracing-subscriber = { workspace = true, features = ["registry", "std"] }
 tracing-core = { workspace = true }
 tracing-opentelemetry = { workspace = true }
 [dev-dependencies]
 anyhow = { workspace = true }
 dotenvy = { workspace = true }
@@ -83,6 +91,11 @@ tokio = { workspace = true, features = ["full"] }
 time = { workspace = true }
 nym-bin-common = { path = "../../../common/bin-common", features = ["basic_tracing"] }
 opentelemetry-semantic-conventions = { workspace = true, features = ["semconv_experimental"] }
 opentelemetry-otlp = { workspace = true, features = ["metrics", "grpc-tonic", "tls",
    "tls-webpki-roots", ] }
 opentelemetry-stdout = { workspace = true, features = ["trace", "metrics"] }
 # extra dependencies for libp2p examples
 #libp2p = { git = "https://github.com/ChainSafe/rust-libp2p.git", rev = "e3440d25681df380c9f0f8cfdcfd5ecc0a4f2fb6", features = [ "identify", "macros", "ping", "tokio", "tcp", "dns", "websocket", "noise", "mplex", "yamux", "gossipsub" ]}
 tokio-stream = { workspace = true }
@@ -92,3 +105,4 @@ hex = { workspace = true }
 [features]
 libp2p-vanilla = []
@@ -1,28 +1,208 @@
 use dotenvy::dotenv;
 use nym_sdk::mixnet::{
    AnonymousSenderTag, MixnetClientBuilder, MixnetMessageSender, ReconstructedMessage,
    StoragePaths,
 };
 use opentelemetry::trace::TraceContextExt;
 use opentelemetry::trace::Tracer;
 use opentelemetry::trace::TracerProvider;
 use opentelemetry::Context;
 use opentelemetry::{global, KeyValue};
 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::IdGenerator;
 use opentelemetry_sdk::trace::{RandomIdGenerator, SdkTracerProvider};
 use opentelemetry_sdk::{trace::Sampler, Resource};
 use opentelemetry_semantic_conventions::{
    attribute::{DEPLOYMENT_ENVIRONMENT_NAME, SERVICE_VERSION},
    SCHEMA_URL,
 };
 use std::path::PathBuf;
 use tempfile::TempDir;
 use tracing::info_span;
 use tracing::instrument;
 use tracing::{info, warn};
 use tracing_core::Level;
 use tracing_opentelemetry::{MetricsLayer, OpenTelemetryLayer};
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
-#[tokio::main]
+fn resource() -> Resource {
-async fn main() {
+    Resource::builder()
-    nym_bin_common::logging::setup_tracing_logger();
+        .with_service_name("sdk-example-surb-reply")
        .with_schema_url(
            [
                KeyValue::new(SERVICE_VERSION, env!("CARGO_PKG_VERSION")),
                KeyValue::new(DEPLOYMENT_ENVIRONMENT_NAME, "develop"),
            ],
            SCHEMA_URL,
        )
        .build()
 }
-    // Specify some config options
+fn init_tracer_provider(metadata: MetadataMap) -> anyhow::Result<SdkTracerProvider> {
-    let config_dir: PathBuf = TempDir::new().unwrap().path().to_path_buf();
+    let endpoint = std::env::var("SIGNOZ_ENDPOINT").expect("SIGNOZ_ENDPOINT not set");
-    let storage_paths = StoragePaths::new_from_dir(&config_dir).unwrap();
+    println!("SIGNOZ_ENDPOINT = {}", endpoint);
-    // Create the client with a storage backend, and enable it by giving it some paths. If keys
+    // Configure OTLP exporter with metadata
-    // exists at these paths, they will be loaded, otherwise they will be generated.
+    let mut exporter_builder = opentelemetry_otlp::SpanExporter::builder()
-    let client = MixnetClientBuilder::new_with_default_storage(storage_paths)
+        .with_tonic()
-        .await
+        .with_metadata(metadata)
-        .unwrap()
+        .with_endpoint(&endpoint);
    // Try with TLS - seems to work
    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()
        // Customize sampling strategy
        .with_sampler(Sampler::ParentBased(Box::new(Sampler::TraceIdRatioBased(
            1.0,
        ))))
        // If export trace to AWS X-Ray, you can use XrayIdGenerator
        .with_id_generator(RandomIdGenerator::default())
        .with_resource(resource())
        .with_batch_exporter(exporter)
        .build();
    // We set this in meter provider but didn't in here
    // :facepalm:
    global::set_tracer_provider(tracer.clone());
    Ok(tracer)
 }
 fn init_meter_provider() -> SdkMeterProvider {
    let exporter = opentelemetry_otlp::MetricExporter::builder()
        .with_tonic()
        .with_temporality(opentelemetry_sdk::metrics::Temporality::default())
        .build()
        .unwrap();
    let reader = PeriodicReader::builder(exporter)
        .with_interval(std::time::Duration::from_secs(30))
        .build();
    // For debugging in development
    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());
    meter_provider
 }
 fn init_tracing_subscriber(metadata: MetadataMap) -> OtelGuard {
    let tracer_provider = init_tracer_provider(metadata).expect("Initializing tracer failed");
    let meter_provider = init_meter_provider();
    let tracer = tracer_provider.tracer("tracing-otel-subscriber");
    tracing_subscriber::registry()
        // The global level filter prevents the exporter network stack
        // from reentering the globally installed OpenTelemetryLayer with
        // its own spans while exporting, as the libraries should not use
        // tracing levels below DEBUG. If the OpenTelemetry layer needs to
        // trace spans and events with higher verbosity levels, consider using
        // per-layer filtering to target the telemetry layer specifically,
        // e.g. by target matching.
        .with(tracing_subscriber::filter::LevelFilter::from_level(
            Level::DEBUG,
        ))
        .with(tracing_subscriber::fmt::layer())
        .with(MetricsLayer::new(meter_provider.clone()))
        .with(OpenTelemetryLayer::new(tracer))
        .init();
    OtelGuard {
        tracer_provider,
        meter_provider,
    }
 }
 struct OtelGuard {
    tracer_provider: SdkTracerProvider,
    meter_provider: SdkMeterProvider,
 }
 impl Drop for OtelGuard {
    fn drop(&mut self) {
        if let Err(err) = self.tracer_provider.shutdown() {
            eprintln!("{err:?}");
        }
        if let Err(err) = self.meter_provider.shutdown() {
            eprintln!("{err:?}");
        }
    }
 }
 #[tokio::main]
 #[instrument]
 async fn main() -> anyhow::Result<()> {
    // nym_bin_common::logging::setup_tracing_logger();
    dotenv().ok();
    let key = std::env::var("SIGNOZ_INGESTION_KEY").expect("SIGNOZ_INGESTION_KEY not set");
    println!("SIGNOZ_INGESTION_KEY = {}", key);
    let mut metadata = MetadataMap::new();
    metadata.insert("signoz-ingestion-key", key.parse()?);
    let _guard = init_tracing_subscriber(metadata);
    let tracer = global::tracer("sdk-example-surb-reply");
    let span = tracer.start("test_span");
    let cx = Context::current_with_span(span);
    let _guard = cx.clone().attach();
    let trace_id = cx.span().span_context().trace_id();
    warn!("Main TRACE_ID: {:?}", trace_id);
    let span = info_span!(
        "surb_reply_example_session",
        trace_id = %trace_id.to_string()
    );
    let _enter = span.enter();
    let otel_context = opentelemetry::Context::current();
    warn!("OTEL CONTEXT: {:?}", otel_context);
    let span = otel_context.span();
    let context = span.span_context();
    let trace_id = context.trace_id();
    warn!("TRACE_ID: {:?}", trace_id);
    // panic!();
    // Specify some config options
    // let config_dir: PathBuf = TempDir::new().unwrap().path().to_path_buf();
    // let storage_paths = StoragePaths::new_from_dir(&config_dir).unwrap();
    // Create the client with a storage backend, and enable it by giving it some paths. If keys
    // exists at these paths, they will be loaded, otherwise they will be generated.
    // let client = MixnetClientBuilder::new_with_default_storage(storage_paths)
    //     .await
    //     .unwrap()
    //     .build()
    //     .unwrap();
    let client_builder = MixnetClientBuilder::new_ephemeral();
    let mixnet_client = client_builder
        .request_gateway("BAF2aYpzcK9KbSS3Y7EdLisxiogkTr88FXkdL8EDNigH".to_string())
        .with_ignore_epoch_roles(true)
        .with_extended_topology(true)
        .build()?;
    // Now we connect to the mixnet, using keys now stored in the paths provided.
-    let mut client = client.connect_to_mixnet().await.unwrap();
+    let mut client = mixnet_client.connect_to_mixnet().await.unwrap();
    // Be able to get our client address
    let our_address = client.nym_address();
@@ -69,4 +249,6 @@ async fn main() {
    client
        .on_messages(|msg| println!("\nReceived: {}", String::from_utf8_lossy(&msg.message)))
        .await;
    Ok(())
 }
@@ -396,6 +396,21 @@ where
    derivation_material: Option<DerivationMaterial>,
 }
 impl<S> std::fmt::Debug for DisconnectedMixnetClient<S>
 where
    S: MixnetClientStorage + Clone + 'static,
    S::ReplyStore: Send + Sync,
    S::GatewaysDetailsStore: Sync,
    <S::ReplyStore as ReplyStorageBackend>::StorageError: Sync + Send,
    <S::CredentialStore as CredentialStorage>::StorageError: Send + Sync,
    <S::KeyStore as KeyStore>::StorageError: Send + Sync,
    <S::GatewaysDetailsStore as GatewaysDetailsStore>::StorageError: Send + Sync,
 {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("DisconnectedMixnetClient").finish()
    }
 }
 impl<S> DisconnectedMixnetClient<S>
 where
    S: MixnetClientStorage + Clone + 'static,
@@ -474,6 +489,7 @@ where
            .collect()
    }
    #[tracing::instrument]
    async fn setup_client_keys(&self) -> Result<()> {
        let mut rng = OsRng;
        let key_store = self.storage.key_store();
@@ -571,6 +587,7 @@ where
    ///
    /// This function will return an error if you try to re-register when in an already registered
    /// state.
    #[tracing::instrument]
    pub async fn setup_gateway(&mut self) -> Result<()> {
        if !matches!(self.state, BuilderState::New) {
            return Err(Error::ReregisteringGatewayNotSupported);
@@ -661,6 +678,7 @@ where
        )
    }
    #[tracing::instrument]
    async fn connect_to_mixnet_common(mut self) -> Result<(BaseClient, Recipient)> {
        self.setup_client_keys().await?;
        self.setup_gateway().await?;
@@ -811,6 +829,7 @@ where
    ///     let client = client.connect_to_mixnet().await.unwrap();
    /// }
    /// ```
    #[tracing::instrument]
    pub async fn connect_to_mixnet(self) -> Result<MixnetClient> {
        if self.socks5_config.is_some() {
            return Err(Error::Socks5Config { set: true });
@@ -6,7 +6,7 @@ use url::Url;
 const DEFAULT_SDK_CLIENT_ID: &str = "_default-nym-sdk-client";
 /// Config struct for [`crate::mixnet::MixnetClient`]
-#[derive(Default)]
+#[derive(Default, Debug)]
 pub struct Config {
    /// If the user has explicitly specified a gateway.
    pub user_chosen_gateway: Option<String>,
@@ -22,6 +22,8 @@ use nym_task::{
    TaskHandle,
 };
 use nym_topology::{NymRouteProvider, NymTopology};
 use std::fmt;
 use std::fmt::{Debug, Formatter};
 use std::pin::Pin;
 use std::sync::Arc;
 use std::task::{Context, Poll};
@@ -64,6 +66,14 @@ pub struct MixnetClient {
    pub(crate) remember_me: RememberMe,
 }
 impl Debug for MixnetClient {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        f.debug_struct("MixnetClient")
            .field("address", &self.nym_address)
            .finish()
    }
 }
 impl MixnetClient {
    #[allow(clippy::too_many_arguments)]
    pub(crate) fn new(
@@ -194,7 +204,15 @@ impl MixnetClient {
    }
    /// Wait for messages from the mixnet
    #[tracing::instrument]
    pub async fn wait_for_messages(&mut self) -> Option<Vec<ReconstructedMessage>> {
        let span = tracing::info_span!(
            "wait_for_messages",
            "address = {}",
            self.nym_address.to_string()
        );
        let _enter = span.enter();
        self.reconstructed_receiver.next().await
    }
@@ -69,6 +69,9 @@ pub trait MixnetMessageSender {
    where
        M: AsRef<[u8]> + Send,
    {
        let span = tracing::info_span!("send_message", "address = {}", address.to_string());
        let _enter = span.enter();
        let lane = TransmissionLane::General;
        let input_msg = match surbs {
            IncludedSurbs::Amount(surbs) => InputMessage::new_anonymous(
@@ -107,6 +110,13 @@ pub trait MixnetMessageSender {
    where
        M: AsRef<[u8]> + Send,
    {
        let span = tracing::info_span!(
            "send_reply",
            "recipient_tag = {}",
            recipient_tag.to_string()
        );
        let _enter = span.enter();
        let lane = TransmissionLane::General;
        let input_msg = InputMessage::new_reply(
            recipient_tag,
@@ -0,0 +1 @@
 .env
Author	SHA1	Message	Date
Floriane TUERNAL SABOTINOV	190ddc0d7b	Revert "handle_binary" This reverts commit `bc47fdfdfd`.	2025-09-02 15:25:21 +02:00
Floriane TUERNAL SABOTINOV	7567b57553	Revert "missing span" This reverts commit `281de87871`.	2025-09-02 15:25:20 +02:00
Floriane TUERNAL SABOTINOV	3268aa63e6	Revert "initial_auth missing span" This reverts commit `d86a393412`.	2025-09-02 15:25:19 +02:00
Floriane TUERNAL SABOTINOV	132a8c66f6	Revert "debug handle_request instrument" This reverts commit `f6dffa2a38`.	2025-09-02 15:25:18 +02:00
Floriane TUERNAL SABOTINOV	f932135799	Revert "rm noisy instrument" This reverts commit `0fe5264231`.	2025-09-02 15:25:16 +02:00
Floriane TUERNAL SABOTINOV	3b8b29a0ab	Revert "add span propagation test" This reverts commit `68ebe93ba5`.	2025-09-02 15:25:15 +02:00
Floriane TUERNAL SABOTINOV	cfec1781a8	Revert "packet forwarding spans" This reverts commit `fa02376403`.	2025-09-02 15:25:11 +02:00
Floriane TUERNAL SABOTINOV	03280cd9b4	Revert "auth and gateway changes" This reverts commit `7609d6ae4d`.	2025-09-02 15:25:08 +02:00
Floriane TUERNAL SABOTINOV	cd16239cf3	Revert "test lifetime span into tokio select" This reverts commit `7fa5a778aa`.	2025-09-02 15:24:52 +02:00
Floriane TUERNAL SABOTINOV	7fa5a778aa	test lifetime span into tokio select	2025-08-27 14:12:15 +02:00
Floriane TUERNAL SABOTINOV	7609d6ae4d	auth and gateway changes	2025-08-27 09:10:29 +02:00
Floriane TUERNAL SABOTINOV	fa02376403	packet forwarding spans	2025-08-26 13:44:59 +02:00
Floriane TUERNAL SABOTINOV	68ebe93ba5	add span propagation test	2025-08-26 09:12:26 +02:00
Floriane TUERNAL SABOTINOV	0fe5264231	rm noisy instrument	2025-08-25 15:04:45 +02:00
Floriane TUERNAL SABOTINOV	f6dffa2a38	debug handle_request instrument	2025-08-25 15:04:18 +02:00
Floriane TUERNAL SABOTINOV	d86a393412	initial_auth missing span	2025-08-25 12:33:33 +02:00
Floriane TUERNAL SABOTINOV	281de87871	missing span	2025-08-25 11:37:24 +02:00
Floriane TUERNAL SABOTINOV	bc47fdfdfd	handle_binary	2025-08-22 15:38:56 +02:00
Mark Sinclair	05dd39699d	add tracing event formatter with trace_id and span_id	2025-08-06 11:28:53 +01:00
mfahampshire	5cf97977a1	add feature flag to tracing-sub	2025-08-05 20:30:13 +02:00
Mark Sinclair	a47a10fdde	JSON log format	2025-08-05 18:29:18 +01:00
mfahampshire	2a8265371d	try fix the propogation of trace_id across client-node v2	2025-08-05 19:09:42 +02:00
mfahampshire	0b7513ff55	try fix the propogation of trace_id across client-node	2025-08-05 18:43:15 +02:00
mfahampshire	312c51535f	adding tracing to syslog	2025-08-05 18:10:56 +02:00
mfahampshire	54fb9ebfab	try add traceID to syslogs	2025-08-05 17:54:05 +02:00
mfahampshire	3ec9c4d8d7	change to check authv2	2025-08-05 16:20:56 +02:00
mfahampshire	6d0b899648	yet more logging	2025-08-05 14:43:38 +02:00
mfahampshire	bb5187eb0a	warning logs (more)	2025-08-05 14:04:34 +02:00
mfahampshire	558df0975b	warning logs	2025-08-05 12:11:46 +02:00
mfahampshire	952fcdb2b3	added tracing command for testing + extra logging	2025-08-05 11:21:31 +02:00
mfahampshire	7bc4a69a1c	pull guard into main fn scope	2025-08-04 18:22:58 +02:00
mfahampshire	dd1e46ec15	force connect to gateway	2025-08-04 14:29:14 +02:00
mfahampshire	8c219f0603	Made logging conditional on execution	2025-08-04 12:44:12 +02:00
mfahampshire	8c0addb987	moved telemetry to logging from mod	2025-08-02 00:27:31 +02:00
mfahampshire	fc53eec241	add telemetry builder to node.run()	2025-08-01 17:17:14 +02:00
Mark Sinclair	12649627a5	tidy up	2025-08-01 13:58:17 +01:00
mfahampshire	99684e79e4	think its fixed	2025-08-01 14:53:18 +02:00
Mark Sinclair	fc76c2d7a0	wip	2025-08-01 12:58:52 +01:00
Mark Sinclair	18f7ba92bb	wip	2025-07-31 20:09:38 +01:00