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",
- "opentelemetry_sdk",
+ "futures-core",
+ "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-executor",
+ "futures-core",
+ "futures-util",
 "http 0.2.12",
 "isahc",
- "once_cell",
- "opentelemetry",
- "opentelemetry-http",
- "opentelemetry-semantic-conventions",
- "thiserror 1.0.69",
+ "opentelemetry 0.23.0",
+ "opentelemetry-http 0.12.0",
+ "opentelemetry-semantic-conventions 0.15.0",
+ "opentelemetry_sdk 0.23.0",
 "thrift",
 "tokio",
 ]

 [[package]]
-name = "opentelemetry-semantic-conventions"
-version = "0.11.0"
+name = "opentelemetry-otlp"
+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"
-version = "0.19.0"
+name = "opentelemetry-proto"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed41783a5bf567688eb38372f2b7a8530f5a607a4b49d38dd7573236c23ca7e2"
+checksum = "2e046fd7660710fe5a05e8748e70d9058dc15c94ba914e7c4faa7c728f0e8ddc"
 dependencies = [
- "fnv",
- "futures-channel",
- "futures-util",
- "indexmap 1.9.3",
- "once_cell",
- "pin-project-lite",
- "thiserror 1.0.69",
- "urlencoding",
+ "opentelemetry 0.30.0",
+ "opentelemetry_sdk 0.30.0",
+ "prost 0.13.5",
+ "tonic 0.13.1",
+]
+
+[[package]]
+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-jaeger = "0.18.0"
+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-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)?,
-            Commands::BondingInformation(args) => {
-                { Self::execute_async(bonding_information::execute(args))? }?
+            // Sync commands get logger w. no OTEL
+            Commands::BuildInfo(args) => {
+                setup_no_otel_logger()?;
+                build_info::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::Migrate(args) => {
+                setup_no_otel_logger()?;
+                migrate::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()
-        .with(default_tracing_fmt_layer(std::io::stderr))
-        .with(granual_filtered_env()?))
+    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().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-subscriber = { workspace = true, features = ["env-filter"] }
+#tracing.workspace = true
+#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]
-async fn main() {
-    nym_bin_common::logging::setup_tracing_logger();
+fn resource() -> Resource {
+    Resource::builder()
+        .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
-    let config_dir: PathBuf = TempDir::new().unwrap().path().to_path_buf();
-    let storage_paths = StoragePaths::new_from_dir(&config_dir).unwrap();
+fn init_tracer_provider(metadata: MetadataMap) -> anyhow::Result<SdkTracerProvider> {
+    let endpoint = std::env::var("SIGNOZ_ENDPOINT").expect("SIGNOZ_ENDPOINT not set");
+    println!("SIGNOZ_ENDPOINT = {}", endpoint);

-    // 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()
+    // Configure OTLP exporter with metadata
+    let mut exporter_builder = opentelemetry_otlp::SpanExporter::builder()
+        .with_tonic()
+        .with_metadata(metadata)
+        .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