🥮 mooncakes.io

moonslokit

SLO, error budget, and burn-rate evaluation primitives for MoonBit.

slo
error-budget
burn-rate
availability
monitoring
moon add Zxy666668/moonslokit@0.2.0
Download zip
Author
Version
0.2.0
License
Apache-2.0
Repository
Last updated
yesterday
Downloads
6
README

#MoonSLOKit

CI

MoonSLOKit is a MoonBit foundation library for SLO evaluation, error-budget tracking, and burn-rate alert decisions.

It is intended for service reliability tooling, CI gates, API stability checks, and monitoring dashboards that need deterministic SLO math.

Repository: GitHub · GitLink

#Prerequisites

Install the current MoonBit toolchain (the OSC2026 validation environment uses MoonBit 0.10.3) from the official installation guide. Verify the installation before using the commands below:

moon version --all

#Features

  • SLO target definition in basis points.
  • Request windows with good/bad request counts.
  • Minute-level traffic sample aggregation into request windows.
  • Availability and error-rate calculation.
  • Error-budget consumed and remaining reports.
  • Error-budget exhaustion forecasting.
  • Burn-rate calculation.
  • Burn-rate alert rules with page/ticket decisions.
  • Standard multi-window burn-rate templates.
  • Multi-window evaluation.
  • Release gate decisions for CI and rollout workflows.
  • Service-level objective evaluation.
  • Deploy and incident annotations for explainable windows.
  • Configuration validation with actionable diagnostics.
  • Rolling observation series and request-event aggregation.
  • Incident impact timelines and escalation policy routing.
  • Portfolio-level health summaries and release-readiness reports.
  • Prometheus-style metrics export for dashboards and alerting.
  • Budget projection, compliance scoring, and latency summaries.
  • Stable JSON export and CLI demo.

#Quick Example

///|
test {
  let target = SloTarget::new("api", 9900, 30 * 24 * 60)
  let window = RequestWindow::new("5m", 5, 1000, 980)
  let burn = calculate_burn_rate(target, window)

  assert_eq(burn.rate_label(), "2.00x")
}

#Commands

moon check --target all
moon test --target wasm
moon test --target wasm-gc
moon run cmd/main

The repository CI runs the complete cross-backend check and test matrix on Ubuntu, macOS, and Windows. The local equivalent is:

moon update
moon check --target all
moon test --target all
moon fmt && git diff --exit-code
moon info && git diff --exit-code

#Boundary

MoonSLOKit is not a metrics collector, storage engine, web server, or dashboard. It provides the reusable SLO math and explainable decision layer that those systems can embed.

#Industrial Scenario

MoonSLOKit now covers a complete small reliability workflow:

  1. Aggregate traffic samples into SLO windows.
  2. Evaluate availability and error-budget consumption.
  3. Compute burn rates across standard short and long windows.
  4. Forecast budget exhaustion from recent traffic.
  5. Produce a release-gate decision for CI or rollout tooling.
  6. Attach deploy or incident annotations to explain window behavior.
  7. Validate configuration and request samples before evaluation.
  8. Aggregate request events into rolling windows and latency summaries.
  9. Export service, portfolio, and health reports as JSON, Markdown, or metrics.

#Install and External Consumer

After the package is published to Mooncakes, create a separate MoonBit project and install it by package name:

moon new slo-consumer
cd slo-consumer
moon add Zxy666668/moonslokit

The module name is exactly Zxy666668/moonslokit; use that spelling and capitalization in both moon add and the import path.

Use the dependency from the consumer package, not this repository checkout:

///|
import {
  "Zxy666668/moonslokit" @slo,
}

///|
fn main {
  let target = @slo.SloTarget::new("checkout-api", 9900, 30 * 24 * 60)
  let window = @slo.RequestWindow::new("5m", 5, 1000, 980)
  println(@slo.evaluate_budget(target, window).to_json())
}

Verify the external consumer with moon run; it should print a JSON budget report. This verifies the published dependency rather than importing files from this checkout. If the package has not yet been published, moon add will fail until the Mooncakes release is available.

