pyfect-dev 0.1.0__py3-none-any.whl

pyfect/persistence/__init__.py

@@ -0,0 +1,77 @@
+"""Persistence (Effect's ``effect/persistence``): key-value stores,
+requests whose outcomes are stored, and caches over them.
+
+- ``key_value_store``: ``KeyValueStore``, a string-keyed store of text and
+  bytes in memory, files, SQL or any text mapping, and schema-typed stores.
+- ``persistable``: ``Persistable`` requests, which carry the schemas of
+  their success and error and a ``primary_key()``.
+- ``persistence``: ``Persistence``, request outcomes stored by those
+  schemas in memory, a ``KeyValueStore`` or SQL.
+- ``persisted_cache``: ``PersistedCache``, a ``Cache`` in front of a store.
+- ``persisted_queue``: ``PersistedQueue``, durable at-least-once queues in
+  memory, SQL or Redis.
+- ``user_directories``: ``UserDirectories``, where a program keeps its
+  files per user.
+- ``rate_limiter``: ``RateLimiter``, limits per key by fixed window or
+  token bucket, and adaptive limits learned from ``429`` responses.
+- ``circuit_breaker``: ``CircuitBreaker``, stops calling a key that keeps
+  failing.
+- ``redis``: the ``Redis`` service the Redis stores run on, made over a
+  client by ``redis.make``; ``redis_py`` (extra ``pyfect-dev[redis]``, imported
+  on its own) provides it on redis-py.
+
+``RequestResolver.persisted`` stores a resolver's outcomes.
+"""
+
+from pyfect._public import publish
+from pyfect.persistence import (
+    circuit_breaker,
+    key_value_store,
+    persistable,
+    persisted_cache,
+    persisted_queue,
+    persistence,
+    rate_limiter,
+    redis,
+    user_directories,
+)
+from pyfect.persistence._error import PersistenceError
+from pyfect.persistence.circuit_breaker import CircuitBreaker, CircuitBreakerError
+from pyfect.persistence.key_value_store import KeyValueStore, KeyValueStoreError
+from pyfect.persistence.persistable import Persistable
+from pyfect.persistence.persisted_cache import PersistedCache
+from pyfect.persistence.persisted_queue import PersistedQueue, PersistedQueueError
+from pyfect.persistence.persistence import BackingPersistence, Persistence
+from pyfect.persistence.rate_limiter import RateLimiter, RateLimiterError
+from pyfect.persistence.redis import Redis, RedisError
+from pyfect.persistence.user_directories import UserDirectories
+
+__all__ = [
+    "BackingPersistence",
+    "CircuitBreaker",
+    "CircuitBreakerError",
+    "KeyValueStore",
+    "KeyValueStoreError",
+    "Persistable",
+    "PersistedCache",
+    "PersistedQueue",
+    "PersistedQueueError",
+    "Persistence",
+    "PersistenceError",
+    "RateLimiter",
+    "RateLimiterError",
+    "Redis",
+    "RedisError",
+    "UserDirectories",
+    "circuit_breaker",
+    "key_value_store",
+    "persistable",
+    "persisted_cache",
+    "persisted_queue",
+    "persistence",
+    "rate_limiter",
+    "redis",
+    "user_directories",
+]
+
+publish(globals())

pyfect/persistence/_columns.py

@@ -0,0 +1,32 @@
+"""Reading the columns the SQL stores select: drivers type a row's values
+as ``object``."""
+
+from __future__ import annotations
+
+from typing import cast
+
+
+def column_int(value: object) -> int:
+    """A count or a small integer column (some drivers give ``Decimal`` or
+    text for ``COUNT(*)``)."""
+    return value if isinstance(value, int) else int(str(value))
+
+
+def column_bytes(value: object) -> bytes:
+    """A ``BLOB`` / ``BYTEA`` column."""
+    match value:
+        case bytes():
+            return value
+        case bytearray() | memoryview():
+            return bytes(cast("bytearray", value))
+        case _:
+            raise TypeError(f"expected a binary column value, got {type(value).__name__}")
+
+
+def column_text(value: object) -> str:
+    """A text column, or a ``VARBINARY`` one holding UTF-8 (a MySQL key)."""
+    match value:
+        case bytes() | bytearray() | memoryview():
+            return bytes(cast("bytes", value)).decode()
+        case _:
+            return str(value)

pyfect/persistence/_error.py

