mooncakes.io

cmd
→
core
→
examples
→
models
→
reports
→
README
U
Backoff
U
CircuitBreaker
U
CircuitBreakerConfig
U
CircuitBreakerResult
U
CounterSample
U
DemoDescriptor
U
Duration
U
EventFailureCase
U
EventId
U
EventKind
U
EventMutationPolicy
U
EventRecord
U
EventReplayResult
U
EventStream
U
EventStreamSnapshot
U
EventView
U
ExperimentCase
U
ExperimentReport
U
FeatureCell
U
FeatureCoverage
U
FeatureMatrix
U
ForkComparison
U
HttpFailureCase
U
HttpOutcome
U
HttpReliabilityPolicy
U
HttpReplayOptions
U
HttpReplayResult
U
HttpRequest
U
HttpResponse
U
IntRange
U
InvariantCheck
U
InvariantReport
U
LoadBalancerConfig
U
LoadBalancerResult
U
Message
U
MessageBus
U
MetricDelta
U
MetricDiff
U
MetricSnapshot
U
Metrics
U
ModelSummary
U
NetworkConfig
U
NetworkResult
U
QueueConfig
U
QueueResult
U
QueueStats
U
RecordedHttpExchange
U
RecordedHttpTransport
U
ReliabilityConfig
U
ReliabilityResult
U
ReplayBaseline
U
ReplayComparison
U
RetryConfig
U
RetryResult
U
Rng
U
RunReport
U
RunStep
U
RunStopReason
U
SampleDistribution
U
SampleSummary
U
Scenario
U
ScenarioCase
U
ScenarioExpectation
U
ScenarioFailure
U
ScenarioReport
U
ScenarioSuite
U
ScenarioSuiteReport
U
ScheduledEvent
U
SeedMatrix
U
SeedMatrixComparison
U
SeedRun
U
ServiceResilienceConfig
U
ServiceResilienceResult
U
Sim
U
SimSnapshot
U
StateMachine
U
SweepPoint
U
SweepReport
U
Tick
U
TimelineBucket
U
TimelineView
U
TimerPlan
U
TokenBucket
U
TokenBucketResult
U
TraceComparison
U
TraceEntry
U
TraceExpectation
U
TraceKindCount
U
TraceMismatch
U
TraceQuery
U
TraceQueryResult
U
TraceStats
U
TrafficConfig
U
TrafficResult
U
Transition
U
TransitionResult
U
ValidationIssue
U
ValidationReport
U
WeightedChoice
U
WorkflowPlan
U
WorkflowResult
U
WorkflowTask
U
WorkflowTaskRun
V
build_feature_matrix
V
build_timeline
V
check_counter_at_least
V
check_no_pending
V
check_sim_invariants
V
circuit_breaker_config
V
compare_event
V
compare_experiments
V
compare_forks
V
compare_replay
V
compare_seed_matrices
V
compare_traces
V
default_features
V
demo_catalog
V
demo_descriptor
V
demo_experiment
V
demo_names
V
diff_metrics
V
duration
V
event_failure_case
V
event_id
V
event_mutation_policy
V
event_stream
V
expect_trace_contains_detail
V
expect_trace_contains_kind
V
expect_trace_digest
V
expect_trace_kind_count
V
expect_trace_monotonic_ticks
V
expect_trace_order
V
experiment_case
V
external_call_event_kind
V
find_demo
V
http_cancelled_outcome
V
http_connection_failure_outcome
V
http_reliability_policy
V
http_replay_options
V
http_request
V
http_response
V
http_response_outcome
V
invariant_check
V
load_balancer_config
V
load_balancer_seed_matrix
V
load_balancer_summary
V
message_event_kind
V
metrics_counter_delta
V
network_config
V
network_seed_matrix
V
network_summary
V
query_trace
V
queue_config
V
queue_summary
V
recorded_http_exchange
V
recorded_http_transport
V
reliability_config
V
render_demo_catalog
V
render_experiment_report
V
render_feature_coverage
V
render_feature_matrix
V
render_metric_diff
V
render_metrics_report
V
render_model_summaries
V
render_replay_comparison
V
render_sample_distribution
V
render_scenario_report
V
render_scenario_suite_report
V
render_service_resilience_report
V
render_sim_report
V
render_trace_report
V
replay_baseline
V
retry_config
V
retry_seed_matrix
V
retry_summary
V
retry_timeout_fault_policy
V
retry_timeout_fixed_policy
V
retry_timeout_recording
V
run_circuit_breaker_model
V
run_load_balancer_model
V
run_network_model
V
run_queue_model
V
run_reliability_model
V
run_retry_model
V
run_service_resilience_suite
V
run_token_bucket_model
V
run_traffic_model
V
run_workflow_model
V
seed_run
V
service_resilience_config
V
service_resilience_seed_matrix
V
state_transition_event_kind
V
sweep_load_balancer_strategies
V
sweep_point
V
sweep_reliability_failure_rates
V
task_event_kind
V
tick
V
timer_event_kind
V
timer_plan
V
trace_digest
V
trace_entry
V
trace_filter_detail
V
trace_filter_kind
V
trace_filter_tick_range
V
trace_query
V
trace_query_result
V
trace_stats
V
trace_to_text
V
traffic_config
V
traffic_summary
V
transition
V
validate_metrics
V
validate_sim
V
validate_trace
V
validation_issue
V
version
V
weighted_choice
V
workflow_critical_path

README

zlhahaha/moonsim/core does not have a README file

#
Backoff

pub(all) struct Backoff {
  initial : Int
  factor : Int
  max_delay : Int
  jitter : Int
  current : Int
}

#
Backoff::new

source

fn Backoff::new(initial? : Int, factor? : Int, max_delay? : Int, jitter? : Int) -> Backoff

#
Backoff::next_delay

source

fn Backoff::next_delay(self : Backoff, rng : Rng) -> Int

#
Backoff::reset

source

fn Backoff::reset(self : Backoff) -> Unit

#
CounterSample

source

pub(all) struct CounterSample {
  name : String
  value : Int
}

#
Duration

source