#
AlertChannel

source
pub(all) enum AlertChannel {
  Pager
  Ticketing
  Log
} derive(Eq, 
Debug)

#
AlertDecision

source
pub(all) struct AlertDecision {
  level : AlertLevel
  rule_name : String
  burn_rate_x100 : Int
  reason : String
} derive(Eq, 
Debug)

#
AlertDecision::is_alert

source
fn AlertDecision::is_alert(self : AlertDecision) -> Bool

#
AlertDecision::level_name

source
fn AlertDecision::level_name(self : AlertDecision) -> String

#
AlertDecision::to_json

source
fn AlertDecision::to_json(self : AlertDecision) -> String

#
AlertLevel

source
pub(all) enum AlertLevel {
  Ok
  Page
  Ticket
} derive(Eq, 
Debug)

#
AlertLevel::name

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

#
AlertRoute

source
pub(all) struct AlertRoute {
  level : AlertLevel
  channel : AlertChannel
  destination : String
} derive(Eq, 
Debug)

#
AlertRoute::channel_name

source
fn AlertRoute::channel_name(self : AlertRoute) -> String

#
AlertRoute::new

source
fn AlertRoute::new(level : AlertLevel, channel : AlertChannel, destination : String) -> AlertRoute

#
AnnotatedWindow

source
pub(all) struct AnnotatedWindow {
  window : RequestWindow
  annotations : Array[SloAnnotation]
} derive(Eq, 
Debug)

#
AnnotatedWindow::has_kind

source
fn AnnotatedWindow::has_kind(self : AnnotatedWindow, kind : String) -> Bool

#
BudgetForecast

source
pub(all) struct BudgetForecast {
  report : BudgetReport
  lookback_minutes : Int
  bad_per_hour_x100 : Int
  minutes_to_exhaustion : Int
  state : String
} derive(Eq, 
Debug)

#
BudgetForecast::exhausted

source
fn BudgetForecast::exhausted(self : BudgetForecast) -> Bool

#
BudgetForecast::to_json

source
fn BudgetForecast::to_json(self : BudgetForecast) -> String

#
BudgetProjection

source
pub(all) struct BudgetProjection {
  target : SloTarget
  current : BudgetReport
  projected_bad : Int
  projected_total : Int
  projected_consumed_bp : Int
  remaining_after_projection : Int
  status : String
} derive(Eq, 
Debug)

#
BudgetProjection::safe

source
fn BudgetProjection::safe(self : BudgetProjection) -> Bool

#
BudgetProjection::status_name

source
fn BudgetProjection::status_name(self : BudgetProjection) -> String

#
BudgetProjection::to_json

source
fn BudgetProjection::to_json(self : BudgetProjection) -> String

#
BudgetReport

source
pub(all) struct BudgetReport {
  target : SloTarget
  window : RequestWindow
  allowed_bad : Int
  actual_bad : Int
  consumed_bp : Int
  remaining_bad : Int
} derive(Eq, 
Debug)

#
BudgetReport::budget_status

source
fn BudgetReport::budget_status(self : BudgetReport) -> String

#
BudgetReport::healthy

source
fn BudgetReport::healthy(self : BudgetReport) -> Bool

#
BudgetReport::remaining_ratio_bp

source
fn BudgetReport::remaining_ratio_bp(self : BudgetReport) -> Int

#
BudgetReport::to_json

source
fn BudgetReport::to_json(self : BudgetReport) -> String

#
BudgetReport::to_metrics

source
fn BudgetReport::to_metrics(self : BudgetReport, service : String) -> String

#
BurnReport

source
pub(all) struct BurnReport {
  window : RequestWindow
  allowed_error_bp : Int
  observed_error_bp : Int
  burn_rate_x100 : Int
} derive(Eq, 
Debug)

#
BurnReport::rate_label

source
fn BurnReport::rate_label(self : BurnReport) -> String

#
BurnReport::to_json

source
fn BurnReport::to_json(self : BurnReport) -> String

#
BurnReport::to_metrics