@@ -0,0 +1,14 @@
+"""``PersistenceError``: a persistence store failed."""
+
+from __future__ import annotations
+
+from pyfect import schema as S
+
+
+class PersistenceError(S.TaggedError, identifier="effect/persistence/Persistence/PersistenceError"):
+    """A persistence store could not read or write; ``cause`` is what its
+    backend raised. A schema class, so a persisted request may fail with
+    it and have the failure stored."""
+
+    message: str
+    cause: object = S.field(S.Union(S.Null, S.Defect()), default=None)

pyfect/persistence/_seconds.py

@@ -0,0 +1,68 @@
+"""Effect's millisecond ``Duration`` arithmetic, in whole nanoseconds as
+Effect's is, and ``SECONDS_FROM_MILLIS``: a duration in ``Seconds``
+written as milliseconds (Effect's ``Schema.DurationFromMillis``)."""
+
+from __future__ import annotations
+
+import math
+from typing import TypeIs
+
+from pyfect import _js as js
+from pyfect import schema as S
+from pyfect.duration import Seconds, to_millis
+from pyfect.schema import transformation as T
+
+
+def _is_seconds(value: object) -> TypeIs[Seconds]:
+    return isinstance(value, Seconds)
+
+
+def _round_away(value: float) -> int:
+    return int(math.copysign(js.round(abs(value)), value))
+
+
+def whole_nanos(millis: float) -> float:
+    """``millis`` rounded to whole nanoseconds, ties away from zero, as
+    Effect's ``Duration`` keeps a fractional millisecond count."""
+    if not math.isfinite(millis) or float(millis).is_integer():
+        return millis
+    return _round_away(millis * 1_000_000) / 1_000_000
+
+
+def millis(value: float) -> Seconds:
+    """``Seconds`` of ``value`` milliseconds in whole nanoseconds (Effect's
+    ``Duration.millis``); NaN is zero."""
+    if not math.isfinite(value) or float(value).is_integer():
+        return Seconds(value / 1000)
+    return Seconds(_round_away(value * 1_000_000) / 1_000_000_000)
+
+
+def divide_millis(millis: float, by: float) -> float:
+    """``millis`` divided by ``by`` in whole nanoseconds, as Effect's
+    ``Duration.divideUnsafe``: a non-finite ``by`` gives zero, a zero one
+    an infinity. A duration of a fractional millisecond count is held in
+    nanoseconds there, divided as an integer (truncated); Effect gives zero
+    when ``by`` is not an integer too, which would turn a limit off, so
+    that case rounds instead."""
+    if not math.isfinite(by):
+        return 0.0
+    if math.isinf(millis):
+        return 0.0 if by == 0 else millis * math.copysign(1.0, by)
+    if float(millis).is_integer():
+        quotient = js.divide(millis, by)
+        return 0.0 if math.isnan(quotient) else whole_nanos(quotient)
+    nanos = _round_away(millis * 1_000_000)
+    if by == 0:
+        return math.copysign(math.inf, nanos) * math.copysign(1.0, by)
+    if not float(by).is_integer():
+        return _round_away(nanos / by) / 1_000_000
+    quotient = abs(nanos) // abs(int(by))
+    return quotient * (1 if (nanos < 0) == (by < 0) else -1) / 1_000_000
+
+
+SECONDS_FROM_MILLIS = S.Finite.pipe(
+    S.decode_to(
+        S.declare(_is_seconds, expected="Seconds"),
+        T.transform(decode=millis, encode=to_millis),
+    )
+)

pyfect/persistence/_sql_keys.py

