feat(api): complete versioning coverage, OpenAPI docs sync, WebSocket…

api-server/Cargo.toml

@@ -53,7 +53,7 @@ regex = "1"
 base64 = "0.22"
 flate2 = "1.0"
 brotli = "7.0"
-redis = { version = "1", features = ["r2d2"] }
+redis = { version = "0.27", features = ["r2d2", "tokio-comp", "aio", "connection-manager"] }
 r2d2 = "0.8"
 
 [dev-dependencies]

api-server/src/cache.rs

@@ -339,9 +339,7 @@ pub fn invalidate_pattern(pattern: &str) {
 
 /// Scan for keys matching a Redis glob `pattern` and delete them.
 fn redis_delete_matching(conn: &mut redis::Connection, pattern: &str) -> redis::RedisResult<()> {
-    let keys: Vec<String> = conn
-        .scan_match::<_, String>(pattern)?
-        .collect::<Result<Vec<String>, redis::RedisError>>()?;
+    let keys: Vec<String> = conn.scan_match::<_, String>(pattern)?.collect();
     if !keys.is_empty() {
         let _: () = conn.del(keys)?;
     }

api-server/src/circuit_breaker.rs

@@ -95,10 +95,15 @@ impl CircuitBreaker {
             let now = SystemTime::now()
                 .duration_since(UNIX_EPOCH)
                 .unwrap()
-                .as_secs();
+                .as_millis() as u64;
             let last_failure = self.last_failure_time.load(Ordering::SeqCst);
+            let timeout_ms = if self.config.timeout_secs == 0 {
+                5
+            } else {
+                self.config.timeout_secs * 1000
+            };
 
-            if now.saturating_sub(last_failure) >= self.config.timeout_secs {
+            if now.saturating_sub(last_failure) >= timeout_ms {
                 let prev = *state;
                 *state = CircuitState::HalfOpen;
                 self.half_open_calls.store(0, Ordering::SeqCst);
@@ -137,7 +142,7 @@ impl CircuitBreaker {
         let now = SystemTime::now()
             .duration_since(UNIX_EPOCH)
             .unwrap()
-            .as_secs();
+            .as_millis() as u64;
         self.last_failure_time.store(now, Ordering::SeqCst);
 
         let state = self.get_state();

api-server/src/distributed_tracing.rs

@@ -151,19 +151,21 @@ pub async fn distributed_tracing_middleware(
 
     let cx = Context::current_with_span(span.clone_as_boxed_ref());
     // Attach a compatible context so tracing:: macros pick up the OTel trace-ID.
-    let _guard = cx.clone().attach();
-
-    // Expose trace context to downstream handlers via extensions.
-    req.extensions_mut().insert(trace_ctx.clone());
-
-    tracing::info!(
-        trace_id = %trace_ctx.trace_id,
-        span_id  = %trace_ctx.span_id,
-        parent_span_id = ?trace_ctx.parent_span_id,
-        method = %method,
-        uri    = %uri,
-        "request started"
-    );
+    {
+        let _guard = cx.clone().attach();
+
+        // Expose trace context to downstream handlers via extensions.
+        req.extensions_mut().insert(trace_ctx.clone());
+
+        tracing::info!(
+            trace_id = %trace_ctx.trace_id,
+            span_id  = %trace_ctx.span_id,
+            parent_span_id = ?trace_ctx.parent_span_id,
+            method = %method,
+            uri    = %uri,
+            "request started"
+        );
+    }
 
     let mut response = next.run(req).await;
     let duration = trace_ctx.start_time.elapsed();
@@ -314,11 +316,11 @@ pub fn get_trace_context(headers: &HeaderMap) -> DistributedTraceContext {
 // ── Trait to allow span boxing without object-safety constraints ──────────────
 
 trait SpanExt {
-    fn clone_as_boxed_ref(&mut self) -> opentelemetry::trace::BoxedSpan;
+    fn clone_as_boxed_ref(&mut self) -> opentelemetry::global::BoxedSpan;
 }
 
 impl<S: Span> SpanExt for S {
-    fn clone_as_boxed_ref(&mut self) -> opentelemetry::trace::BoxedSpan {
+    fn clone_as_boxed_ref(&mut self) -> opentelemetry::global::BoxedSpan {
         // For the context guard we start a no-op placeholder; the real span
         // lives in `span` and is ended explicitly above.
         opentelemetry::global::tracer("atomic-patent")