source
fn BurnReport::to_metrics(self : BurnReport, service : String) -> String

#
BurnRule

source
pub(all) struct BurnRule {
  name : String
  level : AlertLevel
  threshold_x100 : Int
} derive(Eq, 
Debug)

#
BurnRule::new

source
fn BurnRule::new(name : String, level : AlertLevel, threshold_x100 : Int) -> BurnRule

#
EscalationPolicy

source
pub(all) struct EscalationPolicy {
  name : String
  routes : Array[AlertRoute]
  default_route : AlertRoute
} derive(Eq, 
Debug)

#
EscalationPolicy::has_channel

source
fn EscalationPolicy::has_channel(self : EscalationPolicy, channel : AlertChannel) -> Bool

#
EscalationPolicy::new

source
fn EscalationPolicy::new(name : String, routes : Array[AlertRoute]) -> EscalationPolicy

#
EscalationPolicy::route

source

#
EscalationPolicy::route_count

source
fn EscalationPolicy::route_count(self : EscalationPolicy) -> Int

#
EscalationPolicy::route_for_level

source
fn EscalationPolicy::route_for_level(self : EscalationPolicy, level : AlertLevel) -> AlertRoute

#
EscalationPolicy::routes_for

source
fn EscalationPolicy::routes_for(self : EscalationPolicy, level : AlertLevel) -> Array[AlertRoute]

#
EscalationPolicy::to_json

source
fn EscalationPolicy::to_json(self : EscalationPolicy) -> String

#
GateDecision

source
pub(all) struct GateDecision {
  gate_name : String
  allowed : Bool
  reason : String
  consumed_bp : Int
  highest_level : AlertLevel
} derive(Eq, 
Debug)

#
GateDecision::to_json

source
fn GateDecision::to_json(self : GateDecision) -> String

#
HealthReport

source
pub(all) struct HealthReport {
  service : String
  target : SloTarget
  statistics : WindowStatistics
  latest : BudgetReport
  peak_burn_x100 : Int
  incident_count : Int
  severity : ReportSeverity
  incidents : IncidentTimeline
} derive(Eq, 
Debug)

#
HealthReport::from_windows

source
fn HealthReport::from_windows(service : String, target : SloTarget, windows : Array[RequestWindow], incidents : IncidentTimeline) -> HealthReport

#
HealthReport::healthy

source
fn HealthReport::healthy(self : HealthReport) -> Bool

#
HealthReport::recommendation

source
fn HealthReport::recommendation(self : HealthReport) -> String

#
HealthReport::risk_score

source
fn HealthReport::risk_score(self : HealthReport) -> Int

#
HealthReport::severity_name

source
fn HealthReport::severity_name(self : HealthReport) -> String

#
HealthReport::to_json

source
fn HealthReport::to_json(self : HealthReport) -> String

#
HealthReport::to_markdown

source
fn HealthReport::to_markdown(self : HealthReport) -> String

#
HealthReport::to_metrics

source
fn HealthReport::to_metrics(self : HealthReport) -> String

#
Incident

source
pub(all) struct Incident {
  id : String
  started_minute : Int
  ended_minute : Int
  severity : IncidentSeverity
  title : String
  impact_bp : Int
} derive(Eq, 
Debug)

#
Incident::active_at

source
fn Incident::active_at(self : Incident, minute : Int) -> Bool

#
Incident::duration

source
fn Incident::duration(self : Incident) -> Int

#
Incident::new

source
fn Incident::new(id : String, started_minute : Int, ended_minute : Int, severity : IncidentSeverity, title : String, impact_bp : Int) -> Incident

#
Incident::severity_name

source
fn Incident::severity_name(self : Incident) -> String

#
IncidentSeverity

source
pub(all) enum IncidentSeverity {
  Info
  Warning
  Critical
} derive(Eq, 
Debug)

#
IncidentTimeline

source
pub(all) struct IncidentTimeline {
  incidents : Array[Incident]
} derive(Eq, 
Debug)

#
IncidentTimeline::active_at