@@ -0,0 +1,47 @@
+"""The string keys of the SQL stores on MySQL and SQL Server, compared
+exactly.
+
+Both servers compare strings under the column's collation. Their usual
+defaults (``utf8mb4_0900_ai_ci``, ``*_CI_AS``) ignore case (and on MySQL
+accents), and every SQL Server collation, like MySQL's ``PAD SPACE`` ones
+(``utf8mb4_bin`` among them), ignores trailing spaces in ``=``: ``K:Alice``,
+``K:alice`` and ``K:alice `` would be one key. On MySQL a key is
+``VARBINARY``, whose bytes all count. On SQL Server it is a ``BIN2``
+``NVARCHAR`` compared with ``key_equals`` / ``mssql_match``, which also
+compare lengths; a write whose key differs from a stored one only in
+trailing spaces then fails on the primary key instead of replacing it.
+"""
+
+from __future__ import annotations
+
+from typing import Final, LiteralString
+
+from pyfect.sql.client import SqlClientService
+from pyfect.sql.statement import Fragment
+
+MYSQL_KEY: Final = "VARBINARY(764)"
+"""191 four-byte characters, as the ``VARCHAR(191)`` it replaces."""
+MSSQL_KEY: Final = "NVARCHAR(450) COLLATE Latin1_General_100_BIN2"
+MSSQL_PAIR_KEY: Final = "NVARCHAR(191) COLLATE Latin1_General_100_BIN2"
+"""Each half of a two-column key (the index key stays under 900 bytes)."""
+
+
+def _same_length(column: LiteralString, value: LiteralString) -> LiteralString:
+    return f"DATALENGTH({column}) = DATALENGTH(CAST({value} AS NVARCHAR(4000)))"
+
+
+def key_equals(sql: SqlClientService, column: str, key: str) -> Fragment:
+    """``column = key``, counting every character on every dialect."""
+    name = sql.identifier(column)
+    return sql.on_dialect_or_else(
+        mssql=lambda: sql(f"({{}} = {{}} AND {_same_length('{}', '{}')})", name, key, name, key),
+        or_else=lambda: sql("{} = {}", name, key),
+    )
+
+
+def mssql_match(column: LiteralString) -> LiteralString:
+    """The ``MERGE ... ON`` condition matching ``target.column`` to
+    ``source.column`` exactly."""
+    target = f"target.{column}"
+    source = f"source.{column}"
+    return f"{target} = {source} AND {_same_length(target, source)}"

pyfect/persistence/circuit_breaker/__init__.py

@@ -0,0 +1,120 @@
+"""Circuit breakers per key (Effect's ``effect/persistence/CircuitBreaker``)::
+
+    breaker = yield from circuit_breaker.make(
+        trip_policy=circuit_breaker.consecutive(5), open_duration=30
+    )
+    yield from call_api.pipe(breaker.execute(key="api"))
+
+A key's circuit is ``Closed`` (calls run and are counted), ``Open`` (calls
+fail with ``CircuitOpen`` for the open time) or ``HalfOpen`` (one probe
+runs; its success closes the circuit, its failure reopens it). The trip
+policy is ``consecutive`` failures or a failure ``rate``; ``classify``
+decides how a call counts (``success``, ``ignored``, ``failure()``).
+
+States live in a ``CircuitBreakerStore``: ``layer_store_memory``, or
+``layer_store_redis`` (shared by every process using that Redis).
+"""
+
+from pyfect._public import publish
+from pyfect.persistence.circuit_breaker._breaker import (
+    CircuitBreaker,
+    CircuitBreakerService,
+    Classify,
+    Executor,
+    OnStoreError,
+    OpenDuration,
+    layer,
+    make,
+)
+from pyfect.persistence.circuit_breaker._errors import (
+    CIRCUIT_BREAKER_ERROR_REASON,
+    CircuitBreakerError,
+    CircuitBreakerErrorReason,
+    CircuitBreakerStoreError,
+    CircuitHalfOpen,
+    CircuitOpen,
+)
+from pyfect.persistence.circuit_breaker._memory import layer_store_memory, make_store_memory
+from pyfect.persistence.circuit_breaker._redis import (
+    layer_store_redis,
+    layer_store_redis_config,
+    make_store_redis,
+)
+from pyfect.persistence.circuit_breaker._store import (
+    CircuitBreakerStore,
+    CircuitBreakerStoreService,
+    Record,
+)
+from pyfect.persistence.circuit_breaker._types import (
+    Admission,
+    Closed,
+    CloseTransition,
+    Consecutive,
+    FailureOutcome,
+    HalfOpen,
+    HalfOpenTransition,
+    IgnoredOutcome,
+    Open,
+    OpenTransition,
+    Outcome,
+    OutcomeKind,
+    Rate,
+    State,
+    SuccessOutcome,
+    Transition,
+    TripPolicy,
+    consecutive,
+    failure,
+    ignored,
+    rate,
+    success,
+)
+
+__all__ = [
+    "CIRCUIT_BREAKER_ERROR_REASON",
+    "Admission",
+    "CircuitBreaker",
+    "CircuitBreakerError",
+    "CircuitBreakerErrorReason",
+    "CircuitBreakerService",
+    "CircuitBreakerStore",
+    "CircuitBreakerStoreError",
+    "CircuitBreakerStoreService",
+    "CircuitHalfOpen",
+    "CircuitOpen",
+    "Classify",
+    "CloseTransition",
+    "Closed",
+    "Consecutive",
+    "Executor",
+    "FailureOutcome",
+    "HalfOpen",
+    "HalfOpenTransition",
+    "IgnoredOutcome",
+    "OnStoreError",
+    "Open",
+    "OpenDuration",
+    "OpenTransition",
+    "Outcome",
+    "OutcomeKind",
+    "Rate",
+    "Record",
+    "State",
+    "SuccessOutcome",
+    "Transition",
+    "TripPolicy",
+    "consecutive",
+    "failure",
+    "ignored",
+    "layer",
+    "layer_store_memory",
+    "layer_store_redis",
+    "layer_store_redis_config",
+    "make",
+    "make_store_memory",
+    "make_store_redis",
+    "rate",
+    "success",
+]
+
+publish(globals())

