Log hygiene: sample/demote the 4 cosmetic high-volume WARNs (~75k/node/19h)

None touch consensus or production timing — verified: the PoH count is an embedded
VDF proof (never a timing/election gate), and block_ts is slot-anchored/deterministic
(cannot fork). The noise is steady-state + heterogeneous-hardware, not a fault.

- PoH "Clock drift X%" (poh.rs): sampled 1 per 300 slots (~5 min). Drift = this node's
  CPU hash-rate vs wall mapping; it never gates production/round/election.
- PACING "chain off real-time schedule" (node.rs): sampled 1 per 300 blocks; the lag
  is cosmetic since block_ts is deterministic.
- P2P "Certificate already cached, skipping" (unified_p2p.rs): WARN->DBG — an expected
  dedup no-op, not a warning.
- QUIC "uni_read_failed" (quic_transport.rs): WARN->DBG — a benign early close of a
  one-way broadcast stream; the payload still arrives via other peers/repair.

Genuine P2P/QUIC/BFT warnings stay at WARN. cargo check clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: AIQnetLab

development/qnet-integration/src/crypto/poh.rs

@@ -64,6 +64,9 @@ const HASHES_PER_SLOT: u64 = HASHES_PER_TICK * 100; // 500,000
 
 /// Maximum drift allowed between PoH time and wall clock (5%)
 const MAX_DRIFT_PERCENT: f64 = 0.05;
+/// Drift is cosmetic (PoH count is an embedded proof, never a timing/consensus gate); log it at most
+/// once per this many slots (~5 min) instead of every slot, so non-nominal hardware doesn't spam.
+const POH_DRIFT_LOG_SLOTS: u64 = 300;
 
 // ============================================================================
 // DATA STRUCTURES
@@ -328,23 +331,20 @@ impl PoH {
                 POH_HASH_COUNT.inc_by(HASHES_PER_TICK as f64);
                 POH_CURRENT_SLOT.set(new_slot as f64);
 
-                // Check drift on slot change
-                if new_slot > old_slot {
+                // Drift = this node's PoH-count vs wall mapping (hardware-dependent). Sampled every
+                // POH_DRIFT_LOG_SLOTS (~5 min): non-nominal hardware drifts every slot, but the rate
+                // is purely informational — PoH count is an embedded VDF proof, NEVER a consensus or
+                // production-timing gate, so it cannot desync the node.
+                if new_slot > old_slot && new_slot % POH_DRIFT_LOG_SLOTS == 0 {
                     let elapsed = start_time.elapsed();
                     let expected = Duration::from_secs(new_slot);
-                    
-                    if elapsed > expected {
-                        let drift = (elapsed - expected).as_secs_f64() / expected.as_secs_f64();
-                        if drift > MAX_DRIFT_PERCENT {
-                            println!("[PoH] ⚠️ Clock drift: {:.2}% slow (slot {})", 
-                                    drift * 100.0, new_slot);
-                        }
+                    let (drift, dir) = if elapsed > expected {
+                        ((elapsed - expected).as_secs_f64() / expected.as_secs_f64(), "slow")
                     } else {
-                        let drift = (expected - elapsed).as_secs_f64() / expected.as_secs_f64();
-                        if drift > MAX_DRIFT_PERCENT {
-                            println!("[PoH] ⚠️ Clock drift: {:.2}% fast (slot {})", 
-                                    drift * 100.0, new_slot);
-                        }
+                        ((expected - elapsed).as_secs_f64() / expected.as_secs_f64(), "fast")
+                    };
+                    if drift > MAX_DRIFT_PERCENT {
+                        println!("[PoH] ⚠️ Clock drift: {:.2}% {} (slot {})", drift * 100.0, dir, new_slot);
                     }
                 }
 

development/qnet-integration/src/node.rs

@@ -776,10 +776,15 @@ pub fn observe_clock_drift(block_ts: u64, local_now: u64) {
     // median ring, so a drifted node already converges with the network on
     // the slot-offset computation without any process-exit gate.
     let ema_secs = next / 1000;
-    if ema_secs > 10 && is_warn() {
+    // Sampled (1 per PACING_LOG_EVERY blocks, ~5 min): the lag is informational — block_ts is
+    // slot-anchored/deterministic, so it cannot fork; logging every block just spams.
+    const PACING_LOG_EVERY: u64 = 300;
+    static PACING_LOG_CTR: AtomicU64 = AtomicU64::new(0);
+    if ema_secs > 10 && is_warn()
+        && PACING_LOG_CTR.fetch_add(1, Ordering::Relaxed) % PACING_LOG_EVERY == 0 {
         println!(
-            "[WARN][PACING] ema={}s peak={}s wall={} block_ts={} — chain off real-time schedule",
-            ema_secs, abs_drift_secs, local_now, block_ts
+            "[WARN][PACING] ema={}s peak={}s wall={} block_ts={} — chain off real-time schedule (sampled 1/{})",
+            ema_secs, abs_drift_secs, local_now, block_ts, PACING_LOG_EVERY
         );
     }
 }

development/qnet-integration/src/quic_transport.rs

@@ -1750,8 +1750,10 @@ impl QuicTransport {
         ).await {
             Ok(Ok(d)) => d,
             Ok(Err(e)) => {
-                if crate::node::is_warn() {
-                    println!("[WARN][QUIC] uni_read_failed peer={} err={:?}",
+                // One-way broadcast uni-stream read error (mostly a benign early stream close) — the
+                // payload still arrives from other peers / repair, so this is DBG, not a node fault.
+                if crate::node::is_debug() {
+                    println!("[DBG][QUIC] uni_read_failed peer={} err={:?}",
                         get_privacy_id_for_addr(&peer_addr.to_string()), e);
                 }
                 return;

development/qnet-integration/src/unified_p2p.rs

@@ -14286,8 +14286,9 @@ impl SimplifiedP2P {
                     // Check if already in pending or verified
                     if cert_manager.remote_certificates.contains_key(&cert_serial) ||
                        cert_manager.pending_certificates.contains_key(&cert_serial) {
-                        if crate::node::is_info() {
-                            println!("[WARN][P2P] Certificate {} already cached, skipping", cert_serial);
+                        // Expected dedup of a re-offered cert — a no-op, not a warning (DBG only).
+                        if crate::node::is_debug() {
+                            println!("[DBG][P2P] cert_already_cached serial={} (dedup skip)", cert_serial);
                         }
                         return;
                     }