source
fn IncidentTimeline::active_at(self : IncidentTimeline, minute : Int) -> Bool

#
IncidentTimeline::active_count

source
fn IncidentTimeline::active_count(self : IncidentTimeline, minute : Int) -> Int

#
IncidentTimeline::count

source
fn IncidentTimeline::count(self : IncidentTimeline) -> Int

#
IncidentTimeline::impact_at

source
fn IncidentTimeline::impact_at(self : IncidentTimeline, minute : Int) -> Int

#
IncidentTimeline::impact_average

source
fn IncidentTimeline::impact_average(self : IncidentTimeline, start_minute : Int, end_minute : Int) -> Int

#
IncidentTimeline::new

source

#
IncidentTimeline::overlap_count

source
fn IncidentTimeline::overlap_count(self : IncidentTimeline, start_minute : Int, end_minute : Int) -> Int

#
IncidentTimeline::record

source

#
IncidentTimeline::severity_at

source
fn IncidentTimeline::severity_at(self : IncidentTimeline, minute : Int) -> IncidentSeverity

#
IncidentTimeline::to_json

source
fn IncidentTimeline::to_json(self : IncidentTimeline) -> String

#
LatencySummary

source
pub(all) struct LatencySummary {
  count : Int
  average_ms : Int
  min_ms : Int
  max_ms : Int
  slow_count : Int
} derive(Eq, 
Debug)

#
LatencySummary::empty

source

#
LatencySummary::healthy

source
fn LatencySummary::healthy(self : LatencySummary, budget_ms : Int) -> Bool

#
LatencySummary::to_json

source
fn LatencySummary::to_json(self : LatencySummary) -> String

#
MultiWindowReport

source
pub(all) struct MultiWindowReport {
  target : SloTarget
  reports : Array[BurnReport]
  decisions : Array[AlertDecision]
} derive(Eq, 
Debug)

#
MultiWindowReport::highest_level

source
fn MultiWindowReport::highest_level(self : MultiWindowReport) -> AlertLevel

#
ObservationSeries

source
pub(all) struct ObservationSeries {
  name : String
  window_minutes : Int
  samples : Array[TrafficSample]
} derive(Eq, 
Debug)

#
ObservationSeries::add

source

#
ObservationSeries::budget_reports

source
fn ObservationSeries::budget_reports(self : ObservationSeries, target : SloTarget) -> Array[BudgetReport]

#
ObservationSeries::burn_reports

source
fn ObservationSeries::burn_reports(self : ObservationSeries, target : SloTarget) -> Array[BurnReport]

#
ObservationSeries::coverage_minutes

source
fn ObservationSeries::coverage_minutes(self : ObservationSeries) -> Int

#
ObservationSeries::first_minute

source
fn ObservationSeries::first_minute(self : ObservationSeries) -> Int

#
ObservationSeries::from_samples

source
fn ObservationSeries::from_samples(name : String, window_minutes : Int, samples : Array[TrafficSample]) -> ObservationSeries

#
ObservationSeries::is_continuous

source
fn ObservationSeries::is_continuous(self : ObservationSeries) -> Bool

#
ObservationSeries::last_minute

source
fn ObservationSeries::last_minute(self : ObservationSeries) -> Int

#
ObservationSeries::new

source
fn ObservationSeries::new(name : String, window_minutes : Int) -> ObservationSeries

#
ObservationSeries::peak_burn

source
fn ObservationSeries::peak_burn(self : ObservationSeries, target : SloTarget) -> Int

#
ObservationSeries::sample_count

source
fn ObservationSeries::sample_count(self : ObservationSeries) -> Int

#
ObservationSeries::to_json

source
fn ObservationSeries::to_json(self : ObservationSeries) -> String

#
ObservationSeries::window_at

source
fn ObservationSeries::window_at(self : ObservationSeries, now_minute : Int) -> RequestWindow

#
ObservationSeries::window_from

source
fn ObservationSeries::window_from(self : ObservationSeries, start_minute : Int, end_minute : Int) -> RequestWindow

#
ObservationSeries::windows

source

