reliakit 0.1.5

Reliability building blocks for Rust: validated primitives, secrets, bounded collections, backoff, retry helpers, circuit breaker, rate limiting, concurrency limiting, timeouts, health reporting, and strict JSON/CSV. Zero-dependency, no_std-friendly, no unsafe. One name; enable only the building blocks you need via features.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

<p align="center">
  <img src="https://raw.githubusercontent.com/satyakwok/reliakit/main/assets/reliakit-logo.png" alt="Reliakit" width="400">
</p>

# reliakit

[![Crates.io](https://img.shields.io/crates/v/reliakit.svg)](https://crates.io/crates/reliakit)
[![Crates.io Downloads](https://img.shields.io/crates/d/reliakit.svg)](https://crates.io/crates/reliakit)
[![Docs.rs](https://docs.rs/reliakit/badge.svg)](https://docs.rs/reliakit)
[![CI](https://github.com/satyakwok/reliakit/actions/workflows/ci.yml/badge.svg)](https://github.com/satyakwok/reliakit/actions/workflows/ci.yml)
[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/satyakwok/reliakit/blob/main/LICENSE)

The umbrella crate for the **Reliakit** reliability toolkit: one name that
re-exports the individual `reliakit-*` building blocks behind feature flags.

This crate contains no logic of its own. It exists so you can depend on a single
name and turn on only the pieces you need. Nothing is pulled in by default beyond
the `std` flag — each module appears only when its feature is enabled, so the
zero-dependency, `no_std`-friendly nature of each building block is preserved.

## What This Crate Does

- Gives the toolkit **one import name** instead of a dozen.
- Re-exports each building block as a module: `reliakit::ratelimit`,
  `reliakit::secret`, `reliakit::circuit`, and so on.
- Forwards `std`/`alloc` to whichever sub-crates you enable, so `no_std` works
  through the umbrella exactly as it does for the individual crates.

## When To Use It

- You want several Reliakit building blocks and prefer one dependency line and
  one version to track.
- You are exploring the toolkit and want everything reachable under one name
  (`features = ["full"]`).

## When Not To Use It

- You need exactly one building block and want the tightest possible dependency
  graph — depend on that crate directly (e.g. `reliakit-ratelimit`). The umbrella
  adds no capability, only convenience.

## Installation

Enable only the building blocks you need:

```toml
[dependencies]
reliakit = { version = "0.1", features = ["ratelimit", "secret"] }
```

```rust
use reliakit::ratelimit::RateLimiter;
use reliakit::secret::Secret;
```

`no_std` with `alloc`:

```toml
[dependencies]
reliakit = { version = "0.1", default-features = false, features = ["alloc", "primitives"] }
```

Everything at once:

```toml
[dependencies]
reliakit = { version = "0.1", features = ["full"] }
```

## Examples

The building blocks are designed to compose, all reached through the one
`reliakit` name.

**A resilient client** — guard one call to a flaky dependency with an overall
deadline, rate limiting, a circuit breaker, and backoff, driven by a single clock:

```sh
cargo run -p reliakit --example resilient_client \
  --features "timeout ratelimit circuit backoff"
```

See [`examples/resilient_client.rs`](./examples/resilient_client.rs).

**A config check** — validate a service config from raw, untrusted strings,
reporting every problem at once with the credential kept out of logs:

```sh
cargo run -p reliakit --example config_check \
  --features "primitives validate secret"
```

See [`examples/config_check.rs`](./examples/config_check.rs).

**Typed JSON** — parse untrusted JSON strictly, then lift the raw fields into
validated primitive types:

```sh
cargo run -p reliakit --example typed_json --features "json primitives"
```

See [`examples/typed_json.rs`](./examples/typed_json.rs).

## Building Blocks

| Feature | Module | Crate |
|---|---|---|
| `core` | `reliakit::core` | [`reliakit-core`](https://crates.io/crates/reliakit-core) — `Clock` trait + clocks |
| `primitives` | `reliakit::primitives` | [`reliakit-primitives`](https://crates.io/crates/reliakit-primitives) — validated primitive types |
| `secret` | `reliakit::secret` | [`reliakit-secret`](https://crates.io/crates/reliakit-secret) — secret redaction wrappers |
| `validate` | `reliakit::validate` | [`reliakit-validate`](https://crates.io/crates/reliakit-validate) — validation traits + error aggregation |
| `collections` | `reliakit::collections` | [`reliakit-collections`](https://crates.io/crates/reliakit-collections) — bounded collections |
| `codec` | `reliakit::codec` | [`reliakit-codec`](https://crates.io/crates/reliakit-codec) — canonical binary encoding |
| `csv` | `reliakit::csv` | [`reliakit-csv`](https://crates.io/crates/reliakit-csv) — strict, bounded CSV |
| `backoff` | `reliakit::backoff` | [`reliakit-backoff`](https://crates.io/crates/reliakit-backoff) — retry backoff policies |
| `retry` | `reliakit::retry` | [`reliakit-retry`](https://crates.io/crates/reliakit-retry) — runtime-agnostic retry helpers |
| `circuit` | `reliakit::circuit` | [`reliakit-circuit`](https://crates.io/crates/reliakit-circuit) — circuit breaker |
| `ratelimit` | `reliakit::ratelimit` | [`reliakit-ratelimit`](https://crates.io/crates/reliakit-ratelimit) — token-bucket rate limiter |
| `timeout` | `reliakit::timeout` | [`reliakit-timeout`](https://crates.io/crates/reliakit-timeout) — deadlines and timeouts |
| `json` | `reliakit::json` | [`reliakit-json`](https://crates.io/crates/reliakit-json) — strict, bounded JSON |
| `derive` | `reliakit::derive` | [`reliakit-derive`](https://crates.io/crates/reliakit-derive) — derive macros |
| `decide` | `reliakit::decide` | [`reliakit-decide`](https://crates.io/crates/reliakit-decide) — utility decision engine |

## Feature Flags

| Feature | Default | Effect |
|---|---|---|
| `std` | yes | Implies `alloc`; forwards `std` to enabled crates. |
| `alloc` | via `std` | Forwards `alloc` to enabled crates that need owned storage. |
| `core` | no | Adds `reliakit::core` and enables the clock-aware `*_now` methods of any enabled resilience crate. |
| `<crate>` | no | Adds that crate's module (see table above). |
| `full` | no | Enables every building block. |
| `json-canonical` | no | Enables `reliakit-json`'s RFC 8785 canonical serialization. |
| `json-primitives` | no | Typed JSON extraction into `reliakit-primitives`. |
| `json-validate` | no | Accumulating JSON field validation into `reliakit-validate`. |
| `codec-primitives` | no | Canonical codec impls for `reliakit-primitives` types. |

## `no_std`

`no_std`-compatible (`default-features = false`). Enable the umbrella's `alloc`
feature for the modules whose owned storage is gated behind it — `primitives`,
`secret`, `validate`, `collections`, and `codec`. `json` and `decide` always
include `alloc` on their own, so they need no extra feature. The pure-`core`
blocks (`backoff`, `circuit`, `ratelimit`, `timeout`) need neither `std` nor
`alloc`.

## Safety

`#![forbid(unsafe_code)]`. The umbrella adds no code beyond re-exports; each
building block forbids unsafe code in its own right.

## Minimum Supported Rust Version

Rust `1.85` and newer. No nightly features are used.

## Status

Pre-1.0. A thin re-export layer over the `reliakit-*` building blocks; its public
surface is the set of feature flags, which may gain backward-compatible additions
before a 1.0 release.

## License

Licensed under the MIT License. See [`LICENSE`](https://github.com/satyakwok/reliakit/blob/main/LICENSE).