pyfect/persistence/circuit_breaker/_breaker.py

@@ -0,0 +1,317 @@
+"""``CircuitBreaker``: stops calling a key that keeps failing."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Generator
+from typing import Any, Literal, Never, overload
+
+from pyfect._core import Effect
+from pyfect._effect_args import require_effect
+from pyfect._primitives import Restore, uninterruptible_mask
+from pyfect.cause import Cause, Fail
+from pyfect.clock import ClockService, clock_with
+from pyfect.context import Tag
+from pyfect.duration import ZERO, Duration, Seconds, to_seconds
+from pyfect.effect import fail_cause, gen, provide_service, succeed, suspend, void
+from pyfect.exit import Exit, Failure, Success
+from pyfect.exit import succeed as exit_succeed
+from pyfect.layer import Layer
+from pyfect.layer import effect as layer_effect
+from pyfect.logger._log import log_unhandled
+from pyfect.persistence.circuit_breaker._errors import (
+    CircuitBreakerError,
+    CircuitBreakerStoreError,
+)
+from pyfect.persistence.circuit_breaker._store import (
+    CircuitBreakerStore,
+    CircuitBreakerStoreService,
+)
+from pyfect.persistence.circuit_breaker._types import (
+    Admission,
+    Consecutive,
+    FailureOutcome,
+    Outcome,
+    State,
+    SuccessOutcome,
+    Transition,
+    TripPolicy,
+    failure,
+    ignored,
+    success,
+)
+from pyfect.pubsub import PubSub
+from pyfect.result import Ok
+from pyfect.schedule import Schedule, Stop, to_step
+from pyfect.scope import CloseableScope, Scope, add_finalizer, scoped_with
+from pyfect.stream import Stream, from_pubsub_take
+from pyfect.take import Take
+
+type OnStoreError = Literal["allow", "fail"]
+"""When the store cannot admit a call: ``"allow"`` runs it unrecorded
+(reporting the cause at the ``UnhandledLogLevel``), ``"fail"`` fails with
+the ``CircuitBreakerStoreError``."""
+
+type OpenDuration = Duration | Schedule[object, int]
+"""How long an opening lasts: a duration, or a schedule replayed with the
+number of consecutive openings (its delays measured from the opening)."""
+
+type Classify[A, E, R = Never] = Callable[[Exit[A, E]], Outcome | Effect[Outcome, Never, R]]
+"""How a call's exit counts; without it a success is a ``success`` and a
+failure a ``failure()``. An interrupt-only exit is always ``ignored``."""
+
+
+def recovering(message: str) -> Callable[[Cause[Any]], Effect[None]]:
+    """Reports a recoverable failure at the ``UnhandledLogLevel``; a cause
+    holding a defect keeps failing."""
+
+    def handle(cause: Cause[Any]) -> Effect[None]:
+        found = cause.find_recoverable_error()
+        return log_unhandled(message, cause) if isinstance(found, Fail) else fail_cause(found)
+
+    return handle
+
+
+def _open_duration(open_duration: OpenDuration) -> Callable[[int], Effect[Seconds]]:
+    if not isinstance(open_duration, Schedule):
+        fixed: Effect[Seconds] = succeed(to_seconds(open_duration))
+        return lambda _: fixed
+    schedule = open_duration
+
+    # Replays the schedule on a simulated clock, so ``up_to`` measures the
+    # time spent open rather than wall time.
+    def replay(openings: int) -> Effect[Seconds]:
+        def body(clock: ClockService) -> Generator[Effect[Any], Any, Seconds]:
+            step = yield from to_step(schedule)
+            now = clock.now_unsafe()
+            delay = ZERO
+            for attempt in range(1, openings + 1):
+                decision = yield from step(now, attempt)
+                if isinstance(decision, Stop):
+                    break
+                delay = decision.delay
+                now += delay
+            return delay
+
+        return clock_with(lambda clock: gen(lambda: body(clock)))
+
+    return replay
+
+
+def _classify[A, E, R](
+    exit: Exit[A, E], classify: Classify[A, E, R] | None, restore: Restore
+) -> Effect[Exit[Outcome, Never], Never, R]:
+    if isinstance(exit, Failure) and exit.cause.has_interrupts_only:
+        return succeed(exit_succeed(ignored))
+    if classify is None:
+        return succeed(exit_succeed(success if isinstance(exit, Success) else failure()))
+    run = classify
+
+    def call() -> Effect[Outcome, Never, R]:
+        outcome = run(exit)
+        return outcome if isinstance(outcome, Effect) else succeed(outcome)
+
+    return restore(suspend(call)).exit()
+
+
+class CircuitBreakerService:
+    """Runs calls per key through a circuit (see ``make``)."""
+
+    __slots__ = ("_max_open", "_on_store_error", "_open_duration", "_policy", "_pubsub", "_store")
+
+    def __init__(  # noqa: PLR0917
+        self,
+        store: CircuitBreakerStoreService,
+        pubsub: PubSub[Take[Transition]],
+        policy: TripPolicy,
+        open_duration: OpenDuration,
+        max_open_duration: Seconds,
+        on_store_error: OnStoreError,
+    ) -> None:
+        self._store = store
+        self._pubsub = pubsub
+        self._policy = policy
+        self._open_duration = _open_duration(open_duration)
+        self._max_open = max_open_duration
+        self._on_store_error = on_store_error
+
+    @property
+    def transitions(self) -> Stream[Transition]:
+        """Every transition from now on; it ends when the breaker's scope
+        closes. A slow reader loses the oldest past 128."""
+        return from_pubsub_take(self._pubsub)
+
+    def state(self, key: str) -> Effect[State, CircuitBreakerError]:
+        """``key``'s state now."""
+        return self._store.state(key)
+
+    @overload
+    def execute[R2 = Never](
+        self, effect: None = None, /, *, key: str, classify: Classify[Any, Any, R2] | None = None
+    ) -> Executor[R2]: ...
+    @overload
+    def execute[A, E, R, R2 = Never](
+        self,
+        effect: Effect[A, E, R],
+        /,
+        *,
+        key: str,
+        classify: Classify[A, E, R2] | None = None,
+    ) -> Effect[A, E | CircuitBreakerError, R | R2]: ...
+    def execute(
+        self,
+        effect: Effect[Any, Any, Any] | None = None,
+        /,
+        *,
+        key: str,
+        classify: Classify[Any, Any, Any] | None = None,
+    ) -> Executor[Any] | Effect[Any, Any, Any]:
+        """Run ``effect`` through ``key``'s circuit: rejected with
+        ``CircuitOpen`` while it is open and ``CircuitHalfOpen`` while its
+        probe runs, else run and counted by ``classify``. Without
+        ``effect``, the function doing that for ``.pipe``."""
+        if effect is None:
+            return Executor(self, key, classify)
+        require_effect(effect, "effect")
+        return self._run(effect, key, classify)
+
+    def _publish(self, transition: Transition | None) -> Effect[None]:
+        return void if transition is None else self._pubsub.publish((transition,)).as_void()
+
+    def _open_for(self, outcome: Outcome, admission: Admission) -> Effect[Seconds]:
+        # Only an outcome that can open the circuit needs the open time.
+        if not isinstance(outcome, FailureOutcome) and (
+            not isinstance(outcome, SuccessOutcome)
+            or admission.probe
+            or isinstance(self._policy, Consecutive)
+        ):
+            return succeed(ZERO)
+        hint = outcome.retry_after if isinstance(outcome, FailureOutcome) else None
+        max_open = self._max_open
+
+        def hinted(delay: Seconds) -> Seconds:
+            return delay if hint is None else max(delay, min(hint, max_open))
+
+        return self._open_duration(admission.consecutive_openings + 1).map(hinted)
+
+    def _run[A, E, R, R2](
+        self, effect: Effect[A, E, R], key: str, classify: Classify[A, E, R2] | None
+    ) -> Effect[A, E | CircuitBreakerError, R | R2]:
+        store = self._store
+
+        def admitted(
+            restore: Restore, scope: CloseableScope
+        ) -> Generator[Effect[Any, Any, Any], Any, A]:
+            admit = yield from store.admit(key).pipe(provide_service(Scope, scope)).exit()
+            if isinstance(admit, Failure):
+                error = admit.cause.find_error()
+                if (
+                    self._on_store_error == "fail"
+                    or not isinstance(error, Ok)
+                    or not isinstance(error.value.reason, CircuitBreakerStoreError)
+                ):
+                    return (yield from fail_cause(admit.cause))
+                yield from log_unhandled(
+                    "CircuitBreaker store unavailable, running the call unrecorded", admit.cause
+                )
+                return (yield from restore(effect))
+            admission = admit.value
+            yield from self._publish(admission.transition)
+            exit = yield from restore(effect).exit()
+            classified = yield from _classify(exit, classify, restore)
+            outcome = classified.value if isinstance(classified, Success) else ignored
+            open_for = yield from self._open_for(outcome, admission)
+            yield from (
+                store.record(
+                    key=key,
+                    generation=admission.generation,
+                    outcome=outcome.kind,
+                    trip_policy=self._policy,
+                    open_for=open_for,
+                )
+                .flat_map(self._publish)
+                .catch_cause(recovering("CircuitBreaker failed to record an outcome"))
+            )
+            if isinstance(classified, Success):
+                if isinstance(exit, Success):
+                    return exit.value
+                return (yield from fail_cause(exit.cause))
+            cause: Cause[Any] = (
+                exit.cause + classified.cause if isinstance(exit, Failure) else classified.cause
+            )
+            return (yield from fail_cause(cause))
+
+        return uninterruptible_mask(
+            lambda restore: scoped_with(lambda scope: gen(lambda: admitted(restore, scope)))
+        )
+
+
+class Executor[R2 = Never]:
+    """``breaker.execute(key=...)``: runs an effect through the circuit."""
+
+    __slots__ = ("_breaker", "_classify", "_key")
+
+    def __init__(
+        self,
+        breaker: CircuitBreakerService,
+        key: str,
+        classify: Classify[Any, Any, R2] | None,
+    ) -> None:
+        self._breaker = breaker
+        self._key = key
+        self._classify = classify
+
+    def __call__[A, E, R](
+        self, effect: Effect[A, E, R]
+    ) -> Effect[A, E | CircuitBreakerError, R | R2]:
+        require_effect(effect, "effect")
+        return self._breaker.execute(effect, key=self._key, classify=self._classify)
+
+
+class CircuitBreaker(Tag[CircuitBreakerService], key="~effect/persistence/CircuitBreaker"):
+    """Stops calling a key that keeps failing."""
+
+
+def make(
+    *,
+    trip_policy: TripPolicy,
+    open_duration: OpenDuration,
+    max_open_duration: Duration = 3600,
+    on_store_error: OnStoreError = "allow",
+) -> Effect[CircuitBreakerService, Never, CircuitBreakerStore | Scope]:
+    """A breaker on the ``CircuitBreakerStore``. A closed key opens when
+    ``trip_policy`` says; an opening lasts ``open_duration`` (a schedule
+    gives longer ones as openings repeat), or a failure's ``retry_after``
+    up to ``max_open_duration`` (default an hour). After it, one probe
+    runs: its success closes the key, its failure reopens it. A key closed
+    as long as its last opening starts counting openings afresh.
+    ``transitions`` ends when the scope closes."""
+    max_open = to_seconds(max_open_duration)
+
+    def build() -> Generator[Effect[Any, Never, Any], Any, CircuitBreakerService]:
+        store = yield from CircuitBreakerStore()
+        pubsub: PubSub[Take[Transition]] = yield from PubSub[Take[Transition]].sliding(128)
+        yield from add_finalizer(lambda _: pubsub.end(exit_succeed(None)))
+        return CircuitBreakerService(
+            store, pubsub, trip_policy, open_duration, max_open, on_store_error
+        )
+
+    return gen(build)
+
+
+def layer(
+    *,
+    trip_policy: TripPolicy,
+    open_duration: OpenDuration,
+    max_open_duration: Duration = 3600,
+    on_store_error: OnStoreError = "allow",
+) -> Layer[CircuitBreaker, Never, CircuitBreakerStore]:
+    """Provides ``CircuitBreaker`` (see ``make``)."""
+    return layer_effect(
+        CircuitBreaker,
+        make(
+            trip_policy=trip_policy,
+            open_duration=open_duration,
+            max_open_duration=max_open_duration,
+            on_store_error=on_store_error,
+        ),
+    )