#
PortfolioSummary

source
pub(all) struct PortfolioSummary {
  portfolio : String
  service_count : Int
  healthy_count : Int
  unhealthy_count : Int
  total_requests : Int
  total_bad : Int
  availability_bp : Int
} derive(Eq, 
Debug)

#
PortfolioSummary::healthy

source
fn PortfolioSummary::healthy(self : PortfolioSummary) -> Bool

#
PortfolioSummary::to_json

source
fn PortfolioSummary::to_json(self : PortfolioSummary) -> String

#
PortfolioSummary::to_metrics

source
fn PortfolioSummary::to_metrics(self : PortfolioSummary) -> String

#
ReleaseGate

source
pub(all) struct ReleaseGate {
  name : String
  max_consumed_bp : Int
  allow_ticket : Bool
} derive(Eq, 
Debug)

#
ReleaseGate::new

source
fn ReleaseGate::new(name : String, max_consumed_bp : Int, allow_ticket : Bool) -> ReleaseGate

#
ReliabilityResult

source
pub(all) struct ReliabilityResult {
  id : String
  budget : BudgetReport
  burn : BurnReport
  label : String
  recommendation : String
} derive(Eq, 
Debug)

#
ReliabilityResult::approved

source
fn ReliabilityResult::approved(self : ReliabilityResult) -> Bool

#
ReliabilityResult::status_line

source
fn ReliabilityResult::status_line(self : ReliabilityResult) -> String

#
ReliabilityResult::to_json

source
fn ReliabilityResult::to_json(self : ReliabilityResult) -> String

#
ReliabilityRun

source
pub(all) struct ReliabilityRun {
  id : String
  target : SloTarget
  window : RequestWindow
} derive(Eq, 
Debug)

#
ReliabilityRun::evaluate

source

#
ReliabilityRun::new

source
fn ReliabilityRun::new(id : String, target : SloTarget, window : RequestWindow) -> ReliabilityRun

#
ReportSeverity

source
pub(all) enum ReportSeverity {
  Stable
  Watch
  ActionRequired
  Emergency
} derive(Eq, 
Debug)

#
RequestBatch

source
pub(all) struct RequestBatch {
  name : String
  events : Array[RequestEvent]
} derive(Eq, 
Debug)

#
RequestBatch::add

source

#
RequestBatch::failed

source
fn RequestBatch::failed(self : RequestBatch) -> Int

#
RequestBatch::latency

source
fn RequestBatch::latency(self : RequestBatch, slow_after_ms : Int) -> LatencySummary

#
RequestBatch::minutes

source
fn RequestBatch::minutes(self : RequestBatch) -> Int

#
RequestBatch::new

source
fn RequestBatch::new(name : String) -> RequestBatch

#
RequestBatch::slow_count

source
fn RequestBatch::slow_count(self : RequestBatch, slow_after_ms : Int) -> Int

#
RequestBatch::succeeded

source
fn RequestBatch::succeeded(self : RequestBatch) -> Int

#
RequestBatch::to_json

source
fn RequestBatch::to_json(self : RequestBatch) -> String

#
RequestBatch::to_series

source
fn RequestBatch::to_series(self : RequestBatch, window_minutes : Int) -> ObservationSeries

#
RequestBatch::to_window

source
fn RequestBatch::to_window(self : RequestBatch, minutes : Int) -> RequestWindow

#
RequestBatch::total

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

#
RequestEvent

source
pub(all) struct RequestEvent {
  minute : Int
  succeeded : Bool
  latency_ms : Int
} derive(Eq, 
Debug)

#
RequestEvent::failed

source
fn RequestEvent::failed(self : RequestEvent) -> Bool

#
RequestEvent::latency_band

source
fn RequestEvent::latency_band(self : RequestEvent, slow_after_ms : Int) -> String

#
RequestEvent::new

source
fn RequestEvent::new(minute : Int, succeeded : Bool, latency_ms : Int) -> RequestEvent

#
RequestWindow

source
pub(all) struct RequestWindow {
  name : String
  minutes : Int
  total : Int
  good : Int
} derive(Eq, 
Debug)

