🥮 mooncakes.io

moonlimit

Composable rate limiting algorithms for MoonBit applications

rate-limit
token-bucket
gcra
moonbit
throttling
moon add RunnerQuan/moonlimit@0.1.1
Download zip
Version
0.1.1
License
Apache-2.0
Repository
Last updated
last month
Downloads
35
README

#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