CircuitBreaker

import { Effect, Schedule } from "effect"
import { CircuitBreaker } from "effect/persistence"

// Openings last 1, 2, 4, 8, 16 and 32 seconds. By then 63 seconds have been
// spent open, past the one-minute cap, so later openings stay at 32 seconds.
const program = Effect.gen(function*() {
  const breaker = yield* CircuitBreaker.make({
    tripPolicy: CircuitBreaker.consecutive(5),
    openDuration: Schedule.exponential("1 second").pipe(
      Schedule.upTo({ duration: "1 minute" })
    )
  })
  return yield* Effect.succeed("ok").pipe(breaker.execute({ key: "payments" }))
}).pipe(Effect.scoped, Effect.provide(CircuitBreaker.layerStoreMemory()))

await Effect.runPromise(program) // => "ok"

import { Effect } from "effect"
import { CircuitBreaker } from "effect/persistence"

const program = Effect.gen(function*() {
  const breaker = yield* CircuitBreaker.make({
    tripPolicy: CircuitBreaker.consecutive(1),
    openDuration: "1 minute"
  })

  yield* Effect.never.pipe(
    Effect.timeout("10 millis"),
    breaker.execute({ key: "inside" }),
    Effect.ignore
  )
  yield* Effect.never.pipe(
    breaker.execute({ key: "outside" }),
    Effect.timeout("10 millis"),
    Effect.ignore
  )

  const inside = yield* breaker.state("inside")
  const outside = yield* breaker.state("outside")
  return [inside._tag, outside._tag]
}).pipe(Effect.scoped, Effect.provide(CircuitBreaker.layerStoreMemory()))

await Effect.runPromise(program) // => ["Open", "Closed"]

import { Data, Effect, Ref, Schedule } from "effect"
import { CircuitBreaker } from "effect/persistence"

class InventoryError extends Data.TaggedError("InventoryError") {}

const program = Effect.gen(function*() {
  const breaker = yield* CircuitBreaker.make({
    tripPolicy: CircuitBreaker.consecutive(1),
    openDuration: "1 minute"
  })
  const attempts = yield* Ref.make(0)
  // Fails twice, then succeeds.
  const stock = Effect.flatMap(
    Ref.updateAndGet(attempts, (n) => n + 1),
    (n) => n <= 2 ? Effect.fail(new InventoryError()) : Effect.succeed(7)
  )

  const result = yield* stock.pipe(
    Effect.retry({ schedule: Schedule.exponential("1 millis"), times: 3 }),
    breaker.execute({ key: "inventory" })
  )
  const state = yield* breaker.state("inventory")
  return [result, state._tag]
}).pipe(Effect.scoped, Effect.provide(CircuitBreaker.layerStoreMemory()))

await Effect.runPromise(program) // => [7, "Closed"]

import { Context, Data, Effect, ExecutionPlan, Layer } from "effect"
import { CircuitBreaker } from "effect/persistence"

class GeocoderError extends Data.TaggedError("GeocoderError") {}

class Geocoder extends Context.Service<Geocoder, {
  readonly lookup: (address: string) => Effect.Effect<string, GeocoderError | CircuitBreaker.CircuitBreakerError>
}>()("app/Geocoder") {}

const provider = (name: string, lookup: (address: string) => Effect.Effect<string, GeocoderError>) =>
  Layer.effect(
    Geocoder,
    Effect.gen(function*() {
      const breaker = yield* CircuitBreaker.CircuitBreaker
      return Geocoder.of({
        lookup: (address) => lookup(address).pipe(breaker.execute({ key: `geocoder:${name}` }))
      })
    })
  )

const Primary = provider("primary", () => Effect.fail(new GeocoderError()))
const Fallback = provider("fallback", (address) => Effect.succeed(`${address} (fallback)`))

const plan = ExecutionPlan.make({ provide: Primary }, { provide: Fallback })

const program = Effect.gen(function*() {
  const geocoder = yield* Geocoder
  return yield* geocoder.lookup("1 Main St")
}).pipe(
  Effect.withExecutionPlan(plan),
  Effect.provide(
    CircuitBreaker.layer({ tripPolicy: CircuitBreaker.consecutive(3), openDuration: "30 seconds" }).pipe(
      Layer.provide(CircuitBreaker.layerStoreMemory())
    )
  )
)

await Effect.runPromise(program) // => "1 Main St (fallback)"

import { Effect, Metric, Stream } from "effect"
import { CircuitBreaker } from "effect/persistence"

const transitionsTotal = Metric.counter("circuit_breaker_transitions_total", { incremental: true })

const countTransitions = (breaker: CircuitBreaker.CircuitBreaker) =>
  breaker.transitions.pipe(
    Stream.runForEach((transition) =>
      Metric.update(Metric.withAttributes(transitionsTotal, { from: transition.from, to: transition.to }), 1)
    ),
    Effect.forkScoped({ startImmediately: true })
  )

const program = Effect.gen(function*() {
  const breaker = yield* CircuitBreaker.make({
    tripPolicy: CircuitBreaker.consecutive(1),
    openDuration: "1 minute"
  })
  yield* countTransitions(breaker)

  yield* Effect.fail("unavailable").pipe(breaker.execute({ key: "a" }), Effect.ignore)
  yield* Effect.fail("unavailable").pipe(breaker.execute({ key: "b" }), Effect.ignore)
  yield* Effect.yieldNow

  const opened = yield* Metric.value(Metric.withAttributes(transitionsTotal, { from: "Closed", to: "Open" }))
  return opened.count
}).pipe(
  Effect.scoped,
  Effect.provide(CircuitBreaker.layerStoreMemory()),
  Effect.provideService(Metric.MetricRegistry, new Map())
)

await Effect.runPromise(program) // => 2

import { Effect, LayerMap, Schedule } from "effect"
import { CircuitBreaker } from "effect/persistence"

class Breakers extends LayerMap.Service<Breakers>()("app/Breakers", {
  lookup: (dependency: "payments" | "search") =>
    dependency === "payments"
      ? CircuitBreaker.layer({ tripPolicy: CircuitBreaker.consecutive(5), openDuration: "30 seconds" })
      : CircuitBreaker.layer({
        tripPolicy: CircuitBreaker.rate({ threshold: 0.5, size: 20 }),
        openDuration: Schedule.exponential("1 second")
      }),
  // One store shared by every entry.
  dependencies: [CircuitBreaker.layerStoreMemory()],
  idleTimeToLive: "10 minutes"
}) {}

const search = Effect.gen(function*() {
  const breaker = yield* CircuitBreaker.CircuitBreaker
  return yield* Effect.succeed(["result"]).pipe(breaker.execute({ key: "search:eu" }))
}).pipe(Effect.provide(Breakers.get("search")))

await Effect.runPromise(search.pipe(Effect.provide(Breakers.layer))) // => ["result"]