#
RequestWindow::availability_bp

source
fn RequestWindow::availability_bp(self : RequestWindow) -> Int

#
RequestWindow::bad

source
fn RequestWindow::bad(self : RequestWindow) -> Int

#
RequestWindow::error_bp

source
fn RequestWindow::error_bp(self : RequestWindow) -> Int

#
RequestWindow::new

source
fn RequestWindow::new(name : String, minutes : Int, total : Int, good : Int) -> RequestWindow

#
ServiceEvaluation

source
pub(all) struct ServiceEvaluation {
  service : String
  target_name : String
  budget : BudgetReport
  multi_window : MultiWindowReport
  gate : GateDecision
} derive(Eq, 
Debug)

#
ServiceEvaluation::healthy

source
fn ServiceEvaluation::healthy(self : ServiceEvaluation) -> Bool

#
ServiceEvaluation::to_json

source
fn ServiceEvaluation::to_json(self : ServiceEvaluation) -> String

#
ServiceEvaluation::to_metrics

source
fn ServiceEvaluation::to_metrics(self : ServiceEvaluation) -> String

#
ServiceObjective

source
pub(all) struct ServiceObjective {
  service : String
  target : SloTarget
  burn_rules : Array[BurnRule]
} derive(Eq, 
Debug)

#
ServiceObjective::new

source
fn ServiceObjective::new(service : String, target : SloTarget, burn_rules : Array[BurnRule]) -> ServiceObjective

#
ServiceSnapshot

source
pub(all) struct ServiceSnapshot {
  service : String
  budget : BudgetReport
} derive(Eq, 
Debug)

#
ServiceSnapshot::availability_bp

source
fn ServiceSnapshot::availability_bp(self : ServiceSnapshot) -> Int

#
ServiceSnapshot::healthy

source
fn ServiceSnapshot::healthy(self : ServiceSnapshot) -> Bool

#
ServiceSnapshot::new

source
fn ServiceSnapshot::new(service : String, budget : BudgetReport) -> ServiceSnapshot

#
SloAnnotation

source
pub(all) struct SloAnnotation {
  minute : Int
  kind : String
  message : String
} derive(Eq, 
Debug)

#
SloAnnotation::new

source
fn SloAnnotation::new(minute : Int, kind : String, message : String) -> SloAnnotation

#
SloAnnotation::to_json

source
fn SloAnnotation::to_json(self : SloAnnotation) -> String

#
SloConfig

source
pub(all) struct SloConfig {
  target : SloTarget
  windows : Array[WindowPolicy]
  rules : Array[BurnRule]
} derive(Eq, 
Debug)

#
SloConfig::has_rule

source
fn SloConfig::has_rule(self : SloConfig, name : String) -> Bool

#
SloConfig::has_window

source
fn SloConfig::has_window(self : SloConfig, name : String) -> Bool

#
SloConfig::new

source
fn SloConfig::new(target : SloTarget, windows : Array[WindowPolicy], rules : Array[BurnRule]) -> SloConfig

#
SloConfig::required_windows

source
fn SloConfig::required_windows(self : SloConfig) -> Array[WindowPolicy]

#
SloConfig::rule_count

source
fn SloConfig::rule_count(self : SloConfig) -> Int

#
SloConfig::to_json

source
fn SloConfig::to_json(self : SloConfig) -> String

#
SloConfig::window_count

source
fn SloConfig::window_count(self : SloConfig) -> Int

#
SloPortfolio

source
pub(all) struct SloPortfolio {
  name : String
  services : Array[ServiceSnapshot]
} derive(Eq, 
Debug)

#
SloPortfolio::add

source

#
SloPortfolio::contains

source
fn SloPortfolio::contains(self : SloPortfolio, service : String) -> Bool

#
SloPortfolio::healthy_count

source
fn SloPortfolio::healthy_count(self : SloPortfolio) -> Int

#
SloPortfolio::new

source
fn SloPortfolio::new(name : String) -> SloPortfolio

