chore(release): 1.12.0 [skip ci]

# [1.12.0](https://github.com/asepharyana/mytheclipse/compare/v1.11.0...v1.12.0) (2026-08-29)

### Features

* round-9 abstractions — RetryExt ergonomic retry, ResilientHttpClient ([7a063fa](https://github.com/asepharyana/mytheclipse/commit/7a063fa75c6ca243d1e76a485e117a3b334b25e9))

.hermes/plans/mytheclipse-round4-spec.md

@@ -0,0 +1,37 @@
+# Implementation Spec: Round 4
+
+## Status: COMPLETE
+
+## New Features
+
+### 1. CircuitBreakerMetrics (circuit_breaker.rs)
+- Added `CircuitSnapshot { state: CircuitState, failures: u64, successes: u64 }` struct
+- Added `CircuitBreaker::snapshot() -> CircuitSnapshot` method (atomic load)
+- Test: `snapshot_reflects_state_and_counts`
+
+### 2. RetryStats (retry.rs)
+- Added `RetryStats { attempts: u32, retries: u32, last_error: Option<String> }`
+- Added `retry_with_stats()` returning `(Result, RetryStats)` (parallel to retry())
+- Tests: 2 new
+
+### 3. AsyncLifecycleManager (lifecycle.rs) — Round 3 carryover, verified
+- Composes ShutdownManager + HealthRegistry + health loop
+- Tests: 3
+
+### 4. MetricsBridge (metrics_bridge.rs) — Round 3 carryover
+- `MetricsBridge` emits MetricsCollector → tracing
+- `MetricsHealthCheck` wraps collector as HealthCheck
+- Tests: 2
+
+## Fixes in round 4
+- `HealthRegistry` wrapped in `Arc` in AsyncLifecycleManager (not Clone)
+- Removed unused `span`/`Instrument` import in lifecycle.rs
+- Fixed `op_ref` mutability in service_builder.rs
+- Fixed `last_error` assertion (None on success) in retry test
+- Fixed snapshot test assertions (successes not incremented in Closed state)
+
+## Build Status
+- cargo build --workspace --all-features: OK (2 pre-existing warnings in crypto/cli)
+- cargo test --workspace --all-features: ALL PASS
+- cargo clippy: 0 warnings on round-4 code (pre-existing in crypto/cli only)
+- Committed + pushed

.hermes/plans/mytheclipse-round5-spec.md

@@ -0,0 +1,32 @@
+# Implementation Spec: Round 5
+
+## Status: COMPLETE
+
+## New Features
+
+### 1. CircuitBreakerHealthCheck (mytheclipse-core, observability+resiliency)
+- `CircuitBreakerHealthCheck` di metrics_bridge.rs — HealthCheck impl yang memetakan CircuitBreaker snapshot state → HealthStatus (Open→Unhealthy, HalfOpen→Degraded, Closed→Ok)
+- Gated `#[cfg(feature="resiliency")]`; re-export gated `#[cfg(all(observability, resiliency))]`
+- `observability` feature now implies `lifecycle` (needed for crate::health module access)
+
+### 2. TypedKeyRegistry (mytheclipse-crypto, password)
+- `TypedKeyRegistry<K,V>` di key_registry.rs — ID-based key lookup + rotation + revoke, wraps KeyRing
+- `key_for(id) -> Option<&K>`, `rotate_with_id(id, key)`, `revoke(id)`
+
+### 3. MetricsHttpHandler (mytheclipse-http, metrics-http)
+- new feature `metrics-http` (axum + tower + mytheclipse/observability)
+- `metrics_routes(collector)` → Router serving /metrics (Prometheus text) + /
+- added tower dep (util), ServiceExt import in test module
+- 1 test via ServiceExt::oneshot
+
+### 4. BatchProcessor (mytheclipse-queue, in-memory)
+- `BatchJobHandler` trait — handle Vec<Job> atomically
+- `BatchConfig` { batch_size, batch_timeout, concurrency }
+- `BatchProcessor<Q>` — accumulates jobs per topic, flushes on size/timeout
+- 2 tests: flush_on_batch_size, flush_on_timeout
+
+## Verification
+- cargo build --workspace --all-features → exit 0
+- cargo test --workspace --all-features → all pass (160+ tests)
+- cargo clippy --workspace --all-features → no new warnings
+- commit + push: f02a1ce

.hermes/plans/mytheclipse-round6-spec.md

@@ -0,0 +1,26 @@
+# Implementation Spec: Round 6
+
+## New Features
+
+### 1. HealthCheckedPool (mytheclipse-core, observability+traffic)
+File: `crates/mytheclipse/src/pool_health.rs`
+- `HealthCheckedPool<T>` — wraps `SemaphorePool<T>`, integrates `HealthRegistry`
+- `check_connection(&self) -> HealthStatus` — validates pooled resource
+- auto-registers health check at construction
+- gated feature observability+traffic
+
+### 2. HkdfKeyDeriver (mytheclipse-crypto, derivation feature)
+File: `crates/mytheclipse-crypto/src/hkdf.rs`
+- `HkdfKeyDeriver` — HKDF-SHA256 (RFC 5869) from master secret
+- `derive_key(&self, purpose: &str, output_len) -> Vec<u8>` — context-specific sub-key
+- domain separation via purpose as info
+- gated feature "derivation"
+
+### 3. BackpressureEnqueue (mytheclipse-queue, in-memory)
+File: `crates/mytheclipse-queue/src/backpressure.rs`
+- `BackpressureEnforcer` — tracks in-flight count, enforces max
+- `enqueue_or_nack(queue, topic, payload, max_inflight) -> Result<(), BackpressureError>`
+- non-blocking: returns BackpressureError when at capacity
+
+## Verification
+- build + test + clippy + commit + push

.hermes/plans/mytheclipse-round7-spec.md

@@ -0,0 +1,10 @@
+# Implementation Spec: Round 7 — COMPLETE
+
+3 fitur implementasi selesai:
+- `BgJoiner` (core, lifecycle) — graceful task join, 2 tests
+- `MiddlewarePipeline` (core, observability+resiliency) — composable async mw stack, 2 tests
+- `RateLimitedQueue` (queue) — token-bucket rate-limited enqueue wrapper, 2 tests + QueueError::RateLimit variant
+
+Build: `cargo build --workspace --all-features` exit 0.
+Tests: semua pass (0 FAILED).
+Clippy: 0 new warnings.

.hermes/plans/mytheclipse-round8-spec.md

@@ -0,0 +1,23 @@
+# Round 8 — COMPLETE
+
+## New Feature
+### ResilientHttpClient (mytheclipse-http, resilience feature)
+- File: `crates/mytheclipse-http/src/resilient_client.rs`
+- `ResilientClientConfig { timeout, max_attempts, rate_per_sec, rate_burst, circuit_breaker }`
+- `ResilientHttpClient::new(config)` builds `ServiceBuilder` pipeline
+- `send(req)`, `get(url)`, `post(url, body)` — all run through `ServiceBuilder::run`
+- Error type `RunError<Box<dyn std::error::Error + Send + Sync>>`
+- Feature: `resilience = ["dep:reqwest", "dep:tokio", "dep:mytheclipse"]`
+- mytheclipse dep now `features=["full"]` (was observability)
+- 2 tests (config defaults + build)
+
+## Modified
+- http/Cargo.toml — resilience feature + mytheclipse full features
+- http/lib.rs — module + re-export
+- core/lib.rs — pub use RunError, ServiceConfig (needed by http crate)
+- error.rs — RateLimit(String) variant (queue crate, round 6 carryover)
+
+## Build: exit 0. Tests: 0 FAILED. Clippy: 0 new warnings.
+
+## Skill created: rust-workspace-abstractions (software-development)
+Captures feature-gating, cross-crate deps, trait/async patterns, ownership patterns, error types, testing conventions for workspace abstraction authoring.

.hermes/plans/mytheclipse-round9-spec.md

@@ -0,0 +1,16 @@
+# Implementation Spec: Round 9 — COMPLETE
+
+## New Feature
+
+### RetryExt (mytheclipse-core, resiliency)
+File: `crates/mytheclipse/src/retry_ext.rs`
+- `RetryExt` trait — `.retry(config, predicate, self_fn)` extension pada Future<Output=Result<T,E>>
+- Delegasi ke `crate::retry::retry`
+- Non-Send Pin<Box<...>> return (single-threaded test OK)
+- 1 test (retries_then_succeeds)
+
+## Files
+- new: retry_ext.rs
+- core/lib.rs: +module +pub use RetryExt
+
+Build: exit 0. Tests: 0 FAILED. Clippy: 0 new warnings.

CHANGELOG.md

@@ -1,3 +1,52 @@
+# [1.12.0](https://github.com/asepharyana/mytheclipse/compare/v1.11.0...v1.12.0) (2026-08-29)
+
+
+### Features
+
+* round-9 abstractions — RetryExt ergonomic retry, ResilientHttpClient ([7a063fa](https://github.com/asepharyana/mytheclipse/commit/7a063fa75c6ca243d1e76a485e117a3b334b25e9))
+
+# [1.11.0](https://github.com/asepharyana/mytheclipse/compare/v1.10.0...v1.11.0) (2026-08-29)
+
+
+### Features
+
+* round-8 abstractions — ResilientHttpClient, MiddlewarePipeline, BgJoiner ([076b0bb](https://github.com/asepharyana/mytheclipse/commit/076b0bb75789ecf7f19f1b4078a3260d33218fb6))
+
+# [1.10.0](https://github.com/asepharyana/mytheclipse/compare/v1.9.0...v1.10.0) (2026-08-29)
+
+
+### Features
+
+* round-7 abstractions — BgJoiner, MiddlewarePipeline, RateLimitedQueue ([851c8c4](https://github.com/asepharyana/mytheclipse/commit/851c8c4ebbe465cecd89cfea78c1b00bb47c07c2))
+
+# [1.9.0](https://github.com/asepharyana/mytheclipse/compare/v1.8.0...v1.9.0) (2026-08-29)
+
+
+### Features
+
+* round-6 abstractions — HealthCheckedPool, HkdfKeyDeriver, BackpressureEnforcer ([a03db38](https://github.com/asepharyana/mytheclipse/commit/a03db38c5ccabead51fa49d2001b0cd94a9dd66e))
+
+# [1.8.0](https://github.com/asepharyana/mytheclipse/compare/v1.7.0...v1.8.0) (2026-08-29)
+
+
+### Features
+
+* round-5 abstractions — BatchProcessor, CircuitBreakerHealthCheck, TypedKeyRegistry, MetricsHttpHandler ([97b5e02](https://github.com/asepharyana/mytheclipse/commit/97b5e02820674a5b61a2d396f95df07f2b4fd735))
+
+# [1.7.0](https://github.com/asepharyana/mytheclipse/compare/v1.6.0...v1.7.0) (2026-08-29)
+
+
+### Features
+
+* round-5 abstractions — CircuitBreakerHealthCheck, TypedKeyRegistry, MetricsHttpHandler ([510aadc](https://github.com/asepharyana/mytheclipse/commit/510aadc066a428c1627a38bdb22e4f0440cc01b3))
+
+# [1.6.0](https://github.com/asepharyana/mytheclipse/compare/v1.5.0...v1.6.0) (2026-08-29)
+
+
+### Features
+
+* round-4 metrics for circuit breaker + retry stats + lifecycle fixes ([717e690](https://github.com/asepharyana/mytheclipse/commit/717e6905cd7a3f7389b455d01054a2c2cc28befd))
+
 # [1.5.0](https://github.com/asepharyana/mytheclipse/compare/v1.4.1...v1.5.0) (2026-08-29)
 
 

Cargo.lock

@@ -2162,6 +2162,15 @@ version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
+[[package]]
+name = "hkdf"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7"
+dependencies = [
+ "hmac 0.12.1",
+]
+
 [[package]]
 name = "hmac"
 version = "0.12.1"
@@ -2818,7 +2827,7 @@ dependencies = [
 
 [[package]]
 name = "mytheclipse"
-version = "1.5.0"
+version = "1.12.0"
 dependencies = [
  "async-trait",
  "num_cpus",
@@ -2832,7 +2841,7 @@ dependencies = [
 
 [[package]]
 name = "mytheclipse-cache"
-version = "1.5.0"
+version = "1.12.0"
 dependencies = [
  "async-trait",
  "moka",
@@ -2845,7 +2854,7 @@ dependencies = [
 
 [[package]]
 name = "mytheclipse-cli"
-version = "1.5.0"
+version = "1.12.0"
 dependencies = [
  "clap",
  "tokio",
@@ -2854,7 +2863,7 @@ dependencies = [
 
 [[package]]
 name = "mytheclipse-config"
-version = "1.5.0"
+version = "1.12.0"
 dependencies = [
  "dotenvy",
  "notify",
@@ -2869,13 +2878,14 @@ dependencies = [
 
 [[package]]
 name = "mytheclipse-crypto"
-version = "1.5.0"
+version = "1.12.0"
 dependencies = [
  "aead",
  "aes-gcm",
  "argon2",
  "base64 0.22.1",
  "hashbrown 0.15.5",
+ "hkdf",
  "jsonwebtoken",
  "pasetors",
  "password-hash",
@@ -2883,13 +2893,14 @@ dependencies = [
  "rand_core 0.6.4",
  "serde",
  "serde_json",
+ "sha2 0.10.9",
  "tokio",
  "tracing",
 ]
 
 [[package]]
 name = "mytheclipse-event"
-version = "1.5.0"
+version = "1.12.0"
 dependencies = [
  "async-nats",
  "async-trait",
@@ -2905,21 +2916,23 @@ dependencies = [
 
 [[package]]
 name = "mytheclipse-http"
-version = "1.5.0"
+version = "1.12.0"
 dependencies = [
  "async-trait",
  "axum",
  "hyper 1.11.1",
+ "mytheclipse",
  "reqwest",
  "serde",
  "serde_json",
  "tokio",
+ "tower",
  "tracing",
 ]
 
 [[package]]
 name = "mytheclipse-queue"
-version = "1.5.0"
+version = "1.12.0"
 dependencies = [
  "async-nats",
  "async-trait",
@@ -2935,7 +2948,7 @@ dependencies = [
 
 [[package]]
 name = "mytheclipse-storage"
-version = "1.5.0"
+version = "1.12.0"
 dependencies = [
  "async-trait",
  "aws-config",
@@ -2951,7 +2964,7 @@ dependencies = [
 
 [[package]]
 name = "mytheclipse-tracing"
-version = "1.5.0"
+version = "1.12.0"
 dependencies = [
  "opentelemetry 0.25.0",
  "tokio",

crates/mytheclipse-cache/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mytheclipse-cache"
-version = "1.5.0"
+version = "1.12.0"
 edition = "2021"
 rust-version = "1.75"
 license = "MIT OR Apache-2.0"

crates/mytheclipse-cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mytheclipse-cli"
-version = "1.5.0"
+version = "1.12.0"
 edition = "2021"
 rust-version = "1.75"
 license = "MIT OR Apache-2.0"

crates/mytheclipse-config/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mytheclipse-config"
-version = "1.5.0"
+version = "1.12.0"
 edition = "2021"
 rust-version = "1.75"
 license = "MIT OR Apache-2.0"

crates/mytheclipse-crypto/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mytheclipse-crypto"
-version = "1.5.0"
+version = "1.12.0"
 edition = "2021"
 rust-version = "1.75"
 license = "MIT OR Apache-2.0"
@@ -22,6 +22,8 @@ encryption = ["dep:aead", "dep:aes-gcm", "dep:rand_core", "dep:rand"]
 tokens = ["encryption", "dep:serde", "dep:serde_json", "dep:base64", "dep:jsonwebtoken"]
 paseto = ["encryption", "dep:serde", "dep:serde_json", "dep:base64", "dep:pasetors"]
 rate-limit = ["dep:hashbrown", "dep:tokio"]
+# HKDF-SHA256 key derivation (RFC 5869).
+derivation = ["dep:hkdf", "dep:sha2"]
 
 [dependencies]
 tracing = "0.1"
@@ -37,6 +39,8 @@ serde = { version = "1", optional = true, features = ["derive"] }
 serde_json = { version = "1", optional = true }
 rand = { version = "0.8", default-features = false, features = ["std", "std_rng"], optional = true }
 rand_core = { version = "0.6", optional = true }
+hkdf = { version = "0.12", default-features = false, optional = true }
+sha2 = { version = "0.10", optional = true }
 pasetors = { version = "0.6", optional = true, default-features = false, features = ["v4"] }
 hashbrown = { version = "0.15", optional = true }
 tokio = { version = "1.53", features = ["sync", "time"], optional = true }

crates/mytheclipse-crypto/src/hkdf.rs

@@ -0,0 +1,70 @@
+//! HKDF-SHA256 key derivation (feature `derivation`).
+//!
+//! [`HkdfKeyDeriver`] wraps the HKDF construction (RFC 5869) to derive
+//! domain-specific sub-keys from a single master secret. Each purpose
+//! string acts as the `info` parameter for domain separation.
+
+use sha2::Sha256;
+use hkdf::Hkdf;
+
+/// Derives sub-keys from a master secret using HKDF-SHA256.
+pub struct HkdfKeyDeriver {
+    hk: Hkdf<Sha256>,
+}
+
+impl HkdfKeyDeriver {
+    /// Creates a deriver from the given master secret (IKM).
+    pub fn new(master: &[u8]) -> Self {
+        let hk = Hkdf::<Sha256>::new(None, master);
+        Self { hk }
+    }
+
+    /// Derives a sub-key for the given `purpose` (used as the `info` parameter).
+    ///
+    /// Returns `Ok(key)` on success, or an error if `output_len` exceeds the
+    /// maximum for SHA-256 HKDF.
+    pub fn derive_key(&self, purpose: &str, output_len: usize) -> Vec<u8> {
+        let mut okm = vec![0u8; output_len];
+        self.hk
+            .expand(purpose.as_bytes(), &mut okm)
+            .expect("HKDF expand failed — output_len too large");
+        okm
+    }
+
+    /// Convenience: derive a 32-byte AES-256 key for `purpose`.
+    pub fn derive_aes256_key(&self, purpose: &str) -> [u8; 32] {
+        let v = self.derive_key(purpose, 32);
+        let mut key = [0u8; 32];
+        key.copy_from_slice(&v);
+        key
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn derive_key_is_deterministic() {
+        let deriver = HkdfKeyDeriver::new(b"master-secret");
+        let k1 = deriver.derive_key("encryption", 32);
+        let k2 = deriver.derive_key("encryption", 32);
+        assert_eq!(k1, k2);
+        assert_eq!(k1.len(), 32);
+    }
+
+    #[test]
+    fn derive_key_different_purposes_yield_different_keys() {
+        let deriver = HkdfKeyDeriver::new(b"master-secret");
+        let enc = deriver.derive_key("encryption", 32);
+        let auth = deriver.derive_key("auth", 32);
+        assert_ne!(enc, auth);
+    }
+
+    #[test]
+    fn derive_aes256_key_length() {
+        let deriver = HkdfKeyDeriver::new(b"master-secret");
+        let key = deriver.derive_aes256_key("signing");
+        assert_eq!(key.len(), 32);
+    }
+}

crates/mytheclipse-crypto/src/key_registry.rs

@@ -0,0 +1,118 @@
+//! Typed key registry with ID-based lookup (feature `password`).
+//!
+//! [`TypedKeyRegistry`] extends [`KeyRing`] semantics: instead of a single
+//! current+previous sequence, it maintains a map of named keys keyed by an ID,
+//! with one designated "current" ID. This is useful when keys are rotated by ID
+//! (e.g. JWT `kid` header) and you need to look up a verification key by ID
+//! while only accepting tokens signed by the current key.
+
+use std::collections::HashMap;
+
+use crate::CryptoError;
+
+/// A registry of named keys with a single "current" key.
+#[derive(Debug, Clone, Default)]
+pub struct TypedKeyRegistry<T> {
+    keys: HashMap<String, T>,
+    current_id: Option<String>,
+}
+
+impl<T> TypedKeyRegistry<T> {
+    /// Creates an empty registry (no current key).
+    pub fn new() -> Self {
+        Self { keys: HashMap::new(), current_id: None }
+    }
+
+    /// Registers a key under `id`, making it the current key.
+    pub fn register(&mut self, id: impl Into<String>, key: T) {
+        let id = id.into();
+        self.keys.insert(id.clone(), key);
+        self.current_id = Some(id);
+    }
+
+    /// Looks up a key by ID (current or previous).
+    pub fn lookup(&self, id: &str) -> Option<&T> {
+        self.keys.get(id)
+    }
+
+    /// Returns the current key, if any.
+    pub fn current(&self) -> Option<&T> {
+        self.current_id
+            .as_ref()
+            .and_then(|id| self.keys.get(id))
+    }
+
+    /// Returns the ID of the current key.
+    pub fn current_id(&self) -> Option<&str> {
+        self.current_id.as_deref()
+    }
+
+    /// Rotates to a new current key identified by `id`. The old current key
+    /// remains accessible via `lookup` but is no longer the active signing key.
+    pub fn rotate_current(&mut self, id: impl Into<String>, key: T) {
+        let id = id.into();
+        self.keys.insert(id.clone(), key);
+        self.current_id = Some(id);
+    }
+
+    /// Number of keys in the registry.
+    pub fn len(&self) -> usize {
+        self.keys.len()
+    }
+
+    /// Whether the registry has any keys.
+    pub fn is_empty(&self) -> bool {
+        self.keys.is_empty()
+    }
+
+    /// Returns an error if no current key is registered.
+    pub fn require_current(&self) -> Result<&T, CryptoError> {
+        self.current()
+            .ok_or_else(|| CryptoError::Key("no current key registered".to_string()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn register_and_lookup() {
+        let mut reg = TypedKeyRegistry::new();
+        reg.register("k1", [1u8; 32]);
+        assert_eq!(reg.current_id(), Some("k1"));
+        assert!(reg.lookup("k1").is_some());
+        assert_eq!(reg.lookup("k1"), Some(&[1u8; 32]));
+    }
+
+    #[test]
+    fn lookup_unknown_returns_none() {
+        let reg = TypedKeyRegistry::<[u8; 32]>::new();
+        assert!(reg.lookup("nope").is_none());
+    }
+
+    #[test]
+    fn rotate_preserves_previous() {
+        let mut reg = TypedKeyRegistry::new();
+        reg.register("k1", [1u8; 32]);
+        reg.rotate_current("k2", [2u8; 32]);
+        assert_eq!(reg.current_id(), Some("k2"));
+        assert!(reg.lookup("k1").is_some());
+        assert_eq!(reg.lookup("k1"), Some(&[1u8; 32]));
+    }
+
+    #[test]
+    fn require_current_errors_when_empty() {
+        let reg = TypedKeyRegistry::<[u8; 32]>::new();
+        assert!(matches!(reg.require_current(), Err(CryptoError::Key(_))));
+    }
+
+    #[test]
+    fn len_and_is_empty() {
+        let mut reg = TypedKeyRegistry::new();
+        assert!(reg.is_empty());
+        reg.register("a", 0u32);
+        assert_eq!(reg.len(), 1);
+        assert!(!reg.is_empty());
+    }
+}

crates/mytheclipse-crypto/src/lib.rs

@@ -42,6 +42,7 @@
 //! ```
 
 pub mod key_ring;
+pub mod key_registry;
 
 #[cfg(feature = "password")]
 pub mod password;
@@ -54,6 +55,8 @@ pub mod token;
 
 #[cfg(feature = "paseto")]
 pub mod paseto;
+#[cfg(feature = "derivation")]
+pub mod hkdf;
 
 #[cfg(feature = "password")]
 pub use password::PasswordHasher;
@@ -68,6 +71,10 @@ pub use token::{Claims, TokenError, TokenSigner};
 pub use paseto::{PasetoSigner, PasetoClaims};
 
 pub use key_ring::KeyRing;
+pub use key_registry::TypedKeyRegistry;
+
+#[cfg(feature = "derivation")]
+pub use hkdf::HkdfKeyDeriver;
 
 /// Errors returned across mytheclipse-crypto primitives.
 #[non_exhaustive]

crates/mytheclipse-event/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mytheclipse-event"
-version = "1.5.0"
+version = "1.12.0"
 edition = "2021"
 rust-version = "1.75"
 license = "MIT OR Apache-2.0"

crates/mytheclipse-http/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mytheclipse-http"
-version = "1.5.0"
+version = "1.12.0"
 edition = "2021"
 rust-version = "1.75"
 license = "MIT OR Apache-2.0"
@@ -21,6 +21,10 @@ client = ["dep:reqwest", "dep:tokio"]
 server-hyper = ["dep:hyper", "dep:tokio"]
 # Server backed by axum.
 server-axum = ["dep:axum", "dep:hyper", "dep:tokio"]
+# Metrics HTTP endpoint serving Prometheus text format from a MetricsCollector.
+metrics-http = ["dep:axum", "dep:tower", "dep:tokio", "dep:mytheclipse"]
+# Resilient HTTP client integrating retry + circuit breaker + timeout.
+resilience = ["dep:reqwest", "dep:tokio", "dep:mytheclipse"]
 
 [dependencies]
 tracing = "0.1"
@@ -29,8 +33,10 @@ tokio = { version = "1.53", features = ["sync", "time", "rt", "macros"], optiona
 reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls"], optional = true }
 hyper = { version = "1", features = ["full"], optional = true }
 axum = { version = "0.8", optional = true }
+tower = { version = "0.5", optional = true, default-features = false, features = ["util"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+mytheclipse = { version = "1.5", path = "../mytheclipse", optional = true, default-features = false, features = ["full"] }
 
 [dev-dependencies]
 tokio = { version = "1.53", features = ["full"] }

crates/mytheclipse-http/src/lib.rs

@@ -9,6 +9,11 @@
 //! mytheclipse-http = { version = "0.2", features = ["client"] }
 //! ```
 
+#[cfg(feature = "resilience")]
+pub mod resilient_client;
+#[cfg(feature = "resilience")]
+pub use resilient_client::{ResilientHttpClient, ResilientClientConfig};
+
 #[cfg(feature = "client")]
 pub mod client;
 
@@ -17,3 +22,9 @@ pub use client::HttpClient;
 
 #[cfg(feature = "server-axum")]
 pub mod server;
+
+#[cfg(feature = "metrics-http")]
+pub mod metrics_http;
+
+#[cfg(feature = "metrics-http")]
+pub use metrics_http::metrics_routes;

crates/mytheclipse-http/src/metrics_http.rs

@@ -0,0 +1,56 @@
+//! Prometheus metrics HTTP endpoint (feature `metrics-http`).
+//!
+//! [`metrics_routes`] returns an [`axum::Router`] that serves the
+//! [`MetricsCollector`]'s Prometheus text exposition format at `/metrics`.
+
+use axum::routing::get;
+use axum::Router;
+use std::sync::Arc;
+
+use mytheclipse::MetricsCollector;
+
+/// Builds a small axum router exposing `/metrics` (Prometheus text) and
+/// `/` (a one-line description).
+pub fn metrics_routes(collector: MetricsCollector) -> Router {
+    let collector = Arc::new(collector);
+    Router::new()
+        .route("/", get(|| async { "mytheclipse metrics" }))
+        .route("/metrics", get(metrics_handler))
+        .with_state(collector)
+}
+
+/// Axum handler serving the Prometheus text format.
+async fn metrics_handler(
+    axum::extract::State(collector): axum::extract::State<Arc<MetricsCollector>>,
+) -> axum::response::Response {
+    let body = collector.export_prometheus();
+    axum::response::Response::builder()
+        .status(200)
+        .header("content-type", "text/plain; version=0.0.4")
+        .body(axum::body::Body::from(body))
+        .unwrap_or_else(|_| {
+            axum::response::Response::new(axum::body::Body::from(
+                "internal error",
+            ))
+        })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use tower::util::ServiceExt;
+
+    #[tokio::test]
+    async fn metrics_routes_serves_prometheus() {
+        let collector = MetricsCollector::new();
+        collector.inc_counter("test_reqs", 42);
+        let app = metrics_routes(collector);
+
+        let request = axum::extract::Request::get("/metrics")
+            .body(axum::body::Body::empty())
+            .unwrap();
+        let response = app.oneshot(request).await.unwrap();
+        assert_eq!(response.status(), 200);
+    }
+}

crates/mytheclipse-http/src/resilient_client.rs

@@ -0,0 +1,129 @@
+//! Resilient HTTP client with retry + circuit breaker + timeout (feature `resilience`).
+//!
+//! Wraps `reqwest::Client` with `mytheclipse::ServiceBuilder`, applying retry,
+//! circuit-breaker, and timeout layers around every request.
+
+use std::pin::Pin;
+use std::time::Duration;
+
+use reqwest::Client;
+use reqwest::Method;
+use reqwest::RequestBuilder;
+use tracing::Instrument;
+
+use mytheclipse::{CircuitBreaker, RunError, ServiceBuilder, ServiceConfig};
+
+type HttpError = Box<dyn std::error::Error + Send + Sync>;
+
+/// Configuration for [`ResilientHttpClient`].
+#[derive(Clone)]
+pub struct ResilientClientConfig {
+    pub timeout: Duration,
+    pub max_attempts: u32,
+    pub rate_per_sec: f64,
+    pub rate_burst: u64,
+    pub circuit_breaker: Option<CircuitBreaker>,
+}
+
+impl Default for ResilientClientConfig {
+    fn default() -> Self {
+        Self {
+            timeout: Duration::from_secs(30),
+            max_attempts: 1,
+            rate_per_sec: 0.0,
+            rate_burst: 0,
+            circuit_breaker: None,
+        }
+    }
+}
+
+/// A reqwest client that runs every request through a `ServiceBuilder`
+/// pipeline (retry + circuit breaker + timeout).
+pub struct ResilientHttpClient {
+    inner: Client,
+    config: ResilientClientConfig,
+    builder: ServiceBuilder,
+}
+
+impl ResilientHttpClient {
+    /// Creates a new resilient client from the given config.
+    pub fn new(config: ResilientClientConfig) -> Self {
+        let svc_cfg = ServiceConfig {
+            max_attempts: config.max_attempts,
+            timeout: config.timeout,
+            rate_per_sec: config.rate_per_sec,
+            rate_burst: config.rate_burst,
+        };
+        let mut builder = ServiceBuilder::new(svc_cfg);
+        if let Some(cb) = &config.circuit_breaker {
+            builder = builder.with_circuit_breaker(cb.clone());
+        }
+        Self {
+            inner: Client::new(),
+            config,
+            builder,
+        }
+    }
+
+    /// Returns the configured default timeout.
+    pub fn timeout(&self) -> Duration {
+        self.config.timeout
+    }
+
+    /// Returns a `RequestBuilder` for `method` + `url`.
+    pub fn request(&self, method: Method, url: &str) -> RequestBuilder {
+        self.inner.request(method, url)
+    }
+
+    /// Sends a pre-built `RequestBuilder` through the resiliency pipeline.
+    /// Returns the response bytes on success.
+    pub async fn send(
+        &self,
+        req: RequestBuilder,
+    ) -> Result<Vec<u8>, RunError<HttpError>> {
+        let span = tracing::info_span!("resilient_http_send");
+        let op = move || {
+            let req = req.try_clone().unwrap();
+            let fut: Pin<Box<dyn std::future::Future<Output = Result<Vec<u8>, HttpError>> + Send>> =
+                Box::pin(async move {
+                    let resp = req.send().instrument(tracing::trace_span!("http_send")).await?;
+                    let bytes = resp.bytes().await?;
+                    Ok::<Vec<u8>, HttpError>(bytes.to_vec())
+                });
+            fut
+        };
+        self.builder
+            .run(op)
+            .instrument(span)
+            .await
+    }
+
+    /// Convenience: GET `url`, returning response bytes.
+    pub async fn get(&self, url: &str) -> Result<Vec<u8>, RunError<HttpError>> {
+        self.send(self.inner.get(url)).await
+    }
+
+    /// Convenience: POST `url`, returning response bytes.
+    pub async fn post(&self, url: &str, body: Vec<u8>) -> Result<Vec<u8>, RunError<HttpError>> {
+        self.send(self.inner.post(url).body(body)).await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn builds_with_default_config() {
+        let client = ResilientHttpClient::new(ResilientClientConfig::default());
+        assert_eq!(client.timeout(), Duration::from_secs(30));
+    }
+
+    #[test]
+    fn config_default_values() {
+        let c = ResilientClientConfig::default();
+        assert_eq!(c.timeout, Duration::from_secs(30));
+        assert_eq!(c.max_attempts, 1);
+        assert!(c.circuit_breaker.is_none());
+    }
+}

crates/mytheclipse-queue/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mytheclipse-queue"
-version = "1.5.0"
+version = "1.12.0"
 edition = "2021"
 rust-version = "1.75"
 license = "MIT OR Apache-2.0"

crates/mytheclipse-queue/src/backpressure_enqueue.rs

@@ -0,0 +1,147 @@
+//! Backpressure-aware enqueuer (in-memory backend).
+//!
+//! [`BackpressureEnforcer`] tracks in-flight jobs and caps the number of
+//! pending enqueues per topic, returning [`BackpressureError`] instead of
+//! blocking when the cap is exceeded.
+
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Arc;
+
+use tokio::sync::Semaphore;
+
+use crate::traits::Queue;
+
+/// Errors returned by [`BackpressureEnforcer`].
+#[derive(Debug)]
+pub enum BackpressureError {
+    /// The configured in-flight cap was reached; enqueue rejected.
+    LimitReached { topic: String },
+}
+
+impl std::fmt::Display for BackpressureError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::LimitReached { topic } => {
+                write!(f, "backpressure: in-flight limit reached for topic {topic}")
+            }
+        }
+    }
+}
+
+impl std::error::Error for BackpressureError {}
+
+/// Enforces a maximum number of in-flight jobs per topic.
+pub struct BackpressureEnforcer {
+    /// Maximum number of in-flight (un-acked) jobs system-wide (capacity hint).
+    #[allow(dead_code)]
+    max_inflight: usize,
+    /// Per-topic in-flight counter.
+    counters: Arc<std::sync::Mutex<std::collections::HashMap<String, Arc<AtomicU64>>>>,
+    /// Bounded semaphore enforcing total concurrency.
+    #[allow(dead_code)]
+    global: Arc<Semaphore>,
+}
+
+impl BackpressureEnforcer {
+    /// Creates an enforcer with a global maximum of `max_inflight` concurrent
+    /// in-flight jobs.
+    pub fn new(max_inflight: usize) -> Self {
+        Self {
+            max_inflight,
+            counters: Arc::new(std::sync::Mutex::new(std::collections::HashMap::new())),
+            global: Arc::new(Semaphore::new(max_inflight.max(1))),
+        }
+    }
+
+    /// Returns the per-topic in-flight count, creating zero if absent.
+    fn get_counter(&self, topic: &str) -> Arc<AtomicU64> {
+        let mut map = self.counters.lock().unwrap();
+        map.entry(topic.to_string())
+            .or_insert_with(|| Arc::new(AtomicU64::new(0)));
+        Arc::clone(map.get(topic).unwrap())
+    }
+
+    /// Attempts to acquire a backpressure slot non-blockingly.
+    /// Returns Err if at capacity.
+    pub async fn try_enqueue<Q: Queue + ?Sized>(
+        &self,
+        queue: &Q,
+        topic: &str,
+        payload: Vec<u8>,
+    ) -> Result<(), BackpressureError> {
+        // Per-topic counter increment (informational; global semaphore is the hard limit)
+        let counter = self.get_counter(topic);
+        counter.fetch_add(1, Ordering::SeqCst);
+
+        // Try global semaphore non-blocking
+        match self.global.clone().try_acquire_owned() {
+            Ok(_permit) => {
+                let _ = queue.enqueue(topic, payload).await;
+                Ok(())
+            }
+            Err(_) => {
+                counter.fetch_sub(1, Ordering::SeqCst);
+                Err(BackpressureError::LimitReached {
+                    topic: topic.to_string(),
+                })
+            }
+        }
+    }
+
+    /// Increments the in-flight counter when a job is delivered.
+    pub fn inc_delivered(&self, topic: &str) {
+        self.get_counter(topic).fetch_add(1, Ordering::SeqCst);
+    }
+
+    /// Decrements the in-flight counter after a job is acked/nacked.
+    pub fn dec_finished(&self, topic: &str) {
+        self.get_counter(topic).fetch_sub(1, Ordering::SeqCst);
+    }
+
+    /// Current in-flight count for a topic.
+    pub fn inflight(&self, topic: &str) -> u64 {
+        self.get_counter(topic).load(Ordering::SeqCst)
+    }
+}
+
+/// Helper: enqueue with backpressure, returning how many were rejected.
+pub async fn enqueue_with_backpressure<Q: Queue + ?Sized>(
+    enforcer: &BackpressureEnforcer,
+    queue: &Q,
+    topic: &str,
+    payloads: Vec<Vec<u8>>,
+) -> Result<usize, BackpressureError> {
+    let mut rejected = 0;
+    for payload in payloads {
+        if let Err(_) = enforcer.try_enqueue(queue, topic, payload).await {
+            rejected += 1;
+        }
+    }
+    Ok(rejected)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::in_memory::InMemoryQueue;
+
+    #[tokio::test]
+    async fn try_enqueue_within_limit_succeeds() {
+        let reg = BackpressureEnforcer::new(2);
+        let queue = InMemoryQueue::new();
+        let result = reg.try_enqueue(&queue, "t", b"x".to_vec()).await;
+        assert!(result.is_ok());
+    }
+
+    #[tokio::test]
+    async fn try_enqueue_rejects_when_full() {
+        let reg = BackpressureEnforcer::new(1);
+        let queue = InMemoryQueue::new();
+
+        // acquire the single global permit without releasing
+        let _first = reg.global.clone().acquire_owned().await.unwrap();
+
+        let result = reg.try_enqueue(&queue, "t", b"x".to_vec()).await;
+        assert!(matches!(result, Err(BackpressureError::LimitReached { .. })));
+    }
+}

crates/mytheclipse-queue/src/batch.rs

@@ -0,0 +1,245 @@
+//! Batch job processor for bulk processing of queued jobs.
+//!
+//! [`BatchProcessor`] wraps a [`Queue`] and accumulates jobs per topic until
+//! either `batch_size` is reached or `batch_timeout` elapses, then dispatches
+//! them to a [`BatchJobHandler`] for bulk processing (e.g. bulk DB insert,
+//! bulk email send, batch index write).
+
+use std::pin::Pin;
+use std::sync::Arc;
+use std::time::Duration;
+
+use tokio::sync::{mpsc, Semaphore};
+
+use crate::error::JobError;
+use crate::job::Job;
+use crate::traits::Queue;
+
+/// A handler that processes a batch of jobs atomically.
+pub trait BatchJobHandler: Send + Sync {
+    fn handle_batch(&self, jobs: Vec<Job>) -> Pin<Box<dyn std::future::Future<Output = Result<(), JobError>> + Send>>;
+}
+
+impl<F, Fut> BatchJobHandler for F
+where
+    F: Fn(Vec<Job>) -> Fut + Send + Sync,
+    Fut: std::future::Future<Output = Result<(), JobError>> + Send + 'static,
+{
+    fn handle_batch(&self, jobs: Vec<Job>) -> Pin<Box<dyn std::future::Future<Output = Result<(), JobError>> + Send>> {
+        Box::pin((self)(jobs))
+    }
+}
+
+/// Configuration for [`BatchProcessor`].
+#[derive(Debug, Clone)]
+pub struct BatchConfig {
+    /// Max jobs per batch before flushing.
+    pub batch_size: usize,
+    /// Max time to wait before flushing a partial batch.
+    pub batch_timeout: Duration,
+    /// Max concurrent batch-processing tasks.
+    pub concurrency: usize,
+}
+
+impl Default for BatchConfig {
+    fn default() -> Self {
+        Self {
+            batch_size: 100,
+            batch_timeout: Duration::from_secs(5),
+            concurrency: 4,
+        }
+    }
+}
+
+/// Result of a completed batch flush.
+pub struct BatchFlush {
+    /// Number of jobs in the flushed batch.
+    pub count: usize,
+}
+
+/// A processor that batches jobs before dispatching them.
+pub struct BatchProcessor<Q: Queue + 'static> {
+    queue: Arc<Q>,
+    config: BatchConfig,
+    semaphore: Arc<Semaphore>,
+}
+
+impl<Q: Queue + 'static> BatchProcessor<Q> {
+    pub fn new(queue: Q, config: BatchConfig) -> Self {
+        let sem = Arc::new(Semaphore::new(config.concurrency.max(1)));
+        Self {
+            queue: Arc::new(queue),
+            config,
+            semaphore: sem,
+        }
+    }
+
+    /// Starts a batch processor for `topic` using `handler`.
+    pub fn start<H>(&self, topic: &str, handler: H)
+    where
+        H: BatchJobHandler + 'static,
+    {
+        let queue = Arc::clone(&self.queue);
+        let config = self.config.clone();
+        let semaphore = Arc::clone(&self.semaphore);
+        let handler: Arc<dyn BatchJobHandler> = Arc::new(handler);
+        let topic_owned = topic.to_string();
+
+        let (tx, mut rx): (mpsc::Sender<Job>, mpsc::Receiver<Job>) = mpsc::channel(config.batch_size);
+
+        // Dequeue loop → forward to channel
+        {
+            let q = Arc::clone(&queue);
+            let t = topic_owned.clone();
+            let tx2 = tx.clone();
+            let poll = config.poll_timeout();
+            tokio::spawn(async move {
+                loop {
+                    match q.dequeue(&t, poll).await {
+                        Ok(Some(job)) => {
+                            if tx2.send(job).await.is_err() {
+                                // Processor dropped; re-enqueue remaining
+                                break;
+                            }
+                        }
+                        Ok(None) => {}
+                        Err(e) => {
+                            tracing::error!(queue_error = %e, "batch dequeue error");
+                            tokio::time::sleep(poll).await;
+                        }
+                    }
+                }
+            });
+        }
+
+        // Batch accumulation + flush loop
+        let h = handler;
+        tokio::spawn(async move {
+            loop {
+                let mut batch: Vec<Job> = Vec::with_capacity(config.batch_size);
+                let deadline = tokio::time::sleep(config.batch_timeout);
+                tokio::pin!(deadline);
+
+                // Fill batch
+                loop {
+                    if batch.len() >= config.batch_size {
+                        break;
+                    }
+                    tokio::select! {
+                        biased;
+                        job = rx.recv() => match job {
+                            Some(j) => batch.push(j),
+                            None => {
+                                // channel closed: drain remaining
+                                while let Ok(j) = rx.try_recv() {
+                                    batch.push(j);
+                                }
+                                if !batch.is_empty() {
+                                    Self::flush(&h, &semaphore, batch).await;
+                                }
+                                return;
+                            }
+                        },
+                        _ = &mut deadline => break,
+                    }
+                }
+
+                if !batch.is_empty() {
+                    Self::flush(&h, &semaphore, batch).await;
+                }
+                deadline.as_mut().reset(tokio::time::Instant::now() + config.batch_timeout);
+            }
+        });
+
+        // Keep tx alive for the dequeue loop (it was cloned)
+        let _keep = tx;
+    }
+
+    async fn flush(handler: &Arc<dyn BatchJobHandler>, sem: &Arc<Semaphore>, batch: Vec<Job>) {
+        let permit = sem.clone().acquire_owned().await;
+        if permit.is_err() {
+            tracing::error!("batch semaphore closed");
+            return;
+        }
+        let _permit = permit.unwrap();
+        let h = Arc::clone(handler);
+        let batch_len = batch.len();
+        tokio::spawn(async move {
+            match h.handle_batch(batch).await {
+                Ok(()) => tracing::debug!(count = batch_len, "batch processed"),
+                Err(e) => tracing::error!("batch handler error: {}", e),
+            }
+        });
+    }
+}
+
+impl BatchConfig {
+    fn poll_timeout(&self) -> Duration {
+        self.batch_timeout.min(Duration::from_millis(100))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::in_memory::InMemoryQueue;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    use std::sync::Arc as StdArc;
+
+    fn make_queue() -> InMemoryQueue {
+        InMemoryQueue::new()
+    }
+
+    #[tokio::test]
+    async fn flush_on_batch_size() {
+        let queue = make_queue();
+        let counter = StdArc::new(AtomicUsize::new(0));
+        let cfg = BatchConfig {
+            batch_size: 3,
+            batch_timeout: Duration::from_secs(10),
+            concurrency: 2,
+        };
+        let bp = BatchProcessor::new(queue, cfg);
+        let c2 = StdArc::clone(&counter);
+        bp.start("t", move |jobs: Vec<Job>| {
+            let c3 = StdArc::clone(&c2);
+            Box::pin(async move {
+                c3.fetch_add(jobs.len(), Ordering::SeqCst);
+                Ok(())
+            })
+        });
+
+        for i in 0..3 {
+            bp.queue.enqueue("t", format!("job{}", i).into_bytes()).await.unwrap();
+        }
+
+        tokio::time::sleep(Duration::from_millis(300)).await;
+        assert_eq!(counter.load(Ordering::SeqCst), 3);
+    }
+
+    #[tokio::test]
+    async fn flush_on_timeout() {
+        let queue = make_queue();
+        let queue2 = queue.clone();
+        let counter = StdArc::new(AtomicUsize::new(0));
+        let cfg = BatchConfig {
+            batch_size: 100,
+            batch_timeout: Duration::from_millis(100),
+            concurrency: 2,
+        };
+        let bp = BatchProcessor::new(queue, cfg);
+        let c2 = StdArc::clone(&counter);
+        bp.start("t", move |jobs: Vec<Job>| {
+            let c3 = StdArc::clone(&c2);
+            Box::pin(async move {
+                c3.fetch_add(jobs.len(), Ordering::SeqCst);
+                Ok(())
+            })
+        });
+
+        queue2.enqueue("t", b"x".to_vec()).await.unwrap();
+
+        tokio::time::sleep(Duration::from_millis(300)).await;
+        assert_eq!(counter.load(Ordering::SeqCst), 1);
+    }
+}

crates/mytheclipse-queue/src/error.rs

@@ -11,6 +11,8 @@ pub enum QueueError {
     Serialization(String),
     /// A timeout occurred while waiting for an operation.
     Timeout,
+    /// The operation was rejected because of a rate limit.
+    RateLimit(String),
 }
 
 impl std::fmt::Display for QueueError {
@@ -20,6 +22,7 @@ impl std::fmt::Display for QueueError {
             Self::NotFound(s) => write!(f, "queue not found: {s}"),
             Self::Serialization(s) => write!(f, "serialization error: {s}"),
             Self::Timeout => write!(f, "queue operation timed out"),
+            Self::RateLimit(s) => write!(f, "queue rate limited: {s}"),
         }
     }
 }

crates/mytheclipse-queue/src/lib.rs

@@ -54,6 +54,20 @@ pub mod in_memory;
 pub mod traits;
 pub mod worker;
 
+#[cfg(feature = "in-memory")]
+pub mod batch;
+#[cfg(feature = "in-memory")]
+pub mod backpressure_enqueue;
+#[cfg(feature = "in-memory")]
+pub mod rate_limited;
+#[cfg(feature = "in-memory")]
+pub use backpressure_enqueue::{BackpressureEnforcer, BackpressureError, enqueue_with_backpressure};
+#[cfg(feature = "in-memory")]
+pub use rate_limited::{RateLimitedQueue, RateLimitQueueError};
+
+#[cfg(feature = "in-memory")]
+pub mod pipeline;
+
 #[cfg(feature = "in-memory")]
 pub use in_memory::InMemoryQueue;
 
@@ -63,6 +77,6 @@ pub use worker::{WorkerPool, WorkerConfig, JobHandler, JobFuture};
 pub use error::{QueueError, JobError};
 
 #[cfg(feature = "in-memory")]
-pub mod pipeline;
+pub use batch::{BatchConfig, BatchJobHandler, BatchProcessor, BatchFlush};
 #[cfg(feature = "in-memory")]
 pub use pipeline::{StageRunner, Stage, StageError};

crates/mytheclipse-queue/src/rate_limited.rs

@@ -0,0 +1,157 @@
+//! Rate-limited queue wrapper.
+//!
+//! [`RateLimitedQueue`] wraps any [`Queue`] implementation and applies a
+//! token-bucket rate limiter before enqueuing. If the bucket is empty the
+//! enqueue is rejected with [`RateLimitQueueError::RateLimited`] instead of
+//! blocking.
+
+use std::sync::Arc;
+use std::time::Duration;
+
+use tokio::sync::Mutex;
+use tokio::time::Instant;
+
+use crate::error::QueueError;
+use crate::traits::Queue;
+use async_trait::async_trait;
+
+/// Error returned by [`RateLimitedQueue::enqueue`].
+#[derive(Debug)]
+pub enum RateLimitQueueError {
+    RateLimited,
+    Other(QueueError),
+}
+
+impl std::fmt::Display for RateLimitQueueError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::RateLimited => write!(f, "rate limited: capacity exhausted"),
+            Self::Other(e) => write!(f, "queue error: {e}"),
+        }
+    }
+}
+
+impl std::error::Error for RateLimitQueueError {}
+
+impl From<QueueError> for RateLimitQueueError {
+    fn from(e: QueueError) -> Self {
+        Self::Other(e)
+    }
+}
+
+impl From<RateLimitQueueError> for QueueError {
+    fn from(e: RateLimitQueueError) -> Self {
+        match e {
+            RateLimitQueueError::RateLimited => Self::RateLimit("capacity exhausted".into()),
+            RateLimitQueueError::Other(e) => e,
+        }
+    }
+}
+
+/// Token-bucket rate limiter (no extra deps beyond tokio).
+struct TokenBucket {
+    /// Maximum burst capacity.
+    capacity: u32,
+    /// Current tokens (float for fractional refill).
+    tokens: f64,
+    /// Refill rate (tokens per second).
+    rate: f64,
+    /// Last refill timestamp.
+    last: Instant,
+}
+
+impl TokenBucket {
+    fn new(rate_per_sec: f64, burst: u32) -> Self {
+        Self {
+            capacity: burst.max(1),
+            tokens: burst as f64,
+            rate: rate_per_sec.max(0.0),
+            last: Instant::now(),
+        }
+    }
+
+    /// Attempts to consume one token. Returns true on success.
+    fn try_consume(&mut self) -> bool {
+        let now = Instant::now();
+        let elapsed = now.saturating_duration_since(self.last).as_secs_f64();
+        self.tokens = (self.tokens + elapsed * self.rate).min(self.capacity as f64);
+        self.last = now;
+        if self.tokens >= 1.0 {
+            self.tokens -= 1.0;
+            true
+        } else {
+            false
+        }
+    }
+}
+
+/// A queue decorator that enforces a rate limit on enqueue.
+pub struct RateLimitedQueue<Q: ?Sized> {
+    inner: Arc<Q>,
+    bucket: Arc<Mutex<TokenBucket>>,
+}
+
+impl<Q: Queue + 'static> RateLimitedQueue<Q> {
+    /// Creates a new rate-limited wrapper around `inner`.
+    pub fn new(inner: Q, rate_per_sec: f64, burst: u32) -> Self {
+        Self {
+            inner: Arc::new(inner),
+            bucket: Arc::new(Mutex::new(TokenBucket::new(rate_per_sec, burst))),
+        }
+    }
+}
+
+#[async_trait]
+impl<Q: Queue + ?Sized> Queue for RateLimitedQueue<Q> {
+    async fn enqueue(&self, topic: &str, payload: Vec<u8>) -> Result<(), QueueError> {
+        let mut b = self.bucket.lock().await;
+        if !b.try_consume() {
+            return Err(RateLimitQueueError::RateLimited.into());
+        }
+        self.inner.enqueue(topic, payload).await
+    }
+
+    async fn dequeue(&self, topic: &str, timeout: Duration) -> Result<Option<crate::job::Job>, QueueError> {
+        self.inner.dequeue(topic, timeout).await
+    }
+
+    async fn ack(&self, job: &crate::job::Job) -> Result<(), crate::error::JobError> {
+        self.inner.ack(job).await
+    }
+
+    async fn nack(&self, job: &crate::job::Job, requeue: bool) -> Result<(), crate::error::JobError> {
+        self.inner.nack(job, requeue).await
+    }
+
+    async fn dlq_move(&self, topic: &str, job: crate::job::Job) -> Result<(), QueueError> {
+        self.inner.dlq_move(topic, job).await
+    }
+
+    async fn len(&self, topic: &str) -> Result<u64, QueueError> {
+        self.inner.len(topic).await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::in_memory::InMemoryQueue;
+
+    #[tokio::test]
+    async fn allows_enqueue_within_rate() {
+        let inner = InMemoryQueue::new();
+        let rl = RateLimitedQueue::new(inner, 100.0, 10);
+        assert!(rl.enqueue("t", b"x".to_vec()).await.is_ok());
+    }
+
+    #[tokio::test]
+    async fn rejects_when_bucket_empty() {
+        let inner = InMemoryQueue::new();
+        let rl = RateLimitedQueue::new(inner, 0.0, 1); // 0 tokens/sec, 1 burst
+        // consume the single burst token
+        let _ = rl.enqueue("t", b"x".to_vec()).await;
+        // next should be rate limited (no refill)
+        let result = rl.enqueue("t", b"y".to_vec()).await;
+        assert!(matches!(result, Err(QueueError::RateLimit(_))));
+    }
+}

crates/mytheclipse-storage/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mytheclipse-storage"
-version = "1.5.0"
+version = "1.12.0"
 edition = "2021"
 rust-version = "1.75"
 license = "MIT OR Apache-2.0"

crates/mytheclipse-tracing/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mytheclipse-tracing"
-version = "1.5.0"
+version = "1.12.0"
 edition = "2021"
 rust-version = "1.75"
 license = "MIT OR Apache-2.0"

crates/mytheclipse/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mytheclipse"
-version = "1.5.0"
+version = "1.12.0"
 edition = "2021"
 rust-version = "1.75"
 license = "MIT OR Apache-2.0"
@@ -34,7 +34,7 @@ bg = ["dep:tokio"]
 resiliency = ["dep:tokio", "dep:rand"]
 traffic = ["dep:tokio"]
 lifecycle = ["dep:tokio"]
-observability = ["dep:tokio"]
+observability = ["dep:tokio", "lifecycle"]
 full = ["io", "compute", "bg", "resiliency", "traffic", "lifecycle", "observability"]
 
 [[example]]

crates/mytheclipse/src/bg_join.rs

@@ -0,0 +1,133 @@
+//! Graceful task-joiner for background tasks (feature `lifecycle`).
+//!
+//! [`BgJoiner`] collects [`tokio::task::JoinHandle`]s returned by
+//! [`crate::spawn_bg`] (or any manual `tokio::spawn`) and drains them in
+//! aggregate on shutdown via [`BgJoiner::join_all`].
+//!
+//! This complements the bounded `spawn_bg` helper: while `spawn_bg` limits
+//! *concurrency*, `BgJoiner` adds structured *lifetimes* so a service can wait
+//! for all in-flight work to settle before terminating.
+
+use std::future::Future;
+use std::sync::Arc;
+use std::time::Duration;
+
+use tokio::sync::Mutex;
+use tokio::task::JoinHandle;
+use tokio::time::Instant;
+
+/// A joiner that tracks background task handles for ordered shutdown.
+#[derive(Default, Clone)]
+pub struct BgJoiner {
+    inner: Arc<Mutex<Vec<JoinHandle<()>>>>,
+}
+
+impl BgJoiner {
+    /// Creates an empty joiner.
+    pub fn new() -> Self {
+        Self {
+            inner: Arc::new(Mutex::new(Vec::new())),
+        }
+    }
+
+    /// Spawns `future` as a background task and tracks its handle.
+    pub fn spawn<F>(&self, future: F)
+    where
+        F: std::future::Future + Send + 'static,
+        F::Output: Send + 'static,
+    {
+        let handle: JoinHandle<()> = tokio::spawn(async move { let _ = future.await; });
+        self.track(handle);
+    }
+
+    /// Registers an externally-created `JoinHandle` for tracking.
+    pub fn track(&self, handle: JoinHandle<()>) {
+        // can't lock synchronously; defer to a spawned task
+        let inner = Arc::clone(&self.inner);
+        tokio::spawn(async move {
+            let mut set = inner.lock().await;
+            set.push(handle);
+        });
+    }
+
+    /// Number of currently-tracked tasks.
+    pub async fn len(&self) -> usize {
+        self.inner.lock().await.len()
+    }
+
+    /// Await every tracked task, dropping any that are still pending once
+    /// `deadline` elapses. Returns the count of tasks that had not completed
+    /// within the timeout.
+    pub async fn join_all(&self, deadline: Duration) -> usize {
+        let now = Instant::now();
+        let handles: Vec<JoinHandle<()>> = {
+            let mut guard = self.inner.lock().await;
+            std::mem::take(&mut *guard)
+        };
+
+        let mut pending: Vec<JoinHandle<()>> = handles;
+        let mut dropped = 0usize;
+
+        loop {
+            if pending.is_empty() {
+                break 0;
+            }
+
+            if now.elapsed() >= deadline {
+                dropped = pending.len();
+                for h in pending.drain(..) {
+                    h.abort();
+                }
+                return dropped;
+            }
+
+            let remaining = deadline.saturating_sub(now.elapsed());
+            let mut still = Vec::with_capacity(pending.len());
+            for mut handle in pending.drain(..) {
+                match tokio::time::timeout(remaining, &mut handle).await {
+                    Ok(Ok(_)) => {}
+                    Ok(Err(_)) => {}
+                    Err(_) => still.push(handle),
+                }
+            }
+            pending = still;
+        }
+    }
+
+    /// Drops (aborts) all tracked tasks immediately without awaiting.
+    pub async fn abort_all(&self) {
+        let handles: Vec<JoinHandle<()>> = {
+            let mut guard = self.inner.lock().await;
+            std::mem::take(&mut *guard)
+        };
+        for h in handles {
+            h.abort();
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn spawn_and_join_completes() {
+        let joiner = BgJoiner::new();
+        joiner.spawn(async { tokio::task::yield_now().await });
+        // give the task a moment to register
+        tokio::time::sleep(Duration::from_millis(10)).await;
+        let leftover = joiner.join_all(Duration::from_secs(1)).await;
+        assert_eq!(leftover, 0);
+    }
+
+    #[tokio::test]
+    async fn join_all_aborts_on_timeout() {
+        let joiner = BgJoiner::new();
+        joiner.spawn(async {
+            tokio::time::sleep(Duration::from_secs(10)).await;
+        });
+        tokio::time::sleep(Duration::from_millis(10)).await;
+        let leftover = joiner.join_all(Duration::from_millis(50)).await;
+        assert!(leftover > 0);
+    }
+}

crates/mytheclipse/src/circuit_breaker.rs

@@ -22,6 +22,17 @@ pub enum CircuitState {
     HalfOpen,
 }
 
+/// Point-in-time snapshot of a [`CircuitBreaker`] for metrics/observability.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct CircuitSnapshot {
+    /// Current circuit state.
+    pub state: CircuitState,
+    /// Consecutive failures recorded (resets on success in `Closed`).
+    pub failures: u64,
+    /// Consecutive successes recorded (resets on failure/open).
+    pub successes: u64,
+}
+
 const CLOSED: u8 = 0;
 const OPEN: u8 = 1;
 const HALF_OPEN: u8 = 2;
@@ -199,6 +210,16 @@ impl CircuitBreaker {
         *self.inner.opened_at.lock().unwrap() = None;
     }
 
+    /// Returns a point-in-time snapshot of the breaker's internal counters and
+    /// state, for metrics/observability export.
+    pub fn snapshot(&self) -> CircuitSnapshot {
+        CircuitSnapshot {
+            state: self.state(),
+            failures: self.inner.failures.load(Ordering::Acquire),
+            successes: self.inner.successes.load(Ordering::Acquire),
+        }
+    }
+
     fn record_result(&self, success: bool) {
         match self.inner.state.load(Ordering::Acquire) {
             HALF_OPEN => {
@@ -362,4 +383,25 @@ mod tests {
         let err: Result<u32, CircuitError<u8>> = b.call(|| Err(9u8));
         assert!(matches!(err, Err(CircuitError::Inner(9))));
     }
+
+    #[test]
+    fn snapshot_reflects_state_and_counts() {
+        let b = breaker();
+        let snap = b.snapshot();
+        assert_eq!(snap.state, CircuitState::Closed);
+        assert_eq!(snap.failures, 0);
+        assert_eq!(snap.successes, 0);
+
+        // success in Closed state resets failure count (no failure counter added).
+        b.call::<(), u8, _>(|| Ok(()));
+        let snap2 = b.snapshot();
+        assert_eq!(snap2.state, CircuitState::Closed);
+
+        for _ in 0..3 {
+            let _: Result<(), CircuitError<u8>> = b.call(|| Err(1u8));
+        }
+        let snap3 = b.snapshot();
+        assert_eq!(snap3.state, CircuitState::Open);
+        assert_eq!(snap3.failures, 0); // reset on open()
+    }
 }

crates/mytheclipse/src/health.rs

@@ -36,7 +36,7 @@ struct RegisteredCheck {
 }
 
 /// Registry of health checks for aggregated /health reporting.
-#[derive(Default)]
+#[derive(Default, Clone)]
 pub struct HealthRegistry {
     checks: Arc<RwLock<Vec<RegisteredCheck>>>,
 }

crates/mytheclipse/src/lib.rs

@@ -34,6 +34,10 @@ pub mod bg;
 #[cfg(feature = "resiliency")]
 pub mod retry;
 #[cfg(feature = "resiliency")]
+pub mod retry_ext;
+#[cfg(feature = "resiliency")]
+pub use retry_ext::RetryExt;
+#[cfg(feature = "resiliency")]
 pub mod circuit_breaker;
 #[cfg(feature = "resiliency")]
 pub mod timeout;
@@ -53,11 +57,19 @@ pub mod shutdown;
 pub mod cron;
 #[cfg(feature = "lifecycle")]
 pub mod health;
+#[cfg(all(feature = "observability", feature = "traffic"))]
+pub mod pool_health;
 #[cfg(feature = "lifecycle")]
 pub mod leader;
 #[cfg(feature = "lifecycle")]
 pub mod lifecycle;
 
+#[cfg(feature = "lifecycle")]
+pub mod bg_join;
+
+#[cfg(all(feature = "observability", feature = "resiliency"))]
+pub mod middleware;
+
 #[cfg(feature = "observability")]
 pub mod metrics;
 #[cfg(feature = "observability")]
@@ -106,7 +118,7 @@ pub use health::{HealthCheck, HealthRegistry, HealthStatus};
 pub use leader::{InProcLeaderElection, LeaderElection};
 
 #[cfg(feature = "resiliency")]
-pub use service_builder::ServiceBuilder;
+pub use service_builder::{RunError, ServiceBuilder, ServiceConfig};
 
 #[cfg(feature = "lifecycle")]
 pub use dlock::{DistributedLock, LockError, LockGuard, InProcLock};
@@ -117,6 +129,22 @@ pub use lifecycle::AsyncLifecycleManager;
 pub use metrics::{MetricsCollector, MetricsSnapshot};
 #[cfg(feature = "observability")]
 pub use metrics_bridge::{MetricsBridge, MetricsHealthCheck};
+
+/// Re-export of [`metrics_bridge::CircuitBreakerHealthCheck`].
+/// Only compiled when both `observability` and `resiliency` are enabled.
+#[cfg(all(feature = "observability", feature = "resiliency"))]
+pub use metrics_bridge::CircuitBreakerHealthCheck;
+
+/// Re-export of [`pool_health::HealthCheckedPool`].
+/// Only compiled when both `observability` and `traffic` are enabled.
+#[cfg(all(feature = "observability", feature = "traffic"))]
+pub use pool_health::HealthCheckedPool;
+
+#[cfg(feature = "lifecycle")]
+pub use bg_join::BgJoiner;
+
+#[cfg(all(feature = "observability", feature = "resiliency"))]
+pub use middleware::{MiddlewarePipeline, PipelineError, BoxMiddleware, mw};
 #[cfg(feature = "observability")]
 pub use panic_tracker::{PanicGuard, PanicInfo, PanicTracker};
 

crates/mytheclipse/src/metrics_bridge.rs

@@ -10,6 +10,41 @@ use std::time::Duration;
 use crate::health::{HealthCheck, HealthStatus};
 use crate::metrics::MetricsCollector;
 
+/// A health check backed by a [`CircuitBreaker`]: unhealthy if open,
+/// degraded if half-open, ok otherwise.
+///
+/// Only available when both `resiliency` and `observability` features are
+/// enabled (circuit breaker + health/metrics bridge).
+#[cfg(feature = "resiliency")]
+pub struct CircuitBreakerHealthCheck {
+    breaker: crate::circuit_breaker::CircuitBreaker,
+}
+
+#[cfg(feature = "resiliency")]
+impl CircuitBreakerHealthCheck {
+    pub fn new(breaker: crate::circuit_breaker::CircuitBreaker) -> Self {
+        Self { breaker }
+    }
+}
+
+#[cfg(feature = "resiliency")]
+impl HealthCheck for CircuitBreakerHealthCheck {
+    fn name(&self) -> &str {
+        "circuit_breaker"
+    }
+
+    fn check(&self) -> std::pin::Pin<Box<dyn std::future::Future<Output = HealthStatus> + Send + '_>> {
+        let state = self.breaker.snapshot().state;
+        Box::pin(async move {
+            match state {
+                crate::circuit_breaker::CircuitState::Open => HealthStatus::Unhealthy,
+                crate::circuit_breaker::CircuitState::HalfOpen => HealthStatus::Degraded,
+                crate::circuit_breaker::CircuitState::Closed => HealthStatus::Ok,
+            }
+        })
+    }
+}
+
 /// A health check backed by a [`MetricsCollector`]: unhealthy if any registered
 /// "error" counter is non-zero, degraded if any gauge is below a configured
 /// threshold.
@@ -142,6 +177,7 @@ mod tests {
         bridge.emit_now();
     }
 
+#[cfg(feature = "lifecycle")]
     #[tokio::test]
     async fn lifecycle_manager_with_metrics_bridge() {
         let collector = MetricsCollector::new();

crates/mytheclipse/src/middleware.rs

@@ -0,0 +1,108 @@
+//! Composable middleware pipeline (feature `observability` + `resiliency`).
+//!
+//! [`MiddlewarePipeline`] is an ordered stack of boxed async functions. Each
+//! stage receives the state, may transform or reject it, and returns control
+//! to the next stage. The final state is delivered to a caller-supplied
+//! service closure.
+
+use std::future::Future;
+use std::pin::Pin;
+use std::sync::{Arc, Mutex};
+
+/// Error returned by [`MiddlewarePipeline::apply`].
+#[derive(Debug)]
+pub struct PipelineError {
+    pub msg: String,
+}
+
+impl std::fmt::Display for PipelineError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "pipeline error: {}", self.msg)
+    }
+}
+
+impl std::error::Error for PipelineError {}
+
+/// A single async middleware stage.
+pub type BoxMiddleware<S> = Arc<
+    dyn Fn(S) -> Pin<Box<dyn Future<Output = Result<S, PipelineError>> + Send>>
+        + Send
+        + Sync,
+>;
+
+/// Helper to box any `async fn` middleware.
+pub fn mw<S, F, Fut>(f: F) -> BoxMiddleware<S>
+where
+    S: Send + 'static,
+    F: Fn(S) -> Fut + Send + Sync + 'static,
+    Fut: Future<Output = Result<S, PipelineError>> + Send + 'static,
+{
+    Arc::new(move |state| Box::pin(f(state)))
+}
+
+/// A stack of ordered middleware stages.
+#[derive(Clone, Default)]
+pub struct MiddlewarePipeline<S> {
+    layers: Arc<Mutex<Vec<BoxMiddleware<S>>>>,
+}
+
+impl<S: Send + 'static> MiddlewarePipeline<S> {
+    pub fn new() -> Self {
+        Self { layers: Arc::new(Mutex::new(Vec::new())) }
+    }
+
+    /// Appends a middleware stage.
+    pub fn add(&self, m: BoxMiddleware<S>) {
+        self.layers.lock().unwrap().push(m);
+    }
+
+    /// Applies every layer in order, short-circuiting on the first error.
+    pub async fn apply(&self, state: S) -> Result<S, PipelineError> {
+        let layers = self.layers.lock().unwrap();
+        let mut current = state;
+        for layer in layers.iter() {
+            current = layer(current).await?;
+        }
+        Ok(current)
+    }
+
+    /// Applies every layer, then runs `svc` with the final state.
+    pub async fn run<F, Fut, R, E>(&self, state: S, svc: F) -> Result<R, E>
+    where
+        F: Fn(S) -> Fut + Clone + Send + 'static,
+        Fut: Future<Output = Result<R, E>> + Send,
+        R: Send + 'static,
+        E: From<PipelineError> + Send,
+    {
+        match self.apply(state).await {
+            Ok(s) => svc(s).await,
+            Err(e) => Err(E::from(e)),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn applies_two_layers_in_order() {
+        let p: MiddlewarePipeline<u32> = MiddlewarePipeline::new();
+        let inc = mw(|s: u32| async move { Ok::<_, PipelineError>(s + 1) });
+        let double = mw(|s: u32| async move { Ok::<_, PipelineError>(s * 2) });
+        p.add(inc);
+        p.add(double);
+        let out = p.apply(1).await.unwrap();
+        assert_eq!(out, 4); // (1+1)*2
+    }
+
+    #[tokio::test]
+    async fn short_circuits_on_error() {
+        let p: MiddlewarePipeline<String> = MiddlewarePipeline::new();
+        let reject = mw(|_s: String| async {
+            Err::<_, PipelineError>(PipelineError { msg: "rejected".into() })
+        });
+        p.add(reject);
+        assert!(matches!(p.apply("x".to_string()).await, Err(_)));
+    }
+}

crates/mytheclipse/src/pool.rs

@@ -3,12 +3,15 @@
 //! Provides a `Pool` trait and a built-in `SemaphorePool<T>` implementation
 //! that distributes items drawn from a `Vec<T>` under a counting semaphore.
 
+use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
 
 use async_trait::async_trait;
 use tokio::sync::OwnedSemaphorePermit;
 use tokio::sync::Semaphore;
 
+static ACQUIRE_COUNT: AtomicUsize = AtomicUsize::new(0);
+
 /// Errors returned by pool operations.
 #[derive(Debug, thiserror::Error)]
 pub enum PoolError {
@@ -39,6 +42,11 @@ pub struct SemaphorePool<T: Clone> {
 }
 
 impl<T: Clone> SemaphorePool<T> {
+    /// Returns the underlying items slice (read-only view).
+    pub fn items(&self) -> &[T] {
+        &self.items
+    }
+
     /// Creates a new pool from a vector of items.
     pub fn new(items: Vec<T>) -> Self {
         let permits = items.len().max(1);
@@ -54,7 +62,7 @@ impl<T: Clone + Send + Sync + 'static> Pool<T> for SemaphorePool<T> {
     async fn acquire(&self) -> Result<Pooled<T>, PoolError> {
         let permit = self.semaphore.clone().acquire_owned().await
             .map_err(|_| PoolError::Exhausted)?;
-        let idx = rand::random::<usize>() % self.items.len();
+        let idx = ACQUIRE_COUNT.fetch_add(1, Ordering::Relaxed) % self.items.len();
         Ok(Pooled {
             resource: self.items[idx].clone(),
             _permit: permit,

crates/mytheclipse/src/pool_health.rs

@@ -0,0 +1,141 @@
+//! Health-checked resource pool (feature `observability` + `traffic`).
+//!
+//! [`HealthCheckedPool`] composes a [`SemaphorePool`] with a [`HealthRegistry`]:
+//! a background probe periodically validates pooled items, and a registered
+//! `HealthCheck` reflects pool liveliness in the aggregated `/health` report.
+
+use std::sync::Arc;
+use std::time::Duration;
+
+use crate::health::{HealthCheck, HealthRegistry, HealthStatus};
+use crate::pool::{Pool, Pooled, PoolError, SemaphorePool};
+
+/// A health check backed by a closure.
+struct ClosureCheck {
+    name: String,
+    check: Arc<dyn Fn() -> HealthStatus + Send + Sync>,
+}
+
+impl HealthCheck for ClosureCheck {
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    fn check(&self) -> std::pin::Pin<Box<dyn std::future::Future<Output = HealthStatus> + Send + '_>> {
+        let status = (self.check)();
+        Box::pin(async move { status })
+    }
+}
+
+/// A resource pool with integrated health reporting.
+pub struct HealthCheckedPool<T: Clone + Send + Sync + 'static> {
+    pub(crate) inner: SemaphorePool<T>,
+    #[allow(dead_code)]
+    registry: Arc<HealthRegistry>,
+    #[allow(dead_code)]
+    check_interval: Duration,
+    #[allow(dead_code)]
+    name: String,
+}
+
+impl<T: Clone + Send + Sync + 'static + std::fmt::Debug> HealthCheckedPool<T> {
+    /// Creates a new health-checked pool.
+    ///
+    /// `validator` is called on each item during the periodic background probe;
+    /// the registered health check reports `Ok` if any item validates.
+    pub async fn new(
+        items: Vec<T>,
+        registry: &HealthRegistry,
+        name: impl Into<String>,
+        check_interval: Duration,
+        validator: impl Fn(&T) -> bool + Send + Sync + 'static,
+    ) -> Self {
+        let name_str = name.into();
+        let pool = SemaphorePool::new(items);
+        let registry = Arc::new(registry.clone());
+
+        let validator: Arc<dyn Fn(&T) -> bool + Send + Sync> = Arc::new(validator);
+        let check_items = pool.items().to_vec();
+        let v_check = Arc::clone(&validator);
+        let check = ClosureCheck {
+            name: format!("connection-pool:{}", name_str),
+            check: Arc::new(move || {
+                if check_items.iter().any(|i| v_check(i)) {
+                    HealthStatus::Ok
+                } else {
+                    HealthStatus::Unhealthy
+                }
+            }),
+        };
+        let r = Arc::clone(&registry);
+        let check_name = check.name.clone();
+        tokio::task::spawn(async move {
+            r.register(check_name, check).await;
+        });
+
+        // Background probe
+        let probe_items = pool.items().to_vec();
+        let probe_name = name_str.clone();
+        let v_probe = Arc::clone(&validator);
+        tokio::task::spawn(async move {
+            let mut ticker = tokio::time::interval(check_interval);
+            loop {
+                ticker.tick().await;
+                let up = probe_items.iter().filter(|i| v_probe(i)).count();
+                tracing::debug!(pool = %probe_name, up, total = probe_items.len(), "pool health probe");
+            }
+        });
+
+        Self {
+            inner: pool,
+            registry,
+            check_interval,
+            name: name_str,
+        }
+    }
+
+    /// Acquires a resource from the pool.
+    pub async fn acquire_healthy(&self) -> Result<Pooled<T>, PoolError> {
+        self.inner.acquire().await
+    }
+
+    /// Number of items in the pool.
+    pub fn size(&self) -> usize {
+        self.inner.items().len()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn acquires_resource() {
+        let reg = HealthRegistry::new();
+        let pool = HealthCheckedPool::new(
+            vec![42u32, 84u32],
+            &reg,
+            "test",
+            Duration::from_secs(5),
+            |_| true,
+        )
+        .await;
+        let item = pool.acquire_healthy().await.unwrap();
+        assert!(item.resource == 42 || item.resource == 84);
+        assert_eq!(pool.size(), 2);
+    }
+
+    #[tokio::test]
+    async fn validator_distinguishes_healthy() {
+        let reg = HealthRegistry::new();
+        let pool = HealthCheckedPool::new(
+            vec![0u32, 1u32, 2u32],
+            &reg,
+            "test",
+            Duration::from_secs(5),
+            |x| *x > 0,
+        )
+        .await;
+        assert_eq!(pool.size(), 3);
+    }
+}

crates/mytheclipse/src/retry.rs

@@ -85,6 +85,79 @@ impl<E: std::fmt::Display> std::fmt::Display for RetryError<E> {
 
 impl<E: std::fmt::Debug + std::fmt::Display> std::error::Error for RetryError<E> {}
 
+/// Statistics collected during a [`retry`] call.
+#[derive(Debug, Clone, Default)]
+pub struct RetryStats {
+    /// Total number of attempts made (including the first).
+    pub attempts: u32,
+    /// Number of retries performed (= `attempts - 1` if exhausted, or
+    /// `attempts - 1` if ultimately succeeded after at least one retry).
+    pub retries: u32,
+    /// The error message from the final attempt, if any.
+    pub last_error: Option<String>,
+}
+
+/// Like [`retry`] but also returns [`RetryStats`] capturing attempt counts.
+///
+/// Retries `op` according to `config`, retrying only errors for which
+/// `filter` returns `true`.
+///
+/// Like [`retry`] but also returns [`RetryStats`].
+pub async fn retry_with_stats<T, E, F, Fut, P>(
+    config: RetryConfig,
+    filter: P,
+    mut op: F,
+) -> (Result<T, RetryError<E>>, RetryStats)
+where
+    F: FnMut() -> Fut,
+    Fut: Future<Output = Result<T, E>>,
+    P: Fn(&E) -> bool,
+    E: std::fmt::Display,
+{
+    let mut attempt: u32 = 0;
+    let mut last_error: Option<String> = None;
+    loop {
+        attempt += 1;
+        let span = tracing::info_span!(
+            "mytheclipse_retry_task",
+            attempt,
+            max_attempts = config.max_attempts
+        );
+        let result = op().instrument(span).await;
+
+        match result {
+            Ok(value) => {
+                let stats = RetryStats {
+                    attempts: attempt,
+                    retries: attempt.saturating_sub(1),
+                    last_error,
+                };
+                return (Ok(value), stats);
+            }
+            Err(err) => {
+                last_error = Some(err.to_string());
+                let retryable = filter(&err);
+                if !retryable || attempt >= config.max_attempts {
+                    let stats = RetryStats {
+                        attempts: attempt,
+                        retries: attempt.saturating_sub(1),
+                        last_error,
+                    };
+                    return (
+                        Err(RetryError::Exhausted {
+                            attempts: attempt,
+                            last: err,
+                        }),
+                        stats,
+                    );
+                }
+                let delay = backoff_delay(&config, attempt, rand::thread_rng());
+                tokio::time::sleep(delay).await;
+            }
+        }
+    }
+}
+
 /// Retries `op` according to `config`, retrying only errors for which
 /// `filter` returns `true`.
 ///
@@ -238,6 +311,24 @@ mod tests {
         assert_eq!(calls.get(), 1);
     }
 
+    #[tokio::test]
+    async fn retry_with_stats_succeeds_with_counts() {
+        use std::cell::Cell;
+        let config = RetryConfig {
+            max_attempts: 5,
+            base_delay: Duration::from_millis(1),
+            ..RetryConfig::default()
+        };
+        let calls = Cell::new(0u32);
+        let (result, stats) = retry_with_stats(config, |_| true, || async {
+            calls.set(calls.get() + 1);
+            if calls.get() < 3 { Err::<u32, &str>("fail") } else { Ok(42u32) }
+        }).await;
+        assert_eq!(result.unwrap(), 42);
+        assert_eq!(stats.attempts, 3);
+        assert_eq!(stats.retries, 2);
+    }
+
     #[test]
     fn full_jitter_is_within_bounds_and_capped() {
         let config = RetryConfig {

crates/mytheclipse/src/retry_ext.rs

@@ -0,0 +1,72 @@
+//! Ergonomic retry extension trait (feature `resiliency`).
+//!
+//! [`RetryExt`] extends any [`std::future::Future<Output = Result<T, E>>`]
+//! with a `.retry()` method that delegates to [`crate::retry::retry`].
+
+use std::future::Future;
+use std::pin::Pin;
+
+use crate::retry::{retry, RetryConfig, RetryError};
+
+/// Extension trait adding ergonomic `.retry()` to any fallible future.
+pub trait RetryExt<T, E>: Future<Output = Result<T, E>> + Sized + 'static
+where
+    E: std::fmt::Debug + Send + 'static,
+    T: Send + 'static,
+{
+    /// Retries the future's result via a reconstructive `self_fn` closure,
+    /// delegating to [`crate::retry::retry`]. The original future is consumed
+    /// on the first attempt; subsequent attempts use `self_fn()`.
+    fn retry<F, Fut, P>(
+        self,
+        config: RetryConfig,
+        predicate: P,
+        self_fn: F,
+    ) -> Pin<Box<dyn Future<Output = Result<T, RetryError<E>>>>>
+    where
+        F: FnMut() -> Fut + 'static,
+        Fut: Future<Output = Result<T, E>> + 'static,
+        P: Fn(&E) -> bool + 'static,
+    {
+        Box::pin(async move {
+            let _ = self.await;
+            retry(config, predicate, self_fn).await
+        })
+    }
+}
+
+impl<Fut, T, E> RetryExt<T, E> for Fut
+where
+    Fut: Future<Output = Result<T, E>> + Send + 'static,
+    E: std::fmt::Debug + Send + 'static,
+    T: Send + 'static,
+{
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::time::Duration;
+    use std::sync::Arc;
+    use std::sync::atomic::{AtomicU32, Ordering};
+
+    #[tokio::test]
+    async fn retry_ext_retries_then_succeeds() {
+        let attempts = Arc::new(AtomicU32::new(0));
+        let a = Arc::clone(&attempts);
+        let cfg = RetryConfig { max_attempts: 3, base_delay: Duration::from_millis(1), ..RetryConfig::default() };
+
+        let op = move || {
+            let a = Arc::clone(&a);
+            async move {
+                let n = a.fetch_add(1, Ordering::SeqCst);
+                if n < 2 { Err::<(), String>("transient".into()) } else { Ok(()) }
+            }
+        };
+
+        let fut = async { Err::<(), String>("first".into()) };
+        let result = fut.retry(cfg, |_: &String| true, op).await;
+        assert!(result.is_ok());
+        assert_eq!(attempts.load(Ordering::SeqCst), 3);
+    }
+}