feat: add tower-service compatibility to seatbelt (#252)

As title says. Seatbelt can now interop natively with tower-based
ecosystem. The downside is decreased ergonomics and performance.

Author: martintmk

Cargo.lock

@@ -85,6 +85,7 @@ proc-macro2 = { version = "1.0.103", default-features = false }
 quote = { version = "1.0.42", default-features = false }
 rapidhash = { version = "4.1.1", default-features = false }
 regex = { version = "1.12.2", default-features = false }
+rstest = { version = "0.24", default-features = false }
 rustc-hash = { version = "2.1.0", default-features = false }
 serde = { version = "1.0.228", default-features = false }
 serde_core = { version = "1.0.228", default-features = false }

Cargo.toml

@@ -0,0 +1,14 @@
+# AI Agents Guidelines for `seatbelt`
+
+Code in this crate should follow the [Microsoft Rust Guidelines](https://microsoft.github.io/rust-guidelines/agents/all.txt).
+
+## Dual Service Implementations
+
+Each middleware has two logic-equivalent `Service` trait impls in the same file: one for
+`layered::Service` (`execute`) and one for `tower_service::Service` (`call`). The business
+logic flow must be identical between the two — they differ only mechanically (boxed futures,
+`poll_ready`, `Arc` cloning, `Result` output type).
+
+**Any change to `execute` must be mirrored in `call`, and vice versa.** Prefer adding logic to
+the shared `*Shared` helper structs rather than inlining into both methods. Integration tests
+use `rstest` cases that exercise both implementations — new test scenarios should do the same.

crates/seatbelt/AGENTS.md

@@ -26,6 +26,7 @@ allowed_external_types = [
     "recoverable::RecoveryKind",
     "tick::clock::Clock",
     "tower_layer::Layer",
+    "tower_service::Service",
 ]
 
 [package.metadata.docs.rs]
@@ -38,13 +39,15 @@ retry = ["dep:fastrand"]
 breaker = ["dep:fastrand"]
 metrics = ["dep:opentelemetry", "opentelemetry/metrics"]
 logs = ["dep:tracing"]
+tower-service = ["dep:tower-service"]
 
 [dependencies]
 fastrand = { workspace = true, optional = true }
 layered = { workspace = true }
 opentelemetry = { workspace = true, optional = true }
 recoverable = { workspace = true }
 tick = { workspace = true }
+tower-service = { workspace = true, optional = true }
 tracing = { workspace = true, optional = true }
 
 [dev-dependencies]
@@ -53,15 +56,18 @@ criterion.workspace = true
 fastrand.workspace = true
 futures = { workspace = true, features = ["executor"] }
 http.workspace = true
-layered = { workspace = true }
+layered = { workspace = true, features = ["tower-service"] }
 mutants.workspace = true
 ohno = { workspace = true, features = ["app-err"] }
 opentelemetry = { workspace = true, default-features = false, features = ["metrics"] }
 opentelemetry-stdout = { workspace = true, default-features = false, features = ["metrics", "logs"] }
 opentelemetry_sdk = { workspace = true, default-features = false, features = ["metrics", "testing", "experimental_metrics_custom_reader"] }
+rstest.workspace = true
 static_assertions.workspace = true
 tick = { workspace = true, features = ["test-util", "tokio"] }
 tokio = { workspace = true, features = ["rt", "macros"] }
+tower = { workspace = true, features = ["util"] }
+tower-service.workspace = true
 tracing.workspace = true
 tracing-subscriber = { workspace = true, features = ["fmt", "std"] }
 
@@ -89,6 +95,10 @@ required-features = ["retry"]
 name = "resilience_pipeline"
 required-features = ["retry", "timeout"]
 
+[[example]]
+name = "tower"
+required-features = ["retry", "timeout", "tower-service"]
+
 [[example]]
 name = "breaker"
 required-features = ["breaker", "metrics"]

crates/seatbelt/Cargo.toml

@@ -91,6 +91,39 @@ for each module for details on how to use them.
 * [`retry`][__link9] - Middleware that automatically retries failed operations.
 * [`breaker`][__link10] - Middleware that prevents cascading failures.
 
+## Tower Compatibility
+
+All resilience middleware are compatible with the Tower ecosystem when the `tower-service`
+feature is enabled. This allows you to use `tower::ServiceBuilder` to compose middleware stacks:
+
+```rust
+use seatbelt::retry::Retry;
+use seatbelt::timeout::Timeout;
+use seatbelt::{RecoveryInfo, ResilienceContext};
+use tower::ServiceBuilder;
+
+let context: ResilienceContext<String, Result<String, String>> =
+    ResilienceContext::new(&clock);
+
+let service = ServiceBuilder::new()
+    .layer(
+        Retry::layer("my_retry", &context)
+            .clone_input()
+            .recovery_with(|result: &Result<String, String>, _| match result {
+                Ok(_) => RecoveryInfo::never(),
+                Err(_) => RecoveryInfo::retry(),
+            }),
+    )
+    .layer(
+        Timeout::layer("my_timeout", &context)
+            .timeout(Duration::from_secs(30))
+            .timeout_error(|_| "operation timed out".to_string()),
+    )
+    .service_fn(|input: String| async move {
+        Ok::<_, String>(format!("processed: {input}"))
+    });
+```
+
 ## Features
 
 This crate provides several optional features that can be enabled in your `Cargo.toml`:
@@ -101,20 +134,23 @@ This crate provides several optional features that can be enabled in your `Cargo
 * **`breaker`** - Enables the [`breaker`][__link13] middleware for preventing cascading failures.
 * **`metrics`** - Exposes the OpenTelemetry metrics API for collecting and reporting metrics.
 * **`logs`** - Enables structured logging for resilience middleware using the `tracing` crate.
+* **`tower-service`** - Enables [`tower_service::Service`][__link14] trait implementations for all
+  resilience middleware.
 
 
 <hr/>
 <sub>
 This crate was developed as part of <a href="../..">The Oxidizer Project</a>. Browse this crate's <a href="https://github.com/microsoft/oxidizer/tree/main/crates/seatbelt">source code</a>.
 </sub>
 
- [__cargo_doc2readme_dependencies_info]: ggGkYW0CYXSEGy4k8ldDFPOhG2VNeXtD5nnKG6EPY6OfW5wBG8g18NOFNdxpYXKEG-dV5_BMYStiGz3ob6YYJlksG_4wPpDb0HzfG4spY1f17r0dYWSEgmdsYXllcmVkZTAuMy4wgmtyZWNvdmVyYWJsZWUwLjEuMIJoc2VhdGJlbHRlMC4yLjCCZHRpY2tlMC4xLjI
+ [__cargo_doc2readme_dependencies_info]: ggGkYW0CYXSEGy4k8ldDFPOhG2VNeXtD5nnKG6EPY6OfW5wBG8g18NOFNdxpYXKEG4m9a89kCnclG9jGIjV2D_1yGzTaydkW8mVgG84_sI5bv3pNYWSFgmdsYXllcmVkZTAuMy4wgmtyZWNvdmVyYWJsZWUwLjEuMIJoc2VhdGJlbHRlMC4yLjCCZHRpY2tlMC4xLjKCbXRvd2VyX3NlcnZpY2VlMC4zLjM
  [__link0]: https://crates.io/crates/layered/0.3.0
  [__link1]: https://docs.rs/layered/0.3.0/layered/?search=Stack
  [__link10]: https://docs.rs/seatbelt/0.2.0/seatbelt/breaker/index.html
  [__link11]: https://docs.rs/seatbelt/0.2.0/seatbelt/timeout/index.html
  [__link12]: https://docs.rs/seatbelt/0.2.0/seatbelt/retry/index.html
  [__link13]: https://docs.rs/seatbelt/0.2.0/seatbelt/breaker/index.html
+ [__link14]: https://docs.rs/tower_service/0.3.3/tower_service/?search=Service
  [__link2]: https://docs.rs/tick/0.1.2/tick/?search=Clock
  [__link3]: https://crates.io/crates/tick/0.1.2
  [__link4]: https://docs.rs/seatbelt/0.2.0/seatbelt/?search=ResilienceContext

crates/seatbelt/README.md

@@ -0,0 +1,55 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+//! This example demonstrates how to combine multiple resilience middlewares
+//! using the `seatbelt` crate with Tower's `ServiceBuilder` to create a robust
+//! execution pipeline compatible with the Tower ecosystem.
+
+use std::future::poll_fn;
+use std::time::Duration;
+
+use ohno::{app_err, bail};
+use seatbelt::retry::Retry;
+use seatbelt::timeout::Timeout;
+use seatbelt::{RecoveryInfo, ResilienceContext};
+use tick::Clock;
+use tower::ServiceBuilder;
+use tower_service::Service;
+
+#[tokio::main]
+async fn main() -> Result<(), ohno::AppError> {
+    // Shared context for resilience middleware
+    let context = ResilienceContext::new(Clock::new_tokio()).name("tower_pipeline");
+
+    // Build a Tower service with retry and timeout middlewares using ServiceBuilder.
+    // Layers are applied bottom-to-top: timeout wraps the inner service first,
+    // then retry wraps the timeout layer.
+    let mut service = ServiceBuilder::new()
+        .layer(
+            Retry::layer("my_retry", &context)
+                .clone_input()
+                .recovery_with(|output, _args| match output {
+                    Ok(_) => RecoveryInfo::never(),
+                    Err(_) => RecoveryInfo::retry(),
+                }),
+        )
+        .layer(
+            Timeout::layer("my_timeout", &context)
+                .timeout(Duration::from_secs(1))
+                .timeout_error(|_args| app_err!("timeout")),
+        )
+        .service_fn(|request| async move {
+            if fastrand::i16(0..10) > 4 {
+                bail!("random failure")
+            }
+            Ok(request)
+        });
+
+    // Execute the service using Tower's Service trait
+    poll_fn(|cx| service.poll_ready(cx)).await?;
+    let output = service.call("value".to_string()).await?;
+
+    println!("execution finished, output: {output}");
+
+    Ok(())
+}

crates/seatbelt/examples/tower.rs

@@ -291,6 +291,8 @@ pub(super) use callbacks::*;
 pub use layer::BreakerLayer;
 #[doc(inline)]
 pub use service::Breaker;
+#[cfg(feature = "tower-service")]
+pub use service::BreakerFuture;
 pub(crate) use service::BreakerShared;
 
 mod execution_result;