#
SloPortfolio::service_count

source
fn SloPortfolio::service_count(self : SloPortfolio) -> Int

#
SloPortfolio::summary

source

#
SloPortfolio::to_json

source
fn SloPortfolio::to_json(self : SloPortfolio) -> String

#
SloPortfolio::unhealthy_services

source
fn SloPortfolio::unhealthy_services(self : SloPortfolio) -> Array[String]

#
SloTarget

source
pub(all) struct SloTarget {
  name : String
  target_bp : Int
  period_minutes : Int
} derive(Eq, 
Debug)

#
SloTarget::allowed_error_bp

source
fn SloTarget::allowed_error_bp(self : SloTarget) -> Int

#
SloTarget::new

source
fn SloTarget::new(name : String, target_bp : Int, period_minutes : Int) -> SloTarget

#
SloTarget::to_metrics

source
fn SloTarget::to_metrics(self : SloTarget) -> String

#
TrafficSample

source
pub(all) struct TrafficSample {
  minute : Int
  total : Int
  good : Int
} derive(Eq, 
Debug)

#
TrafficSample::new

source
fn TrafficSample::new(minute : Int, total : Int, good : Int) -> TrafficSample

#
ValidationIssue

source
pub(all) struct ValidationIssue {
  code : String
  message : String
  kind : ValidationKind
} derive(Eq, 
Debug)

#
ValidationKind

source
pub(all) enum ValidationKind {
  EmptyName
  InvalidTarget
  InvalidWindow
  InvalidRule
  EmptyCollection
} derive(Eq, 
Debug)

#
ValidationReport

source
pub(all) struct ValidationReport {
  valid : Bool
  checked : Int
  issues : Array[ValidationIssue]
} derive(Eq, 
Debug)

#
ValidationReport::has_code

source
fn ValidationReport::has_code(self : ValidationReport, code : String) -> Bool

#
ValidationReport::issue_count

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

#
ValidationReport::summary

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

#
WindowPolicy

source
pub(all) struct WindowPolicy {
  name : String
  minutes : Int
  required : Bool
} derive(Eq, 
Debug)

#
WindowPolicy::duration_label

source
fn WindowPolicy::duration_label(self : WindowPolicy) -> String

#
WindowPolicy::new

source
fn WindowPolicy::new(name : String, minutes : Int, required : Bool) -> WindowPolicy

#
WindowStatistics

source
pub(all) struct WindowStatistics {
  window_count : Int
  total_requests : Int
  total_good : Int
  total_bad : Int
  min_availability_bp : Int
  max_availability_bp : Int
  average_availability_bp : Int
} derive(Eq, 
Debug)

#
WindowStatistics::error_rate_bp

source
fn WindowStatistics::error_rate_bp(self : WindowStatistics) -> Int

#
WindowStatistics::from_windows

source
fn WindowStatistics::from_windows(windows : Array[RequestWindow]) -> WindowStatistics

#
WindowStatistics::healthy

source
fn WindowStatistics::healthy(self : WindowStatistics, target : SloTarget) -> Bool

#
WindowStatistics::merge

source

#
WindowStatistics::to_json

source
fn WindowStatistics::to_json(self : WindowStatistics) -> String

#
aggregate_recent_samples

source
fn aggregate_recent_samples(name : String, now_minute : Int, window_minutes : Int, samples : Array[TrafficSample]) -> RequestWindow

#
aggregate_samples

source
fn aggregate_samples(name : String, window_minutes : Int, samples : Array[TrafficSample]) -> RequestWindow

#
annotate_window

source
fn annotate_window(window : RequestWindow, start_minute : Int, annotations : Array[SloAnnotation]) -> AnnotatedWindow

#
availability_band

source
fn availability_band(availability_bp : Int) -> String

#
batch_availability_bp

source
fn batch_availability_bp(batch : RequestBatch) -> Int

#
batch_error_rate_bp

source
fn batch_error_rate_bp(batch : RequestBatch) -> Int

#
best_window

source
fn best_window(windows : Array[RequestWindow]) -> RequestWindow

