🥮 mooncakes.io

    moonlimit

    Composable rate limiting algorithms for MoonBit applications

    rate-limit
    token-bucket
    gcra
    moonbit
    throttling
    Download zip
    Version
    0.1.1
    License
    Apache-2.0
    Repository
    Last updated
    2 months ago
    Downloads
    39

    #MoonLimit

    Composable rate limiting algorithms for MoonBit applications.

    MoonLimit currently includes token bucket, leaky bucket, fixed window, sliding window, sliding log, GCRA, warmup token bucket, quota window, concurrency, keyed variants, policy engines, simulation helpers, and cookbook recipes.

    let limiter = @moonlimit.TokenBucket::new(2, 1, 1000)
    let decision = limiter.allow_at(0)
    inspect(decision.is_allowed(), content="true")

    AdmissionMode

    source
    pub(all) enum AdmissionMode {
      AllOf
      AnyOf
    } derive(Eq, 
    Debug    )

    AlgorithmDoc

    source
    pub(all) struct AlgorithmDoc {
      doc_name : String
      summary : String
      strengths : String
      tradeoffs : String
    } derive(Eq, 
    Debug    )

    AlgorithmDoc::line

    source
    fn AlgorithmDoc::line(self : AlgorithmDoc) -> String

    AlgorithmDoc::markdown

    source
    fn AlgorithmDoc::markdown(self : AlgorithmDoc) -> String

    AlgorithmDoc::name

    source
    fn AlgorithmDoc::name(self : AlgorithmDoc) -> String

    AllowInfo

    source
    pub(all) struct AllowInfo {
      remaining : Int
      reset_after_ms : Int
    } derive(Eq, 
    Debug    )

    Successful admission details returned by a limiter.

    BatchDecision

    source
    pub(all) struct BatchDecision {
      decisions : Array[Decision]
    } derive(
    Debug    )

    BatchDecision::all_allowed

    source
    fn BatchDecision::all_allowed(self : BatchDecision) -> Bool

    BatchDecision::allowed

    source
    fn BatchDecision::allowed(self : BatchDecision) -> Int

    BatchDecision::len

    source
    fn BatchDecision::len(self : BatchDecision) -> Int

    BatchDecision::max_retry_after_ms

    source
    fn BatchDecision::max_retry_after_ms(self : BatchDecision) -> Int

    BatchDecision::new

    source

    BatchDecision::push

    source
    fn BatchDecision::push(self : BatchDecision, decision : Decision) -> Unit

    BatchDecision::rejected

    source
    fn BatchDecision::rejected(self : BatchDecision) -> Int

    BatchTokenBucket

    source
    pub(all) struct BatchTokenBucket {
      bucket : TokenBucket
    } derive(
    Debug    )

    BatchTokenBucket::allow_many

    source
    fn BatchTokenBucket::allow_many(self : BatchTokenBucket, times : Array[Int]) -> BatchDecision

    BatchTokenBucket::new

    source
    fn BatchTokenBucket::new(capacity : Int, refill_tokens : Int, refill_period_ms : Int) -> BatchTokenBucket

    CompositeLimiter

    source
    pub(all) struct CompositeLimiter {
      token_buckets : Array[TokenBucket]
      fixed_windows : Array[FixedWindow]
    } derive(
    Debug    )

    CompositeLimiter::add_fixed_window

    source
    fn CompositeLimiter::add_fixed_window(self : CompositeLimiter, limit : Int, window_ms : Int) -> Unit

    CompositeLimiter::add_token_bucket

    source
    fn CompositeLimiter::add_token_bucket(self : CompositeLimiter, capacity : Int, refill_tokens : Int, refill_period_ms : Int) -> Unit

    CompositeLimiter::all

    source

    CompositeLimiter::allow_at

    source
    fn CompositeLimiter::allow_at(self : CompositeLimiter, now_ms : Int) -> Decision

    ConcurrencyLimiter

    source
    pub(all) struct ConcurrencyLimiter {
      capacity : Int
      in_flight : Int
    } derive(
    Debug    )

    ConcurrencyLimiter::acquire

    source

    ConcurrencyLimiter::in_use

    source
    fn ConcurrencyLimiter::in_use(self : ConcurrencyLimiter) -> Int

    ConcurrencyLimiter::new

    source
    fn ConcurrencyLimiter::new(capacity : Int) -> ConcurrencyLimiter

    ConcurrencyLimiter::release

    source
    fn ConcurrencyLimiter::release(self : ConcurrencyLimiter) -> Bool

    CookbookEntry

    source
    pub(all) struct CookbookEntry {
      entry_name : String
      description : String
      spec : LimitSpec
    } derive(Eq, 
    Debug    )

    CookbookEntry::name

    source
    fn CookbookEntry::name(self : CookbookEntry) -> String

    CookbookEntry::summary

    source
    fn CookbookEntry::summary(self : CookbookEntry) -> String

    Decision

    source
    pub(all) enum Decision {
      Allowed(AllowInfo)
      Rejected(RejectInfo)
    } derive(Eq, 
    Debug    )

    Rate limiter decision with enough context for logs, tests, and clients.

    Decision::explain

    source
    fn Decision::explain(self : Decision) -> String

    Decision::is_allowed

    source
    fn Decision::is_allowed(self : Decision) -> Bool

    Decision::remaining

    source
    fn Decision::remaining(self : Decision) -> Int

    Decision::reset_after_ms

    source
    fn Decision::reset_after_ms(self : Decision) -> Int

    Decision::retry_after_ms

    source
    fn Decision::retry_after_ms(self : Decision) -> Int

    DecisionStats

    source
    pub(all) struct DecisionStats {
      allowed_count : Int
      rejected_count : Int
      retry_after_total_ms : Int
      retry_after_max_ms : Int
    } derive(
    Debug    )

    DecisionStats::allowed

    source
    fn DecisionStats::allowed(self : DecisionStats) -> Int

    DecisionStats::average_retry_after_ms

    source
    fn DecisionStats::average_retry_after_ms(self : DecisionStats) -> Int

    DecisionStats::max_retry_after_ms

    source
    fn DecisionStats::max_retry_after_ms(self : DecisionStats) -> Int

    DecisionStats::new

    source

    DecisionStats::record

    source
    fn DecisionStats::record(self : DecisionStats, decision : Decision) -> Unit

    DecisionStats::rejected

    source
    fn DecisionStats::rejected(self : DecisionStats) -> Int

    DecisionStats::summary

    source
    fn DecisionStats::summary(self : DecisionStats) -> String

    DecisionStats::total

    source
    fn DecisionStats::total(self : DecisionStats) -> Int

    Duration

    source
    pub(all) struct Duration {
      value_ms : Int
    } derive(Eq, 
    Debug    )

    Duration::from_millis

    source
    fn Duration::from_millis(value_ms : Int) -> Duration

    Duration::millis

    source
    fn Duration::millis(self : Duration) -> Int

    Duration::parse

    source
    fn Duration::parse(text : String) -> Duration

    Duration::seconds

    source
    fn Duration::seconds(self : Duration) -> Int

    EngineRule

    source
    pub(all) struct EngineRule {
      rule_name : String
      kind : LimitKind
      token_bucket : TokenBucket
      fixed_window : FixedWindow
      sliding_log : SlidingLog
      quota_window : QuotaWindow
    } derive(
    Debug    )

    EngineRule::allow_at

    source
    fn EngineRule::allow_at(self : EngineRule, now_ms : Int, cost? : Int) -> Decision

    EngineRule::describe

    source
    fn EngineRule::describe(self : EngineRule) -> String

    EngineRule::fixed_window

    source
    fn EngineRule::fixed_window(name : String, limit : Int, window_ms : Int) -> EngineRule

    EngineRule::kind_name

    source
    fn EngineRule::kind_name(self : EngineRule) -> String

    EngineRule::name

    source
    fn EngineRule::name(self : EngineRule) -> String

    EngineRule::quota

    source
    fn EngineRule::quota(name : String, quota : Int, period_ms : Int) -> EngineRule

    EngineRule::sliding_log

    source
    fn EngineRule::sliding_log(name : String, limit : Int, window_ms : Int) -> EngineRule

    EngineRule::token_bucket

    source
    fn EngineRule::token_bucket(name : String, capacity : Int, refill_tokens : Int, refill_period_ms : Int) -> EngineRule

    FixedWindow

    source
    pub(all) struct FixedWindow {
      limit : Int
      window_ms : Int
      window_start_ms : Int
      used : Int
    } derive(
    Debug    )

    FixedWindow::allow_at

    source
    fn FixedWindow::allow_at(self : FixedWindow, now_ms : Int, cost? : Int) -> Decision

    FixedWindow::new

    source
    fn FixedWindow::new(limit : Int, window_ms : Int, start_ms? : Int) -> FixedWindow

    Gcra

    source
    pub(all) struct Gcra {
      interval_ms : Int
      burst_capacity : Int
      theoretical_arrival_ms : Int
    } derive(
    Debug    )

    Gcra::allow_at

    source
    fn Gcra::allow_at(self : Gcra, now_ms : Int, cost? : Int) -> Decision

    Gcra::new

    source
    fn Gcra::new(limit : Int, period_ms : Int, burst_capacity? : Int, start_ms? : Int) -> Gcra

    KeyedConcurrencyLimiter

    source
    pub(all) struct KeyedConcurrencyLimiter {
      capacity : Int
      states : 
    HashMap    [String, ConcurrencyLimiter]
    } derive(
    Debug    )

    KeyedConcurrencyLimiter::acquire

    source
    fn KeyedConcurrencyLimiter::acquire(self : KeyedConcurrencyLimiter, key : String) -> Decision

    KeyedConcurrencyLimiter::in_use

    source
    fn KeyedConcurrencyLimiter::in_use(self : KeyedConcurrencyLimiter, key : String) -> Int

    KeyedConcurrencyLimiter::len

    source

    KeyedConcurrencyLimiter::new

    source

    KeyedConcurrencyLimiter::release

    source
    fn KeyedConcurrencyLimiter::release(self : KeyedConcurrencyLimiter, key : String) -> Bool

    KeyedFixedWindow

    source
    pub(all) struct KeyedFixedWindow {
      limit : Int
      window_ms : Int
      windows : 
    HashMap    [String, FixedWindow]
      last_seen : 
    HashMap    [String, Int]
    } derive(
    Debug    )

    KeyedFixedWindow::allow_at

    source
    fn KeyedFixedWindow::allow_at(self : KeyedFixedWindow, key : String, now_ms : Int, cost? : Int) -> Decision

    KeyedFixedWindow::len

    source
    fn KeyedFixedWindow::len(self : KeyedFixedWindow) -> Int

    KeyedFixedWindow::new

    source
    fn KeyedFixedWindow::new(limit : Int, window_ms : Int) -> KeyedFixedWindow

    KeyedFixedWindow::prune_idle

    source
    fn KeyedFixedWindow::prune_idle(self : KeyedFixedWindow, now_ms : Int, max_idle_ms : Int) -> Int

    KeyedGcra

    source
    pub(all) struct KeyedGcra {
      limit : Int
      period_ms : Int
      burst_capacity : Int
      states : 
    HashMap    [String, Gcra]
      last_seen : 
    HashMap    [String, Int]
    } derive(
    Debug    )

    KeyedGcra::allow_at

    source
    fn KeyedGcra::allow_at(self : KeyedGcra, key : String, now_ms : Int, cost? : Int) -> Decision

    KeyedGcra::len

    source
    fn KeyedGcra::len(self : KeyedGcra) -> Int

    KeyedGcra::new

    source
    fn KeyedGcra::new(limit : Int, period_ms : Int, burst_capacity? : Int) -> KeyedGcra

    KeyedGcra::prune_idle

    source
    fn KeyedGcra::prune_idle(self : KeyedGcra, now_ms : Int, max_idle_ms : Int) -> Int

    KeyedSlidingLog

    source
    pub(all) struct KeyedSlidingLog {
      limit : Int
      window_ms : Int
      logs : 
    HashMap    [String, SlidingLog]
      last_seen : 
    HashMap    [String, Int]
    } derive(
    Debug    )

    KeyedSlidingLog::allow_at

    source
    fn KeyedSlidingLog::allow_at(self : KeyedSlidingLog, key : String, now_ms : Int, cost? : Int) -> Decision

    KeyedSlidingLog::len

    source
    fn KeyedSlidingLog::len(self : KeyedSlidingLog) -> Int

    KeyedSlidingLog::new

    source
    fn KeyedSlidingLog::new(limit : Int, window_ms : Int) -> KeyedSlidingLog

    KeyedSlidingLog::prune_idle

    source
    fn KeyedSlidingLog::prune_idle(self : KeyedSlidingLog, now_ms : Int, max_idle_ms : Int) -> Int

    KeyedTokenBucket

    source
    pub(all) struct KeyedTokenBucket {
      capacity : Int
      refill_tokens : Int
      refill_period_ms : Int
      buckets : 
    HashMap    [String, TokenBucket]
      last_seen : 
    HashMap    [String, Int]
    } derive(
    Debug    )

    KeyedTokenBucket::allow_at

    source
    fn KeyedTokenBucket::allow_at(self : KeyedTokenBucket, key : String, now_ms : Int, cost? : Int) -> Decision

    KeyedTokenBucket::len

    source
    fn KeyedTokenBucket::len(self : KeyedTokenBucket) -> Int

    KeyedTokenBucket::new

    source
    fn KeyedTokenBucket::new(capacity : Int, refill_tokens : Int, refill_period_ms : Int) -> KeyedTokenBucket

    KeyedTokenBucket::prune_idle

    source
    fn KeyedTokenBucket::prune_idle(self : KeyedTokenBucket, now_ms : Int, max_idle_ms : Int) -> Int

    LeakyBucket

    source
    pub(all) struct LeakyBucket {
      capacity : Int
      leak_tokens : Int
      leak_period_ms : Int
      level : Int
      last_leak_ms : Int
    } derive(
    Debug    )

    LeakyBucket::allow_at

    source
    fn LeakyBucket::allow_at(self : LeakyBucket, now_ms : Int, cost? : Int) -> Decision

    LeakyBucket::new

    source
    fn LeakyBucket::new(capacity : Int, leak_tokens : Int, leak_period_ms : Int, start_ms? : Int) -> LeakyBucket

    LimitKind

    source
    pub(all) enum LimitKind {
      TokenBucket
      FixedWindow
      SlidingLog
      GcraSpec
    } derive(Eq, 
    Debug    )

    LimitSpec

    source
    pub(all) struct LimitSpec {
      kind : LimitKind
      spec_name : String
      first : Int
      second : Int
      third : Int
    } derive(Eq, 
    Debug    )

    LimitSpec::explain

    source
    fn LimitSpec::explain(self : LimitSpec) -> String

    LimitSpec::fixed_window

    source
    fn LimitSpec::fixed_window(name : String, limit : Int, window_ms : Int) -> LimitSpec

    LimitSpec::kind_name

    source
    fn LimitSpec::kind_name(self : LimitSpec) -> String

    LimitSpec::name

    source
    fn LimitSpec::name(self : LimitSpec) -> String

    LimitSpec::parse

    source
    fn LimitSpec::parse(text : String) -> LimitSpec

    LimitSpec::sliding_log

    source
    fn LimitSpec::sliding_log(name : String, limit : Int, window_ms : Int) -> LimitSpec

    LimitSpec::to_fixed_window

    source
    fn LimitSpec::to_fixed_window(self : LimitSpec) -> FixedWindow

    LimitSpec::to_sliding_log

    source
    fn LimitSpec::to_sliding_log(self : LimitSpec) -> SlidingLog

    LimitSpec::to_token_bucket

    source
    fn LimitSpec::to_token_bucket(self : LimitSpec) -> TokenBucket

    LimitSpec::token_bucket

    source
    fn LimitSpec::token_bucket(name : String, capacity : Int, refill_tokens : Int, refill_period_ms : Int) -> LimitSpec

    LimitSpec::validate

    source
    fn LimitSpec::validate(self : LimitSpec) -> ValidationReport

    LimiterRecipe

    source
    pub(all) struct LimiterRecipe {
      recipe_name : String
      audience : String
      engine : PolicyEngine
      workload : Workload
    } derive(
    Debug    )

    LimiterRecipe::describe

    source
    fn LimiterRecipe::describe(self : LimiterRecipe) -> String

    LimiterRecipe::name

    source
    fn LimiterRecipe::name(self : LimiterRecipe) -> String

    LimiterRecipe::run

    source

    ParseError

    source
    pub(all) struct ParseError {
      field : String
      message : String
    } derive(Eq, 
    Debug    )

    ParseError::field

    source
    fn ParseError::field(self : ParseError) -> String

    ParseError::message

    source
    fn ParseError::message(self : ParseError) -> String

    ParseError::new

    source
    fn ParseError::new(field : String, message : String) -> ParseError

    ParseResult

    source
    pub(all) enum ParseResult {
      ParseOk(LimitSpec)
      ParseFailed(ParseError)
    } derive(Eq, 
    Debug    )

    ParseResult::error_field

    source
    fn ParseResult::error_field(self : ParseResult) -> String

    ParseResult::error_message

    source
    fn ParseResult::error_message(self : ParseResult) -> String

    ParseResult::is_ok

    source
    fn ParseResult::is_ok(self : ParseResult) -> Bool

    ParseResult::parse_limit

    source
    fn ParseResult::parse_limit(text : String) -> ParseResult

    ParseResult::spec

    source
    fn ParseResult::spec(self : ParseResult) -> LimitSpec

    PolicyEngine

    source
    pub(all) struct PolicyEngine {
      mode : AdmissionMode
      rules : Array[EngineRule]
    } derive(
    Debug    )

    PolicyEngine::add_fixed_window

    source
    fn PolicyEngine::add_fixed_window(self : PolicyEngine, name : String, limit : Int, window_ms : Int) -> Unit

    PolicyEngine::add_quota

    source
    fn PolicyEngine::add_quota(self : PolicyEngine, name : String, quota : Int, period_ms : Int) -> Unit

    PolicyEngine::add_rule

    source
    fn PolicyEngine::add_rule(self : PolicyEngine, rule : EngineRule) -> Unit

    PolicyEngine::add_sliding_log

    source
    fn PolicyEngine::add_sliding_log(self : PolicyEngine, name : String, limit : Int, window_ms : Int) -> Unit

    PolicyEngine::add_token_bucket

    source
    fn PolicyEngine::add_token_bucket(self : PolicyEngine, name : String, capacity : Int, refill_tokens : Int, refill_period_ms : Int) -> Unit

    PolicyEngine::all

    source

    PolicyEngine::allow_at

    source
    fn PolicyEngine::allow_at(self : PolicyEngine, now_ms : Int, cost? : Int) -> Decision

    PolicyEngine::any

    source

    PolicyEngine::describe

    source
    fn PolicyEngine::describe(self : PolicyEngine) -> String

    PolicyEngine::len

    source
    fn PolicyEngine::len(self : PolicyEngine) -> Int

    PolicyEngine::simulate

    source
    fn PolicyEngine::simulate(self : PolicyEngine, workload : Workload) -> SimulationReport

    QuotaWindow

    source
    pub(all) struct QuotaWindow {
      quota : Int
      period_ms : Int
      window_start_ms : Int
      used : Int
    } derive(
    Debug    )

    QuotaWindow::allow_at

    source
    fn QuotaWindow::allow_at(self : QuotaWindow, now_ms : Int, cost? : Int) -> Decision

    QuotaWindow::new

    source
    fn QuotaWindow::new(quota : Int, period_ms : Int, start_ms? : Int) -> QuotaWindow

    QuotaWindow::remaining_quota

    source
    fn QuotaWindow::remaining_quota(self : QuotaWindow) -> Int

    QuotaWindow::used

    source
    fn QuotaWindow::used(self : QuotaWindow) -> Int

    Rate

    source
    pub(all) struct Rate {
      count : Int
      period : Duration
    } derive(Eq, 
    Debug    )

    Rate::events

    source
    fn Rate::events(self : Rate) -> Int

    Rate::new

    source
    fn Rate::new(count : Int, period : Duration) -> Rate

    Rate::parse

    source
    fn Rate::parse(text : String) -> Rate

    Rate::period_ms

    source
    fn Rate::period_ms(self : Rate) -> Int

    RejectInfo

    source
    pub(all) struct RejectInfo {
      retry_after_ms : Int
      reason : String
    } derive(Eq, 
    Debug    )

    Rejection details returned by a limiter.

    RequestEvent

    source
    pub(all) struct RequestEvent {
      at_ms : Int
      cost : Int
      key : String
    } derive(Eq, 
    Debug    )

    RetryAdvice

    source
    pub(all) struct RetryAdvice {
      should_retry : Bool
      wait_ms : Int
      message : String
    } derive(Eq, 
    Debug    )

    RetryAdvice::from_decision

    source
    fn RetryAdvice::from_decision(decision : Decision) -> RetryAdvice

    RetryAdvice::message

    source
    fn RetryAdvice::message(self : RetryAdvice) -> String

    RetryAdvice::should_retry

    source
    fn RetryAdvice::should_retry(self : RetryAdvice) -> Bool

    RetryAdvice::wait_ms

    source
    fn RetryAdvice::wait_ms(self : RetryAdvice) -> Int

    RetrySchedule

    source
    pub(all) struct RetrySchedule {
      base_ms : Int
      max_ms : Int
      factor : Int
    } derive(Eq, 
    Debug    )

    RetrySchedule::delay_at

    source
    fn RetrySchedule::delay_at(self : RetrySchedule, attempt : Int) -> Int

    RetrySchedule::delays

    source
    fn RetrySchedule::delays(self : RetrySchedule, attempts : Int) -> Array[Int]

    RetrySchedule::describe

    source
    fn RetrySchedule::describe(self : RetrySchedule, attempts : Int) -> String

    RetrySchedule::exponential

    source
    fn RetrySchedule::exponential(base_ms : Int, max_ms : Int, factor? : Int) -> RetrySchedule

    RuleSet

    source
    pub(all) struct RuleSet {
      specs : Array[LimitSpec]
    } derive(
    Debug    )

    RuleSet::get

    source
    fn RuleSet::get(self : RuleSet, index : Int) -> LimitSpec?

    RuleSet::len

    source
    fn RuleSet::len(self : RuleSet) -> Int

    RuleSet::new

    source
    fn RuleSet::new() -> RuleSet

    RuleSet::parse_lines

    source
    fn RuleSet::parse_lines(text : String) -> RuleSet

    RuleSet::push

    source
    fn RuleSet::push(self : RuleSet, spec : LimitSpec) -> Unit

    RuleSet::validate

    source
    fn RuleSet::validate(self : RuleSet) -> ValidationReport

    Severity

    source
    pub(all) enum Severity {
      Info
      Warning
      Error
    } derive(Eq, 
    Debug    )

    SimulationReport

    source
    pub(all) struct SimulationReport {
      trace : Array[TraceEntry]
      allowed_count : Int
      rejected_count : Int
    } derive(
    Debug    )

    SimulationReport::allowed

    source
    fn SimulationReport::allowed(self : SimulationReport) -> Int

    SimulationReport::allowed_per_thousand

    source
    fn SimulationReport::allowed_per_thousand(self : SimulationReport) -> Int

    SimulationReport::csv

    source
    fn SimulationReport::csv(self : SimulationReport) -> String

    SimulationReport::max_retry_after_ms

    source
    fn SimulationReport::max_retry_after_ms(self : SimulationReport) -> Int

    SimulationReport::new

    source

    SimulationReport::record

    source
    fn SimulationReport::record(self : SimulationReport, at_ms : Int, decision : Decision) -> Unit

    SimulationReport::rejected

    source
    fn SimulationReport::rejected(self : SimulationReport) -> Int

    SimulationReport::rejected_per_thousand

    source
    fn SimulationReport::rejected_per_thousand(self : SimulationReport) -> Int

    SimulationReport::summary_line

    source
    fn SimulationReport::summary_line(self : SimulationReport) -> String

    SimulationReport::total

    source
    fn SimulationReport::total(self : SimulationReport) -> Int

    Simulator

    source
    pub(all) struct Simulator {
    }

    Simulator::run_fixed_window

    source
    fn Simulator::run_fixed_window(limiter : FixedWindow, workload : Workload) -> SimulationReport

    Simulator::run_token_bucket

    source
    fn Simulator::run_token_bucket(limiter : TokenBucket, workload : Workload) -> SimulationReport

    SlidingLog

    source
    pub(all) struct SlidingLog {
      limit : Int
      window_ms : Int
      events : Array[Int]
    } derive(
    Debug    )

    SlidingLog::allow_at

    source
    fn SlidingLog::allow_at(self : SlidingLog, now_ms : Int, cost? : Int) -> Decision

    SlidingLog::len

    source
    fn SlidingLog::len(self : SlidingLog) -> Int

    SlidingLog::new

    source
    fn SlidingLog::new(limit : Int, window_ms : Int) -> SlidingLog

    SlidingWindow

    source
    pub(all) struct SlidingWindow {
      limit : Int
      window_ms : Int
      window_start_ms : Int
      current_count : Int
      previous_count : Int
    } derive(
    Debug    )

    SlidingWindow::allow_at

    source
    fn SlidingWindow::allow_at(self : SlidingWindow, now_ms : Int, cost? : Int) -> Decision

    SlidingWindow::new

    source
    fn SlidingWindow::new(limit : Int, window_ms : Int, start_ms? : Int) -> SlidingWindow

    TokenBucket

    source
    pub(all) struct TokenBucket {
      capacity : Int
      refill_tokens : Int
      refill_period_ms : Int
      tokens : Int
      last_refill_ms : Int
    } derive(
    Debug    )

    TokenBucket::allow_at

    source
    fn TokenBucket::allow_at(self : TokenBucket, now_ms : Int, cost? : Int) -> Decision

    TokenBucket::new

    source
    fn TokenBucket::new(capacity : Int, refill_tokens : Int, refill_period_ms : Int, start_ms? : Int) -> TokenBucket

    TraceEntry

    source
    pub(all) struct TraceEntry {
      at_ms : Int
      decision : Decision
    } derive(
    Debug    )

    ValidationIssue

    source
    pub(all) struct ValidationIssue {
      severity : Severity
      field : String
      message : String
    } derive(Eq, 
    Debug    )

    ValidationIssue::error

    source
    fn ValidationIssue::error(field : String, message : String) -> ValidationIssue

    ValidationIssue::field

    source
    fn ValidationIssue::field(self : ValidationIssue) -> String

    ValidationIssue::info

    source
    fn ValidationIssue::info(field : String, message : String) -> ValidationIssue

    ValidationIssue::is_error

    source
    fn ValidationIssue::is_error(self : ValidationIssue) -> Bool

    ValidationIssue::message

    source
    fn ValidationIssue::message(self : ValidationIssue) -> String

    ValidationIssue::warning

    source
    fn ValidationIssue::warning(field : String, message : String) -> ValidationIssue

    ValidationReport

    source
    pub(all) struct ValidationReport {
      issues : Array[ValidationIssue]
    } derive(
    Debug    )

    ValidationReport::error_count

    source
    fn ValidationReport::error_count(self : ValidationReport) -> Int

    ValidationReport::is_ok

    source
    fn ValidationReport::is_ok(self : ValidationReport) -> Bool

    ValidationReport::len

    source
    fn ValidationReport::len(self : ValidationReport) -> Int

    ValidationReport::new

    source

    ValidationReport::push

    source
    fn ValidationReport::push(self : ValidationReport, issue : ValidationIssue) -> Unit

    ValidationReport::summary

    source
    fn ValidationReport::summary(self : ValidationReport) -> String

    ValidationReport::warning_count

    source
    fn ValidationReport::warning_count(self : ValidationReport) -> Int

    WarmupTokenBucket

    source
    pub(all) struct WarmupTokenBucket {
      capacity : Int
      refill_tokens : Int
      refill_period_ms : Int
      warmup_ms : Int
      start_ms : Int
      tokens : Int
      last_refill_ms : Int
    } derive(
    Debug    )

    WarmupTokenBucket::allow_at

    source
    fn WarmupTokenBucket::allow_at(self : WarmupTokenBucket, now_ms : Int, cost? : Int) -> Decision

    WarmupTokenBucket::capacity_at

    source
    fn WarmupTokenBucket::capacity_at(self : WarmupTokenBucket, now_ms : Int) -> Int

    WarmupTokenBucket::new

    source
    fn WarmupTokenBucket::new(capacity : Int, refill_tokens : Int, refill_period_ms : Int, warmup_ms : Int, start_ms? : Int) -> WarmupTokenBucket

    Workload

    source
    pub(all) struct Workload {
      events : Array[RequestEvent]
    } derive(
    Debug    )

    Workload::alternating_keys

    source
    fn Workload::alternating_keys(count : Int, start_ms : Int, step_ms : Int, left : String, right : String) -> Workload

    Workload::burst

    source
    fn Workload::burst(count : Int, at_ms : Int) -> Workload

    Workload::describe

    source
    fn Workload::describe(self : Workload) -> String

    Workload::first_at

    source
    fn Workload::first_at(self : Workload) -> Int

    Workload::last_at

    source
    fn Workload::last_at(self : Workload) -> Int

    Workload::len

    source
    fn Workload::len(self : Workload) -> Int

    Workload::merge

    source
    fn Workload::merge(left : Workload, right : Workload) -> Workload

    Workload::new

    source
    fn Workload::new() -> Workload

    Workload::push

    source
    fn Workload::push(self : Workload, at_ms : Int, cost? : Int, key? : String) -> Unit

    Workload::ramp

    source
    fn Workload::ramp(count : Int, start_ms : Int, initial_step_ms : Int, decrement_ms : Int) -> Workload

    Workload::repeat

    source
    fn Workload::repeat(self : Workload, times : Int, spacing_ms : Int) -> Workload

    Workload::shift

    source
    fn Workload::shift(self : Workload, delta_ms : Int) -> Workload

    Workload::steady

    source
    fn Workload::steady(count : Int, start_ms : Int, step_ms : Int) -> Workload

    algorithm_docs

    source
    fn algorithm_docs() -> Array[AlgorithmDoc]

    algorithm_markdown

    source
    fn algorithm_markdown() -> String

    algorithm_summary_table

    source
    fn algorithm_summary_table() -> String

    ceil_div

    source
    fn ceil_div(numerator : Int, denominator : Int) -> Int

    clamp_non_negative

    source
    fn clamp_non_negative(value : Int) -> Int

    cookbook_admin_api

    source
    fn cookbook_admin_api() -> CookbookEntry

    cookbook_ai_inference

    source
    fn cookbook_ai_inference() -> CookbookEntry

    cookbook_audit_export

    source
    fn cookbook_audit_export() -> CookbookEntry

    cookbook_backup_job

    source
    fn cookbook_backup_job() -> CookbookEntry

    cookbook_billing_sync

    source
    fn cookbook_billing_sync() -> CookbookEntry

    cookbook_checkout_flow

    source
    fn cookbook_checkout_flow() -> CookbookEntry

    cookbook_comment_posting

    source
    fn cookbook_comment_posting() -> CookbookEntry

    cookbook_count

    source
    fn cookbook_count() -> Int

    cookbook_crawler_host

    source
    fn cookbook_crawler_host() -> CookbookEntry

    cookbook_download_endpoint

    source
    fn cookbook_download_endpoint() -> CookbookEntry

    cookbook_email_worker

    source
    fn cookbook_email_worker() -> CookbookEntry

    cookbook_embedding_job

    source
    fn cookbook_embedding_job() -> CookbookEntry

    cookbook_entries

    source
    fn cookbook_entries() -> Array[CookbookEntry]

    cookbook_feed_refresh

    source
    fn cookbook_feed_refresh() -> CookbookEntry

    cookbook_find

    source
    fn cookbook_find(name : String) -> CookbookEntry?

    cookbook_image_worker

    source
    fn cookbook_image_worker() -> CookbookEntry

    cookbook_log_ingest

    source
    fn cookbook_log_ingest() -> CookbookEntry

    cookbook_login_endpoint

    source
    fn cookbook_login_endpoint() -> CookbookEntry

    cookbook_markdown

    source
    fn cookbook_markdown() -> String

    cookbook_message_sending

    source
    fn cookbook_message_sending() -> CookbookEntry

    cookbook_metrics_ingest

    source
    fn cookbook_metrics_ingest() -> CookbookEntry

    cookbook_notification_push

    source
    fn cookbook_notification_push() -> CookbookEntry

    cookbook_password_reset_endpoint

    source
    fn cookbook_password_reset_endpoint() -> CookbookEntry

    cookbook_payment_attempts

    source
    fn cookbook_payment_attempts() -> CookbookEntry

    cookbook_public_api_edge

    source
    fn cookbook_public_api_edge() -> CookbookEntry

    cookbook_report_worker

    source
    fn cookbook_report_worker() -> CookbookEntry

    cookbook_search_typeahead

    source
    fn cookbook_search_typeahead() -> CookbookEntry

    cookbook_signup_endpoint

    source
    fn cookbook_signup_endpoint() -> CookbookEntry

    cookbook_sms_worker

    source
    fn cookbook_sms_worker() -> CookbookEntry

    cookbook_tenant_plan_free

    source
    fn cookbook_tenant_plan_free() -> CookbookEntry

    cookbook_tenant_plan_pro

    source
    fn cookbook_tenant_plan_pro() -> CookbookEntry

    cookbook_thumbnail_job

    source
    fn cookbook_thumbnail_job() -> CookbookEntry

    cookbook_upload_endpoint

    source
    fn cookbook_upload_endpoint() -> CookbookEntry

    cookbook_webhook_worker

    source
    fn cookbook_webhook_worker() -> CookbookEntry

    doc_concurrency

    source
    fn doc_concurrency() -> AlgorithmDoc

    doc_fixed_window

    source
    fn doc_fixed_window() -> AlgorithmDoc

    doc_gcra

    source
    fn doc_gcra() -> AlgorithmDoc

    doc_leaky_bucket

    source
    fn doc_leaky_bucket() -> AlgorithmDoc

    doc_quota

    source
    fn doc_quota() -> AlgorithmDoc

    doc_sliding_log

    source
    fn doc_sliding_log() -> AlgorithmDoc

    doc_sliding_window

    source
    fn doc_sliding_window() -> AlgorithmDoc

    doc_token_bucket

    source
    fn doc_token_bucket() -> AlgorithmDoc

    recipe_all

    source
    fn recipe_all() -> Array[LimiterRecipe]

    recipe_api_gateway

    source
    fn recipe_api_gateway() -> LimiterRecipe

    recipe_batch_import

    source
    fn recipe_batch_import() -> LimiterRecipe

    recipe_checkout_guard

    source
    fn recipe_checkout_guard() -> LimiterRecipe

    recipe_crawler_politeness

    source
    fn recipe_crawler_politeness() -> LimiterRecipe

    recipe_email_sender

    source
    fn recipe_email_sender() -> LimiterRecipe

    recipe_image_renderer

    source
    fn recipe_image_renderer() -> LimiterRecipe

    recipe_login_guard

    source
    fn recipe_login_guard() -> LimiterRecipe

    recipe_markdown_index

    source
    fn recipe_markdown_index() -> String

    recipe_names

    source
    fn recipe_names() -> Array[String]

    recipe_password_reset

    source
    fn recipe_password_reset() -> LimiterRecipe

    fn recipe_search_box() -> LimiterRecipe

    recipe_sms_sender

    source
    fn recipe_sms_sender() -> LimiterRecipe

    recipe_tenant_fairness

    source
    fn recipe_tenant_fairness() -> LimiterRecipe

    recipe_webhook_dispatch

    source
    fn recipe_webhook_dispatch() -> LimiterRecipe

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io