pub(all) struct Duration {
  value : Int
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Virtual simulation duration.

#
Duration::is_zero

source

fn Duration::is_zero(self : Duration) -> Bool

#
Duration::scale

source

fn Duration::scale(self : Duration, factor : Int) -> Duration

#
Duration::to_int

source

fn Duration::to_int(self : Duration) -> Int

#
EventFailureCase

source

pub(all) struct EventFailureCase {
  seed : UInt64
  rule : String
  digest : UInt64
  events : Array[EventRecord]
  policy : EventMutationPolicy
  source_events : Array[EventRecord]
}

#
EventFailureCase::replay

source

fn EventFailureCase::replay(self : EventFailureCase) -> EventReplayResult

#
EventId

source

pub(all) struct EventId {
  value : Int
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Stable simulation event identifier.

#
EventId::to_int

source

fn EventId::to_int(self : EventId) -> Int

#
EventKind

source

pub enum EventKind {
  Message
  Task
  Timer
  StateTransition
  ExternalCall
}

Built-in event categories for deterministic model traces.

#
EventKind::label

source

fn EventKind::label(self : EventKind) -> String

#
EventMutationPolicy

source

pub(all) struct EventMutationPolicy {
  seed : UInt64
  max_delay : Int
  delay_percent : Int
  drop_percent : Int
  duplicate_percent : Int
  reorder_same_tick : Bool
  failure_percent : Int
}

#
EventRecord

source

pub(all) struct EventRecord {
  id : Int
  kind : EventKind
  tick : Int
  priority : Int
  correlation_id : String
  source : String
  target : String
  label : String
  parent_id : Int
  payload : String
  dropped : Bool
  failed : Bool
}

#
EventReplayResult

source

pub(all) struct EventReplayResult {
  seed : UInt64
  digest : UInt64
  events : Array[EventRecord]
  scheduled : Int
  dropped : Int
  duplicated : Int
  failed : Int
}

#
EventReplayResult::invariants

source

fn EventReplayResult::invariants(self : EventReplayResult) -> InvariantReport

#
EventReplayResult::matches_digest

source

fn EventReplayResult::matches_digest(self : EventReplayResult, other : EventReplayResult) -> Bool

#
EventStream

source

pub(all) struct EventStream {
  next_id : Int
  events : Array[EventRecord]
}

#
EventStream::append

source

fn EventStream::append(self : EventStream, event : EventRecord) -> EventRecord

#
EventStream::digest

source

fn EventStream::digest(self : EventStream) -> UInt64

#
EventStream::events

source

fn EventStream::events(self : EventStream) -> Array[EventRecord]

#
EventStream::invariants

source

fn EventStream::invariants(self : EventStream) -> InvariantReport

#
EventStream::new

source

fn EventStream::new() -> EventStream

#
EventStream::ordered

source

fn EventStream::ordered(self : EventStream) -> Array[EventRecord]

#
EventStream::record

source

fn EventStream::record(self : EventStream, kind : EventKind, tick : Int, label : String, correlation_id? : String, source? : String, target? : String, parent_id? : Int, payload? : String, priority? : Int, dropped? : Bool, failed? : Bool) -> EventRecord

#
EventStream::replay

source

fn EventStream::replay(self : EventStream, policy : EventMutationPolicy) -> EventReplayResult

#
EventStream::restore

source

fn EventStream::restore(self : EventStream, snapshot : EventStreamSnapshot) -> Unit

#
EventStream::snapshot

source

fn EventStream::snapshot(self : EventStream) -> EventStreamSnapshot

#
EventStreamSnapshot

source

pub(all) struct EventStreamSnapshot {
  next_id : Int
  events : Array[EventRecord]
}

#
EventView

source

pub(all) struct EventView {
  id : Int
  tick : Int
  priority : Int
  name : String
  status : String
}

#
ForkComparison

source

pub(all) struct ForkComparison {
  left_name : String
  right_name : String
  left_digest : UInt64
  right_digest : UInt64
  same_digest : Bool
  left_events : Int
  right_events : Int
}

#
ForkComparison::summary

source

fn ForkComparison::summary(self : ForkComparison) -> String

#
IntRange

source

pub(all) struct IntRange {
  min : Int
  max : Int
}

#
InvariantCheck

source

pub(all) struct InvariantCheck {
  name : String
  passed : Bool
  detail : String
}

#
InvariantReport

source

pub(all) struct InvariantReport {
  subject : String
  checks : Array[InvariantCheck]
}

#
InvariantReport::add

source

fn InvariantReport::add(self : InvariantReport, check : InvariantCheck) -> InvariantReport

#
InvariantReport::check_count

source

fn InvariantReport::check_count(self : InvariantReport) -> Int

#
InvariantReport::failed_count

source

fn InvariantReport::failed_count(self : InvariantReport) -> Int

#
InvariantReport::has_check

source

fn InvariantReport::has_check(self : InvariantReport, name : String) -> Bool

#
InvariantReport::is_empty

source

fn InvariantReport::is_empty(self : InvariantReport) -> Bool

#
InvariantReport::merge

source

fn InvariantReport::merge(self : InvariantReport, other : InvariantReport) -> InvariantReport

#
InvariantReport::new

source

fn InvariantReport::new(subject : String) -> InvariantReport

#
InvariantReport::only_failures

source

fn InvariantReport::only_failures(self : InvariantReport) -> InvariantReport

#
InvariantReport::passed

source

fn InvariantReport::passed(self : InvariantReport) -> Bool

#
InvariantReport::passed_count

source

fn InvariantReport::passed_count(self : InvariantReport) -> Int

#
InvariantReport::render

source

fn InvariantReport::render(self : InvariantReport) -> String

#
InvariantReport::summary

source

fn InvariantReport::summary(self : InvariantReport) -> String

#
Message

source

pub(all) struct Message {
  id : Int
  from : String
  to : String
  body : String
  send_tick : Int
  deliver_tick : Int
  dropped : Bool
}

#
MessageBus

source

pub(all) struct MessageBus {
  next_message_id : Int
  messages : Array[Message]
}

#
MessageBus::deliver_due

source

fn MessageBus::deliver_due(self : MessageBus, sim : Sim) -> Int

#
MessageBus::drop

source

fn MessageBus::drop(self : MessageBus, sim : Sim, id : Int) -> Bool

#
MessageBus::event_stream

source

fn MessageBus::event_stream(self : MessageBus) -> EventStream

Projects message send and delivery facts into the generic event stream.

#
MessageBus::messages

source

fn MessageBus::messages(self : MessageBus) -> Array[Message]

#
MessageBus::new

source

fn MessageBus::new() -> MessageBus

#
MessageBus::pending

source

fn MessageBus::pending(self : MessageBus, sim : Sim) -> Int

#
MessageBus::send

source

fn MessageBus::send(self : MessageBus, sim : Sim, from : String, to : String, body : String, delay? : Int) -> Int

#
MetricDelta

source

pub(all) struct MetricDelta {
  name : String
  before : Int
  after : Int
  delta : Int
}

#
MetricDiff

source

pub(all) struct MetricDiff {
  counters : Array[MetricDelta]
  gauges : Array[MetricDelta]
  sample_delta : Int
}

#
MetricDiff::summary

source

fn MetricDiff::summary(self : MetricDiff) -> String

#
MetricSnapshot

source

pub(all) struct MetricSnapshot {
  counters : Array[CounterSample]
  gauges : Array[CounterSample]
  samples : Array[CounterSample]
}

#
Metrics

source

pub(all) struct Metrics {
  counters : Array[CounterSample]
  gauges : Array[CounterSample]
  samples : Array[CounterSample]
}

#
Metrics::counter

source

fn Metrics::counter(self : Metrics, name : String) -> Int

#
Metrics::diff_from

source

fn Metrics::diff_from(self : Metrics, before : MetricSnapshot) -> MetricDiff

#
Metrics::distribution

source

fn Metrics::distribution(self : Metrics, name : String) -> SampleDistribution

#
Metrics::gauge

source

fn Metrics::gauge(self : Metrics, name : String) -> Int

#
Metrics::gauge_snapshot

source

fn Metrics::gauge_snapshot(self : Metrics) -> Array[CounterSample]

#
Metrics::inc

source

fn Metrics::inc(self : Metrics, name : String, delta? : Int) -> Unit

#
Metrics::metric_snapshot

source

fn Metrics::metric_snapshot(self : Metrics) -> MetricSnapshot

#
Metrics::new

source

fn Metrics::new() -> Metrics

#
Metrics::sample

source

fn Metrics::sample(self : Metrics, name : String, value : Int) -> Unit

#
Metrics::sample_count

source

fn Metrics::sample_count(self : Metrics, name : String) -> Int

#
Metrics::sample_snapshot

source

fn Metrics::sample_snapshot(self : Metrics) -> Array[CounterSample]

#
Metrics::sample_values

source

fn Metrics::sample_values(self : Metrics, name : String) -> Array[Int]

#
Metrics::set_gauge

source

fn Metrics::set_gauge(self : Metrics, name : String, value : Int) -> Unit

#
Metrics::snapshot

source

fn Metrics::snapshot(self : Metrics) -> Array[CounterSample]

#
Metrics::summary

source

fn Metrics::summary(self : Metrics, name : String) -> SampleSummary

#
QueueStats

source

pub(all) struct QueueStats {
  pending : Int
  cancelled : Int
  earliest_tick : Int
  latest_tick : Int
}

#
ReplayBaseline

source

pub(all) struct ReplayBaseline {
  name : String
  digest : UInt64
  entries : Array[TraceEntry]
  counters : Array[CounterSample]
  gauges : Array[CounterSample]
}

#
ReplayComparison

source

pub(all) struct ReplayComparison {
  name : String
  matched : Bool
  trace : TraceComparison
  counter_mismatches : Int
  gauge_mismatches : Int
}

#
ReplayComparison::summary

source

fn ReplayComparison::summary(self : ReplayComparison) -> String

#
Rng

source

pub(all) struct Rng {
  state : UInt64
}

Deterministic pseudo-random generator for reproducible simulations.

This generator is not cryptographic. It is intentionally small and portable so simulations behave the same across MoonBit targets.

#
Rng::choose

source

fn[T] Rng::choose(self : Rng, items : Array[T]) -> T?

#
Rng::choose_weighted

source

fn Rng::choose_weighted(self : Rng, choices : Array[WeightedChoice]) -> String?

#
Rng::new

source

fn Rng::new(seed : UInt64) -> Rng

#
Rng::next_bool

source

fn Rng::next_bool(self : Rng) -> Bool

#
Rng::next_int

source

fn Rng::next_int(self : Rng, bound : Int) -> Int

#
Rng::next_range

source

fn Rng::next_range(self : Rng, low : Int, high : Int) -> Int

#
Rng::next_u64

source

fn Rng::next_u64(self : Rng) -> UInt64

#
Rng::shuffle

source

fn[T] Rng::shuffle(self : Rng, items : Array[T]) -> Array[T]

#
Rng::state

source

fn Rng::state(self : Rng) -> UInt64

#
RunReport

source

pub(all) struct RunReport {
  steps : Int
  final_tick : Int
  pending : Int
  reason : RunStopReason
}

#
RunStep

source

pub(all) enum RunStep {
  Executed(ScheduledEvent)
  Idle
}

#
RunStopReason

source

pub(all) enum RunStopReason {
  Idle
  StepLimit
  TickLimit
}

#
SampleDistribution

source

pub(all) struct SampleDistribution {
  name : String
  count : Int
  min : Int
  max : Int
  median : Int
  p90 : Int
}

#
SampleSummary

source

pub(all) struct SampleSummary {
  name : String
  count : Int
  min : Int
  max : Int
  sum : Int
}

#
SampleSummary::average

source

fn SampleSummary::average(self : SampleSummary) -> Double

#
Scenario

source

pub(all) struct Scenario {
  name : String
  seed : UInt64
  max_steps : Int
  expectations : Array[ScenarioExpectation]
}

#
Scenario::create_sim

source

fn Scenario::create_sim(self : Scenario) -> Sim

#
Scenario::expect_counter

source

fn Scenario::expect_counter(self : Scenario, name : String, value : Int) -> Scenario

#
Scenario::expect_counter_range

source

fn Scenario::expect_counter_range(self : Scenario, name : String, min : Int, max : Int) -> Scenario

#
Scenario::expect_digest

source

fn Scenario::expect_digest(self : Scenario, value : UInt64) -> Scenario

#
Scenario::expect_final_tick

source

fn Scenario::expect_final_tick(self : Scenario, value : Int) -> Scenario

#
Scenario::expect_final_tick_range

source

fn Scenario::expect_final_tick_range(self : Scenario, min : Int, max : Int) -> Scenario

#
Scenario::expect_gauge

source

fn Scenario::expect_gauge(self : Scenario, name : String, value : Int) -> Scenario

#
Scenario::expect_no_validation_issues

source

fn Scenario::expect_no_validation_issues(self : Scenario) -> Scenario

#
Scenario::expect_pending

source

fn Scenario::expect_pending(self : Scenario, value : Int) -> Scenario

#
Scenario::expect_sample_count

source

fn Scenario::expect_sample_count(self : Scenario, name : String, value : Int) -> Scenario

#
Scenario::expect_summary_average_range

source

fn Scenario::expect_summary_average_range(self : Scenario, name : String, min : Int, max : Int) -> Scenario

#
Scenario::expect_summary_max

source

fn Scenario::expect_summary_max(self : Scenario, name : String, value : Int) -> Scenario

#
Scenario::expect_summary_min

source

fn Scenario::expect_summary_min(self : Scenario, name : String, value : Int) -> Scenario

#
Scenario::expect_trace_contains

source

fn Scenario::expect_trace_contains(self : Scenario, text : String) -> Scenario

#
Scenario::expect_trace_kind_count

source

fn Scenario::expect_trace_kind_count(self : Scenario, kind : String, count : Int) -> Scenario

#
Scenario::new

source

fn Scenario::new(name : String, seed? : UInt64, max_steps? : Int) -> Scenario

#
Scenario::verify

source

fn Scenario::verify(self : Scenario, sim : Sim) -> ScenarioReport

#
ScenarioCase

source

pub(all) struct ScenarioCase {
  scenario : Scenario
  sim : Sim
}

#
ScenarioExpectation

source

pub(all) struct ScenarioExpectation {
  kind : String
  name : String
  expected : String
}

#
ScenarioFailure

source

pub(all) struct ScenarioFailure {
  kind : String
  name : String
  expected : String
  actual : String
}

#
ScenarioReport

source

pub(all) struct ScenarioReport {
  name : String
  passed : Bool
  steps : Int
  final_tick : Int
  digest : UInt64
  failures : Array[ScenarioFailure]
}

#
ScenarioReport::detailed_text

source

fn ScenarioReport::detailed_text(self : ScenarioReport) -> String

#
ScenarioReport::failure_count

source

fn ScenarioReport::failure_count(self : ScenarioReport) -> Int

#
ScenarioReport::failure_text

source

fn ScenarioReport::failure_text(self : ScenarioReport) -> String

#
ScenarioReport::summary

source

fn ScenarioReport::summary(self : ScenarioReport) -> String

#
ScenarioSuite

source

pub(all) struct ScenarioSuite {
  name : String
  cases : Array[ScenarioCase]
}

#
ScenarioSuite::add

source

fn ScenarioSuite::add(self : ScenarioSuite, scenario : Scenario, sim : Sim) -> ScenarioSuite

#
ScenarioSuite::new

source

fn ScenarioSuite::new(name : String) -> ScenarioSuite

#
ScenarioSuite::run

source

fn ScenarioSuite::run(self : ScenarioSuite) -> ScenarioSuiteReport

#
ScenarioSuiteReport

source

pub(all) struct ScenarioSuiteReport {
  name : String
  reports : Array[ScenarioReport]
}

#
ScenarioSuiteReport::failed_count

source

fn ScenarioSuiteReport::failed_count(self : ScenarioSuiteReport) -> Int

#
ScenarioSuiteReport::passed

source

fn ScenarioSuiteReport::passed(self : ScenarioSuiteReport) -> Bool

#
ScenarioSuiteReport::passed_count

source

fn ScenarioSuiteReport::passed_count(self : ScenarioSuiteReport) -> Int

#
ScenarioSuiteReport::render

source

fn ScenarioSuiteReport::render(self : ScenarioSuiteReport) -> String

#
ScenarioSuiteReport::summary

source

fn ScenarioSuiteReport::summary(self : ScenarioSuiteReport) -> String

#
ScheduledEvent

source

pub(all) struct ScheduledEvent {
  id : Int
  tick : Int
  priority : Int
  name : String
  cancelled : Bool
  repeat_every : Int
  remaining_runs : Int
}

A scheduled simulation event.

Events are ordered by tick, priority, then id. The id tie-breaker makes same-tick execution stable and replayable.

#
ScheduledEvent::cancel

source

fn ScheduledEvent::cancel(self : ScheduledEvent) -> Unit

#
ScheduledEvent::is_cancelled

source

fn ScheduledEvent::is_cancelled(self : ScheduledEvent) -> Bool

#
ScheduledEvent::is_repeating

source

fn ScheduledEvent::is_repeating(self : ScheduledEvent) -> Bool

#
ScheduledEvent::new

source

fn ScheduledEvent::new(id : Int, tick : Int, name : String, priority? : Int) -> ScheduledEvent

#
ScheduledEvent::next_repeat

source

fn ScheduledEvent::next_repeat(self : ScheduledEvent) -> ScheduledEvent

#
ScheduledEvent::repeating

source

fn ScheduledEvent::repeating(id : Int, tick : Int, name : String, every : Int, times : Int, priority? : Int) -> ScheduledEvent

#
Sim

source

pub(all) struct Sim {
  now : Int
  next_id : Int
  events : Array[ScheduledEvent]
  trace_entries : Array[TraceEntry]
  rng : Rng
  metrics : Metrics
}

Deterministic simulation state.

#
Sim::cancel

source

fn Sim::cancel(self : Sim, event_id : Int) -> Bool

#
Sim::choose

source

fn[T] Sim::choose(self : Sim, label : String, items : Array[T]) -> T?

#
Sim::choose_weighted

source

fn Sim::choose_weighted(self : Sim, label : String, choices : Array[WeightedChoice]) -> String?

#
Sim::digest

source

fn Sim::digest(self : Sim) -> UInt64

#
Sim::event_views

source

fn Sim::event_views(self : Sim) -> Array[EventView]

#
Sim::inc_counter

source

fn Sim::inc_counter(self : Sim, name : String, delta? : Int) -> Unit

#
Sim::install_timer

source

fn Sim::install_timer(self : Sim, plan : TimerPlan) -> Int

#
Sim::metrics

source

fn Sim::metrics(self : Sim) -> Metrics

#
Sim::new

source

fn Sim::new(seed? : UInt64) -> Sim

#
Sim::next_int

source

fn Sim::next_int(self : Sim, bound : Int) -> Int

#
Sim::next_range

source

fn Sim::next_range(self : Sim, low : Int, high : Int) -> Int

#
Sim::pending_count

source

fn Sim::pending_count(self : Sim) -> Int

#
Sim::queue_stats

source

fn Sim::queue_stats(self : Sim) -> QueueStats

#
Sim::record

source

fn Sim::record(self : Sim, event_id : Int, kind : String, detail : String) -> Unit

#
Sim::record_transition

source

fn Sim::record_transition(self : Sim, machine : StateMachine, result : TransitionResult) -> Unit

#
Sim::restore

source

fn Sim::restore(snapshot : SimSnapshot) -> Sim

#
Sim::run_next

source

fn Sim::run_next(self : Sim) -> ScheduledEvent?

#
Sim::run_report_until_idle

source

fn Sim::run_report_until_idle(self : Sim, max_steps? : Int) -> RunReport

#
Sim::run_until_idle

source

fn Sim::run_until_idle(self : Sim, max_steps? : Int) -> Int

#
Sim::run_until_tick

source

fn Sim::run_until_tick(self : Sim, tick_limit : Int, max_steps? : Int) -> RunReport

#
Sim::sample

source

fn Sim::sample(self : Sim, name : String, value : Int) -> Unit

#
Sim::schedule_after

source

fn Sim::schedule_after(self : Sim, delay : Int, name : String, priority? : Int) -> Int

#
Sim::schedule_after_duration

source

fn Sim::schedule_after_duration(self : Sim, delay : Duration, name : String, priority? : Int) -> EventId

#
Sim::schedule_at

source

fn Sim::schedule_at(self : Sim, tick : Int, name : String, priority? : Int) -> Int

#
Sim::schedule_at_tick

source

fn Sim::schedule_at_tick(self : Sim, at : Tick, name : String, priority? : Int) -> EventId

#
Sim::schedule_backoff

source

fn Sim::schedule_backoff(self : Sim, backoff : Backoff, name : String) -> Int

#
Sim::schedule_repeating

source

fn Sim::schedule_repeating(self : Sim, start_after : Int, every : Int, times : Int, name : String, priority? : Int) -> Int

#
Sim::schedule_timeout

source

fn Sim::schedule_timeout(self : Sim, after : Int, name : String) -> Int

#
Sim::set_gauge

source

fn Sim::set_gauge(self : Sim, name : String, value : Int) -> Unit

#
Sim::shuffle

source

fn[T] Sim::shuffle(self : Sim, label : String, items : Array[T]) -> Array[T]

#
Sim::snapshot

source

fn Sim::snapshot(self : Sim, name? : String) -> SimSnapshot

#
Sim::step

source

fn Sim::step(self : Sim) -> RunStep

#
Sim::tick

source

fn Sim::tick(self : Sim) -> Tick

#
Sim::time

source

fn Sim::time(self : Sim) -> Int

#
Sim::timeline

source

fn Sim::timeline(self : Sim, bucket_size? : Int) -> TimelineView

#
Sim::timeline_text

source

fn Sim::timeline_text(self : Sim) -> String

#
Sim::trace

source

fn Sim::trace(self : Sim) -> Array[TraceEntry]

#
Sim::trace_stats

source

fn Sim::trace_stats(self : Sim) -> TraceStats

#
Sim::trace_text

source

fn Sim::trace_text(self : Sim) -> String

#
Sim::validate

source

fn Sim::validate(self : Sim) -> ValidationReport

#
SimSnapshot

source

pub(all) struct SimSnapshot {
  name : String
  time : Int
  next_id : Int
  rng_state : UInt64
  digest : UInt64
  events : Array[ScheduledEvent]
  counters : Array[CounterSample]
  gauges : Array[CounterSample]
  samples : Array[CounterSample]
}

#
SimSnapshot::fork

source

fn SimSnapshot::fork(self : SimSnapshot, name : String) -> Sim

#
StateMachine

source

pub(all) struct StateMachine {
  name : String
  state : String
  transitions : Array[Transition]
  history : Array[TransitionResult]
}

#
StateMachine::add

source

fn StateMachine::add(self : StateMachine, transition : Transition) -> StateMachine

#
StateMachine::event_stream

source

fn StateMachine::event_stream(self : StateMachine) -> EventStream

Projects accepted and rejected transitions into a causally linked event stream.

#
StateMachine::history

source

fn StateMachine::history(self : StateMachine) -> Array[TransitionResult]

#
StateMachine::new

source

fn StateMachine::new(name : String, initial : String) -> StateMachine

#
StateMachine::send

source

fn StateMachine::send(self : StateMachine, event : String) -> TransitionResult

#
StateMachine::state

source

fn StateMachine::state(self : StateMachine) -> String

#
Tick

source

pub(all) struct Tick {
  value : Int
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Virtual simulation tick.

#
Tick::compare

source

fn Tick::compare(self : Tick, other : Tick) -> Int

#
Tick::diff

source

fn Tick::diff(self : Tick, earlier : Tick) -> Duration

#
Tick::plus

source

fn Tick::plus(self : Tick, delta : Duration) -> Tick

#
Tick::to_int

source

fn Tick::to_int(self : Tick) -> Int

#
TimelineBucket

source

pub(all) struct TimelineBucket {
  start_tick : Int
  end_tick : Int
  events : Int
  executions : Int
  metrics : Int
  messages : Int
}

#
TimelineBucket::line

source

fn TimelineBucket::line(self : TimelineBucket) -> String

#
TimelineView

source

pub(all) struct TimelineView {
  bucket_size : Int
  buckets : Array[TimelineBucket]
}

#
TimelineView::bucket_count

source

fn TimelineView::bucket_count(self : TimelineView) -> Int

#
TimelineView::peak_bucket

source

fn TimelineView::peak_bucket(self : TimelineView) -> TimelineBucket

#
TimelineView::render

source

fn TimelineView::render(self : TimelineView) -> String

#
TimelineView::total_events

source

fn TimelineView::total_events(self : TimelineView) -> Int

#
TimerPlan

source

pub(all) struct TimerPlan {
  name : String
  start_after : Int
  interval : Int
  times : Int
  priority : Int
}

#
TimerPlan::event_stream

source

fn TimerPlan::event_stream(self : TimerPlan) -> EventStream

Projects a timer plan into the common deterministic event representation.

#
TraceComparison

source

pub(all) struct TraceComparison {
  matched : Bool
  checked : Int
  left_digest : UInt64
  right_digest : UInt64
  mismatch : TraceMismatch?
}

#
TraceComparison::summary

source

fn TraceComparison::summary(self : TraceComparison) -> String

#
TraceEntry

source

pub(all) struct TraceEntry {
  tick : Int
  event_id : Int
  kind : String
  detail : String
}

A deterministic record of an action observed during a simulation run.

#
TraceEntry::format

source

fn TraceEntry::format(self : TraceEntry) -> String

#
TraceEntry::to_line

source

fn TraceEntry::to_line(self : TraceEntry) -> String

#
TraceExpectation

source

pub(all) struct TraceExpectation {
  passed : Bool
  label : String
  expected : String
  actual : String
}

#
TraceKindCount

source

pub(all) struct TraceKindCount {
  kind : String
  count : Int
}

#
TraceMismatch

source

pub(all) struct TraceMismatch {
  index : Int
  left : String
  right : String
  reason : String
}

#
TraceQuery

source

pub(all) struct TraceQuery {
  kind : String
  detail : String
  min_tick : Int
  max_tick : Int
}

#
TraceQuery::matches

source

fn TraceQuery::matches(self : TraceQuery, entry : TraceEntry) -> Bool

#
TraceQueryResult

source

pub(all) struct TraceQueryResult {
  entries : Array[TraceEntry]
  first_tick : Int
  last_tick : Int
  kind_counts : Array[TraceKindCount]
}

#
TraceQueryResult::kind_count

source

fn TraceQueryResult::kind_count(self : TraceQueryResult, kind : String) -> Int

#
TraceQueryResult::summary

source

fn TraceQueryResult::summary(self : TraceQueryResult) -> String

#
TraceStats

source

pub(all) struct TraceStats {
  entries : Int
  schedules : Int
  executions : Int
  cancellations : Int
  rng_draws : Int
  metrics : Int
  messages : Int
}

#
TraceStats::summary

source

fn TraceStats::summary(self : TraceStats) -> String

#
Transition

source

pub(all) struct Transition {
  from : String
  event : String
  to : String
  action : String
}

#
TransitionResult

source

pub(all) struct TransitionResult {
  accepted : Bool
  from : String
  event : String
  to : String
  action : String
  reason : String
}

#
ValidationIssue

source

pub(all) struct ValidationIssue {
  code : String
  message : String
  severity : String
}

#
ValidationReport

source

pub(all) struct ValidationReport {
  subject : String
  issues : Array[ValidationIssue]
}

#
ValidationReport::passed

source

fn ValidationReport::passed(self : ValidationReport) -> Bool

#
ValidationReport::summary

source

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

#
ValidationReport::text

source

fn ValidationReport::text(self : ValidationReport) -> String

#
WeightedChoice

source

pub(all) struct WeightedChoice {
  label : String
  weight : Int
}

#
build_timeline

source

fn build_timeline(entries : Array[TraceEntry], bucket_size? : Int) -> TimelineView

#
check_counter_at_least

source

fn check_counter_at_least(sim : Sim, name : String, minimum : Int) -> InvariantCheck

#
check_no_pending

source

fn check_no_pending(sim : Sim) -> InvariantCheck

#
check_sim_invariants

source

fn check_sim_invariants(sim : Sim) -> InvariantReport

#
compare_event

source

fn compare_event(a : ScheduledEvent, b : ScheduledEvent) -> Int

#
compare_forks

source

fn compare_forks(left_name : String, left : Sim, right_name : String, right : Sim) -> ForkComparison

#
compare_replay

source

fn compare_replay(baseline : ReplayBaseline, sim : Sim) -> ReplayComparison

#
compare_traces

source

fn compare_traces(left : Array[TraceEntry], right : Array[TraceEntry]) -> TraceComparison

#
diff_metrics

source

fn diff_metrics(before : MetricSnapshot, after : MetricSnapshot) -> MetricDiff

#
duration

source

fn duration(value : Int) -> Duration

#
event_failure_case

source

fn event_failure_case(rule : String, source : EventStream, policy : EventMutationPolicy) -> EventFailureCase

#
event_id

source

fn event_id(value : Int) -> EventId

#
event_mutation_policy

source

fn event_mutation_policy(seed? : UInt64, max_delay? : Int, delay_percent? : Int, drop_percent? : Int, duplicate_percent? : Int, reorder_same_tick? : Bool, failure_percent? : Int) -> EventMutationPolicy

#
event_record

source

fn event_record(kind : EventKind, tick : Int, label : String, correlation_id? : String, source? : String, target? : String, parent_id? : Int, payload? : String, priority? : Int, dropped? : Bool, failed? : Bool) -> EventRecord

#
expect_trace_contains_detail

source

fn expect_trace_contains_detail(entries : Array[TraceEntry], detail : String) -> TraceExpectation

#
expect_trace_contains_kind

source

fn expect_trace_contains_kind(entries : Array[TraceEntry], kind : String) -> TraceExpectation

#
expect_trace_digest

source

fn expect_trace_digest(entries : Array[TraceEntry], digest : UInt64) -> TraceExpectation

#
expect_trace_kind_count

source

fn expect_trace_kind_count(entries : Array[TraceEntry], kind : String, expected : Int) -> TraceExpectation

#
expect_trace_monotonic_ticks

source

fn expect_trace_monotonic_ticks(entries : Array[TraceEntry]) -> TraceExpectation

#
expect_trace_order

source

fn expect_trace_order(entries : Array[TraceEntry], before_detail : String, after_detail : String) -> TraceExpectation

#
external_call_event_kind

source

fn external_call_event_kind() -> EventKind

#
invariant_check

source

fn invariant_check(name : String, passed : Bool, detail? : String) -> InvariantCheck

#
message_event_kind

source

fn message_event_kind() -> EventKind

#
metrics_counter_delta

source

fn metrics_counter_delta(left : Metrics, right : Metrics, name : String) -> Int

#
query_trace

source

fn query_trace(entries : Array[TraceEntry], query : TraceQuery) -> TraceQueryResult

#
replay_baseline

source

fn replay_baseline(name : String, sim : Sim) -> ReplayBaseline

#
state_transition_event_kind

source

fn state_transition_event_kind() -> EventKind

#
task_event_kind

source

fn task_event_kind() -> EventKind

#
tick

source

fn tick(value : Int) -> Tick

#
timer_event_kind

source

fn timer_event_kind() -> EventKind

#
timer_plan

source

fn timer_plan(name : String, start_after? : Int, interval? : Int, times? : Int, priority? : Int) -> TimerPlan

#
trace_digest

source

fn trace_digest(entries : Array[TraceEntry]) -> UInt64

#
trace_entry

source

fn trace_entry(tick : Int, event_id : Int, kind : String, detail : String) -> TraceEntry

#
trace_filter_detail

source

fn trace_filter_detail(entries : Array[TraceEntry], detail : String) -> Array[TraceEntry]

#
trace_filter_kind

source

fn trace_filter_kind(entries : Array[TraceEntry], kind : String) -> Array[TraceEntry]

#
trace_filter_tick_range

source

fn trace_filter_tick_range(entries : Array[TraceEntry], min_tick : Int, max_tick : Int) -> Array[TraceEntry]

#
trace_query

source

fn trace_query(kind? : String, detail? : String, min_tick? : Int, max_tick? : Int) -> TraceQuery

#
trace_query_result

source

fn trace_query_result(entries : Array[TraceEntry]) -> TraceQueryResult

#
trace_stats

source

fn trace_stats(entries : Array[TraceEntry]) -> TraceStats

#
trace_to_text

source

fn trace_to_text(entries : Array[TraceEntry]) -> String

#
transition

source

fn transition(from : String, event : String, to : String, action? : String) -> Transition

#
validate_metrics

source

fn validate_metrics(metrics : Metrics) -> ValidationReport

#
validate_sim

source

fn validate_sim(sim : Sim) -> ValidationReport

#
validate_trace

source

fn validate_trace(entries : Array[TraceEntry]) -> ValidationReport

#
validation_issue

source

fn validation_issue(code : String, message : String, severity? : String) -> ValidationIssue

#
version

source

fn version() -> String

#
weighted_choice

source

fn weighted_choice(label : String, weight : Int) -> WeightedChoice

Source Files

cmd
→
core
→
examples
→
models
→
reports
→
README
U
Backoff
U
CircuitBreaker
U
CircuitBreakerConfig
U
CircuitBreakerResult
U
CounterSample
U
DemoDescriptor
U
Duration
U
EventFailureCase
U
EventId
U
EventKind
U
EventMutationPolicy
U
EventRecord
U
EventReplayResult
U
EventStream
U
EventStreamSnapshot
U
EventView
U
ExperimentCase
U
ExperimentReport
U
FeatureCell
U
FeatureCoverage
U
FeatureMatrix
U
ForkComparison
U
HttpFailureCase
U
HttpOutcome
U
HttpReliabilityPolicy
U
HttpReplayOptions
U
HttpReplayResult
U
HttpRequest
U
HttpResponse
U
IntRange
U
InvariantCheck
U
InvariantReport
U
LoadBalancerConfig
U
LoadBalancerResult
U
Message
U
MessageBus
U
MetricDelta
U
MetricDiff
U
MetricSnapshot
U
Metrics
U
ModelSummary
U
NetworkConfig
U
NetworkResult
U
QueueConfig
U
QueueResult
U
QueueStats
U
RecordedHttpExchange
U
RecordedHttpTransport
U
ReliabilityConfig
U
ReliabilityResult
U
ReplayBaseline
U
ReplayComparison
U
RetryConfig
U
RetryResult
U
Rng
U
RunReport
U
RunStep
U
RunStopReason
U
SampleDistribution
U
SampleSummary
U
Scenario
U
ScenarioCase
U
ScenarioExpectation
U
ScenarioFailure
U
ScenarioReport
U
ScenarioSuite
U
ScenarioSuiteReport
U
ScheduledEvent
U
SeedMatrix
U
SeedMatrixComparison
U
SeedRun
U
ServiceResilienceConfig
U
ServiceResilienceResult
U
Sim
U
SimSnapshot
U
StateMachine
U
SweepPoint
U
SweepReport
U
Tick
U
TimelineBucket
U
TimelineView
U
TimerPlan
U
TokenBucket
U
TokenBucketResult
U
TraceComparison
U
TraceEntry
U
TraceExpectation
U
TraceKindCount
U
TraceMismatch
U
TraceQuery
U
TraceQueryResult
U
TraceStats
U
TrafficConfig
U
TrafficResult
U
Transition
U
TransitionResult
U
ValidationIssue
U
ValidationReport
U
WeightedChoice
U
WorkflowPlan
U
WorkflowResult
U
WorkflowTask
U
WorkflowTaskRun
V
build_feature_matrix
V
build_timeline
V
check_counter_at_least
V
check_no_pending
V
check_sim_invariants
V
circuit_breaker_config
V
compare_event
V
compare_experiments
V
compare_forks
V
compare_replay
V
compare_seed_matrices
V
compare_traces
V
default_features
V
demo_catalog
V
demo_descriptor
V
demo_experiment
V
demo_names
V
diff_metrics
V
duration
V
event_failure_case
V
event_id
V
event_mutation_policy
V
event_stream
V
expect_trace_contains_detail
V
expect_trace_contains_kind
V
expect_trace_digest
V
expect_trace_kind_count
V
expect_trace_monotonic_ticks
V
expect_trace_order
V
experiment_case
V
external_call_event_kind
V
find_demo
V
http_cancelled_outcome
V
http_connection_failure_outcome
V
http_reliability_policy
V
http_replay_options
V
http_request
V
http_response
V
http_response_outcome
V
invariant_check
V
load_balancer_config
V
load_balancer_seed_matrix
V
load_balancer_summary
V
message_event_kind
V
metrics_counter_delta
V
network_config
V
network_seed_matrix
V
network_summary
V
query_trace
V
queue_config
V
queue_summary
V
recorded_http_exchange
V
recorded_http_transport
V
reliability_config
V
render_demo_catalog
V
render_experiment_report
V
render_feature_coverage
V
render_feature_matrix
V
render_metric_diff
V
render_metrics_report
V
render_model_summaries
V
render_replay_comparison
V
render_sample_distribution
V
render_scenario_report
V
render_scenario_suite_report
V
render_service_resilience_report
V
render_sim_report
V
render_trace_report
V
replay_baseline
V
retry_config
V
retry_seed_matrix
V
retry_summary
V
retry_timeout_fault_policy
V
retry_timeout_fixed_policy
V
retry_timeout_recording
V
run_circuit_breaker_model
V
run_load_balancer_model
V
run_network_model
V
run_queue_model
V
run_reliability_model
V
run_retry_model
V
run_service_resilience_suite
V
run_token_bucket_model
V
run_traffic_model
V
run_workflow_model
V
seed_run
V
service_resilience_config
V
service_resilience_seed_matrix
V
state_transition_event_kind
V
sweep_load_balancer_strategies
V
sweep_point
V
sweep_reliability_failure_rates
V
task_event_kind
V
tick
V
timer_event_kind
V
timer_plan
V
trace_digest
V
trace_entry
V
trace_filter_detail
V
trace_filter_kind
V
trace_filter_tick_range
V
trace_query
V
trace_query_result
V
trace_stats
V
trace_to_text
V
traffic_config
V
traffic_summary
V
transition
V
validate_metrics
V
validate_sim
V
validate_trace
V
validation_issue
V
version
V
weighted_choice
V
workflow_critical_path

Site source Report issue Packages Build queue Skills Statistics

#Backoff

#Backoff::new

#Backoff::next_delay

#Backoff::reset

#CounterSample

#Duration

#Duration::is_zero

#Duration::scale

#Duration::to_int

#EventFailureCase

#EventFailureCase::replay

#EventId

#EventId::to_int

#EventKind

#EventKind::label

#EventMutationPolicy

#EventRecord

#EventReplayResult

#EventReplayResult::invariants

#EventReplayResult::matches_digest

#EventStream

#EventStream::append

#EventStream::digest

#EventStream::events

#EventStream::invariants

#EventStream::new

#EventStream::ordered

#EventStream::record

#EventStream::replay

#EventStream::restore

#EventStream::snapshot

#EventStreamSnapshot

#EventView

#ForkComparison

#ForkComparison::summary

#IntRange

#InvariantCheck

#InvariantReport

#InvariantReport::add

#InvariantReport::check_count

#InvariantReport::failed_count

#InvariantReport::has_check

#InvariantReport::is_empty

#InvariantReport::merge

#InvariantReport::new

#InvariantReport::only_failures

#InvariantReport::passed

#InvariantReport::passed_count

#InvariantReport::render

#InvariantReport::summary

#Message

#MessageBus

#MessageBus::deliver_due

#MessageBus::drop

#MessageBus::event_stream

#MessageBus::messages

#MessageBus::new

#MessageBus::pending

#MessageBus::send

#MetricDelta

#MetricDiff

#MetricDiff::summary

#MetricSnapshot

#Metrics

#Metrics::counter

#Metrics::diff_from

#Metrics::distribution

#Metrics::gauge

#Metrics::gauge_snapshot

#Metrics::inc

#Metrics::metric_snapshot

#Metrics::new

#Metrics::sample

#Metrics::sample_count

#Metrics::sample_snapshot

#Metrics::sample_values

#Metrics::set_gauge

#Metrics::snapshot

#Metrics::summary

#QueueStats

#
Backoff

#
Backoff::new

#
Backoff::next_delay

#
Backoff::reset

#
CounterSample

#
Duration

#
Duration::is_zero

#
Duration::scale

#
Duration::to_int

#
EventFailureCase

#
EventFailureCase::replay

#
EventId

#
EventId::to_int

#
EventKind

#
EventKind::label

#
EventMutationPolicy

#
EventRecord

#
EventReplayResult

#
EventReplayResult::invariants

#
EventReplayResult::matches_digest

#
EventStream

#
EventStream::append

#
EventStream::digest

#
EventStream::events

#
EventStream::invariants

#
EventStream::new

#
EventStream::ordered

#
EventStream::record

#
EventStream::replay

#
EventStream::restore

#
EventStream::snapshot

#
EventStreamSnapshot

#
EventView

#
ForkComparison

#
ForkComparison::summary

#
IntRange

#
InvariantCheck

#
InvariantReport

#
InvariantReport::add

#
InvariantReport::check_count

#
InvariantReport::failed_count

#
InvariantReport::has_check

#
InvariantReport::is_empty

#
InvariantReport::merge

#
InvariantReport::new

#
InvariantReport::only_failures

#
InvariantReport::passed

#
InvariantReport::passed_count

#
InvariantReport::render

#
InvariantReport::summary

#
Message

#
MessageBus

#
MessageBus::deliver_due

#
MessageBus::drop

#
MessageBus::event_stream

#
MessageBus::messages

#
MessageBus::new

#
MessageBus::pending

#
MessageBus::send

#
MetricDelta

#
MetricDiff

#
MetricDiff::summary

#
MetricSnapshot

#
Metrics

#
Metrics::counter

#
Metrics::diff_from

#
Metrics::distribution

#
Metrics::gauge

#
Metrics::gauge_snapshot

#
Metrics::inc

#
Metrics::metric_snapshot

#
Metrics::new

#
Metrics::sample

#
Metrics::sample_count

#
Metrics::sample_snapshot

#
Metrics::sample_values

#
Metrics::set_gauge

#
Metrics::snapshot

#
Metrics::summary

#
QueueStats