#
budget_headroom

source
fn budget_headroom(report : BudgetReport) -> Int

#
budget_status_priority

source
fn budget_status_priority(status : String) -> Int

#
calculate_burn_rate

source
fn calculate_burn_rate(target : SloTarget, window : RequestWindow) -> BurnReport

#
compare_reports

source
fn compare_reports(before : HealthReport, after : HealthReport) -> String

#
compliance_label

source
fn compliance_label(score_bp : Int) -> String

#
compliance_score

source
fn compliance_score(target : SloTarget, windows : Array[RequestWindow]) -> Int

#
default_slo_config

source
fn default_slo_config(target : SloTarget) -> SloConfig

#
error_rate_percent

source
fn error_rate_percent(error_bp : Int) -> String

#
evaluate_budget

source
fn evaluate_budget(target : SloTarget, window : RequestWindow) -> BudgetReport

#
evaluate_burn_rule

source
fn evaluate_burn_rule(report : BurnReport, rule : BurnRule) -> AlertDecision

#
evaluate_multi_window

source
fn evaluate_multi_window(target : SloTarget, windows : Array[RequestWindow], rules : Array[BurnRule]) -> MultiWindowReport

#
evaluate_release_gate

source
fn evaluate_release_gate(gate : ReleaseGate, budget : BudgetReport, report : MultiWindowReport) -> GateDecision

#
evaluate_release_readiness

source
fn evaluate_release_readiness(target : SloTarget, current : RequestWindow, recent : Array[RequestWindow]) -> ReliabilityResult

#
evaluate_service_objective

source
fn evaluate_service_objective(objective : ServiceObjective, budget_window : RequestWindow, burn_windows : Array[RequestWindow], gate : ReleaseGate) -> ServiceEvaluation

#
forecast_budget

source
fn forecast_budget(target : SloTarget, window : RequestWindow, lookback_minutes : Int) -> BudgetForecast

#
health_label

source
fn health_label(healthy : Bool) -> String

#
merge_batches

source
fn merge_batches(left : RequestBatch, right : RequestBatch) -> RequestBatch

#
merge_validation

source
fn merge_validation(a : ValidationReport, b : ValidationReport) -> ValidationReport

#
metrics_document

source
fn metrics_document(target : SloTarget, budgets : Array[BudgetReport], service : String) -> String

#
project_budget

source
fn project_budget(target : SloTarget, current : RequestWindow, additional_total : Int, additional_bad : Int) -> BudgetProjection

#
remaining_budget_ratio_bp

source
fn remaining_budget_ratio_bp(report : BudgetReport) -> Int

#
report_is_regression

source
fn report_is_regression(before : HealthReport, after : HealthReport) -> Bool

#
severity_from_score

source
fn severity_from_score(score : Int) -> ReportSeverity

#
standard_burn_rules

source
fn standard_burn_rules() -> Array[BurnRule]

#
standard_window_minutes

source
fn standard_window_minutes() -> Array[Int]

#
standard_window_names

source
fn standard_window_names() -> Array[String]

#
target_gap_bp

source
fn target_gap_bp(target : SloTarget, window : RequestWindow) -> Int

#
target_is_met

source
fn target_is_met(target : SloTarget, window : RequestWindow) -> Bool

#
validate_config

source
fn validate_config(config : SloConfig) -> ValidationReport

#
validate_rule

source
fn validate_rule(rule : BurnRule) -> ValidationReport

#
validate_samples

source
fn validate_samples(samples : Array[TrafficSample]) -> ValidationReport

#
validate_target

source
fn validate_target(target : SloTarget) -> ValidationReport

#
validate_window

source
fn validate_window(window : RequestWindow) -> ValidationReport

#
validate_windows

source
fn validate_windows(windows : Array[RequestWindow]) -> ValidationReport

#
windows_in_range

source
fn windows_in_range(windows : Array[RequestWindow], start : Int, end : Int) -> Array[RequestWindow]

#
worst_window

source
fn worst_window(windows : Array[RequestWindow]) -> RequestWindow

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io