🥮 mooncakes.io

moon-change-point

Production-oriented MoonBit change-point detection, streaming windows, multivariate monitoring, replay, SLO and alert routing

change-point
anomaly-detection
time-series
cusum
moon add Zy789kl/moon-change-point@0.3.0
Download zip
Author
Version
0.3.0
License
Apache-2.0
Repository
Last updated
1 hour ago
Downloads
6
README

#moon-change-point

moon-change-point is a MoonBit library for online and offline statistical change-point detection in production telemetry and time-series pipelines. It targets WASM, WASM-GC, JavaScript, and native builds through the standard MoonBit toolchain.

#Project positioning

The library provides composable detection primitives for mean shifts, variance changes, spikes, trends, distribution drift, and multivariate changes. It also includes the surrounding data-quality, streaming, evaluation, replay, and alerting utilities needed to move from a detector score to an operational signal.

#Core capabilities

  • Online detection: CUSUM, Page-Hinkley, simplified Bayesian online detection, EWMA, Robust-Z, IQR, trend, variance, seasonal, rank, and distribution detectors.
  • Streaming pipelines: bounded windows, time aggregation, watermark-based late-data handling, multi-metric monitoring, suppression, ensembles, and multi-scale evidence.
  • Offline analysis: binary segmentation, dynamic programming, split inspection, change-point metrics, tolerance-aware evaluation, and piecewise-constant error.
  • Multivariate monitoring: vector statistics, projection detection, Mahalanobis distance, covariance/correlation analysis, and correlated-change scoring.
  • Operational utilities: data-quality contracts, threshold calibration, bootstrap estimates, deterministic signal generation, replay comparison, explanations, SLO tracking, incident clustering, alert routing, rollout guardrails, and canary plans.
  • Integration outputs: stable JSON Lines, CSV, Prometheus, Markdown, and summary JSON exports for logs, notebooks, CI artifacts, and dashboards.

#Quick start

Add the package to a MoonBit module:

moon add Zy789kl/moon-change-point

Use a detector through the public package API:

///|
import {
  "Zy789kl/moon-change-point" @cp,
}

///|
fn main {
  let detector = @cp.Cusum::new(target_mean=0.0, control_limit=5.0, drift=0.5)
  let result = detector.update_result(2.0, index=1)
  println(result.summary())
}

DetectionResult exposes changed, score, confidence, direction, index, and evidence, so callers can choose their own storage and alerting policy.

#CLI

The repository includes a small reproducible command-line program:

moon run cmd/main

It generates a fixed 512-sample mean-and-variance-shift scenario and prints a Markdown benchmark table for CUSUM, Robust-Z, and projection ensemble detection. The library API remains the primary integration surface for applications.

#Architecture

The root package is organized by responsibility:

  • types.mbt, stats.mbt, and window.mbt define public results, stable online statistics, and bounded windows.
  • cusum.mbt, page_hinkley.mbt, bayesian.mbt, adaptive_detectors.mbt, and advanced_detectors.mbt implement online detectors.
  • pipeline.mbt, stream_engine.mbt, time_windows.mbt, events.mbt, and alert_routing.mbt compose detectors into streaming workflows.
  • offline_analysis.mbt, segment_quality.mbt, features.mbt, and rank_tests.mbt provide historical analysis and feature-level evidence.
  • multivariate.mbt, matrix.mbt, and correlation.mbt cover vector and cross-series monitoring.
  • quality.mbt, calibration.mbt, sampling.mbt, replay.mbt, explainability.mbt, and reporting.mbt support validation, reproducibility, and integration.
  • production_*.mbt provides production-facing contracts, preprocessing, forecasting, monitoring, incident lifecycle, SLOs, rollout guardrails, canary control, and telemetry export.
  • cmd/main is a runnable benchmark entry point; it does not add a second library abstraction.

#Benchmark

The benchmark uses a deterministic 512-sample scenario with change point 256, baseline 10.0, mean shift 2.0, pre-change noise 0.15, post-change noise 0.7, and seed 20260818.

detectordetectionsfirst detectionprecisionrecallF1
CUSUM772580.01298701298701298810.025641025641025647
Robust-Z112570.0909090909090909110.16666666666666669
Projection ensemble1257111

The complete table, checksums, reproduction command, and local wall-clock measurements are in BENCHMARK.md.

#Tests

The repository contains boundary, regression, integration, and long-stream tests for the public API:

moon fmt --check
moon check --deny-warn --target all
moon build --target all
moon test --deny-warn --target all

The current test suite passes 425 tests. moon info regenerates the tracked public interface files so API changes are visible in review.

#CI

GitHub Actions installs the latest stable MoonBit toolchain and runs format, warning-free checks, all-target builds, generated-interface checks, and tests on Ubuntu, macOS, and Windows. The reproducible benchmark workflow runs manually or for version tags.

#License

Apache-2.0. See LICENSE.

The published package is available as Zy789kl/moon-change-point, and the source repository is github.com/Zy789kl/moon-change-point.

#
AdaptiveBaseline

source
pub struct AdaptiveBaseline {
  moments : OnlineMoments
  value : Double
  learning_rate : Double
  initialized : Bool
}

A slowly adapting baseline for streams whose normal level changes over time.

#
AdaptiveBaseline::new

source
fn AdaptiveBaseline::new(learning_rate? : Double) -> AdaptiveBaseline

#
AdaptiveBaseline::sample_count

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

#
AdaptiveBaseline::summary

source

#
AdaptiveBaseline::update

source
fn AdaptiveBaseline::update(self : AdaptiveBaseline, observation : Double) -> Double

#
AdaptiveBaseline::value

source
fn AdaptiveBaseline::value(self : AdaptiveBaseline) -> Double

#
AdaptiveThreshold

source
pub struct AdaptiveThreshold {
  threshold : Double
  rate : Double
  minimum : Double
  maximum : Double
  count : Int
}

#
AdaptiveThreshold::count

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

#
AdaptiveThreshold::new

source
fn AdaptiveThreshold::new(initial? : Double, rate? : Double, minimum? : Double, maximum? : Double) -> AdaptiveThreshold

#
AdaptiveThreshold::observe

source
fn AdaptiveThreshold::observe(self : AdaptiveThreshold, score : Double, positive : Bool) -> Double

#
AdaptiveThreshold::value

source
fn AdaptiveThreshold::value(self : AdaptiveThreshold) -> Double

#
AggregationKind

source
pub(all) enum AggregationKind {
  MeanAggregate
  SumAggregate
  MinimumAggregate
  MaximumAggregate
  StandardDeviationAggregate
}

Aggregation choices for a fixed streaming window.

#
AlertBudget

source
pub struct AlertBudget {
  capacity : Double
  refill : Double
  tokens : Double
  suppressed : Int
}

#
AlertBudget::allow

source
fn AlertBudget::allow(self : AlertBudget) -> Bool

#
AlertBudget::new

source
fn AlertBudget::new(capacity? : Int, refill? : Double) -> AlertBudget

#
AlertBudget::suppressed

source
fn AlertBudget::suppressed(self : AlertBudget) -> Int

#
AlertBudget::tick

source
fn AlertBudget::tick(self : AlertBudget) -> Unit

#
AlertEvent

source
pub struct AlertEvent {
  metric : String
  point : ChangePoint
  suppressed : Bool
  ordinal : Int
}

A named alert emitted by a multi-series pipeline.

#
AlertEvent::new

source
fn AlertEvent::new(metric : String, point : ChangePoint, suppressed? : Bool, ordinal? : Int) -> AlertEvent

Constructs an alert event.

#
AlertPolicy

source
pub struct AlertPolicy {
  minimum_score : Double
  minimum_confidence : Double
  minimum_gap : Int
  recovery_points : Int
  quiet_points : Int
  healthy_points : Int
}

Controls deduplication, minimum severity, and recovery for one metric.

#
AlertPolicy::accept

source
fn AlertPolicy::accept(self : AlertPolicy, result : DetectionResult) -> Bool

#
AlertPolicy::minimum_score

source
fn AlertPolicy::minimum_score(self : AlertPolicy) -> Double

#
AlertPolicy::new

source
fn AlertPolicy::new(minimum_score? : Double, minimum_confidence? : Double, minimum_gap? : Int, recovery_points? : Int) -> AlertPolicy

#
AlertPolicy::reset

source
fn AlertPolicy::reset(self : AlertPolicy) -> Unit

#
AlertSeverity

source
pub(all) enum AlertSeverity {
  Informational
  Warning
  Critical
}

The severity used by alerting integrations.

#
Ar1Forecaster

source
pub struct Ar1Forecaster {
  mean : Double
  covariance : Double
  variance : Double
  previous : Double
  count : Int
  forgetting : Double
}

#
Ar1Forecaster::new

source
fn Ar1Forecaster::new(forgetting? : Double) -> Ar1Forecaster

#
Ar1Forecaster::update

source
fn Ar1Forecaster::update(self : Ar1Forecaster, value : Double) -> ForecastPoint

#
Bayesian

source
pub struct Bayesian {
  hazard_rate : Double
  run_length_probs : Array[Double]
  mu_t : Array[Double]
  kappa_t : Array[Double]
  alpha_t : Array[Double]
  beta_t : Array[Double]
  mu0 : Double
  kappa0 : Double
  alpha0 : Double
  beta0 : Double
  max_run_length : Int
}

Bayesian implements a simplified Bayesian Online Change Point Detection using a Normal-Gamma conjugate prior.

#
Bayesian::new

source
fn Bayesian::new(hazard_rate? : Double, mu0? : Double, kappa0? : Double, alpha0? : Double, beta0? : Double, max_run_length? : Int) -> Bayesian

Creates a new Bayesian Online Change Point Detector.

#
Bayesian::update

source
fn Bayesian::update(self : Bayesian, value : Double) -> Double

Updates the detector and returns the probability of a change point at the current step.

#
Bayesian::update_result

source
fn Bayesian::update_result(self : Bayesian, value : Double, index? : Int) -> DetectionResult

Rich result form of the Bayesian update.

#
BenchmarkResult

source
pub struct BenchmarkResult {
  name : String
  samples : Int
  passes : Int
  detections : Int
  first_detection : Int
  checksum : Double
  truth_count : Int
  metrics : ChangePointMetrics
}

Results of a deterministic detector benchmark.

#
BenchmarkResult::empty

source
fn BenchmarkResult::empty(name : String) -> BenchmarkResult

#
BenchmarkResult::summary

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

#
BootstrapEstimate

source
pub struct BootstrapEstimate {
  mean : Double
  lower : Double
  upper : Double
  standard_error : Double
  replicates : Int
}

#
ChangeDirection

source
pub(all) enum ChangeDirection {
  Increase
  Decrease
  VarianceIncrease
  VarianceDecrease
  DistributionShift
  Unknown
}

The direction of a distributional change.

#
ChangePoint

source
pub struct ChangePoint {
  timestamp : Int64
  index : Int
  score : Double
  confidence : Double
  severity : AlertSeverity
  direction : ChangeDirection
  detector : String
  baseline : Double
  observed : Double
}

A detected change with enough context for a downstream alert or dashboard.

#
ChangePoint::from_result

source
fn ChangePoint::from_result(point : SignalPoint, result : DetectionResult, detector : String, baseline : Double) -> ChangePoint

Creates a change point from an online result.

#
ChangePoint::summary

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

Returns a stable log line for a change point.

#
ChangePointMetrics

source
pub struct ChangePointMetrics {
  true_positives : Int
  false_positives : Int
  false_negatives : Int
  precision : Double
  recall : Double
  f1 : Double
  mean_detection_delay : Double
}

Quality metrics for a set of predicted change indices.

#
ChangePointMetrics::empty

source

#
ConsecutiveRule

source
pub struct ConsecutiveRule {
  required : Int
  hits : Int
  misses : Int
}

A debouncer that requires several consecutive positive observations.

#
ConsecutiveRule::hits

source
fn ConsecutiveRule::hits(self : ConsecutiveRule) -> Int

#
ConsecutiveRule::new

source
fn ConsecutiveRule::new(required? : Int) -> ConsecutiveRule

#
ConsecutiveRule::push

source
fn ConsecutiveRule::push(self : ConsecutiveRule, positive : Bool) -> Bool

#
Cusum

source
pub struct Cusum {
  target_mean : Double
  control_limit : Double
  drift : Double
  g_positive : Double
  g_negative : Double
  t : Int
}

Cusum implements the Cumulative Sum algorithm for detecting shifts in the mean.

#
Cusum::new

source
fn Cusum::new(target_mean? : Double, control_limit? : Double, drift? : Double) -> Cusum

Creates a new CUSUM detector.

#
Cusum::reset

source
fn Cusum::reset(self : Cusum) -> Unit

Resets the internal accumulators.

#
Cusum::update

source
fn Cusum::update(self : Cusum, value : Double) -> Bool

Updates the CUSUM detector with a new value and returns true if a change is detected.

#
Cusum::update_result

source
fn Cusum::update_result(self : Cusum, value : Double, index? : Int) -> DetectionResult

Rich result form of update, retaining the direction and evidence.

#
DataQualityGate

source
pub struct DataQualityGate {
  minimum_ratio : Double
  reject_non_monotonic : Bool
  reject_dimension_mismatch : Bool
}

#
DataQualityGate::accept

source
fn DataQualityGate::accept(self : DataQualityGate, report : QualityReport) -> Bool

#
DataQualityGate::new

source
fn DataQualityGate::new(minimum_ratio? : Double, reject_non_monotonic? : Bool, reject_dimension_mismatch? : Bool) -> DataQualityGate

#
DetectionExplanation

source
pub struct DetectionExplanation {
  result : DetectionResult
  baseline : Double
  observed : Double
  deviation : Double
  relative_change : Double
  contributions : Array[EvidenceContribution]
  recommendation : String
}

#
DetectionExplanation::empty

source
fn DetectionExplanation::empty(index? : Int) -> DetectionExplanation

#
DetectionResult

source
pub struct DetectionResult {
  changed : Bool
  score : Double
  confidence : Double
  direction : ChangeDirection
  index : Int
  evidence : Double
}

A normalized result returned by online and offline detectors.

#
DetectionResult::new

source
fn DetectionResult::new(changed : Bool, score : Double, confidence : Double, direction : ChangeDirection, index : Int, evidence? : Double) -> DetectionResult

Builds a result while keeping confidence and evidence in a safe range.

#
DetectionResult::quiet

source
fn DetectionResult::quiet(index? : Int) -> DetectionResult

Returns a result that represents an ordinary observation.

#
DetectionResult::summary

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

Produces a compact representation suitable for logs.

#
Detector

source
pub struct Detector {
  detector : DetectorType
  suppression_count : Int
  suppression_limit : Int
}

Detector wraps a specific algorithm and supports multi-metric alert suppression.

#
Detector::new

source
fn Detector::new(detector : DetectorType, suppression_limit? : Int) -> Detector

Creates a new multi-metric detector wrapper.

#
Detector::update

source
fn Detector::update(self : Detector, value : Double) -> Bool

Updates the detector and handles alert suppression. Returns true if an unsuppressed alert is triggered.

#
Detector::update_result

source
fn Detector::update_result(self : Detector, value : Double, index? : Int) -> DetectionResult

Rich result form of the detector wrapper. Suppression is applied to the change flag only.

#
DetectorSpec

source
pub struct DetectorSpec {
  name : String
  family : String
  online : Bool
  multivariate : Bool
  robust : Bool
  default_threshold : Double
  description : String
}

Public algorithm metadata for dashboards and configuration UIs.

#
DetectorSpec::new

source
fn DetectorSpec::new(name : String, family : String, online : Bool, multivariate : Bool, robust : Bool, default_threshold : Double, description : String) -> DetectorSpec

#
DetectorSpec::summary

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

#
DetectorType

source
pub(all) enum DetectorType {
  CusumDetector(Cusum)
  PageHinkleyDetector(PageHinkley)
  BayesianDetector(Bayesian)
}

DetectorType represents the type of change point detector to use.

#
DeterministicRng

source
pub struct DeterministicRng {
  state : Int64
}

A deterministic pseudo-random source used by benchmarks and reproducible tests.

#
DeterministicRng::new

source
fn DeterministicRng::new(seed? : Int64) -> DeterministicRng

#
DeterministicRng::next

source
fn DeterministicRng::next(self : DeterministicRng) -> Int64

#
DeterministicRng::normalish

source
fn DeterministicRng::normalish(self : DeterministicRng, amplitude? : Double) -> Double

#
DeterministicRng::symmetric

source
fn DeterministicRng::symmetric(self : DeterministicRng) -> Double

#
DeterministicRng::unit

source
fn DeterministicRng::unit(self : DeterministicRng) -> Double

#
DistributionShiftDetector

source
pub struct DistributionShiftDetector {
  reference : DoubleWindow
  current : DoubleWindow
  threshold : Double
  index : Int
}

Compares adjacent windows and emits a distribution-shift result.

#
DistributionShiftDetector::new

source
fn DistributionShiftDetector::new(window_size? : Int, threshold? : Double) -> DistributionShiftDetector

#
DistributionShiftDetector::update

source

#
DoubleWindow

source
pub struct DoubleWindow {
  capacity : Int
  values : Array[Double]
  start : Int
  length : Int
}

A bounded ring buffer for numeric streaming windows.

#
DoubleWindow::capacity

source
fn DoubleWindow::capacity(self : DoubleWindow) -> Int

#
DoubleWindow::clear

source
fn DoubleWindow::clear(self : DoubleWindow) -> Unit

#
DoubleWindow::first

source
fn DoubleWindow::first(self : DoubleWindow) -> Double?

#
DoubleWindow::get

source
fn DoubleWindow::get(self : DoubleWindow, index : Int) -> Double?

#
DoubleWindow::is_empty

source
fn DoubleWindow::is_empty(self : DoubleWindow) -> Bool

#
DoubleWindow::is_full

source
fn DoubleWindow::is_full(self : DoubleWindow) -> Bool

#
DoubleWindow::last

source
fn DoubleWindow::last(self : DoubleWindow) -> Double?

#
DoubleWindow::length

source
fn DoubleWindow::length(self : DoubleWindow) -> Int

#
DoubleWindow::mean

source
fn DoubleWindow::mean(self : DoubleWindow) -> Double

#
DoubleWindow::median

source
fn DoubleWindow::median(self : DoubleWindow) -> Double

#
DoubleWindow::new

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

Creates a fixed-capacity window. Non-positive capacities are normalized to one.

#
DoubleWindow::push

source
fn DoubleWindow::push(self : DoubleWindow, value : Double) -> Double?

Adds a value and returns the value evicted from a full window, if any.

#
DoubleWindow::quantile

source
fn DoubleWindow::quantile(self : DoubleWindow, probability : Double) -> Double

#
DoubleWindow::slope

source
fn DoubleWindow::slope(self : DoubleWindow) -> Double

#
DoubleWindow::snapshot

source
fn DoubleWindow::snapshot(self : DoubleWindow) -> StatsSummary

#
DoubleWindow::standard_deviation

source
fn DoubleWindow::standard_deviation(self : DoubleWindow) -> Double

#
DoubleWindow::sum

source
fn DoubleWindow::sum(self : DoubleWindow) -> Double

#
DoubleWindow::to_array

source
fn DoubleWindow::to_array(self : DoubleWindow) -> Array[Double]

#
DoubleWindow::variance

source
fn DoubleWindow::variance(self : DoubleWindow) -> Double

#
DualSidedDetector

source
pub struct DualSidedDetector {
  positive : Cusum
  negative : Cusum
  index : Int
}

#
DualSidedDetector::new

source
fn DualSidedDetector::new(target? : Double, limit? : Double, drift? : Double) -> DualSidedDetector

#
DualSidedDetector::update

source
fn DualSidedDetector::update(self : DualSidedDetector, value : Double) -> DetectionResult

#
EnsembleResult

source
pub struct EnsembleResult {
  result : DetectionResult
  votes : Int
  detector_count : Int
  agreement : Double
}

#
EventHistory

source
pub struct EventHistory {
  capacity : Int
  events : Array[AlertEvent]
  total : Int
}

#
EventHistory::critical_count

source
fn EventHistory::critical_count(self : EventHistory) -> Int

#
EventHistory::events

source
fn EventHistory::events(self : EventHistory) -> Array[AlertEvent]

#
EventHistory::latest

source
fn EventHistory::latest(self : EventHistory) -> AlertEvent?

#
EventHistory::length

source
fn EventHistory::length(self : EventHistory) -> Int

#
EventHistory::new

source
fn EventHistory::new(capacity? : Int) -> EventHistory

#
EventHistory::push

source
fn EventHistory::push(self : EventHistory, event : AlertEvent) -> Unit

#
EventHistory::total

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

#
EventHistory::unsuppressed_count

source
fn EventHistory::unsuppressed_count(self : EventHistory) -> Int

#
EvidenceContribution

source
pub struct EvidenceContribution {
  name : String
  value : Double
  weight : Double
  contribution : Double
}

Structured evidence for explaining why a detector emitted an alert.

#
EvidenceContribution::new

source
fn EvidenceContribution::new(name : String, value : Double, weight? : Double) -> EvidenceContribution

#
EwmaDetector

source
pub struct EwmaDetector {
  baseline : Double
  variance : Double
  alpha : Double
  threshold : Double
  warmup : Int
  count : Int
  index : Int
  initialized : Bool
}

EWMA residual detector. It is useful for low-latency monitoring of a service metric.

#
EwmaDetector::baseline

source
fn EwmaDetector::baseline(self : EwmaDetector) -> Double

#
EwmaDetector::new

source
fn EwmaDetector::new(alpha? : Double, threshold? : Double, warmup? : Int, initial_mean? : Double, initial_variance? : Double) -> EwmaDetector

#
EwmaDetector::reset

source
fn EwmaDetector::reset(self : EwmaDetector) -> Unit

#
EwmaDetector::scale

source
fn EwmaDetector::scale(self : EwmaDetector) -> Double

#
EwmaDetector::update

source
fn EwmaDetector::update(self : EwmaDetector, value : Double) -> DetectionResult

#
FeatureExtractor

source
pub struct FeatureExtractor {
  left : DoubleWindow
  right : DoubleWindow
  threshold : Double
  index : Int
}

#
FeatureExtractor::new

source
fn FeatureExtractor::new(window_size? : Int, threshold? : Double) -> FeatureExtractor

#
FeatureExtractor::update

source
fn FeatureExtractor::update(self : FeatureExtractor, value : Double) -> DetectionResult

#
ForecastPoint

source
pub struct ForecastPoint {
  prediction : Double
  lower : Double
  upper : Double
  residual : Double
}

#
ForecastPoint::new

source
fn ForecastPoint::new(prediction : Double, residual : Double, uncertainty? : Double) -> ForecastPoint

#
Histogram

source
pub struct Histogram {
  minimum : Double
  maximum : Double
  bins : Int
  counts : Array[Int]
  total : Int
}

A fixed-edge histogram for monitoring changes in value distribution.

#
Histogram::bins

source
fn Histogram::bins(self : Histogram) -> Int

#
Histogram::counts

source
fn Histogram::counts(self : Histogram) -> Array[Int]

#
Histogram::new

source
fn Histogram::new(minimum : Double, maximum : Double, bins : Int) -> Histogram

#
Histogram::probabilities

source
fn Histogram::probabilities(self : Histogram) -> Array[Double]

#
Histogram::push

source
fn Histogram::push(self : Histogram, value : Double) -> Unit

#
Histogram::reset

source
fn Histogram::reset(self : Histogram) -> Unit

#
Histogram::total

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

#
HoltForecaster

source
pub struct HoltForecaster {
  level : Double
  trend : Double
  alpha : Double
  beta : Double
  count : Int
}

#
HoltForecaster::new

source
fn HoltForecaster::new(alpha? : Double, beta? : Double) -> HoltForecaster

#
HoltForecaster::update

source
fn HoltForecaster::update(self : HoltForecaster, value : Double, horizon? : Int) -> ForecastPoint

#
HysteresisRule

source
pub struct HysteresisRule {
  enter_threshold : Double
  exit_threshold : Double
  active : Bool
}

Hysteresis prevents alert flapping around a single threshold.

#
HysteresisRule::active

source
fn HysteresisRule::active(self : HysteresisRule) -> Bool

#
HysteresisRule::new

source
fn HysteresisRule::new(enter_threshold? : Double, exit_threshold? : Double) -> HysteresisRule

#
HysteresisRule::push

source
fn HysteresisRule::push(self : HysteresisRule, score : Double) -> Bool

#
Incident

source
pub struct Incident {
  metric : String
  first_timestamp : Int64
  last_timestamp : Int64
  alerts : Int
  critical : Int
  maximum_score : Double
  direction : ChangeDirection
}

Groups nearby alert events into incidents for operators.

#
Incident::add

source
fn Incident::add(self : Incident, event : AlertEvent) -> Unit

#
Incident::duration

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

#
Incident::empty

source
fn Incident::empty(metric : String) -> Incident

#
Incident::is_critical

source
fn Incident::is_critical(self : Incident) -> Bool

#
Incident::summary

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

#
IqrSpikeDetector

source
pub struct IqrSpikeDetector {
  window : DoubleWindow
  multiplier : Double
  warmup : Int
  index : Int
}

A lightweight detector for isolated spikes using a rolling interquartile fence.

#
IqrSpikeDetector::new

source
fn IqrSpikeDetector::new(window_size? : Int, multiplier? : Double) -> IqrSpikeDetector

#
IqrSpikeDetector::update

source
fn IqrSpikeDetector::update(self : IqrSpikeDetector, value : Double) -> DetectionResult

#
LateDataPolicy

source
pub(all) enum LateDataPolicy {
  Drop
  KeepForCorrection
  ReplaceSameTimestamp
}

The policy applied when a timestamp is older than the accepted watermark.

#
LinearForecaster

source
pub struct LinearForecaster {
  window : DoubleWindow
  horizon : Int
  uncertainty_multiplier : Double
}

#
LinearForecaster::fit

source
fn LinearForecaster::fit(self : LinearForecaster, value : Double) -> ForecastPoint

#
LinearForecaster::new

source
fn LinearForecaster::new(window_size? : Int, horizon? : Int, uncertainty_multiplier? : Double) -> LinearForecaster

#
MahalanobisDetector

source
pub struct MahalanobisDetector {
  stats : OnlineVectorStats
  threshold : Double
  warmup : Int
  index : Int
}

Diagonal Mahalanobis detector. It remains usable when a full covariance matrix is unavailable.

#
MahalanobisDetector::count

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

#
MahalanobisDetector::dimension

source
fn MahalanobisDetector::dimension(self : MahalanobisDetector) -> Int

#
MahalanobisDetector::new

source
fn MahalanobisDetector::new(dimension : Int, threshold? : Double, warmup? : Int) -> MahalanobisDetector

#
MahalanobisDetector::update

source
fn MahalanobisDetector::update(self : MahalanobisDetector, values : Array[Double]) -> DetectionResult

#
MeanVarianceDetector

source
pub struct MeanVarianceDetector {
  baseline : DoubleWindow
  current : DoubleWindow
  mean_threshold : Double
  variance_threshold : Double
  index : Int
}

#
MeanVarianceDetector::new

source
fn MeanVarianceDetector::new(window_size? : Int, mean_threshold? : Double, variance_threshold? : Double) -> MeanVarianceDetector

#
MeanVarianceDetector::update

source
fn MeanVarianceDetector::update(self : MeanVarianceDetector, value : Double) -> DetectionResult

#
MetricPipeline

source
pub struct MetricPipeline {
  name : String
  detector : PipelineDetector
  policy : AlertPolicy
  index : Int
  ordinal : Int
  baseline : Double
}

One named metric with a detector and an alert policy.

#
MetricPipeline::index

source
fn MetricPipeline::index(self : MetricPipeline) -> Int

#
MetricPipeline::new

source
fn MetricPipeline::new(name : String, detector : PipelineDetector, policy? : AlertPolicy, baseline? : Double) -> MetricPipeline

#
MetricPipeline::process

source
fn MetricPipeline::process(self : MetricPipeline, timestamp : Int64, value : Double) -> AlertEvent?

#
MetricPipeline::reset

source
fn MetricPipeline::reset(self : MetricPipeline) -> Unit

#
MissingValueStrategy

source
pub(all) enum MissingValueStrategy {
  DropValue
  ImputeLast
  ImputeMean
  ImputeZero
  MarkUnknown
}

Strategy used when an input value is not usable.

#
MultiMetricMonitor

source
pub struct MultiMetricMonitor {
  pipelines : Array[MetricPipeline]
  processed : Int
  emitted : Int
  suppressed : Int
}

A deterministic multi-metric monitor. It is intentionally array-backed for WASM portability.

#
MultiMetricMonitor::emitted_count

source
fn MultiMetricMonitor::emitted_count(self : MultiMetricMonitor) -> Int

#
MultiMetricMonitor::metric_count

source
fn MultiMetricMonitor::metric_count(self : MultiMetricMonitor) -> Int

#
MultiMetricMonitor::new

source

#
MultiMetricMonitor::process

source
fn MultiMetricMonitor::process(self : MultiMetricMonitor, metric_index : Int, timestamp : Int64, value : Double) -> AlertEvent?

#
MultiMetricMonitor::process_batch

source
fn MultiMetricMonitor::process_batch(self : MultiMetricMonitor, metric_index : Int, points : Array[SignalPoint]) -> Array[AlertEvent]

#
MultiMetricMonitor::processed_count

source
fn MultiMetricMonitor::processed_count(self : MultiMetricMonitor) -> Int

#
MultiMetricMonitor::suppressed_count

source
fn MultiMetricMonitor::suppressed_count(self : MultiMetricMonitor) -> Int

#
MultiScaleDetector

source
pub struct MultiScaleDetector {
  short : RobustZDetector
  medium : RobustZDetector
  long : TrendShiftDetector
  minimum_consensus : Double
  index : Int
}

#
MultiScaleDetector::new

source
fn MultiScaleDetector::new(short? : Int, medium? : Int, long? : Int, minimum_consensus? : Double) -> MultiScaleDetector

#
MultiScaleDetector::update

source
fn MultiScaleDetector::update(self : MultiScaleDetector, value : Double) -> DetectionResult

#
MultivariateEnsemble

source
pub struct MultivariateEnsemble {
  detectors : Array[ProjectionDetector]
  quorum : Int
  index : Int
}

An ensemble that combines several multivariate views with a quorum rule.

#
MultivariateEnsemble::detector_count

source
fn MultivariateEnsemble::detector_count(self : MultivariateEnsemble) -> Int

#
MultivariateEnsemble::new

source
fn MultivariateEnsemble::new(detectors : Array[ProjectionDetector], quorum? : Int) -> MultivariateEnsemble

#
MultivariateEnsemble::update

source
fn MultivariateEnsemble::update(self : MultivariateEnsemble, values : Array[Double]) -> DetectionResult

#
OfflineChange

source
pub struct OfflineChange {
  index : Int
  score : Double
  left_mean : Double
  right_mean : Double
  left_variance : Double
  right_variance : Double
  direction : ChangeDirection
}

A candidate change point returned by offline analysis.

#
OnlineEnsemble

source
pub struct OnlineEnsemble {
  detectors : Array[PipelineDetector]
  quorum : Int
  index : Int
}

#
OnlineEnsemble::count

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

#
OnlineEnsemble::new

source
fn OnlineEnsemble::new(detectors : Array[PipelineDetector], quorum? : Int) -> OnlineEnsemble

#
OnlineEnsemble::update

source
fn OnlineEnsemble::update(self : OnlineEnsemble, value : Double) -> EnsembleResult

#
OnlineMoments

source
pub struct OnlineMoments {
  count : Int
  mean : Double
  m2 : Double
  minimum : Double
  maximum : Double
}

Numerically stable online moments using Welford's recurrence.

#
OnlineMoments::count

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

#
OnlineMoments::maximum

source
fn OnlineMoments::maximum(self : OnlineMoments) -> Double

#
OnlineMoments::mean

source
fn OnlineMoments::mean(self : OnlineMoments) -> Double

#
OnlineMoments::merge

source
fn OnlineMoments::merge(self : OnlineMoments, other : OnlineMoments) -> Unit

#
OnlineMoments::minimum

source
fn OnlineMoments::minimum(self : OnlineMoments) -> Double

#
OnlineMoments::new

source

Creates an empty accumulator.

#
OnlineMoments::population_variance

source
fn OnlineMoments::population_variance(self : OnlineMoments) -> Double

#
OnlineMoments::push

source
fn OnlineMoments::push(self : OnlineMoments, value : Double) -> Unit

Adds one observation.

#
OnlineMoments::standard_deviation

source
fn OnlineMoments::standard_deviation(self : OnlineMoments) -> Double

#
OnlineMoments::summary

source
fn OnlineMoments::summary(self : OnlineMoments, median? : Double) -> StatsSummary

#
OnlineMoments::variance

source
fn OnlineMoments::variance(self : OnlineMoments) -> Double

#
OnlineMoments::with_prior

source
fn OnlineMoments::with_prior(mean : Double, variance : Double, weight : Int) -> OnlineMoments

Creates an accumulator with a prior mean and effective sample size.

#
OnlineVectorStats

source
pub struct OnlineVectorStats {
  dimension : Int
  count : Int
  means : Array[Double]
  m2 : Array[Double]
  minima : Array[Double]
  maxima : Array[Double]
}

Per-dimension Welford statistics for a vector stream.

#
OnlineVectorStats::count

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

#
OnlineVectorStats::dimension

source
fn OnlineVectorStats::dimension(self : OnlineVectorStats) -> Int

#
OnlineVectorStats::maximums

source
fn OnlineVectorStats::maximums(self : OnlineVectorStats) -> Array[Double]

#
OnlineVectorStats::means

source
fn OnlineVectorStats::means(self : OnlineVectorStats) -> Array[Double]

#
OnlineVectorStats::minimums

source
fn OnlineVectorStats::minimums(self : OnlineVectorStats) -> Array[Double]

#
OnlineVectorStats::new

source
fn OnlineVectorStats::new(dimension : Int) -> OnlineVectorStats

#
OnlineVectorStats::push

source
fn OnlineVectorStats::push(self : OnlineVectorStats, values : Array[Double]) -> Bool

#
OnlineVectorStats::standard_deviations

source
fn OnlineVectorStats::standard_deviations(self : OnlineVectorStats) -> Array[Double]

#
OnlineVectorStats::standardized

source
fn OnlineVectorStats::standardized(self : OnlineVectorStats, values : Array[Double]) -> Array[Double]

#
OnlineVectorStats::variances

source
fn OnlineVectorStats::variances(self : OnlineVectorStats) -> Array[Double]

#
OrderedPoint

source
pub struct OrderedPoint {
  point : SignalPoint
  late : Bool
  arrival_order : Int
}

A timestamped sample that has passed through a reorder buffer.

#
PageHinkley

source
pub struct PageHinkley {
  target_mean : Double
  control_limit : Double
  delta : Double
  alpha : Double
  sum : Double
  min_sum : Double
  n : Int
}

PageHinkley implements the Page-Hinkley test for online change point detection.

#
PageHinkley::new

source
fn PageHinkley::new(target_mean? : Double, control_limit? : Double, delta? : Double, alpha? : Double) -> PageHinkley

Creates a new Page-Hinkley detector.

#
PageHinkley::reset

source
fn PageHinkley::reset(self : PageHinkley) -> Unit

Resets the internal accumulators.

#
PageHinkley::update

source
fn PageHinkley::update(self : PageHinkley, value : Double) -> Bool

Updates the Page-Hinkley detector with a new value and returns true if a change is detected.

#
PageHinkley::update_result

source
fn PageHinkley::update_result(self : PageHinkley, value : Double, index? : Int) -> DetectionResult

Rich result form of update, retaining direction and cumulative evidence.

#
PersistenceDetector

source
pub struct PersistenceDetector {
  detector : EwmaDetector
  rule : ConsecutiveRule
  index : Int
}

#
PersistenceDetector::new

source
fn PersistenceDetector::new(warmup? : Int, persistence? : Int) -> PersistenceDetector

#
PersistenceDetector::update

source
fn PersistenceDetector::update(self : PersistenceDetector, value : Double) -> DetectionResult

#
PipelineDetector

source
pub(all) enum PipelineDetector {
  LegacyDetector(Detector)
  Ewma(EwmaDetector)
  RobustZ(RobustZDetector)
  VarianceShift(VarianceShiftDetector)
  TrendShift(TrendShiftDetector)
  IqrSpike(IqrSpikeDetector)
}

A detector that can be selected for a production metric pipeline.

#
PipelineDetector::update

source
fn PipelineDetector::update(self : PipelineDetector, value : Double, index : Int) -> DetectionResult

#
ProductionAdaptiveBaselineDetector

source
pub struct ProductionAdaptiveBaselineDetector {
  window : DoubleWindow
  learning_rate : Double
  threshold : Double
  warmup : Int
  baseline : Double
  index : Int
  initialized : Bool
}

Baseline-relative detector for services whose normal level changes gradually.

#
ProductionAdaptiveBaselineDetector::baseline

source

#
ProductionAdaptiveBaselineDetector::index

source

#
ProductionAdaptiveBaselineDetector::new

source
fn ProductionAdaptiveBaselineDetector::new(window_size? : Int, learning_rate? : Double, threshold? : Double, warmup? : Int) -> ProductionAdaptiveBaselineDetector

#
ProductionAdaptiveBaselineDetector::reset

source

#
ProductionAdaptiveBaselineDetector::update

source

#
ProductionAlertConfig

source
pub struct ProductionAlertConfig {
  minimum_score : Double
  minimum_confidence : Double
  minimum_gap : Int64
  recovery_points : Int
  action : RecoveryAction
  severity : AlertSeverity
  budget_per_window : Int
  budget_window : Int64
}

Alert and recovery settings for a monitored metric.

#
ProductionAlertConfig::action

source

#
ProductionAlertConfig::budget_per_window

source
fn ProductionAlertConfig::budget_per_window(self : ProductionAlertConfig) -> Int

#
ProductionAlertConfig::budget_window

source
fn ProductionAlertConfig::budget_window(self : ProductionAlertConfig) -> Int64

#
ProductionAlertConfig::minimum_confidence

source
fn ProductionAlertConfig::minimum_confidence(self : ProductionAlertConfig) -> Double

#
ProductionAlertConfig::minimum_gap

source
fn ProductionAlertConfig::minimum_gap(self : ProductionAlertConfig) -> Int64

#
ProductionAlertConfig::minimum_score

source
fn ProductionAlertConfig::minimum_score(self : ProductionAlertConfig) -> Double

#
ProductionAlertConfig::new

source
fn ProductionAlertConfig::new(minimum_score? : Double, minimum_confidence? : Double, minimum_gap? : Int64, recovery_points? : Int, action? : RecoveryAction, severity? : AlertSeverity, budget_per_window? : Int, budget_window? : Int64) -> ProductionAlertConfig

#
ProductionAlertConfig::recovery_points

source
fn ProductionAlertConfig::recovery_points(self : ProductionAlertConfig) -> Int

#
ProductionAlertConfig::severity

source

#
ProductionAlertEnvelope

source
pub struct ProductionAlertEnvelope {
  fingerprint : String
  event : AlertEvent
  delivery_attempts : Int
  delivered : Bool
  deduplicated : Int
}

Stable alert envelope used for deduplication and delivery retries.

#
ProductionAlertEnvelope::attempt

source

#
ProductionAlertEnvelope::deduplicated

source
fn ProductionAlertEnvelope::deduplicated(self : ProductionAlertEnvelope) -> Int

#
ProductionAlertEnvelope::delivered

source
fn ProductionAlertEnvelope::delivered(self : ProductionAlertEnvelope) -> Bool

#
ProductionAlertEnvelope::delivery_attempts

source
fn ProductionAlertEnvelope::delivery_attempts(self : ProductionAlertEnvelope) -> Int

#
ProductionAlertEnvelope::event

source

#
ProductionAlertEnvelope::fingerprint

source
fn ProductionAlertEnvelope::fingerprint(self : ProductionAlertEnvelope) -> String

#
ProductionAlertEnvelope::mark_delivered

source
fn ProductionAlertEnvelope::mark_delivered(self : ProductionAlertEnvelope) -> Unit

#
ProductionAlertEnvelope::mark_duplicate

source
fn ProductionAlertEnvelope::mark_duplicate(self : ProductionAlertEnvelope) -> Unit

#
ProductionAlertEnvelope::new

source
fn ProductionAlertEnvelope::new(fingerprint : String, event : AlertEvent) -> ProductionAlertEnvelope

#
ProductionBackpressurePolicy

source
pub(all) enum ProductionBackpressurePolicy {
  DropNewestSample
  DropOldestSample
  RejectProducer
}

Policy used when an in-memory stream queue reaches capacity.

#
ProductionBaselineStrategy

source
pub(all) enum ProductionBaselineStrategy {
  FixedBaseline
  RollingMedian
  RollingMean
  ExponentiallyWeighted
  SeasonalBaseline
}

Strategy used to establish a detector baseline.

#
ProductionBatchResult

source
pub struct ProductionBatchResult {
  batch_id : String
  input_count : Int
  accepted_count : Int
  rejected_count : Int
  event_count : Int
  alert_count : Int
  checksum : Double
  duration_ticks : Int64
}

Summary of a bounded batch processing run.

#
ProductionBatchResult::accepted_count

source
fn ProductionBatchResult::accepted_count(self : ProductionBatchResult) -> Int

#
ProductionBatchResult::alert_count

source
fn ProductionBatchResult::alert_count(self : ProductionBatchResult) -> Int

#
ProductionBatchResult::checksum

source
fn ProductionBatchResult::checksum(self : ProductionBatchResult) -> Double

#
ProductionBatchResult::duration_ticks

source
fn ProductionBatchResult::duration_ticks(self : ProductionBatchResult) -> Int64

#
ProductionBatchResult::event_count

source
fn ProductionBatchResult::event_count(self : ProductionBatchResult) -> Int

#
ProductionBatchResult::input_count

source
fn ProductionBatchResult::input_count(self : ProductionBatchResult) -> Int

#
ProductionBatchResult::rejected_count

source
fn ProductionBatchResult::rejected_count(self : ProductionBatchResult) -> Int

#
ProductionBatchResult::summary

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

#
ProductionBatchResult::throughput

source
fn ProductionBatchResult::throughput(self : ProductionBatchResult) -> Double

#
ProductionBucket

source
pub struct ProductionBucket {
  start_timestamp : Int64
  end_timestamp : Int64
  samples : Array[ProductionSample]
}

Fixed-size aggregation by event-time interval.

#
ProductionBucket::count

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

#
ProductionBucket::end

source
fn ProductionBucket::end(self : ProductionBucket) -> Int64

#
ProductionBucket::mean

source
fn ProductionBucket::mean(self : ProductionBucket) -> Double

#
ProductionBucket::new

source
fn ProductionBucket::new(start_timestamp : Int64, size : Int64) -> ProductionBucket

#
ProductionBucket::push

source
fn ProductionBucket::push(self : ProductionBucket, sample : ProductionSample) -> Bool

#
ProductionBucket::start

source
fn ProductionBucket::start(self : ProductionBucket) -> Int64

#
ProductionBucket::sum

source
fn ProductionBucket::sum(self : ProductionBucket) -> Double

#
ProductionBucket::summary

source

#
ProductionBucket::to_points

source

#
ProductionBucketizer

source
pub struct ProductionBucketizer {
  interval : Int64
  origin : Int64
  current : ProductionBucket?
  flushed : Int
  dropped : Int
}

Event-time bucketizer that flushes complete intervals in order.

#
ProductionBucketizer::dropped

source
fn ProductionBucketizer::dropped(self : ProductionBucketizer) -> Int

#
ProductionBucketizer::flush

source

#
ProductionBucketizer::flushed

source
fn ProductionBucketizer::flushed(self : ProductionBucketizer) -> Int

#
ProductionBucketizer::interval

source
fn ProductionBucketizer::interval(self : ProductionBucketizer) -> Int64

#
ProductionBucketizer::new

source
fn ProductionBucketizer::new(interval? : Int64, origin? : Int64) -> ProductionBucketizer

#
ProductionBucketizer::push

source

#
ProductionCalibrationBin

source
pub struct ProductionCalibrationBin {
  lower : Double
  upper : Double
  count : Int
  positives : Int
  mean_score : Double
  observed_rate : Double
}

A reliability bin used to audit score calibration.

#
ProductionCalibrationBin::count

source

#
ProductionCalibrationBin::lower

source

#
ProductionCalibrationBin::mean_score

source
fn ProductionCalibrationBin::mean_score(self : ProductionCalibrationBin) -> Double

#
ProductionCalibrationBin::observed_rate

source
fn ProductionCalibrationBin::observed_rate(self : ProductionCalibrationBin) -> Double

#
ProductionCalibrationBin::positives

source

#
ProductionCalibrationBin::upper

source

#
ProductionCalibrationMode

source
pub(all) enum ProductionCalibrationMode {
  IdentityCalibration
  HistogramCalibration
  PriorWeightedCalibration
}

Online score calibration mode for deployment-specific alert rates.

#
ProductionCanaryTracker

source
pub struct ProductionCanaryTracker {
  plan : ProductionRolloutPlan
  guardrail : ProductionGuardrailController
  observations : Int
  healthy_observations : Int
  blocked_observations : Int
  last_decision : ProductionGuardrailDecision?
}

Bounded canary tracker that joins guard decisions with rollout stages.

#
ProductionCanaryTracker::blocked_observations

source
fn ProductionCanaryTracker::blocked_observations(self : ProductionCanaryTracker) -> Int

#
ProductionCanaryTracker::guardrail

source

#
ProductionCanaryTracker::health

source

#
ProductionCanaryTracker::healthy_observations

source
fn ProductionCanaryTracker::healthy_observations(self : ProductionCanaryTracker) -> Int

#
ProductionCanaryTracker::last_decision

source

#
ProductionCanaryTracker::new

source

#
ProductionCanaryTracker::observations

source
fn ProductionCanaryTracker::observations(self : ProductionCanaryTracker) -> Int

#
ProductionCanaryTracker::observe

source

#
ProductionCanaryTracker::plan

source

#
ProductionCanaryTracker::reset

source

#
ProductionCanaryTracker::try_promote

source
fn ProductionCanaryTracker::try_promote(self : ProductionCanaryTracker, timestamp : Int64) -> Bool

#
ProductionCatalogSummary

source
pub struct ProductionCatalogSummary {
  names : Array[String]
  means : Array[Double]
  variances : Array[Double]
  counts : Array[Int]
  quality : Array[Double]
}

A matrix of rolling metric summaries for health dashboards.

#
ProductionCatalogSummary::counts

source

#
ProductionCatalogSummary::markdown

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

#
ProductionCatalogSummary::means

source

#
ProductionCatalogSummary::names

source

#
ProductionCatalogSummary::quality

source

#
ProductionCatalogSummary::variances

source

#
ProductionConfidenceInterval

source
pub struct ProductionConfidenceInterval {
  estimate : Double
  lower : Double
  upper : Double
  confidence : Double
  samples : Int
  test_kind : ProductionStatTestKind
}

Confidence interval for a production effect estimate.

#
ProductionConfidenceInterval::confidence

source

#
ProductionConfidenceInterval::contains

source
fn ProductionConfidenceInterval::contains(self : ProductionConfidenceInterval, value : Double) -> Bool

#
ProductionConfidenceInterval::estimate

source

#
ProductionConfidenceInterval::lower

source

#
ProductionConfidenceInterval::samples

source

#
ProductionConfidenceInterval::summary

source

#
ProductionConfidenceInterval::test_kind

source

#
ProductionConfidenceInterval::upper

source

#
ProductionConfidenceInterval::width

source

#
ProductionConfigIssue

source
pub struct ProductionConfigIssue {
  field : String
  message : String
  fatal : Bool
}

A single issue found while validating production configuration.

#
ProductionConfigIssue::fatal

source

#
ProductionConfigIssue::field

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

#
ProductionConfigIssue::message

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

#
ProductionConfigIssue::new

source
fn ProductionConfigIssue::new(field : String, message : String, fatal? : Bool) -> ProductionConfigIssue

#
ProductionConfigIssue::summary

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

#
ProductionConfusionMatrix

source
pub struct ProductionConfusionMatrix {
  true_positive : Int
  false_positive : Int
  true_negative : Int
  false_negative : Int
}

Confusion counts for a thresholded change-point decision stream.

#
ProductionConfusionMatrix::balanced_accuracy

source
fn ProductionConfusionMatrix::balanced_accuracy(self : ProductionConfusionMatrix) -> Double

#
ProductionConfusionMatrix::empty

source

#
ProductionConfusionMatrix::f1

source

#
ProductionConfusionMatrix::false_negative

source
fn ProductionConfusionMatrix::false_negative(self : ProductionConfusionMatrix) -> Int

#
ProductionConfusionMatrix::false_positive

source
fn ProductionConfusionMatrix::false_positive(self : ProductionConfusionMatrix) -> Int

#
ProductionConfusionMatrix::false_positive_rate

source
fn ProductionConfusionMatrix::false_positive_rate(self : ProductionConfusionMatrix) -> Double

#
ProductionConfusionMatrix::from_scores

source
fn ProductionConfusionMatrix::from_scores(scores : Array[Double], labels : Array[Bool], threshold : Double) -> ProductionConfusionMatrix

#
ProductionConfusionMatrix::precision

source

#
ProductionConfusionMatrix::recall

source

#
ProductionConfusionMatrix::specificity

source
fn ProductionConfusionMatrix::specificity(self : ProductionConfusionMatrix) -> Double

#
ProductionConfusionMatrix::summary

source

#
ProductionConfusionMatrix::support

source

#
ProductionConfusionMatrix::true_negative

source
fn ProductionConfusionMatrix::true_negative(self : ProductionConfusionMatrix) -> Int

#
ProductionConfusionMatrix::true_positive

source
fn ProductionConfusionMatrix::true_positive(self : ProductionConfusionMatrix) -> Int

#
ProductionContractFieldKind

source
pub(all) enum ProductionContractFieldKind {
  Numeric
  Timestamp
  Sequence
  Label
  Boolean
}

Runtime data types accepted by a production change-point pipeline.

#
ProductionContractReport

source
pub struct ProductionContractReport {
  metric : String
  checked : Int
  accepted : Int
  rejected : Int
  missing : Int
  warnings : Int
  violations : Array[ProductionContractViolation]
  distinct_labels : Array[String]
  first_timestamp : Int64
  last_timestamp : Int64
  has_timestamp : Bool
  monotonic : Bool
}

Result of validating one metric stream.

#
ProductionContractReport::acceptance_rate

source
fn ProductionContractReport::acceptance_rate(self : ProductionContractReport) -> Double

#
ProductionContractReport::accepted

source

#
ProductionContractReport::checked

source

#
ProductionContractReport::distinct_count

source
fn ProductionContractReport::distinct_count(self : ProductionContractReport) -> Int

#
ProductionContractReport::first_timestamp

source
fn ProductionContractReport::first_timestamp(self : ProductionContractReport) -> Int64

#
ProductionContractReport::is_valid

source

#
ProductionContractReport::last_timestamp

source
fn ProductionContractReport::last_timestamp(self : ProductionContractReport) -> Int64

#
ProductionContractReport::metric

source

#
ProductionContractReport::missing

source

#
ProductionContractReport::monotonic

source

#
ProductionContractReport::new

source

#
ProductionContractReport::rejected

source

#
ProductionContractReport::summary

source

#
ProductionContractReport::violations

source

#
ProductionContractReport::warnings

source

#
ProductionContractRule

source
pub struct ProductionContractRule {
  name : String
  field_kind : ProductionContractFieldKind
  required : Bool
  allow_missing : Bool
  minimum : Double
  maximum : Double
  has_minimum : Bool
  has_maximum : Bool
  minimum_samples : Int
  maximum_gap : Int64
  monotonic_timestamps : Bool
  maximum_label_length : Int
  maximum_distinct_values : Int
  severity : ProductionContractSeverity
}

Declarative validation rules for a metric stream.

#
ProductionContractRule::allow_missing

source
fn ProductionContractRule::allow_missing(self : ProductionContractRule) -> Bool

#
ProductionContractRule::field_kind

source

#
ProductionContractRule::has_maximum

source
fn ProductionContractRule::has_maximum(self : ProductionContractRule) -> Bool

#
ProductionContractRule::has_minimum

source
fn ProductionContractRule::has_minimum(self : ProductionContractRule) -> Bool

#
ProductionContractRule::maximum

source
fn ProductionContractRule::maximum(self : ProductionContractRule) -> Double

#
ProductionContractRule::maximum_distinct_values

source
fn ProductionContractRule::maximum_distinct_values(self : ProductionContractRule) -> Int

#
ProductionContractRule::maximum_gap

source
fn ProductionContractRule::maximum_gap(self : ProductionContractRule) -> Int64

#
ProductionContractRule::maximum_label_length

source
fn ProductionContractRule::maximum_label_length(self : ProductionContractRule) -> Int

#
ProductionContractRule::minimum

source
fn ProductionContractRule::minimum(self : ProductionContractRule) -> Double

#
ProductionContractRule::minimum_samples

source
fn ProductionContractRule::minimum_samples(self : ProductionContractRule) -> Int

#
ProductionContractRule::monotonic_timestamps

source
fn ProductionContractRule::monotonic_timestamps(self : ProductionContractRule) -> Bool

#
ProductionContractRule::name

source

#
ProductionContractRule::new

source
fn ProductionContractRule::new(name : String, field_kind? : ProductionContractFieldKind, required? : Bool, allow_missing? : Bool, minimum? : Double, maximum? : Double, has_minimum? : Bool, has_maximum? : Bool, minimum_samples? : Int, maximum_gap? : Int64, monotonic_timestamps? : Bool, maximum_label_length? : Int, maximum_distinct_values? : Int, severity? : ProductionContractSeverity) -> ProductionContractRule

#
ProductionContractRule::required

source
fn ProductionContractRule::required(self : ProductionContractRule) -> Bool

#
ProductionContractRule::severity

source

#
ProductionContractSeverity

source
pub(all) enum ProductionContractSeverity {
  ContractError
  ContractWarning
}

Validation severity used by a data contract.

#
ProductionContractSummary

source
pub struct ProductionContractSummary {
  contract_count : Int
  report_count : Int
  valid_count : Int
  rejected_count : Int
  warning_count : Int
  total_samples : Int
  total_violations : Int
}

A compact contract snapshot suitable for health endpoints.

#
ProductionContractSummary::contract_count

source
fn ProductionContractSummary::contract_count(self : ProductionContractSummary) -> Int

#
ProductionContractSummary::health_score

source
fn ProductionContractSummary::health_score(self : ProductionContractSummary) -> Double

#
ProductionContractSummary::rejected_count

source
fn ProductionContractSummary::rejected_count(self : ProductionContractSummary) -> Int

#
ProductionContractSummary::report_count

source

#
ProductionContractSummary::total_samples

source
fn ProductionContractSummary::total_samples(self : ProductionContractSummary) -> Int

#
ProductionContractSummary::total_violations

source
fn ProductionContractSummary::total_violations(self : ProductionContractSummary) -> Int

#
ProductionContractSummary::valid_count

source

#
ProductionContractSummary::warning_count

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

#
ProductionContractValidator

source
pub struct ProductionContractValidator {
  rules : Array[ProductionContractRule]
  reports : Array[ProductionContractReport]
  total_batches : Int
  total_samples : Int
  total_violations : Int
}

Runtime validator for metric contracts. Rules stay in memory so a service can validate every batch without rebuilding schema state.

#
ProductionContractValidator::clear_reports

source

#
ProductionContractValidator::filter_numeric_batch

source
fn ProductionContractValidator::filter_numeric_batch(self : ProductionContractValidator, metric : String, timestamps : Array[Int64], values : Array[Double]) -> (Array[Int64], Array[Double], ProductionContractReport)

Validate a batch and return only the samples accepted by the contract.

#
ProductionContractValidator::latest_report

source

#
ProductionContractValidator::new

source

#
ProductionContractValidator::register

source

#
ProductionContractValidator::remove

source
fn ProductionContractValidator::remove(self : ProductionContractValidator, name : String) -> Bool

#
ProductionContractValidator::reports

source

#
ProductionContractValidator::rule_count

source

#
ProductionContractValidator::rules

source

#
ProductionContractValidator::summary

source

#
ProductionContractValidator::total_batches

source

#
ProductionContractValidator::total_samples

source

#
ProductionContractValidator::total_violations

source
fn ProductionContractValidator::total_violations(self : ProductionContractValidator) -> Int

#
ProductionContractValidator::validate_label_batch

source
fn ProductionContractValidator::validate_label_batch(self : ProductionContractValidator, metric : String, timestamps : Array[Int64], labels : Array[String]) -> ProductionContractReport

Validate categorical labels while tracking bounded cardinality.

#
ProductionContractValidator::validate_numeric_batch

source
fn ProductionContractValidator::validate_numeric_batch(self : ProductionContractValidator, metric : String, timestamps : Array[Int64], values : Array[Double]) -> ProductionContractReport

Validate numeric samples and event-time ordering for one metric batch.

#
ProductionContractViolation

source
pub struct ProductionContractViolation {
  code : ProductionContractViolationCode
  severity : ProductionContractSeverity
  metric : String
  rule : String
  index : Int
  value : Double
  has_value : Bool
  message : String
}

One contract violation retained for audit and diagnostics.

#
ProductionContractViolation::code

source

#
ProductionContractViolation::has_value

source

#
ProductionContractViolation::index

source

#
ProductionContractViolation::message

source

#
ProductionContractViolation::metric

source

#
ProductionContractViolation::new

source
fn ProductionContractViolation::new(code : ProductionContractViolationCode, severity : ProductionContractSeverity, metric : String, rule : String, index? : Int, value? : Double, has_value? : Bool, message? : String) -> ProductionContractViolation

#
ProductionContractViolation::rule

source

#
ProductionContractViolation::severity

source

#
ProductionContractViolation::summary

source

#
ProductionContractViolation::value

source

#
ProductionContractViolationCode

source
pub(all) enum ProductionContractViolationCode {
  MissingMetric
  MissingValue
  NonFiniteValue
  ValueBelowMinimum
  ValueAboveMaximum
  TimestampOutOfOrder
  TimestampTooOld
  DuplicateSequence
  EmptyLabel
  LabelTooLong
  InvalidBoolean
  InsufficientSamples
  ExcessiveGap
  CardinalityExceeded
  SchemaMismatch
}

Machine-readable reason for rejecting or downgrading an observation.

#
ProductionCurvePoint

source
pub struct ProductionCurvePoint {
  threshold : Double
  precision : Double
  recall : Double
  f1 : Double
  false_positive_rate : Double
  support : Int
}

A point on a threshold evaluation curve.

#
ProductionCurvePoint::f1

source

#
ProductionCurvePoint::false_positive_rate

source
fn ProductionCurvePoint::false_positive_rate(self : ProductionCurvePoint) -> Double

#
ProductionCurvePoint::from_matrix

source
fn ProductionCurvePoint::from_matrix(threshold : Double, matrix : ProductionConfusionMatrix) -> ProductionCurvePoint

#
ProductionCurvePoint::precision

source
fn ProductionCurvePoint::precision(self : ProductionCurvePoint) -> Double

#
ProductionCurvePoint::recall

source
fn ProductionCurvePoint::recall(self : ProductionCurvePoint) -> Double

#
ProductionCurvePoint::support

source
fn ProductionCurvePoint::support(self : ProductionCurvePoint) -> Int

#
ProductionCurvePoint::threshold

source
fn ProductionCurvePoint::threshold(self : ProductionCurvePoint) -> Double

#
ProductionDashboardPoint

source
pub struct ProductionDashboardPoint {
  timestamp : Int64
  value : Double
  baseline : Double
  score : Double
  changed : Bool
  state : ProductionHealthState
}

A time-series point prepared for dashboard rendering.

#
ProductionDashboardPoint::baseline

source
fn ProductionDashboardPoint::baseline(self : ProductionDashboardPoint) -> Double

#
ProductionDashboardPoint::changed

source

#
ProductionDashboardPoint::new

source
fn ProductionDashboardPoint::new(timestamp : Int64, value : Double, baseline : Double, result : DetectionResult, state : ProductionHealthState) -> ProductionDashboardPoint

#
ProductionDashboardPoint::score

source

#
ProductionDashboardPoint::state

source

#
ProductionDashboardPoint::timestamp

source
fn ProductionDashboardPoint::timestamp(self : ProductionDashboardPoint) -> Int64

#
ProductionDashboardPoint::value

source

#
ProductionDashboardSeries

source
pub struct ProductionDashboardSeries {
  name : String
  points : Array[ProductionDashboardPoint]
  dropped : Int
}

#
ProductionDashboardSeries::changed_count

source
fn ProductionDashboardSeries::changed_count(self : ProductionDashboardSeries) -> Int

#
ProductionDashboardSeries::dropped

source

#
ProductionDashboardSeries::latest

source

#
ProductionDashboardSeries::length

source

#
ProductionDashboardSeries::name

source

#
ProductionDashboardSeries::new

source
fn ProductionDashboardSeries::new(name : String, capacity? : Int) -> ProductionDashboardSeries

#
ProductionDashboardSeries::points

source

#
ProductionDashboardSeries::push

source
fn ProductionDashboardSeries::push(self : ProductionDashboardSeries, point : ProductionDashboardPoint, capacity? : Int) -> Unit

#
ProductionDeliveryChannel

source
pub(all) enum ProductionDeliveryChannel {
  ConsoleChannel
  LogChannel
  TicketChannel
  PagerChannel
  WebhookChannel
  DashboardChannel
}

Delivery destination for an operational alert.

#
ProductionDeliveryDecision

source
pub struct ProductionDeliveryDecision {
  rule : String
  channel : ProductionDeliveryChannel
  allowed : Bool
  reason : String
  fingerprint : String
}

The result of evaluating one event against a delivery rule.

#
ProductionDeliveryDecision::allowed

source

#
ProductionDeliveryDecision::channel

source

#
ProductionDeliveryDecision::fingerprint

source
fn ProductionDeliveryDecision::fingerprint(self : ProductionDeliveryDecision) -> String

#
ProductionDeliveryDecision::reason

source

#
ProductionDeliveryDecision::rule

source

#
ProductionDeliveryDecision::summary

source

#
ProductionDeliveryRule

source
pub struct ProductionDeliveryRule {
  name : String
  channel : ProductionDeliveryChannel
  minimum_severity : AlertSeverity
  include_suppressed : Bool
  minimum_score : Double
  cooldown : Int64
}

A rule deciding whether an event should reach one delivery channel.

#
ProductionDeliveryRule::channel

source

#
ProductionDeliveryRule::cooldown

source
fn ProductionDeliveryRule::cooldown(self : ProductionDeliveryRule) -> Int64

#
ProductionDeliveryRule::include_suppressed

source
fn ProductionDeliveryRule::include_suppressed(self : ProductionDeliveryRule) -> Bool

#
ProductionDeliveryRule::matches

source
fn ProductionDeliveryRule::matches(self : ProductionDeliveryRule, event : AlertEvent) -> Bool

#
ProductionDeliveryRule::minimum_score

source
fn ProductionDeliveryRule::minimum_score(self : ProductionDeliveryRule) -> Double

#
ProductionDeliveryRule::minimum_severity

source

#
ProductionDeliveryRule::name

source

#
ProductionDeliveryRule::new

source
fn ProductionDeliveryRule::new(name : String, channel : ProductionDeliveryChannel, minimum_severity? : AlertSeverity, include_suppressed? : Bool, minimum_score? : Double, cooldown? : Int64) -> ProductionDeliveryRule

#
ProductionDetectionConfig

source
pub struct ProductionDetectionConfig {
  detector_name : String
  threshold : Double
  confidence : Double
  warmup_points : Int
  minimum_segment : Int
  maximum_score : Double
  direction_filter : ChangeDirection?
}

Detection settings shared by online monitor instances.

#
ProductionDetectionConfig::accepts

source

#
ProductionDetectionConfig::confidence

source
fn ProductionDetectionConfig::confidence(self : ProductionDetectionConfig) -> Double

#
ProductionDetectionConfig::detector_name

source
fn ProductionDetectionConfig::detector_name(self : ProductionDetectionConfig) -> String

#
ProductionDetectionConfig::direction_filter

source

#
ProductionDetectionConfig::maximum_score

source
fn ProductionDetectionConfig::maximum_score(self : ProductionDetectionConfig) -> Double

#
ProductionDetectionConfig::minimum_segment

source
fn ProductionDetectionConfig::minimum_segment(self : ProductionDetectionConfig) -> Int

#
ProductionDetectionConfig::new

source
fn ProductionDetectionConfig::new(detector_name? : String, threshold? : Double, confidence? : Double, warmup_points? : Int, minimum_segment? : Int, maximum_score? : Double, direction_filter? : ChangeDirection?) -> ProductionDetectionConfig

#
ProductionDetectionConfig::threshold

source

#
ProductionDetectionConfig::warmup_points

source
fn ProductionDetectionConfig::warmup_points(self : ProductionDetectionConfig) -> Int

#
ProductionDetectorKind

source
pub(all) enum ProductionDetectorKind {
  CusumStackDetector
  RobustZStackDetector
  EwmaStackDetector
  VarianceStackDetector
  TrendStackDetector
  SeasonalStackDetector
  DistributionStackDetector
}

Detector selection for the production stack.

#
ProductionDetectorStack

source
pub struct ProductionDetectorStack {
  kinds : Array[ProductionDetectorKind]
  detectors : Array[PipelineDetector]
  weights : Array[Double]
  minimum_votes : Int
  index : Int
}

An array-backed ensemble that keeps detector order stable across targets.

#
ProductionDetectorStack::index

source

#
ProductionDetectorStack::length

source

#
ProductionDetectorStack::new

source
fn ProductionDetectorStack::new(kinds : Array[ProductionDetectorKind], detectors : Array[PipelineDetector], weights? : Array[Double], minimum_votes? : Int) -> ProductionDetectorStack

#
ProductionDetectorStack::reset

source

#
ProductionDetectorStack::update

source

#
ProductionDetectorVote

source
pub struct ProductionDetectorVote {
  kind : ProductionDetectorKind
  result : DetectionResult
  weight : Double
  accepted : Bool
}

One weighted vote from a detector stack.

#
ProductionDetectorVote::accepted

source
fn ProductionDetectorVote::accepted(self : ProductionDetectorVote) -> Bool

#
ProductionDetectorVote::kind

source

#
ProductionDetectorVote::result

source

#
ProductionDetectorVote::weight

source
fn ProductionDetectorVote::weight(self : ProductionDetectorVote) -> Double

#
ProductionDriftReport

source
pub struct ProductionDriftReport {
  baseline_count : Int
  current_count : Int
  mean_shift : Double
  variance_ratio : Double
  ks_distance : Double
  energy_distance : Double
  drift_score : Double
  drifted : Bool
}

A summary of baseline/current distribution drift.

#
ProductionDriftReport::baseline_count

source
fn ProductionDriftReport::baseline_count(self : ProductionDriftReport) -> Int

#
ProductionDriftReport::current_count

source
fn ProductionDriftReport::current_count(self : ProductionDriftReport) -> Int

#
ProductionDriftReport::drift_score

source
fn ProductionDriftReport::drift_score(self : ProductionDriftReport) -> Double

#
ProductionDriftReport::drifted

source
fn ProductionDriftReport::drifted(self : ProductionDriftReport) -> Bool

#
ProductionDriftReport::energy_distance

source
fn ProductionDriftReport::energy_distance(self : ProductionDriftReport) -> Double

#
ProductionDriftReport::from_values

source
fn ProductionDriftReport::from_values(baseline : Array[Double], current : Array[Double], threshold? : Double) -> ProductionDriftReport

#
ProductionDriftReport::ks_distance

source
fn ProductionDriftReport::ks_distance(self : ProductionDriftReport) -> Double

#
ProductionDriftReport::mean_shift

source
fn ProductionDriftReport::mean_shift(self : ProductionDriftReport) -> Double

#
ProductionDriftReport::summary

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

#
ProductionDriftReport::variance_ratio

source
fn ProductionDriftReport::variance_ratio(self : ProductionDriftReport) -> Double

#
ProductionEscalationPolicy

source
pub struct ProductionEscalationPolicy {
  steps : Array[ProductionEscalationStep]
  delivered : Int
}

#
ProductionEscalationPolicy::add

source

#
ProductionEscalationPolicy::delivered

source

#
ProductionEscalationPolicy::due

source

#
ProductionEscalationPolicy::mark_delivered

source
fn ProductionEscalationPolicy::mark_delivered(self : ProductionEscalationPolicy) -> Unit

#
ProductionEscalationPolicy::new

source

#
ProductionEscalationPolicy::steps

source

#
ProductionEscalationPolicy::summary

source

#
ProductionEscalationStep

source
pub struct ProductionEscalationStep {
  channel : String
  delay : Int64
  minimum_severity : AlertSeverity
}

One escalation destination and the delay before it is eligible.

#
ProductionEscalationStep::channel

source

#
ProductionEscalationStep::delay

source

#
ProductionEscalationStep::eligible

source
fn ProductionEscalationStep::eligible(self : ProductionEscalationStep, incident : ProductionIncident, now : Int64) -> Bool

#
ProductionEscalationStep::minimum_severity

source

#
ProductionEscalationStep::new

source
fn ProductionEscalationStep::new(channel : String, delay : Int64, minimum_severity? : AlertSeverity) -> ProductionEscalationStep

#
ProductionEventBudget

source
pub struct ProductionEventBudget {
  capacity : Int
  interval : Int64
  window_start : Int64?
  used : Int
  denied : Int
}

A finite alert budget measured over a rolling event-time interval.

#
ProductionEventBudget::allow

source
fn ProductionEventBudget::allow(self : ProductionEventBudget, timestamp : Int64) -> Bool

#
ProductionEventBudget::denied

source

#
ProductionEventBudget::new

source
fn ProductionEventBudget::new(capacity? : Int, interval? : Int64) -> ProductionEventBudget

#
ProductionEventBudget::remaining

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

#
ProductionEventBudget::used

source

#
ProductionExportBatch

source
pub struct ProductionExportBatch {
  records : Array[ProductionExportRecord]
  capacity : Int
  accepted : Int
  rejected : Int
  duplicate : Int
}

Bounded in-memory batch used to make exports deterministic.

#
ProductionExportBatch::accepted

source
fn ProductionExportBatch::accepted(self : ProductionExportBatch) -> Int

#
ProductionExportBatch::add

source

#
ProductionExportBatch::add_many

source

#
ProductionExportBatch::capacity

source
fn ProductionExportBatch::capacity(self : ProductionExportBatch) -> Int

#
ProductionExportBatch::clear

source

#
ProductionExportBatch::count

source

#
ProductionExportBatch::duplicate

source
fn ProductionExportBatch::duplicate(self : ProductionExportBatch) -> Int

#
ProductionExportBatch::new

source
fn ProductionExportBatch::new(capacity? : Int) -> ProductionExportBatch

#
ProductionExportBatch::ordered

source

Return records ordered by event time without mutating the input batch.

#
ProductionExportBatch::records

source

#
ProductionExportBatch::rejected

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

#
ProductionExportField

source
pub(all) enum ProductionExportField {
  ExportTimestamp
  ExportMetric
  ExportValue
  ExportBaseline
  ExportScore
  ExportHealth
  ExportState
  ExportSource
}

Fields that can be selected in a telemetry export.

#
ProductionExportFormat

source
pub(all) enum ProductionExportFormat {
  ExportJsonLines
  ExportCsv
  ExportPrometheus
  ExportMarkdown
  ExportSummaryJson
}

Wire formats supported by the production telemetry exporter.

#
ProductionExportOptions

source
pub struct ProductionExportOptions {
  format : ProductionExportFormat
  delimiter : String
  include_header : Bool
  include_metadata : Bool
  pretty : Bool
  max_records : Int
  metric_prefix : String
  metric_namespace : String
  line_ending : String
}

Export settings shared by all serializers.

#
ProductionExportOptions::delimiter

source
fn ProductionExportOptions::delimiter(self : ProductionExportOptions) -> String

#
ProductionExportOptions::format

source

#
ProductionExportOptions::include_header

source
fn ProductionExportOptions::include_header(self : ProductionExportOptions) -> Bool

#
ProductionExportOptions::include_metadata

source
fn ProductionExportOptions::include_metadata(self : ProductionExportOptions) -> Bool

#
ProductionExportOptions::line_ending

source
fn ProductionExportOptions::line_ending(self : ProductionExportOptions) -> String

#
ProductionExportOptions::max_records

source
fn ProductionExportOptions::max_records(self : ProductionExportOptions) -> Int

#
ProductionExportOptions::metric_namespace

source
fn ProductionExportOptions::metric_namespace(self : ProductionExportOptions) -> String

#
ProductionExportOptions::metric_prefix

source
fn ProductionExportOptions::metric_prefix(self : ProductionExportOptions) -> String

#
ProductionExportOptions::new

source
fn ProductionExportOptions::new(format? : ProductionExportFormat, delimiter? : String, include_header? : Bool, include_metadata? : Bool, pretty? : Bool, max_records? : Int, metric_prefix? : String, metric_namespace? : String, line_ending? : String) -> ProductionExportOptions

#
ProductionExportOptions::pretty

source

#
ProductionExportOptions::with_format

source

#
ProductionExportRecord

source
pub struct ProductionExportRecord {
  timestamp : Int64
  metric : String
  value : Double
  baseline : Double
  score : Double
  health : Double
  state : String
  source : String
}

One normalized telemetry row emitted by a monitor or replay.

#
ProductionExportRecord::as_key

source
fn ProductionExportRecord::as_key(self : ProductionExportRecord) -> String

#
ProductionExportRecord::baseline

source
fn ProductionExportRecord::baseline(self : ProductionExportRecord) -> Double

#
ProductionExportRecord::field

source

#
ProductionExportRecord::health

source
fn ProductionExportRecord::health(self : ProductionExportRecord) -> Double

#
ProductionExportRecord::is_finite

source
fn ProductionExportRecord::is_finite(self : ProductionExportRecord) -> Bool

#
ProductionExportRecord::metric

source
fn ProductionExportRecord::metric(self : ProductionExportRecord) -> String

#
ProductionExportRecord::new

source
fn ProductionExportRecord::new(timestamp : Int64, metric : String, value : Double, baseline? : Double, score? : Double, health? : Double, state? : String, source? : String) -> ProductionExportRecord

#
ProductionExportRecord::score

source

#
ProductionExportRecord::source

source
fn ProductionExportRecord::source(self : ProductionExportRecord) -> String

#
ProductionExportRecord::state

source

#
ProductionExportRecord::timestamp

source
fn ProductionExportRecord::timestamp(self : ProductionExportRecord) -> Int64

#
ProductionExportRecord::value

source

#
ProductionExportRecord::with_state

source
fn ProductionExportRecord::with_state(self : ProductionExportRecord, state : String) -> ProductionExportRecord

#
ProductionExportStats

source
pub struct ProductionExportStats {
  batches : Int
  records : Int
  bytes : Int
  failures : Int
  truncated : Int
}

Exporter counters are kept separately from the batch so operators can monitor serialization failures across multiple flushes.

#
ProductionExportStats::batches

source
fn ProductionExportStats::batches(self : ProductionExportStats) -> Int

#
ProductionExportStats::bytes

source

#
ProductionExportStats::failures

source
fn ProductionExportStats::failures(self : ProductionExportStats) -> Int

#
ProductionExportStats::new

source

#
ProductionExportStats::records

source
fn ProductionExportStats::records(self : ProductionExportStats) -> Int

#
ProductionExportStats::success_rate

source
fn ProductionExportStats::success_rate(self : ProductionExportStats) -> Double

#
ProductionExportStats::summary

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

#
ProductionExportStats::truncated

source
fn ProductionExportStats::truncated(self : ProductionExportStats) -> Int

#
ProductionFeature

source
pub struct ProductionFeature {
  name : String
  kind : ProductionFeatureKind
  value : Double
  valid : Bool
  sample_count : Int
  source_window : Int
}

One named feature value with quality and provenance metadata.

#
ProductionFeature::kind

source

#
ProductionFeature::name

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

#
ProductionFeature::new

source
fn ProductionFeature::new(kind : ProductionFeatureKind, value : Double, sample_count : Int, source_window : Int) -> ProductionFeature

#
ProductionFeature::sample_count

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

#
ProductionFeature::source_window

source
fn ProductionFeature::source_window(self : ProductionFeature) -> Int

#
ProductionFeature::valid

source
fn ProductionFeature::valid(self : ProductionFeature) -> Bool

#
ProductionFeature::value

source
fn ProductionFeature::value(self : ProductionFeature) -> Double

#
ProductionFeatureConfig

source
pub struct ProductionFeatureConfig {
  window_size : Int
  seasonal_period : Int
  include_distribution : Bool
  include_autocorrelation : Bool
  outlier_threshold : Double
}

Configuration for an explainable feature extraction pass.

#
ProductionFeatureConfig::include_autocorrelation

source
fn ProductionFeatureConfig::include_autocorrelation(self : ProductionFeatureConfig) -> Bool

#
ProductionFeatureConfig::include_distribution

source
fn ProductionFeatureConfig::include_distribution(self : ProductionFeatureConfig) -> Bool

#
ProductionFeatureConfig::new

source
fn ProductionFeatureConfig::new(window_size? : Int, seasonal_period? : Int, include_distribution? : Bool, include_autocorrelation? : Bool, outlier_threshold? : Double) -> ProductionFeatureConfig

#
ProductionFeatureConfig::outlier_threshold

source
fn ProductionFeatureConfig::outlier_threshold(self : ProductionFeatureConfig) -> Double

#
ProductionFeatureConfig::seasonal_period

source
fn ProductionFeatureConfig::seasonal_period(self : ProductionFeatureConfig) -> Int

#
ProductionFeatureConfig::window_size

source
fn ProductionFeatureConfig::window_size(self : ProductionFeatureConfig) -> Int

#
ProductionFeatureKind

source
pub(all) enum ProductionFeatureKind {
  LevelFeature
  SpreadFeature
  TrendFeature
  VolatilityFeature
  SkewFeature
  KurtosisFeature
  AutocorrelationFeature
  DifferenceFeature
  QuantileFeature
  DistributionEntropyFeature
  MissingRatioFeature
  OutlierRatioFeature
  SeasonalStrengthFeature
}

Feature family exposed by the production feature pipeline.

#
ProductionFeaturePipeline

source
pub struct ProductionFeaturePipeline {
  config : ProductionFeatureConfig
  windows : Array[ProductionTimeWindow]
  extracted : Int
  invalid : Int
}

Feature pipeline used before a model or detector call.

#
ProductionFeaturePipeline::config

source

#
ProductionFeaturePipeline::extract

source

#
ProductionFeaturePipeline::extract_batch

source

#
ProductionFeaturePipeline::extract_from_window

source

#
ProductionFeaturePipeline::extracted

source

#
ProductionFeaturePipeline::feature_names

source
fn ProductionFeaturePipeline::feature_names(self : ProductionFeaturePipeline) -> Array[String]

#
ProductionFeaturePipeline::invalid

source

#
ProductionFeaturePipeline::new

source

#
ProductionFeatureScaler

source
pub struct ProductionFeatureScaler {
  centers : Array[Double]
  scales : Array[Double]
  fitted : Bool
}

Robust location and scale parameters learned from feature vectors.

#
ProductionFeatureScaler::centers

source

#
ProductionFeatureScaler::dimension

source

#
ProductionFeatureScaler::fit

source

#
ProductionFeatureScaler::inverse

source
fn ProductionFeatureScaler::inverse(self : ProductionFeatureScaler, values : Array[Double]) -> Array[Double]

#
ProductionFeatureScaler::is_fitted

source
fn ProductionFeatureScaler::is_fitted(self : ProductionFeatureScaler) -> Bool

#
ProductionFeatureScaler::new

source

#
ProductionFeatureScaler::scales

source

#
ProductionFeatureScaler::transform

source

#
ProductionFeatureVector

source
pub struct ProductionFeatureVector {
  features : Array[ProductionFeature]
  values : Array[Double]
  valid_count : Int
  missing_count : Int
}

A fixed-order feature vector suitable for a model or report.

#
ProductionFeatureVector::distance

source

#
ProductionFeatureVector::features

source

#
ProductionFeatureVector::get

source

#
ProductionFeatureVector::missing_count

source
fn ProductionFeatureVector::missing_count(self : ProductionFeatureVector) -> Int

#
ProductionFeatureVector::new

source

#
ProductionFeatureVector::summary

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

#
ProductionFeatureVector::valid_count

source
fn ProductionFeatureVector::valid_count(self : ProductionFeatureVector) -> Int

#
ProductionFeatureVector::valid_ratio

source
fn ProductionFeatureVector::valid_ratio(self : ProductionFeatureVector) -> Double

#
ProductionFeatureVector::values

source

#
ProductionFillPolicy

source
pub(all) enum ProductionFillPolicy {
  ForwardFill
  ZeroFill
  LinearInterpolate
  SkipEmpty
}

Policy for values in empty resampling buckets.

#
ProductionForecastInterval

source
pub struct ProductionForecastInterval {
  timestamp : Int64
  prediction : Double
  lower : Double
  upper : Double
  confidence : Double
  horizon : Int
  model : ProductionForecastKind
}

Forecast interval with explicit coverage and residual diagnostics.

#
ProductionForecastInterval::confidence

source

#
ProductionForecastInterval::horizon

source

#
ProductionForecastInterval::lower

source

#
ProductionForecastInterval::new

source
fn ProductionForecastInterval::new(timestamp : Int64, prediction : Double, uncertainty : Double, confidence? : Double, horizon? : Int, model? : ProductionForecastKind) -> ProductionForecastInterval

#
ProductionForecastInterval::prediction

source

#
ProductionForecastInterval::timestamp

source

#
ProductionForecastInterval::upper

source

#
ProductionForecastInterval::width

source

#
ProductionForecastKind

source
pub(all) enum ProductionForecastKind {
  LastValueForecast
  MeanForecast
  HoltForecast
  SeasonalNaiveForecast
  HoltWintersForecast
}

Forecast family supported by the production model wrapper.

#
ProductionForecastScore

source
pub struct ProductionForecastScore {
  model : ProductionForecastKind
  mae : Double
  rmse : Double
  bias : Double
  coverage : Double
}

Compares several deterministic forecast families on a holdout suffix.

#
ProductionForecastScore::bias

source

#
ProductionForecastScore::coverage

source
fn ProductionForecastScore::coverage(self : ProductionForecastScore) -> Double

#
ProductionForecastScore::mae

source

#
ProductionForecastScore::model

source

#
ProductionForecastScore::rmse

source

#
ProductionForecaster

source
pub struct ProductionForecaster {
  kind : ProductionForecastKind
  period : Int
  horizon : Int
  window : DoubleWindow
  holt : HoltForecaster
  seasonal : ProductionHoltWinters
  residuals : ProductionQuantileState
  count : Int
  missing : Int
}

A model-agnostic production forecaster with a rolling residual envelope.

#
ProductionForecaster::count

source

#
ProductionForecaster::forecast

source
fn ProductionForecaster::forecast(self : ProductionForecaster, start_timestamp : Int64, step : Int64, horizon? : Int, confidence? : Double) -> Array[ProductionForecastInterval]

#
ProductionForecaster::kind

source

#
ProductionForecaster::missing

source
fn ProductionForecaster::missing(self : ProductionForecaster) -> Int

#
ProductionForecaster::new

source
fn ProductionForecaster::new(kind? : ProductionForecastKind, window_size? : Int, period? : Int, horizon? : Int) -> ProductionForecaster

#
ProductionForecaster::predict

source
fn ProductionForecaster::predict(self : ProductionForecaster) -> Double

#
ProductionForecaster::uncertainty

source
fn ProductionForecaster::uncertainty(self : ProductionForecaster, confidence? : Double) -> Double

#
ProductionForecaster::update

source

#
ProductionGuardrailAction

source
pub(all) enum ProductionGuardrailAction {
  GuardrailAllow
  GuardrailObserve
  GuardrailWarn
  GuardrailBlock
  GuardrailRollback
}

Action selected by a production rollout guard.

#
ProductionGuardrailController

source
pub struct ProductionGuardrailController {
  rules : Array[ProductionGuardrailRule]
  history : Array[ProductionGuardrailDecision]
  failure_streak : Int
  recovery_streak : Int
  sequence : Int64
  blocked : Bool
  paused : Bool
  last_timestamp : Int64
  evaluated : Int
  triggered : Int
}

Stateful canary and rollout gate.

#
ProductionGuardrailController::clear_history

source

#
ProductionGuardrailController::evaluate

source

Evaluate one signal and update the controller state.

#
ProductionGuardrailController::evaluate_batch

source

Evaluate aligned observations and return one decision per signal.

#
ProductionGuardrailController::evaluated

source

#
ProductionGuardrailController::failure_streak

source

#
ProductionGuardrailController::history

source

#
ProductionGuardrailController::is_blocked

source

#
ProductionGuardrailController::is_paused

source

#
ProductionGuardrailController::latest

source

#
ProductionGuardrailController::new

source

#
ProductionGuardrailController::pause

source

#
ProductionGuardrailController::recovery_streak

source

#
ProductionGuardrailController::register

source

#
ProductionGuardrailController::remove

source
fn ProductionGuardrailController::remove(self : ProductionGuardrailController, name : String) -> Bool

#
ProductionGuardrailController::resume_guardrail

source

#
ProductionGuardrailController::rule_count

source

#
ProductionGuardrailController::rules

source

#
ProductionGuardrailController::summary

source

#
ProductionGuardrailController::triggered

source

#
ProductionGuardrailController::unblock

source

#
ProductionGuardrailDecision

source
pub struct ProductionGuardrailDecision {
  action : ProductionGuardrailAction
  rule_name : String
  metric : ProductionGuardrailMetricKind
  value : Double
  threshold : Double
  score : Double
  triggered : Bool
  failure_streak : Int
  recovery_streak : Int
  sequence : Int64
  reason : String
}

Decision emitted by a guard after evaluating an observation.

#
ProductionGuardrailDecision::action

source

#
ProductionGuardrailDecision::failure_streak

source

#
ProductionGuardrailDecision::metric

source

#
ProductionGuardrailDecision::reason

source

#
ProductionGuardrailDecision::recovery_streak

source
fn ProductionGuardrailDecision::recovery_streak(self : ProductionGuardrailDecision) -> Int

#
ProductionGuardrailDecision::rule_name

source

#
ProductionGuardrailDecision::score

source

#
ProductionGuardrailDecision::sequence

source

#
ProductionGuardrailDecision::summary

source

#
ProductionGuardrailDecision::threshold

source

#
ProductionGuardrailDecision::triggered

source

#
ProductionGuardrailDecision::value

source

#
ProductionGuardrailDirection

source
pub(all) enum ProductionGuardrailDirection {
  GuardrailAbove
  GuardrailBelow
  GuardrailOutside
}

Direction of an operational threshold.

#
ProductionGuardrailMetricKind

source
pub(all) enum ProductionGuardrailMetricKind {
  GuardrailErrorRate
  GuardrailFalsePositiveRate
  GuardrailDetectionDelay
  GuardrailDataQuality
  GuardrailThroughput
  GuardrailLatency
  GuardrailCoverage
  GuardrailDriftScore
}

Operational signal monitored during a canary rollout.

#
ProductionGuardrailObservation

source
pub struct ProductionGuardrailObservation {
  timestamp : Int64
  metric : ProductionGuardrailMetricKind
  value : Double
  baseline : Double
  sample_count : Int
  confidence : Double
  source : String
}

Observed value supplied to a rollout guard.

#
ProductionGuardrailObservation::baseline

source

#
ProductionGuardrailObservation::confidence

source

#
ProductionGuardrailObservation::is_finite

source

#
ProductionGuardrailObservation::metric

source

#
ProductionGuardrailObservation::new

source
fn ProductionGuardrailObservation::new(timestamp : Int64, metric : ProductionGuardrailMetricKind, value : Double, sample_count? : Int, baseline? : Double, confidence? : Double, source? : String) -> ProductionGuardrailObservation

#
ProductionGuardrailObservation::relative_change

source

#
ProductionGuardrailObservation::sample_count

source

#
ProductionGuardrailObservation::source

source

#
ProductionGuardrailObservation::timestamp

source

#
ProductionGuardrailObservation::value

source

#
ProductionGuardrailRule

source
pub struct ProductionGuardrailRule {
  name : String
  metric : ProductionGuardrailMetricKind
  direction : ProductionGuardrailDirection
  warning_threshold : Double
  blocking_threshold : Double
  rollback_threshold : Double
  minimum_samples : Int
  window_size : Int
  consecutive_failures : Int
  recovery_samples : Int
  weight : Double
  enabled : Bool
}

A single rollout policy for one service-level signal.

#
ProductionGuardrailRule::blocking_threshold

source
fn ProductionGuardrailRule::blocking_threshold(self : ProductionGuardrailRule) -> Double

#
ProductionGuardrailRule::consecutive_failures

source
fn ProductionGuardrailRule::consecutive_failures(self : ProductionGuardrailRule) -> Int

#
ProductionGuardrailRule::direction

source

#
ProductionGuardrailRule::enabled

source

#
ProductionGuardrailRule::metric

source

#
ProductionGuardrailRule::minimum_samples

source
fn ProductionGuardrailRule::minimum_samples(self : ProductionGuardrailRule) -> Int

#
ProductionGuardrailRule::name

source

#
ProductionGuardrailRule::new

source
fn ProductionGuardrailRule::new(name : String, metric? : ProductionGuardrailMetricKind, direction? : ProductionGuardrailDirection, warning_threshold? : Double, blocking_threshold? : Double, rollback_threshold? : Double, minimum_samples? : Int, window_size? : Int, consecutive_failures? : Int, recovery_samples? : Int, weight? : Double, enabled? : Bool) -> ProductionGuardrailRule

#
ProductionGuardrailRule::recovery_samples

source
fn ProductionGuardrailRule::recovery_samples(self : ProductionGuardrailRule) -> Int

#
ProductionGuardrailRule::rollback_threshold

source
fn ProductionGuardrailRule::rollback_threshold(self : ProductionGuardrailRule) -> Double

#
ProductionGuardrailRule::warning_threshold

source
fn ProductionGuardrailRule::warning_threshold(self : ProductionGuardrailRule) -> Double

#
ProductionGuardrailRule::weight

source

#
ProductionGuardrailRule::window_size

source
fn ProductionGuardrailRule::window_size(self : ProductionGuardrailRule) -> Int

#
ProductionGuardrailRule::with_enabled

source
fn ProductionGuardrailRule::with_enabled(self : ProductionGuardrailRule, enabled : Bool) -> ProductionGuardrailRule

#
ProductionGuardrailSummary

source
pub struct ProductionGuardrailSummary {
  evaluated : Int
  triggered : Int
  blocked : Bool
  paused : Bool
  failure_streak : Int
  recovery_streak : Int
  risk_score : Double
}

Compact rollout health summary.

#
ProductionGuardrailSummary::blocked

source

#
ProductionGuardrailSummary::evaluated

source

#
ProductionGuardrailSummary::failure_streak

source
fn ProductionGuardrailSummary::failure_streak(self : ProductionGuardrailSummary) -> Int

#
ProductionGuardrailSummary::paused

source

#
ProductionGuardrailSummary::recovery_streak

source
fn ProductionGuardrailSummary::recovery_streak(self : ProductionGuardrailSummary) -> Int

#
ProductionGuardrailSummary::risk_score

source

#
ProductionGuardrailSummary::triggered

source

#
ProductionHealthState

source
pub(all) enum ProductionHealthState {
  ColdStart
  Healthy
  DegradedQuality
  AlertingState
  RecoveringState
  DisabledState
}

Lifecycle state of an online production monitor.

#
ProductionHoltWinters

source
pub struct ProductionHoltWinters {
  period : Int
  alpha : Double
  beta : Double
  gamma : Double
  levels : Array[Double]
  level : Double
  trend : Double
  count : Int
  index : Int
  initialized : Bool
  residuals : ProductionResidualScale
}

Additive Holt-Winters state for periodic production telemetry.

#
ProductionHoltWinters::count

source

#
ProductionHoltWinters::level

source
fn ProductionHoltWinters::level(self : ProductionHoltWinters) -> Double

#
ProductionHoltWinters::new

source
fn ProductionHoltWinters::new(period? : Int, alpha? : Double, beta? : Double, gamma? : Double) -> ProductionHoltWinters

#
ProductionHoltWinters::period

source

#
ProductionHoltWinters::predict

source
fn ProductionHoltWinters::predict(self : ProductionHoltWinters, horizon? : Int) -> Double

#
ProductionHoltWinters::predict_interval

source
fn ProductionHoltWinters::predict_interval(self : ProductionHoltWinters, timestamp : Int64, horizon? : Int, confidence? : Double) -> ProductionForecastInterval

#
ProductionHoltWinters::seasonals

source
fn ProductionHoltWinters::seasonals(self : ProductionHoltWinters) -> Array[Double]

#
ProductionHoltWinters::trend

source
fn ProductionHoltWinters::trend(self : ProductionHoltWinters) -> Double

#
ProductionHoltWinters::update

source
fn ProductionHoltWinters::update(self : ProductionHoltWinters, value : Double) -> ForecastPoint

#
ProductionIncident

source
pub struct ProductionIncident {
  id : Int
  metric : String
  first_timestamp : Int64
  last_timestamp : Int64
  alert_count : Int
  max_score : Double
  severity : AlertSeverity
  state : ProductionIncidentState
  acknowledged : Bool
  snooze_until : Int64?
  escalation_level : Int
  recovery_observations : Int
}

A grouped set of related monitor events for one metric.

#
ProductionIncident::absorb

source

#
ProductionIncident::acknowledge

source
fn ProductionIncident::acknowledge(self : ProductionIncident) -> Unit

#
ProductionIncident::acknowledged

source
fn ProductionIncident::acknowledged(self : ProductionIncident) -> Bool

#
ProductionIncident::alert_count

source
fn ProductionIncident::alert_count(self : ProductionIncident) -> Int

#
ProductionIncident::duration

source
fn ProductionIncident::duration(self : ProductionIncident) -> Int64

#
ProductionIncident::escalate

source
fn ProductionIncident::escalate(self : ProductionIncident) -> Int

#
ProductionIncident::escalation_level

source
fn ProductionIncident::escalation_level(self : ProductionIncident) -> Int

#
ProductionIncident::first_timestamp

source
fn ProductionIncident::first_timestamp(self : ProductionIncident) -> Int64

#
ProductionIncident::id

source

#
ProductionIncident::is_open

source
fn ProductionIncident::is_open(self : ProductionIncident) -> Bool

#
ProductionIncident::last_timestamp

source
fn ProductionIncident::last_timestamp(self : ProductionIncident) -> Int64

#
ProductionIncident::max_score

source
fn ProductionIncident::max_score(self : ProductionIncident) -> Double

#
ProductionIncident::metric

source
fn ProductionIncident::metric(self : ProductionIncident) -> String

#
ProductionIncident::new

source

#
ProductionIncident::observe_recovery

source
fn ProductionIncident::observe_recovery(self : ProductionIncident) -> Unit

#
ProductionIncident::recovery_observations

source
fn ProductionIncident::recovery_observations(self : ProductionIncident) -> Int

#
ProductionIncident::reopen

source
fn ProductionIncident::reopen(self : ProductionIncident) -> Unit

#
ProductionIncident::resolve

source
fn ProductionIncident::resolve(self : ProductionIncident) -> Unit

#
ProductionIncident::severity

source

#
ProductionIncident::snooze

source
fn ProductionIncident::snooze(self : ProductionIncident, until : Int64) -> Unit

#
ProductionIncident::state

source

#
ProductionIncident::summary

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

#
ProductionIncidentManager

source
pub struct ProductionIncidentManager {
  policy : ProductionIncidentPolicy
  incidents : Array[ProductionIncident]
  next_id : Int
  ingested : Int
  grouped : Int
  resolved : Int
}

Incident manager used by streaming and batch integrations.

#
ProductionIncidentManager::escalate_due

source

#
ProductionIncidentManager::grouped

source

#
ProductionIncidentManager::incident_count

source
fn ProductionIncidentManager::incident_count(self : ProductionIncidentManager) -> Int

#
ProductionIncidentManager::incidents

source

#
ProductionIncidentManager::ingest

source

#
ProductionIncidentManager::ingested

source

#
ProductionIncidentManager::new

source

#
ProductionIncidentManager::observe_healthy

source
fn ProductionIncidentManager::observe_healthy(self : ProductionIncidentManager, metric : String, timestamp : Int64) -> Array[ProductionIncident]

#
ProductionIncidentManager::open_incidents

source

#
ProductionIncidentManager::policy

source

#
ProductionIncidentManager::reset

source

#
ProductionIncidentManager::resolved

source

#
ProductionIncidentPolicy

source
pub struct ProductionIncidentPolicy {
  grouping_gap : Int64
  recovery_points : Int
  escalation_after : Int
  retention : Int
}

Controls incident grouping, recovery and retention.

#
ProductionIncidentPolicy::escalation_after

source
fn ProductionIncidentPolicy::escalation_after(self : ProductionIncidentPolicy) -> Int

#
ProductionIncidentPolicy::grouping_gap

source
fn ProductionIncidentPolicy::grouping_gap(self : ProductionIncidentPolicy) -> Int64

#
ProductionIncidentPolicy::new

source
fn ProductionIncidentPolicy::new(grouping_gap? : Int64, recovery_points? : Int, escalation_after? : Int, retention? : Int) -> ProductionIncidentPolicy

#
ProductionIncidentPolicy::recovery_points

source
fn ProductionIncidentPolicy::recovery_points(self : ProductionIncidentPolicy) -> Int

#
ProductionIncidentPolicy::retention

source

#
ProductionIncidentState

source
pub(all) enum ProductionIncidentState {
  OpenIncident
  AcknowledgedIncident
  SnoozedIncident
  ResolvedIncident
  ReopenedIncident
}

Lifecycle of a grouped production incident.

#
ProductionMaintenanceWindow

source
pub struct ProductionMaintenanceWindow {
  name : String
  start : Int64
  end : Int64
  reason : String
}

A maintenance interval during which alert delivery is intentionally muted.

#
ProductionMaintenanceWindow::contains

source
fn ProductionMaintenanceWindow::contains(self : ProductionMaintenanceWindow, timestamp : Int64) -> Bool

#
ProductionMaintenanceWindow::duration

source

#
ProductionMaintenanceWindow::end

source

#
ProductionMaintenanceWindow::name

source

#
ProductionMaintenanceWindow::new

source
fn ProductionMaintenanceWindow::new(name : String, start : Int64, end : Int64, reason? : String) -> ProductionMaintenanceWindow

#
ProductionMaintenanceWindow::reason

source

#
ProductionMaintenanceWindow::start

source

#
ProductionMetricCatalog

source
pub struct ProductionMetricCatalog {
  series : Array[ProductionMetricSeries]
  ingested : Int
  rejected : Int
}

A deterministic collection of named series for multimetric monitoring.

#
ProductionMetricCatalog::find

source

#
ProductionMetricCatalog::ingest

source
fn ProductionMetricCatalog::ingest(self : ProductionMetricCatalog, name : String, sample : ProductionSample) -> Bool

#
ProductionMetricCatalog::ingest_point

source
fn ProductionMetricCatalog::ingest_point(self : ProductionMetricCatalog, name : String, point : SignalPoint) -> Bool

#
ProductionMetricCatalog::ingested

source

#
ProductionMetricCatalog::metric_count

source
fn ProductionMetricCatalog::metric_count(self : ProductionMetricCatalog) -> Int

#
ProductionMetricCatalog::names

source

#
ProductionMetricCatalog::new

source

#
ProductionMetricCatalog::register

source

#
ProductionMetricCatalog::rejected

source

#
ProductionMetricCatalog::relations

source
fn ProductionMetricCatalog::relations(self : ProductionMetricCatalog, correlation_threshold? : Double) -> Array[ProductionMetricRelation]

#
ProductionMetricCatalog::series

source

#
ProductionMetricCatalog::summary

source

#
ProductionMetricFrame

source
pub struct ProductionMetricFrame {
  timestamp : Int64
  names : Array[String]
  values : Array[Double]
  valid : Array[Bool]
}

A synchronized row across several metric series.

#
ProductionMetricFrame::dimension

source
fn ProductionMetricFrame::dimension(self : ProductionMetricFrame) -> Int

#
ProductionMetricFrame::is_complete

source
fn ProductionMetricFrame::is_complete(self : ProductionMetricFrame) -> Bool

#
ProductionMetricFrame::names

source

#
ProductionMetricFrame::new

source
fn ProductionMetricFrame::new(timestamp : Int64, names : Array[String], values : Array[Double]) -> ProductionMetricFrame

#
ProductionMetricFrame::timestamp

source
fn ProductionMetricFrame::timestamp(self : ProductionMetricFrame) -> Int64

#
ProductionMetricFrame::valid_count

source
fn ProductionMetricFrame::valid_count(self : ProductionMetricFrame) -> Int

#
ProductionMetricFrame::values

source
fn ProductionMetricFrame::values(self : ProductionMetricFrame) -> Array[Double]

#
ProductionMetricRelation

source
pub struct ProductionMetricRelation {
  left : String
  right : String
  correlation : Double
  distance : Double
  related : Bool
}

Cross-series relation used to prioritize correlated incidents.

#
ProductionMetricRelation::correlation

source
fn ProductionMetricRelation::correlation(self : ProductionMetricRelation) -> Double

#
ProductionMetricRelation::distance

source
fn ProductionMetricRelation::distance(self : ProductionMetricRelation) -> Double

#
ProductionMetricRelation::left

source

#
ProductionMetricRelation::related

source

#
ProductionMetricRelation::right

source

#
ProductionMetricSeries

source
pub struct ProductionMetricSeries {
  name : String
  unit : String
  window : ProductionTimeWindow
  updates : Int
  invalid : Int
}

A named metric series with bounded event-time retention.

#
ProductionMetricSeries::change_score

source
fn ProductionMetricSeries::change_score(self : ProductionMetricSeries, split : Int) -> Double

#
ProductionMetricSeries::correlation

source
fn ProductionMetricSeries::correlation(self : ProductionMetricSeries, other : ProductionMetricSeries) -> Double

#
ProductionMetricSeries::invalid

source

#
ProductionMetricSeries::latest

source

#
ProductionMetricSeries::name

source

#
ProductionMetricSeries::new

source
fn ProductionMetricSeries::new(name : String, unit? : String, capacity? : Int) -> ProductionMetricSeries

#
ProductionMetricSeries::push

source

#
ProductionMetricSeries::push_point

source
fn ProductionMetricSeries::push_point(self : ProductionMetricSeries, point : SignalPoint) -> Bool

#
ProductionMetricSeries::summary

source

#
ProductionMetricSeries::unit

source

#
ProductionMetricSeries::updates

source

#
ProductionMetricSeries::values

source

#
ProductionMetricSeries::window

source

#
ProductionMonitor

source
pub struct ProductionMonitor {
  config : ProductionMonitorConfig
  detector : PipelineDetector
  baseline_window : DoubleWindow
  recent_window : ProductionTimeWindow
  events : Array[ProductionMonitorEvent]
  state : ProductionHealthState
  processed : Int
  valid : Int
  invalid : Int
  changes : Int
  emitted : Int
  suppressed : Int
  recovery_count : Int
  consecutive_healthy : Int
  consecutive_alerts : Int
  ordinal : Int
  latest_score : Double
  latest_baseline : Double
  latest_value : Double
  last_timestamp : Int64
  last_value : Double?
}

Stateful online monitor joining data quality, baselines, detection, and alert policy.

#
ProductionMonitor::changes

source
fn ProductionMonitor::changes(self : ProductionMonitor) -> Int

#
ProductionMonitor::checkpoint

source

#
ProductionMonitor::config

source

#
ProductionMonitor::emitted

source
fn ProductionMonitor::emitted(self : ProductionMonitor) -> Int

#
ProductionMonitor::event_count

source
fn ProductionMonitor::event_count(self : ProductionMonitor) -> Int

#
ProductionMonitor::events

source

#
ProductionMonitor::invalid

source
fn ProductionMonitor::invalid(self : ProductionMonitor) -> Int

#
ProductionMonitor::latest_baseline

source
fn ProductionMonitor::latest_baseline(self : ProductionMonitor) -> Double

#
ProductionMonitor::latest_score

source
fn ProductionMonitor::latest_score(self : ProductionMonitor) -> Double

#
ProductionMonitor::latest_value

source
fn ProductionMonitor::latest_value(self : ProductionMonitor) -> Double

#
ProductionMonitor::new

source

#
ProductionMonitor::processed

source
fn ProductionMonitor::processed(self : ProductionMonitor) -> Int

#
ProductionMonitor::recent_summary

source

#
ProductionMonitor::recent_values

source
fn ProductionMonitor::recent_values(self : ProductionMonitor) -> Array[Double]

#
ProductionMonitor::recovery_count

source
fn ProductionMonitor::recovery_count(self : ProductionMonitor) -> Int

#
ProductionMonitor::reset

source
fn ProductionMonitor::reset(self : ProductionMonitor) -> Unit

#
ProductionMonitor::snapshot

source

#
ProductionMonitor::state

source

#
ProductionMonitor::suppressed

source
fn ProductionMonitor::suppressed(self : ProductionMonitor) -> Int

#
ProductionMonitor::update

source

#
ProductionMonitor::update_batch

source

#
ProductionMonitor::update_point

source

#
ProductionMonitor::valid

source
fn ProductionMonitor::valid(self : ProductionMonitor) -> Int

#
ProductionMonitorCheckpoint

source
pub struct ProductionMonitorCheckpoint {
  config_fingerprint : String
  processed : Int
  valid : Int
  invalid : Int
  changes : Int
  emitted : Int
  suppressed : Int
  recovery_count : Int
  last_timestamp : Int64
  baseline : Double
  latest_value : Double
  latest_score : Double
  state : ProductionHealthState
  baseline_values : Array[Double]
  recent_values : Array[Double]
}

Checkpoint data that can be persisted by an embedding service.

#
ProductionMonitorCheckpoint::baseline

source

#
ProductionMonitorCheckpoint::changes

source

#
ProductionMonitorCheckpoint::fingerprint

source

#
ProductionMonitorCheckpoint::invalid

source

#
ProductionMonitorCheckpoint::latest_value

source
fn ProductionMonitorCheckpoint::latest_value(self : ProductionMonitorCheckpoint) -> Double

#
ProductionMonitorCheckpoint::processed

source

#
ProductionMonitorCheckpoint::recent_values

source

#
ProductionMonitorCheckpoint::state

source

#
ProductionMonitorCheckpoint::valid

source

#
ProductionMonitorConfig

source
pub struct ProductionMonitorConfig {
  name : String
  mode : ProductionMonitorMode
  missing_values : MissingValueStrategy
  baseline : ProductionBaselineStrategy
  fixed_baseline : Double
  detection : ProductionDetectionConfig
  window : ProductionWindowConfig
  alerts : ProductionAlertConfig
  dimensions : Int
  version : Int
}

Complete configuration for one production monitor.

#
ProductionMonitorConfig::alerts

source

#
ProductionMonitorConfig::baseline

source

#
ProductionMonitorConfig::detection

source

#
ProductionMonitorConfig::dimensions

source
fn ProductionMonitorConfig::dimensions(self : ProductionMonitorConfig) -> Int

#
ProductionMonitorConfig::fingerprint

source
fn ProductionMonitorConfig::fingerprint(self : ProductionMonitorConfig) -> String

A compact configuration fingerprint for cache keys and deployment audits.

#
ProductionMonitorConfig::fixed_baseline

source
fn ProductionMonitorConfig::fixed_baseline(self : ProductionMonitorConfig) -> Double

#
ProductionMonitorConfig::is_actionable

source
fn ProductionMonitorConfig::is_actionable(self : ProductionMonitorConfig, result : DetectionResult) -> Bool

Determines whether a result is actionable for the configured mode.

#
ProductionMonitorConfig::is_valid

source

#
ProductionMonitorConfig::missing_values

source

#
ProductionMonitorConfig::mode

source

#
ProductionMonitorConfig::name

source

#
ProductionMonitorConfig::new

source
fn ProductionMonitorConfig::new(name? : String, mode? : ProductionMonitorMode, missing_values? : MissingValueStrategy, baseline? : ProductionBaselineStrategy, fixed_baseline? : Double, detection? : ProductionDetectionConfig, window? : ProductionWindowConfig, alerts? : ProductionAlertConfig, dimensions? : Int, version? : Int) -> ProductionMonitorConfig

#
ProductionMonitorConfig::next_version

source

Returns a copy with a bumped configuration version.

#
ProductionMonitorConfig::summary

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

#
ProductionMonitorConfig::validate

source

Validates a complete configuration without throwing, suitable for CI and startup checks.

#
ProductionMonitorConfig::version

source

#
ProductionMonitorConfig::window

source

#
ProductionMonitorEvent

source
pub struct ProductionMonitorEvent {
  metric : String
  timestamp : Int64
  sequence : Int
  kind : ProductionMonitorEventKind
  state : ProductionHealthState
  result : DetectionResult
  baseline : Double
  value : Double
  message : String
  ordinal : Int
}

A durable audit record for each significant state transition.

#
ProductionMonitorEvent::baseline

source
fn ProductionMonitorEvent::baseline(self : ProductionMonitorEvent) -> Double

#
ProductionMonitorEvent::kind

source

#
ProductionMonitorEvent::message

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

#
ProductionMonitorEvent::metric

source
fn ProductionMonitorEvent::metric(self : ProductionMonitorEvent) -> String

#
ProductionMonitorEvent::ordinal

source

#
ProductionMonitorEvent::result

source

#
ProductionMonitorEvent::sequence

source

#
ProductionMonitorEvent::state

source

#
ProductionMonitorEvent::summary

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

#
ProductionMonitorEvent::timestamp

source
fn ProductionMonitorEvent::timestamp(self : ProductionMonitorEvent) -> Int64

#
ProductionMonitorEvent::value

source

#
ProductionMonitorEventKind

source
pub(all) enum ProductionMonitorEventKind {
  Observation
  InvalidInput
  WarmupObservation
  ChangeDetected
  AlertEmitted
  AlertSuppressed
  RecoveryStarted
  RecoveryCompleted
  QualityDegraded
}

Reason carried by an audit event emitted from a monitor.

#
ProductionMonitorMode

source
pub(all) enum ProductionMonitorMode {
  ObserveOnly
  Alerting
  Backfill
  Replay
}

Operating mode for a production monitor.

#
ProductionMonitorSnapshot

source
pub struct ProductionMonitorSnapshot {
  name : String
  state : ProductionHealthState
  processed : Int
  valid : Int
  invalid : Int
  warmup_remaining : Int
  changes : Int
  emitted : Int
  suppressed : Int
  recovery_count : Int
  latest_score : Double
  baseline : Double
  latest_value : Double
  quality_ratio : Double
  last_timestamp : Int64
}

A compact operational snapshot suitable for a dashboard or heartbeat endpoint.

#
ProductionMonitorSnapshot::baseline

source

#
ProductionMonitorSnapshot::changes

source

#
ProductionMonitorSnapshot::emitted

source

#
ProductionMonitorSnapshot::invalid

source

#
ProductionMonitorSnapshot::is_healthy

source

#
ProductionMonitorSnapshot::last_timestamp

source
fn ProductionMonitorSnapshot::last_timestamp(self : ProductionMonitorSnapshot) -> Int64

#
ProductionMonitorSnapshot::latest_score

source
fn ProductionMonitorSnapshot::latest_score(self : ProductionMonitorSnapshot) -> Double

#
ProductionMonitorSnapshot::latest_value

source
fn ProductionMonitorSnapshot::latest_value(self : ProductionMonitorSnapshot) -> Double

#
ProductionMonitorSnapshot::name

source

#
ProductionMonitorSnapshot::processed

source

#
ProductionMonitorSnapshot::quality_ratio

source
fn ProductionMonitorSnapshot::quality_ratio(self : ProductionMonitorSnapshot) -> Double

#
ProductionMonitorSnapshot::recovery_count

source
fn ProductionMonitorSnapshot::recovery_count(self : ProductionMonitorSnapshot) -> Int

#
ProductionMonitorSnapshot::state

source

#
ProductionMonitorSnapshot::summary

source

#
ProductionMonitorSnapshot::suppressed

source

#
ProductionMonitorSnapshot::valid

source

#
ProductionMonitorSnapshot::warmup_remaining

source
fn ProductionMonitorSnapshot::warmup_remaining(self : ProductionMonitorSnapshot) -> Int

#
ProductionOnlineCalibrator

source
pub struct ProductionOnlineCalibrator {
  bins : Array[ProductionScoreBin]
  mode : ProductionCalibrationMode
  observations : Int
  positive : Int
  negative : Int
}

Bounded online calibrator with deployment-safe priors.

#
ProductionOnlineCalibrator::bin_count

source

#
ProductionOnlineCalibrator::bins

source

#
ProductionOnlineCalibrator::calibrate

source
fn ProductionOnlineCalibrator::calibrate(self : ProductionOnlineCalibrator, score : Double) -> Double

#
ProductionOnlineCalibrator::mode

source

#
ProductionOnlineCalibrator::negative

source

#
ProductionOnlineCalibrator::new

source

#
ProductionOnlineCalibrator::observations

source

#
ProductionOnlineCalibrator::positive

source

#
ProductionOnlineCalibrator::reliability_error

source
fn ProductionOnlineCalibrator::reliability_error(self : ProductionOnlineCalibrator) -> Double

#
ProductionOnlineCalibrator::reset

source

#
ProductionOnlineCalibrator::update

source
fn ProductionOnlineCalibrator::update(self : ProductionOnlineCalibrator, score : Double, changed : Bool, weight? : Double) -> Unit

#
ProductionPolicyEngine

source
pub struct ProductionPolicyEngine {
  rules : Array[ProductionDeliveryRule]
  schedule : ProductionSuppressionSchedule
  budget : ProductionEventBudget
  recent : Array[ProductionAlertEnvelope]
  evaluated : Int
  delivered : Int
  suppressed : Int
  duplicates : Int
}

Policy engine combining maintenance, budgets, cooldowns and deduplication.

#
ProductionPolicyEngine::add_maintenance

source
fn ProductionPolicyEngine::add_maintenance(self : ProductionPolicyEngine, window : ProductionMaintenanceWindow) -> Bool

#
ProductionPolicyEngine::add_rule

source

#
ProductionPolicyEngine::delivered

source
fn ProductionPolicyEngine::delivered(self : ProductionPolicyEngine) -> Int

#
ProductionPolicyEngine::duplicates

source
fn ProductionPolicyEngine::duplicates(self : ProductionPolicyEngine) -> Int

#
ProductionPolicyEngine::evaluate

source

#
ProductionPolicyEngine::evaluated

source
fn ProductionPolicyEngine::evaluated(self : ProductionPolicyEngine) -> Int

#
ProductionPolicyEngine::new

source

#
ProductionPolicyEngine::reset

source

#
ProductionPolicyEngine::rules

source

#
ProductionPolicyEngine::suppressed

source
fn ProductionPolicyEngine::suppressed(self : ProductionPolicyEngine) -> Int

#
ProductionPreprocessingReport

source
pub struct ProductionPreprocessingReport {
  input_count : Int
  output_count : Int
  invalid_input : Int
  invalid_output : Int
  clipped : Int
  imputed : Int
  transformed : Int
  finite : Bool
}

Diagnostics from one preprocessing pass.

#
ProductionPreprocessingReport::clipped

source

#
ProductionPreprocessingReport::empty

source

#
ProductionPreprocessingReport::finite

source

#
ProductionPreprocessingReport::imputed

source

#
ProductionPreprocessingReport::input_count

source

#
ProductionPreprocessingReport::invalid_input

source

#
ProductionPreprocessingReport::invalid_output

source

#
ProductionPreprocessingReport::output_count

source

#
ProductionPreprocessingReport::quality

source

#
ProductionPreprocessingReport::summary

source

#
ProductionPreprocessingReport::transformed

source

#
ProductionPreprocessor

source
pub struct ProductionPreprocessor {
  specs : Array[ProductionTransformSpec]
  missing : MissingValueStrategy
  batches : Int
  values : Int
  failed : Int
}

A transform chain that can be reused across batches.

#
ProductionPreprocessor::add

source

#
ProductionPreprocessor::batches

source

#
ProductionPreprocessor::clear

source

#
ProductionPreprocessor::failed

source

#
ProductionPreprocessor::new

source

#
ProductionPreprocessor::specs

source

#
ProductionPreprocessor::transform

source
fn ProductionPreprocessor::transform(self : ProductionPreprocessor, values : Array[Double]) -> (Array[Double], ProductionPreprocessingReport)

#
ProductionPreprocessor::transform_batches

source
fn ProductionPreprocessor::transform_batches(self : ProductionPreprocessor, batches : Array[Array[Double]]) -> Array[Array[Double]]

#
ProductionPreprocessor::transform_points

source

#
ProductionPreprocessor::values

source

#
ProductionQuantileState

source
pub struct ProductionQuantileState {
  capacity : Int
  residuals : Array[Double]
  cursor : Int
}

Robust quantile state for models with non-Gaussian residuals.

#
ProductionQuantileState::absolute_quantile

source
fn ProductionQuantileState::absolute_quantile(self : ProductionQuantileState, probability : Double) -> Double

#
ProductionQuantileState::count

source

#
ProductionQuantileState::middle_spread

source
fn ProductionQuantileState::middle_spread(self : ProductionQuantileState) -> Double

#
ProductionQuantileState::new

source

#
ProductionQuantileState::push

source
fn ProductionQuantileState::push(self : ProductionQuantileState, residual : Double) -> Unit

#
ProductionQuantileState::quantile

source
fn ProductionQuantileState::quantile(self : ProductionQuantileState, probability : Double) -> Double

#
ProductionQueryResult

source
pub struct ProductionQueryResult {
  metric : String
  window : ProductionQueryWindow
  function : ProductionWindowFunction
  value : Double
  count : Int
  quality : Double
}

#
ProductionQueryResult::count

source

#
ProductionQueryResult::function

source

#
ProductionQueryResult::metric

source
fn ProductionQueryResult::metric(self : ProductionQueryResult) -> String

#
ProductionQueryResult::quality

source
fn ProductionQueryResult::quality(self : ProductionQueryResult) -> Double

#
ProductionQueryResult::summary

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

#
ProductionQueryResult::value

source
fn ProductionQueryResult::value(self : ProductionQueryResult) -> Double

#
ProductionQueryResult::window

source

#
ProductionQueryWindow

source
pub struct ProductionQueryWindow {
  start : Int64
  end : Int64
}

#
ProductionQueryWindow::contains

source
fn ProductionQueryWindow::contains(self : ProductionQueryWindow, timestamp : Int64) -> Bool

#
ProductionQueryWindow::duration

source
fn ProductionQueryWindow::duration(self : ProductionQueryWindow) -> Int64

#
ProductionQueryWindow::end

source

#
ProductionQueryWindow::new

source
fn ProductionQueryWindow::new(start : Int64, end : Int64) -> ProductionQueryWindow

#
ProductionQueryWindow::start

source
fn ProductionQueryWindow::start(self : ProductionQueryWindow) -> Int64

#
ProductionRateSummary

source
pub struct ProductionRateSummary {
  samples : Int
  resets : Int
  invalid : Int
  mean_rate : Double
  maximum_rate : Double
  latest_rate : Double
}

A rolling rate and change summary used for counter-based metrics.

#
ProductionRateSummary::from_points

source

#
ProductionRateSummary::invalid

source
fn ProductionRateSummary::invalid(self : ProductionRateSummary) -> Int

#
ProductionRateSummary::latest_rate

source
fn ProductionRateSummary::latest_rate(self : ProductionRateSummary) -> Double

#
ProductionRateSummary::maximum_rate

source
fn ProductionRateSummary::maximum_rate(self : ProductionRateSummary) -> Double

#
ProductionRateSummary::mean_rate

source
fn ProductionRateSummary::mean_rate(self : ProductionRateSummary) -> Double

#
ProductionRateSummary::resets

source

#
ProductionRateSummary::samples

source
fn ProductionRateSummary::samples(self : ProductionRateSummary) -> Int

#
ProductionRateTracker

source
pub struct ProductionRateTracker {
  previous_timestamp : Int64?
  previous_value : Double?
  resets : Int
  invalid : Int
}

Tracks rates and counter resets for monotonic telemetry.

#
ProductionRateTracker::invalid

source
fn ProductionRateTracker::invalid(self : ProductionRateTracker) -> Int

#
ProductionRateTracker::new

source

#
ProductionRateTracker::push

source
fn ProductionRateTracker::push(self : ProductionRateTracker, timestamp : Int64, value : Double) -> Double?

#
ProductionRateTracker::resets

source

#
ProductionReadinessCheck

source
pub struct ProductionReadinessCheck {
  name : String
  passed : Bool
  critical : Bool
  value : Double
  expected : Double
  message : String
}

Result of one startup or liveness check.

#
ProductionReadinessCheck::critical

source

#
ProductionReadinessCheck::expected

source
fn ProductionReadinessCheck::expected(self : ProductionReadinessCheck) -> Double

#
ProductionReadinessCheck::message

source

#
ProductionReadinessCheck::name

source

#
ProductionReadinessCheck::new

source
fn ProductionReadinessCheck::new(name : String, passed : Bool, expected : Double, value : Double, message? : String, critical? : Bool) -> ProductionReadinessCheck

#
ProductionReadinessCheck::passed

source

#
ProductionReadinessCheck::summary

source

#
ProductionReadinessCheck::value

source

#
ProductionReadinessReport

source
pub struct ProductionReadinessReport {
  checks : Array[ProductionReadinessCheck]
  passed : Bool
  critical_failures : Int
  warnings : Int
  status : ProductionServiceStatus
}

Aggregate startup and liveness status.

#
ProductionReadinessReport::checks

source

#
ProductionReadinessReport::critical_failures

source
fn ProductionReadinessReport::critical_failures(self : ProductionReadinessReport) -> Int

#
ProductionReadinessReport::from_checks

source

#
ProductionReadinessReport::markdown

source

#
ProductionReadinessReport::passed

source

#
ProductionReadinessReport::status

source

#
ProductionReadinessReport::summary

source

#
ProductionReadinessReport::warnings

source

#
ProductionReplayConfig

source
pub struct ProductionReplayConfig {
  mode : ProductionReplayMode
  start_timestamp : Int64
  step : Int64
  maximum_points : Int
  compare_tolerance : Double
  include_quiet : Bool
}

Replay options for deterministic regression and incident investigation.

#
ProductionReplayConfig::compare_tolerance

source
fn ProductionReplayConfig::compare_tolerance(self : ProductionReplayConfig) -> Double

#
ProductionReplayConfig::include_quiet

source
fn ProductionReplayConfig::include_quiet(self : ProductionReplayConfig) -> Bool

#
ProductionReplayConfig::maximum_points

source
fn ProductionReplayConfig::maximum_points(self : ProductionReplayConfig) -> Int

#
ProductionReplayConfig::mode

source

#
ProductionReplayConfig::new

source
fn ProductionReplayConfig::new(mode? : ProductionReplayMode, start_timestamp? : Int64, step? : Int64, maximum_points? : Int, compare_tolerance? : Double, include_quiet? : Bool) -> ProductionReplayConfig

#
ProductionReplayConfig::start_timestamp

source
fn ProductionReplayConfig::start_timestamp(self : ProductionReplayConfig) -> Int64

#
ProductionReplayConfig::step

source

#
ProductionReplayDifference

source
pub struct ProductionReplayDifference {
  points_delta : Int
  changes_delta : Int
  emitted_delta : Int
  checksum_delta : Double
  score_delta : Double
  equivalent : Bool
}

Difference between two deterministic replay results.

#
ProductionReplayDifference::changes_delta

source

#
ProductionReplayDifference::checksum_delta

source
fn ProductionReplayDifference::checksum_delta(self : ProductionReplayDifference) -> Double

#
ProductionReplayDifference::emitted_delta

source

#
ProductionReplayDifference::equivalent

source

#
ProductionReplayDifference::from_summaries

source

#
ProductionReplayDifference::points_delta

source

#
ProductionReplayDifference::score_delta

source
fn ProductionReplayDifference::score_delta(self : ProductionReplayDifference) -> Double

#
ProductionReplayDifference::summary

source

#
ProductionReplayMode

source
pub(all) enum ProductionReplayMode {
  StatefulReplay
  ShadowReplay
  CompareReplay
}

Replay mode controls whether detector state is allowed to mutate.

#
ProductionReplayObservation

source
pub struct ProductionReplayObservation {
  index : Int
  timestamp : Int64
  value : Double
  baseline : Double
  result : DetectionResult
  state : ProductionHealthState
  emitted : Bool
}

One normalized replay output row.

#
ProductionReplayObservation::baseline

source

#
ProductionReplayObservation::emitted

source

#
ProductionReplayObservation::index

source

#
ProductionReplayObservation::result

source

#
ProductionReplayObservation::state

source

#
ProductionReplayObservation::summary

source

#
ProductionReplayObservation::timestamp

source

#
ProductionReplayObservation::value

source

#
ProductionReplayRunner

source
pub struct ProductionReplayRunner {
  config : ProductionReplayConfig
  observations : Array[ProductionReplayObservation]
  skipped : Int
}

Runs a configured monitor over a reproducible input signal.

#
ProductionReplayRunner::config

source

#
ProductionReplayRunner::new

source

#
ProductionReplayRunner::observations

source

#
ProductionReplayRunner::reset

source

#
ProductionReplayRunner::run

source

#
ProductionReplayRunner::skipped

source

#
ProductionReplaySummary

source
pub struct ProductionReplaySummary {
  points : Int
  valid : Int
  invalid : Int
  changes : Int
  emitted : Int
  suppressed : Int
  checksum : Double
  first_change : Int
  mean_score : Double
  maximum_score : Double
  final_state : ProductionHealthState
}

Aggregate replay statistics and a deterministic checksum.

#
ProductionReplaySummary::changes

source

#
ProductionReplaySummary::checksum

source
fn ProductionReplaySummary::checksum(self : ProductionReplaySummary) -> Double

#
ProductionReplaySummary::emitted

source

#
ProductionReplaySummary::final_state

source

#
ProductionReplaySummary::first_change

source
fn ProductionReplaySummary::first_change(self : ProductionReplaySummary) -> Int

#
ProductionReplaySummary::invalid

source

#
ProductionReplaySummary::maximum_score

source
fn ProductionReplaySummary::maximum_score(self : ProductionReplaySummary) -> Double

#
ProductionReplaySummary::mean_score

source
fn ProductionReplaySummary::mean_score(self : ProductionReplaySummary) -> Double

#
ProductionReplaySummary::points

source

#
ProductionReplaySummary::summary

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

#
ProductionReplaySummary::suppressed

source
fn ProductionReplaySummary::suppressed(self : ProductionReplaySummary) -> Int

#
ProductionReplaySummary::valid

source

#
ProductionReportFormat

source
pub(all) enum ProductionReportFormat {
  CsvReport
  MarkdownReport
  LineReport
}

Report formats supported by the operational reporting helpers.

#
ProductionReportOptions

source
pub struct ProductionReportOptions {
  format : ProductionReportFormat
  include_events : Bool
  include_features : Bool
  maximum_rows : Int
  decimals : Int
}

Options controlling report size and precision.

#
ProductionReportOptions::decimals

source

#
ProductionReportOptions::format

source

#
ProductionReportOptions::include_events

source
fn ProductionReportOptions::include_events(self : ProductionReportOptions) -> Bool

#
ProductionReportOptions::include_features

source
fn ProductionReportOptions::include_features(self : ProductionReportOptions) -> Bool

#
ProductionReportOptions::maximum_rows

source
fn ProductionReportOptions::maximum_rows(self : ProductionReportOptions) -> Int

#
ProductionReportOptions::new

source
fn ProductionReportOptions::new(format? : ProductionReportFormat, include_events? : Bool, include_features? : Bool, maximum_rows? : Int, decimals? : Int) -> ProductionReportOptions

#
ProductionResampler

source
pub struct ProductionResampler {
  step : Int64
  policy : ProductionFillPolicy
  origin : Int64?
  last : ProductionSample?
  pending_empty : Int
  produced : Int
}

Converts irregular event-time samples into a regular grid.

#
ProductionResampler::flush

source

#
ProductionResampler::new

source
fn ProductionResampler::new(step? : Int64, policy? : ProductionFillPolicy) -> ProductionResampler

#
ProductionResampler::pending_empty

source
fn ProductionResampler::pending_empty(self : ProductionResampler) -> Int

#
ProductionResampler::produced

source
fn ProductionResampler::produced(self : ProductionResampler) -> Int

#
ProductionResampler::push

source

#
ProductionResampler::step

source
fn ProductionResampler::step(self : ProductionResampler) -> Int64

#
ProductionResidualScale

source
pub struct ProductionResidualScale {
  alpha : Double
  center : Double
  deviation : Double
  count : Int
  missing : Int
}

An exponentially weighted residual scale used to construct robust intervals.

#
ProductionResidualScale::center

source

#
ProductionResidualScale::count

source

#
ProductionResidualScale::deviation

source
fn ProductionResidualScale::deviation(self : ProductionResidualScale) -> Double

#
ProductionResidualScale::missing

source

#
ProductionResidualScale::new

source

#
ProductionResidualScale::uncertainty

source
fn ProductionResidualScale::uncertainty(self : ProductionResidualScale, confidence? : Double) -> Double

#
ProductionResidualScale::update

source
fn ProductionResidualScale::update(self : ProductionResidualScale, residual : Double) -> Double

#
ProductionRolloutPlan

source
pub struct ProductionRolloutPlan {
  name : String
  stages : Array[ProductionRolloutStage]
  active_stage : Int
  started_at : Int64
  completed : Bool
  aborted : Bool
}

Ordered rollout plan used by deployment orchestration.

#
ProductionRolloutPlan::abort

source

#
ProductionRolloutPlan::active_stage

source
fn ProductionRolloutPlan::active_stage(self : ProductionRolloutPlan) -> Int

#
ProductionRolloutPlan::add_stage

source

#
ProductionRolloutPlan::current_stage

source

#
ProductionRolloutPlan::describe

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

Stable text representation for deployment audit logs.

#
ProductionRolloutPlan::is_aborted

source
fn ProductionRolloutPlan::is_aborted(self : ProductionRolloutPlan) -> Bool

#
ProductionRolloutPlan::is_completed

source
fn ProductionRolloutPlan::is_completed(self : ProductionRolloutPlan) -> Bool

#
ProductionRolloutPlan::name

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

#
ProductionRolloutPlan::new

source

#
ProductionRolloutPlan::promote

source
fn ProductionRolloutPlan::promote(self : ProductionRolloutPlan, timestamp : Int64, health : Double) -> Bool

#
ProductionRolloutPlan::stage_count

source
fn ProductionRolloutPlan::stage_count(self : ProductionRolloutPlan) -> Int

#
ProductionRolloutPlan::stages

source

#
ProductionRolloutPlan::start

source
fn ProductionRolloutPlan::start(self : ProductionRolloutPlan, timestamp : Int64) -> Bool

#
ProductionRolloutPlan::started_at

source
fn ProductionRolloutPlan::started_at(self : ProductionRolloutPlan) -> Int64

#
ProductionRolloutPlan::validate

source
fn ProductionRolloutPlan::validate(self : ProductionRolloutPlan) -> Array[String]

Validate a plan before it is handed to a deployment service.

#
ProductionRolloutStage

source
pub struct ProductionRolloutStage {
  name : String
  exposure : Double
  minimum_duration : Int64
  maximum_duration : Int64
  required_health : Double
  automatic_promotion : Bool
}

A named canary stage with an explicit exposure range.

#
ProductionRolloutStage::automatic_promotion

source
fn ProductionRolloutStage::automatic_promotion(self : ProductionRolloutStage) -> Bool

#
ProductionRolloutStage::exposure

source
fn ProductionRolloutStage::exposure(self : ProductionRolloutStage) -> Double

#
ProductionRolloutStage::maximum_duration

source
fn ProductionRolloutStage::maximum_duration(self : ProductionRolloutStage) -> Int64

#
ProductionRolloutStage::minimum_duration

source
fn ProductionRolloutStage::minimum_duration(self : ProductionRolloutStage) -> Int64

#
ProductionRolloutStage::name

source

#
ProductionRolloutStage::new

source
fn ProductionRolloutStage::new(name : String, exposure? : Double, minimum_duration? : Int64, maximum_duration? : Int64, required_health? : Double, automatic_promotion? : Bool) -> ProductionRolloutStage

#
ProductionRolloutStage::required_health

source
fn ProductionRolloutStage::required_health(self : ProductionRolloutStage) -> Double

#
ProductionSample

source
pub struct ProductionSample {
  timestamp : Int64
  value : Double
  sequence : Int
  imputed : Bool
  late : Bool
}

A validated sample entering a production analytics pipeline.

#
ProductionSample::imputed

source
fn ProductionSample::imputed(self : ProductionSample) -> Bool

#
ProductionSample::late

source
fn ProductionSample::late(self : ProductionSample) -> Bool

#
ProductionSample::new

source
fn ProductionSample::new(timestamp : Int64, value : Double, sequence? : Int, imputed? : Bool, late? : Bool) -> ProductionSample

#
ProductionSample::sequence

source
fn ProductionSample::sequence(self : ProductionSample) -> Int

#
ProductionSample::timestamp

source
fn ProductionSample::timestamp(self : ProductionSample) -> Int64

#
ProductionSample::value

source
fn ProductionSample::value(self : ProductionSample) -> Double

#
ProductionSampleQueue

source
pub struct ProductionSampleQueue {
  capacity : Int
  policy : ProductionBackpressurePolicy
  samples : Array[ProductionSample]
  accepted : Int
  dropped : Int
  rejected : Int
}

Bounded queue with explicit loss accounting.

#
ProductionSampleQueue::accepted

source
fn ProductionSampleQueue::accepted(self : ProductionSampleQueue) -> Int

#
ProductionSampleQueue::capacity

source
fn ProductionSampleQueue::capacity(self : ProductionSampleQueue) -> Int

#
ProductionSampleQueue::clear

source

#
ProductionSampleQueue::drain

source

#
ProductionSampleQueue::dropped

source
fn ProductionSampleQueue::dropped(self : ProductionSampleQueue) -> Int

#
ProductionSampleQueue::length

source

#
ProductionSampleQueue::new

source

#
ProductionSampleQueue::peek

source

#
ProductionSampleQueue::policy

source

#
ProductionSampleQueue::pop

source

#
ProductionSampleQueue::push

source

#
ProductionSampleQueue::rejected

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

#
ProductionScoreBin

source
pub struct ProductionScoreBin {
  lower : Double
  upper : Double
  total : Double
  positives : Double
  prior_positive : Double
  prior_negative : Double
}

A bin of online score-to-outcome evidence.

#
ProductionScoreBin::add

source
fn ProductionScoreBin::add(self : ProductionScoreBin, positive : Bool, weight : Double) -> Unit

#
ProductionScoreBin::contains

source
fn ProductionScoreBin::contains(self : ProductionScoreBin, score : Double) -> Bool

#
ProductionScoreBin::mean_score

source
fn ProductionScoreBin::mean_score(self : ProductionScoreBin) -> Double

#
ProductionScoreBin::new

source
fn ProductionScoreBin::new(lower : Double, upper : Double, prior_positive? : Double, prior_negative? : Double) -> ProductionScoreBin

#
ProductionScoreBin::positives

source
fn ProductionScoreBin::positives(self : ProductionScoreBin) -> Double

#
ProductionScoreBin::rate

source
fn ProductionScoreBin::rate(self : ProductionScoreBin) -> Double

#
ProductionScoreBin::summary

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

#
ProductionScoreBin::total

source
fn ProductionScoreBin::total(self : ProductionScoreBin) -> Double

#
ProductionSeriesQuery

source
pub struct ProductionSeriesQuery {
  metric : String
  window : ProductionQueryWindow
  function : ProductionWindowFunction
  minimum_quality : Double
}

#
ProductionSeriesQuery::execute

source

#
ProductionSeriesQuery::function

source

#
ProductionSeriesQuery::metric

source
fn ProductionSeriesQuery::metric(self : ProductionSeriesQuery) -> String

#
ProductionSeriesQuery::minimum_quality

source
fn ProductionSeriesQuery::minimum_quality(self : ProductionSeriesQuery) -> Double

#
ProductionSeriesQuery::new

source
fn ProductionSeriesQuery::new(metric : String, window : ProductionQueryWindow, function? : ProductionWindowFunction, minimum_quality? : Double) -> ProductionSeriesQuery

#
ProductionSeriesQuery::window

source

#
ProductionServiceHeartbeat

source
pub struct ProductionServiceHeartbeat {
  service : String
  timestamp : Int64
  status : ProductionServiceStatus
  monitor_count : Int
  fleet_score : Double
  processed : Int
  alerts : Int
  incidents : Int
  p95_latency : Double
}

Heartbeat record for a service exposing monitor health.

#
ProductionServiceHeartbeat::alerts

source

#
ProductionServiceHeartbeat::fleet_score

source
fn ProductionServiceHeartbeat::fleet_score(self : ProductionServiceHeartbeat) -> Double

#
ProductionServiceHeartbeat::incidents

source

#
ProductionServiceHeartbeat::monitor_count

source

#
ProductionServiceHeartbeat::new

source
fn ProductionServiceHeartbeat::new(service : String, timestamp : Int64, snapshots : Array[ProductionMonitorSnapshot], incidents : Int, p95_latency? : Double) -> ProductionServiceHeartbeat

#
ProductionServiceHeartbeat::p95_latency

source
fn ProductionServiceHeartbeat::p95_latency(self : ProductionServiceHeartbeat) -> Double

#
ProductionServiceHeartbeat::processed

source

#
ProductionServiceHeartbeat::service

source

#
ProductionServiceHeartbeat::status

source

#
ProductionServiceHeartbeat::summary

source

#
ProductionServiceHeartbeat::timestamp

source

#
ProductionServiceRegistry

source
pub struct ProductionServiceRegistry {
  service : String
  monitors : Array[ProductionMonitor]
  heartbeats : Int
  status : ProductionServiceStatus
}

A registry for coordinated monitor heartbeats.

#
ProductionServiceRegistry::heartbeat

source
fn ProductionServiceRegistry::heartbeat(self : ProductionServiceRegistry, timestamp : Int64, incidents : Int, p95_latency? : Double) -> ProductionServiceHeartbeat

#
ProductionServiceRegistry::heartbeats

source

#
ProductionServiceRegistry::monitor_count

source
fn ProductionServiceRegistry::monitor_count(self : ProductionServiceRegistry) -> Int

#
ProductionServiceRegistry::names

source

#
ProductionServiceRegistry::new

source

#
ProductionServiceRegistry::process

source

#
ProductionServiceRegistry::process_all

source

#
ProductionServiceRegistry::register

source

#
ProductionServiceRegistry::snapshots

source

#
ProductionServiceRegistry::status

source

#
ProductionServiceStatus

source
pub(all) enum ProductionServiceStatus {
  StartingService
  ReadyService
  DegradedService
  DrainingService
  FailedService
}

Lifecycle status of an embedding service.

#
ProductionSloObjective

source
pub struct ProductionSloObjective {
  name : String
  target : Double
  window : Int64
  burn_limit : Double
  kind : ProductionSloWindowKind
}

Objective for one service-level indicator.

#
ProductionSloObjective::burn_limit

source
fn ProductionSloObjective::burn_limit(self : ProductionSloObjective) -> Double

#
ProductionSloObjective::error_budget

source
fn ProductionSloObjective::error_budget(self : ProductionSloObjective) -> Double

#
ProductionSloObjective::kind

source

#
ProductionSloObjective::name

source

#
ProductionSloObjective::new

source
fn ProductionSloObjective::new(name : String, target? : Double, window? : Int64, burn_limit? : Double, kind? : ProductionSloWindowKind) -> ProductionSloObjective

#
ProductionSloObjective::summary

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

#
ProductionSloObjective::target

source
fn ProductionSloObjective::target(self : ProductionSloObjective) -> Double

#
ProductionSloObjective::window

source

#
ProductionSloReport

source
pub struct ProductionSloReport {
  objective : ProductionSloObjective
  total : Int
  good : Int
  bad : Int
  compliance : Double
  burn_rate : Double
  remaining_budget : Double
  breached : Bool
}

Current burn and compliance state for one SLO.

#
ProductionSloReport::bad

source

#
ProductionSloReport::breached

source
fn ProductionSloReport::breached(self : ProductionSloReport) -> Bool

#
ProductionSloReport::burn_rate

source
fn ProductionSloReport::burn_rate(self : ProductionSloReport) -> Double

#
ProductionSloReport::compliance

source
fn ProductionSloReport::compliance(self : ProductionSloReport) -> Double

#
ProductionSloReport::good

source

#
ProductionSloReport::objective

source

#
ProductionSloReport::remaining_budget

source
fn ProductionSloReport::remaining_budget(self : ProductionSloReport) -> Double

#
ProductionSloReport::summary

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

#
ProductionSloReport::total

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

#
ProductionSloTracker

source
pub struct ProductionSloTracker {
  objective : ProductionSloObjective
  total : Int
  good : Int
  bad : Int
  window_start : Int64?
}

Mutable SLO tracker fed by accepted/rejected monitor outcomes.

#
ProductionSloTracker::bad

source

#
ProductionSloTracker::good

source

#
ProductionSloTracker::new

source

#
ProductionSloTracker::objective

source

#
ProductionSloTracker::observe

source
fn ProductionSloTracker::observe(self : ProductionSloTracker, timestamp : Int64, good : Bool) -> Unit

#
ProductionSloTracker::observe_event

source
fn ProductionSloTracker::observe_event(self : ProductionSloTracker, timestamp : Int64, event : ProductionMonitorEvent) -> Unit

#
ProductionSloTracker::report

source

#
ProductionSloTracker::reset

source
fn ProductionSloTracker::reset(self : ProductionSloTracker) -> Unit

#
ProductionSloTracker::total

source

#
ProductionSloWindowKind

source
pub(all) enum ProductionSloWindowKind {
  ShortSloWindow
  LongSloWindow
  RollingSloWindow
}

SLO window kind for operational change detection services.

#
ProductionStackResult

source
pub struct ProductionStackResult {
  result : DetectionResult
  votes : Array[ProductionDetectorVote]
  agreement : Double
  strongest : ProductionDetectorKind
}

Result of a weighted, explainable ensemble pass.

#
ProductionStackResult::agreement

source
fn ProductionStackResult::agreement(self : ProductionStackResult) -> Double

#
ProductionStackResult::result

source

#
ProductionStackResult::strongest

source

#
ProductionStackResult::summary

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

#
ProductionStackResult::votes

source

#
ProductionStatTestKind

source
pub(all) enum ProductionStatTestKind {
  MeanDifferenceTest
  MedianDifferenceTest
  PermutationShiftTest
  BootstrapIntervalTest
  CorrelationTest
  VarianceRatioTest
}

Statistical test kind used in an evidence report.

#
ProductionStatTestResult

source
pub struct ProductionStatTestResult {
  kind : ProductionStatTestKind
  statistic : Double
  p_value : Double
  effect : Double
  interval : ProductionConfidenceInterval
  significant : Bool
}

Test result with a bounded score and actionable interpretation.

#
ProductionStatTestResult::effect

source

#
ProductionStatTestResult::interval

source

#
ProductionStatTestResult::kind

source

#
ProductionStatTestResult::p_value

source

#
ProductionStatTestResult::significant

source
fn ProductionStatTestResult::significant(self : ProductionStatTestResult) -> Bool

#
ProductionStatTestResult::statistic

source
fn ProductionStatTestResult::statistic(self : ProductionStatTestResult) -> Double

#
ProductionStatTestResult::summary

source

#
ProductionStreamMetrics

source
pub struct ProductionStreamMetrics {
  enqueued : Int
  processed : Int
  emitted : Int
  rejected : Int
  aggregates : Int
  flushes : Int
  last_timestamp : Int64
}

Counters emitted by an online stream processor.

#
ProductionStreamMetrics::aggregates

source
fn ProductionStreamMetrics::aggregates(self : ProductionStreamMetrics) -> Int

#
ProductionStreamMetrics::emitted

source

#
ProductionStreamMetrics::enqueued

source

#
ProductionStreamMetrics::flushes

source

#
ProductionStreamMetrics::last_timestamp

source
fn ProductionStreamMetrics::last_timestamp(self : ProductionStreamMetrics) -> Int64

#
ProductionStreamMetrics::new

source

#
ProductionStreamMetrics::processed

source

#
ProductionStreamMetrics::rejected

source

#
ProductionStreamMetrics::summary

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

#
ProductionStreamMetrics::throughput

source
fn ProductionStreamMetrics::throughput(self : ProductionStreamMetrics, elapsed : Int64) -> Double

#
ProductionStreamProcessor

source
pub struct ProductionStreamProcessor {
  queue : ProductionSampleQueue
  bucketizer : ProductionBucketizer
  monitor : ProductionMonitor
  status : ProductionStreamStatus
  metrics : ProductionStreamMetrics
  started_at : Int64?
}

Backpressure-aware processor joining queue, event-time bucketization and monitor state.

#
ProductionStreamProcessor::continue_processing

source
fn ProductionStreamProcessor::continue_processing(self : ProductionStreamProcessor) -> Unit

#
ProductionStreamProcessor::drain

source

#
ProductionStreamProcessor::elapsed

source
fn ProductionStreamProcessor::elapsed(self : ProductionStreamProcessor, now : Int64) -> Int64

#
ProductionStreamProcessor::enqueue

source

#
ProductionStreamProcessor::flush

source

#
ProductionStreamProcessor::metrics

source

#
ProductionStreamProcessor::monitor

source

#
ProductionStreamProcessor::new

source
fn ProductionStreamProcessor::new(monitor : ProductionMonitor, queue_capacity? : Int, queue_policy? : ProductionBackpressurePolicy, bucket_interval? : Int64) -> ProductionStreamProcessor

#
ProductionStreamProcessor::pause

source

#
ProductionStreamProcessor::queue_length

source

#
ProductionStreamProcessor::restart

source
fn ProductionStreamProcessor::restart(self : ProductionStreamProcessor, timestamp : Int64) -> Unit

#
ProductionStreamProcessor::start

source
fn ProductionStreamProcessor::start(self : ProductionStreamProcessor, timestamp : Int64) -> Unit

#
ProductionStreamProcessor::status

source

#
ProductionStreamStatus

source
pub(all) enum ProductionStreamStatus {
  StartingStream
  RunningStream
  PausedStream
  DrainingStream
  StoppedStream
}

Runtime state of a stream processor.

#
ProductionSuppressionSchedule

source
pub struct ProductionSuppressionSchedule {
  windows : Array[ProductionMaintenanceWindow]
  suppressed : Int
}

A suppression schedule composed of non-overlapping maintenance windows.

#
ProductionSuppressionSchedule::active

source

#
ProductionSuppressionSchedule::add

source

#
ProductionSuppressionSchedule::allow

source
fn ProductionSuppressionSchedule::allow(self : ProductionSuppressionSchedule, timestamp : Int64) -> Bool

#
ProductionSuppressionSchedule::new

source

#
ProductionSuppressionSchedule::suppressed

source

#
ProductionSuppressionSchedule::windows

source

#
ProductionTelemetryCounters

source
pub struct ProductionTelemetryCounters {
  samples_received : Int
  samples_rejected : Int
  samples_imputed : Int
  late_samples : Int
  detector_updates : Int
  alerts_emitted : Int
  alerts_suppressed : Int
  incidents_opened : Int
  incidents_resolved : Int
  report_exports : Int
}

Counter set for monitoring ingestion and alert delivery itself.

#
ProductionTelemetryCounters::alerts_emitted

source

#
ProductionTelemetryCounters::alerts_suppressed

source
fn ProductionTelemetryCounters::alerts_suppressed(self : ProductionTelemetryCounters) -> Int

#
ProductionTelemetryCounters::detector_updates

source
fn ProductionTelemetryCounters::detector_updates(self : ProductionTelemetryCounters) -> Int

#
ProductionTelemetryCounters::incidents_opened

source
fn ProductionTelemetryCounters::incidents_opened(self : ProductionTelemetryCounters) -> Int

#
ProductionTelemetryCounters::incidents_resolved

source
fn ProductionTelemetryCounters::incidents_resolved(self : ProductionTelemetryCounters) -> Int

#
ProductionTelemetryCounters::late_samples

source

#
ProductionTelemetryCounters::new

source

#
ProductionTelemetryCounters::observe_export

source
fn ProductionTelemetryCounters::observe_export(self : ProductionTelemetryCounters) -> Unit

#
ProductionTelemetryCounters::observe_incident

source
fn ProductionTelemetryCounters::observe_incident(self : ProductionTelemetryCounters, opened : Bool, resolved : Bool) -> Unit

#
ProductionTelemetryCounters::observe_result

source
fn ProductionTelemetryCounters::observe_result(self : ProductionTelemetryCounters, result : DetectionResult, emitted : Bool) -> Unit

#
ProductionTelemetryCounters::observe_sample

source
fn ProductionTelemetryCounters::observe_sample(self : ProductionTelemetryCounters, sample : ProductionSample, accepted : Bool) -> Unit

#
ProductionTelemetryCounters::report_exports

source

#
ProductionTelemetryCounters::samples_imputed

source
fn ProductionTelemetryCounters::samples_imputed(self : ProductionTelemetryCounters) -> Int

#
ProductionTelemetryCounters::samples_received

source
fn ProductionTelemetryCounters::samples_received(self : ProductionTelemetryCounters) -> Int

#
ProductionTelemetryCounters::samples_rejected

source
fn ProductionTelemetryCounters::samples_rejected(self : ProductionTelemetryCounters) -> Int

#
ProductionTelemetryCounters::summary

source

#
ProductionTelemetryExporter

source
pub struct ProductionTelemetryExporter {
  options : ProductionExportOptions
  stats : ProductionExportStats
}

#
ProductionTelemetryExporter::export_batch

source

#
ProductionTelemetryExporter::export_csv

source

#
ProductionTelemetryExporter::export_json_lines

source
fn ProductionTelemetryExporter::export_json_lines(self : ProductionTelemetryExporter, records : Array[ProductionExportRecord]) -> String

#
ProductionTelemetryExporter::export_markdown

source

#
ProductionTelemetryExporter::export_prometheus

source
fn ProductionTelemetryExporter::export_prometheus(self : ProductionTelemetryExporter, records : Array[ProductionExportRecord]) -> String

#
ProductionTelemetryExporter::export_summary

source

#
ProductionTelemetryExporter::new

source

#
ProductionTelemetryExporter::options

source

#
ProductionTelemetryExporter::reset_stats

source

#
ProductionTelemetryExporter::stats

source

#
ProductionThresholdController

source
pub struct ProductionThresholdController {
  scores : DoubleWindow
  target_alert_rate : Double
  minimum_threshold : Double
  maximum_threshold : Double
  hysteresis : Double
  threshold : Double
  updates : Int
}

Adaptive threshold controller based on a recent score window and hysteresis.

#
ProductionThresholdController::new

source
fn ProductionThresholdController::new(window_size? : Int, target_alert_rate? : Double, minimum_threshold? : Double, maximum_threshold? : Double, hysteresis? : Double) -> ProductionThresholdController

#
ProductionThresholdController::push

source
fn ProductionThresholdController::push(self : ProductionThresholdController, score : Double) -> Double

#
ProductionThresholdController::reset

source

#
ProductionThresholdController::summary

source

#
ProductionThresholdController::threshold

source

#
ProductionThresholdController::updates

source

#
ProductionThresholdCost

source
pub struct ProductionThresholdCost {
  false_positive : Double
  false_negative : Double
  alert_volume : Double
}

Cost weights used to select an operating threshold.

#
ProductionThresholdCost::alert_volume

source
fn ProductionThresholdCost::alert_volume(self : ProductionThresholdCost) -> Double

#
ProductionThresholdCost::false_negative

source
fn ProductionThresholdCost::false_negative(self : ProductionThresholdCost) -> Double

#
ProductionThresholdCost::false_positive

source
fn ProductionThresholdCost::false_positive(self : ProductionThresholdCost) -> Double

#
ProductionThresholdCost::new

source
fn ProductionThresholdCost::new(false_positive? : Double, false_negative? : Double, alert_volume? : Double) -> ProductionThresholdCost

#
ProductionThresholdCost::score

source

#
ProductionThresholdSelection

source
pub struct ProductionThresholdSelection {
  threshold : Double
  matrix : ProductionConfusionMatrix
  objective : Double
  strategy : String
}

Result of threshold selection on labeled historical data.

#
ProductionThresholdSelection::matrix

source

#
ProductionThresholdSelection::objective

source

#
ProductionThresholdSelection::strategy

source

#
ProductionThresholdSelection::threshold

source

#
ProductionTimeWindow

source
pub struct ProductionTimeWindow {
  capacity : Int
  values : Array[ProductionSample]
  start_index : Int
  length : Int
  dropped : Int
}

A bounded time-ordered window with explicit retention accounting.

#
ProductionTimeWindow::capacity

source
fn ProductionTimeWindow::capacity(self : ProductionTimeWindow) -> Int

#
ProductionTimeWindow::clear

source
fn ProductionTimeWindow::clear(self : ProductionTimeWindow) -> Unit

#
ProductionTimeWindow::dropped

source
fn ProductionTimeWindow::dropped(self : ProductionTimeWindow) -> Int

#
ProductionTimeWindow::first

source

#
ProductionTimeWindow::get

source

#
ProductionTimeWindow::is_empty

source
fn ProductionTimeWindow::is_empty(self : ProductionTimeWindow) -> Bool

#
ProductionTimeWindow::is_full

source
fn ProductionTimeWindow::is_full(self : ProductionTimeWindow) -> Bool

#
ProductionTimeWindow::last

source

#
ProductionTimeWindow::length

source
fn ProductionTimeWindow::length(self : ProductionTimeWindow) -> Int

#
ProductionTimeWindow::new

source
fn ProductionTimeWindow::new(capacity? : Int) -> ProductionTimeWindow

#
ProductionTimeWindow::outlier_count

source
fn ProductionTimeWindow::outlier_count(self : ProductionTimeWindow, z_limit? : Double) -> Int

#
ProductionTimeWindow::push

source

#
ProductionTimeWindow::rolling_change

source
fn ProductionTimeWindow::rolling_change(self : ProductionTimeWindow, split : Int) -> Double

#
ProductionTimeWindow::summary

source

#
ProductionTimeWindow::timestamps

source
fn ProductionTimeWindow::timestamps(self : ProductionTimeWindow) -> Array[Int64]

#
ProductionTimeWindow::to_array

source

#
ProductionTimeWindow::values

source
fn ProductionTimeWindow::values(self : ProductionTimeWindow) -> Array[Double]

#
ProductionTransformKind

source
pub(all) enum ProductionTransformKind {
  IdentityTransform
  ClipTransform
  DifferenceTransform
  Log1pTransform
  SqrtTransform
  ZScoreTransform
  RobustZTransform
  DetrendTransform
  SmoothTransform
  WinsorizeTransform
  SeasonalRemoveTransform
  RateTransform
}

Transformation kinds available in the preprocessing chain.

#
ProductionTransformSpec

source
pub struct ProductionTransformSpec {
  kind : ProductionTransformKind
  parameter_a : Double
  parameter_b : Double
  integer_parameter : Int
}

One configured preprocessing operation.

#
ProductionTransformSpec::integer_parameter

source
fn ProductionTransformSpec::integer_parameter(self : ProductionTransformSpec) -> Int

#
ProductionTransformSpec::kind

source

#
ProductionTransformSpec::new

source
fn ProductionTransformSpec::new(kind : ProductionTransformKind, parameter_a? : Double, parameter_b? : Double, integer_parameter? : Int) -> ProductionTransformSpec

#
ProductionTransformSpec::parameter_a

source
fn ProductionTransformSpec::parameter_a(self : ProductionTransformSpec) -> Double

#
ProductionTransformSpec::parameter_b

source
fn ProductionTransformSpec::parameter_b(self : ProductionTransformSpec) -> Double

#
ProductionTransformSpec::summary

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

#
ProductionWindowConfig

source
pub struct ProductionWindowConfig {
  reorder_capacity : Int
  allowed_lateness : Int64
  aggregate_size : Int
  retention_points : Int
  maximum_gap : Int64?
  deduplicate_timestamps : Bool
}

Event-time and memory settings for an operational stream.

#
ProductionWindowConfig::aggregate_size

source
fn ProductionWindowConfig::aggregate_size(self : ProductionWindowConfig) -> Int

#
ProductionWindowConfig::allowed_lateness

source
fn ProductionWindowConfig::allowed_lateness(self : ProductionWindowConfig) -> Int64

#
ProductionWindowConfig::deduplicate_timestamps

source
fn ProductionWindowConfig::deduplicate_timestamps(self : ProductionWindowConfig) -> Bool

#
ProductionWindowConfig::maximum_gap

source
fn ProductionWindowConfig::maximum_gap(self : ProductionWindowConfig) -> Int64?

#
ProductionWindowConfig::new

source
fn ProductionWindowConfig::new(reorder_capacity? : Int, allowed_lateness? : Int64, aggregate_size? : Int, retention_points? : Int, maximum_gap? : Int64?, deduplicate_timestamps? : Bool) -> ProductionWindowConfig

#
ProductionWindowConfig::reorder_capacity

source
fn ProductionWindowConfig::reorder_capacity(self : ProductionWindowConfig) -> Int

#
ProductionWindowConfig::retention_points

source
fn ProductionWindowConfig::retention_points(self : ProductionWindowConfig) -> Int

#
ProductionWindowFunction

source
pub(all) enum ProductionWindowFunction {
  QueryMean
  QuerySum
  QueryMinimum
  QueryMaximum
  QueryMedian
  QueryP95
  QueryCount
  QueryRate
  QueryChange
}

Aggregation function for a production query window.

#
ProductionWindowSummary

source
pub struct ProductionWindowSummary {
  start_timestamp : Int64
  end_timestamp : Int64
  count : Int
  valid_count : Int
  imputed_count : Int
  late_count : Int
  sum : Double
  mean : Double
  variance : Double
  minimum : Double
  maximum : Double
  median : Double
  first : Double
  last : Double
}

Aggregation statistics for a bounded event-time window.

#
ProductionWindowSummary::count

source

#
ProductionWindowSummary::empty

source

#
ProductionWindowSummary::end

source

#
ProductionWindowSummary::first

source

#
ProductionWindowSummary::has_imputation

source
fn ProductionWindowSummary::has_imputation(self : ProductionWindowSummary) -> Bool

#
ProductionWindowSummary::imputed_count

source
fn ProductionWindowSummary::imputed_count(self : ProductionWindowSummary) -> Int

#
ProductionWindowSummary::last

source

#
ProductionWindowSummary::late_count

source
fn ProductionWindowSummary::late_count(self : ProductionWindowSummary) -> Int

#
ProductionWindowSummary::maximum

source
fn ProductionWindowSummary::maximum(self : ProductionWindowSummary) -> Double

#
ProductionWindowSummary::mean

source

#
ProductionWindowSummary::median

source

#
ProductionWindowSummary::minimum

source
fn ProductionWindowSummary::minimum(self : ProductionWindowSummary) -> Double

#
ProductionWindowSummary::quality_ratio

source
fn ProductionWindowSummary::quality_ratio(self : ProductionWindowSummary) -> Double

#
ProductionWindowSummary::range

source

#
ProductionWindowSummary::slope

source

#
ProductionWindowSummary::start

source

#
ProductionWindowSummary::sum

source

#
ProductionWindowSummary::valid_count

source
fn ProductionWindowSummary::valid_count(self : ProductionWindowSummary) -> Int

#
ProductionWindowSummary::variance

source
fn ProductionWindowSummary::variance(self : ProductionWindowSummary) -> Double

#
ProjectionDetector

source
pub struct ProjectionDetector {
  weights : Array[Double]
  baseline : Double
  variance : Double
  alpha : Double
  threshold : Double
  count : Int
  index : Int
}

Tracks a weighted projection of a vector and detects changes in both projection and energy.

#
ProjectionDetector::dimension

source
fn ProjectionDetector::dimension(self : ProjectionDetector) -> Int

#
ProjectionDetector::new

source
fn ProjectionDetector::new(weights : Array[Double], alpha? : Double, threshold? : Double) -> ProjectionDetector

#
ProjectionDetector::update

source
fn ProjectionDetector::update(self : ProjectionDetector, values : Array[Double]) -> DetectionResult

#
QualityIssue

source
pub(all) enum QualityIssue {
  MissingValue
  NonFiniteValue
  OutOfRange
  NonMonotonicTimestamp
  ExcessiveGap
  DimensionMismatch
}

#
QualityReport

source
pub struct QualityReport {
  count : Int
  valid : Int
  missing : Int
  non_finite : Int
  out_of_range : Int
  non_monotonic : Int
  excessive_gaps : Int
  issues : Array[QualityIssue]
}

#
QualityReport::empty

source

#
QualityReport::is_healthy

source
fn QualityReport::is_healthy(self : QualityReport) -> Bool

#
QualityReport::valid_ratio

source
fn QualityReport::valid_ratio(self : QualityReport) -> Double

#
RankShiftDetector

source
pub struct RankShiftDetector {
  left : DoubleWindow
  right : DoubleWindow
  threshold : Double
  index : Int
}

#
RankShiftDetector::new

source
fn RankShiftDetector::new(window_size? : Int, threshold? : Double) -> RankShiftDetector

#
RankShiftDetector::update

source
fn RankShiftDetector::update(self : RankShiftDetector, value : Double) -> DetectionResult

#
RecoveryAction

source
pub(all) enum RecoveryAction {
  KeepOpen
  AutoResolve
  RequireAcknowledgement
  Escalate
}

Action taken after a detector has reached a stable state.

#
RecoveryPlan

source
pub struct RecoveryPlan {
  severity : AlertSeverity
  immediate_action : String
  verification_window : Int
  cooldown : Int
  escalation_score : Double
}

Recovery guidance and cooldown state for alert consumers.

#
RecoveryPlan::for_result

source
fn RecoveryPlan::for_result(result : DetectionResult) -> RecoveryPlan

#
RecoveryTracker

source
pub struct RecoveryTracker {
  plan : RecoveryPlan
  attempts : Int
  acknowledged : Bool
  recovered : Bool
}

#
RecoveryTracker::acknowledge

source
fn RecoveryTracker::acknowledge(self : RecoveryTracker) -> Unit

#
RecoveryTracker::attempt

source
fn RecoveryTracker::attempt(self : RecoveryTracker) -> Int

#
RecoveryTracker::attempts

source
fn RecoveryTracker::attempts(self : RecoveryTracker) -> Int

#
RecoveryTracker::is_closed

source
fn RecoveryTracker::is_closed(self : RecoveryTracker) -> Bool

#
RecoveryTracker::mark_recovered

source
fn RecoveryTracker::mark_recovered(self : RecoveryTracker) -> Unit

#
RecoveryTracker::new

source

#
ReorderBuffer

source
pub struct ReorderBuffer {
  capacity : Int
  policy : LateDataPolicy
  pending : Array[OrderedPoint]
  watermark : Int64
  arrival_order : Int
  dropped : Int
  late_count : Int
}

A small bounded reorder buffer for streams with late data.

#
ReorderBuffer::dropped_count

source
fn ReorderBuffer::dropped_count(self : ReorderBuffer) -> Int

#
ReorderBuffer::flush

source

Flushes every pending item at the end of a stream.

#
ReorderBuffer::late_count

source
fn ReorderBuffer::late_count(self : ReorderBuffer) -> Int

#
ReorderBuffer::new

source
fn ReorderBuffer::new(capacity? : Int, policy? : LateDataPolicy) -> ReorderBuffer

#
ReorderBuffer::peek

source

Returns a copy of the buffered points without changing the buffer.

#
ReorderBuffer::pending_count

source
fn ReorderBuffer::pending_count(self : ReorderBuffer) -> Int

#
ReorderBuffer::push

source

Inserts a point. Returned points are safe to process in timestamp order.

#
ReorderBuffer::watermark

source
fn ReorderBuffer::watermark(self : ReorderBuffer) -> Int64

#
ReplayComparator

source
pub struct ReplayComparator {
  score_tolerance : Double
  confidence_tolerance : Double
  compared : Int
  mismatches : Int
}

#
ReplayComparator::compare

source
fn ReplayComparator::compare(self : ReplayComparator, expected : DetectionResult, actual : DetectionResult) -> Bool

#
ReplayComparator::compared

source
fn ReplayComparator::compared(self : ReplayComparator) -> Int

#
ReplayComparator::mismatches

source
fn ReplayComparator::mismatches(self : ReplayComparator) -> Int

#
ReplayComparator::new

source
fn ReplayComparator::new(score_tolerance? : Double, confidence_tolerance? : Double) -> ReplayComparator

#
ReplayRecord

source
pub struct ReplayRecord {
  point : SignalPoint
  result : DetectionResult
  elapsed : Int64
}

Deterministic replay utilities for incident investigation and regression tests.

#
ReplayRecord::new

source
fn ReplayRecord::new(point : SignalPoint, result : DetectionResult, elapsed : Int64) -> ReplayRecord

#
ReplaySummary

source
pub struct ReplaySummary {
  total : Int
  changed : Int
  first_change : Int
  last_change : Int
  mean_score : Double
  max_score : Double
  elapsed : Int64
}

#
ReplaySummary::empty

source

#
ReservoirSample

source
pub struct ReservoirSample {
  capacity : Int
  values : Array[Double]
  seen : Int
  rng : DeterministicRng
}

#
ReservoirSample::new

source
fn ReservoirSample::new(capacity : Int, seed? : Int64) -> ReservoirSample

#
ReservoirSample::push

source
fn ReservoirSample::push(self : ReservoirSample, value : Double) -> Unit

#
ReservoirSample::seen

source
fn ReservoirSample::seen(self : ReservoirSample) -> Int

#
ReservoirSample::values

source
fn ReservoirSample::values(self : ReservoirSample) -> Array[Double]

#
RobustZDetector

source
pub struct RobustZDetector {
  window : DoubleWindow
  threshold : Double
  warmup : Int
  index : Int
}

A robust detector based on the rolling median and MAD.

#
RobustZDetector::new

source
fn RobustZDetector::new(window_size? : Int, threshold? : Double) -> RobustZDetector

#
RobustZDetector::reset

source
fn RobustZDetector::reset(self : RobustZDetector) -> Unit

#
RobustZDetector::update

source
fn RobustZDetector::update(self : RobustZDetector, value : Double) -> DetectionResult

#
RoutingBudget

source
pub struct RoutingBudget {
  capacity : Int
  used : Int
}

#
RoutingBudget::allow

source
fn RoutingBudget::allow(self : RoutingBudget, decision : RoutingDecision) -> Bool

#
RoutingBudget::new

source
fn RoutingBudget::new(capacity? : Int) -> RoutingBudget

#
RoutingBudget::remaining

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

#
RoutingBudget::used

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

#
RoutingDecision

source
pub struct RoutingDecision {
  metric : String
  channel : String
  priority : Int
  acknowledged : Bool
  reason : String
}

Converts alert severity into deterministic notification channels.

#
RoutingDecision::acknowledge

source
fn RoutingDecision::acknowledge(self : RoutingDecision) -> Unit

#
RoutingDecision::is_page

source
fn RoutingDecision::is_page(self : RoutingDecision) -> Bool

#
RoutingDecision::new

source
fn RoutingDecision::new(metric : String, channel : String, priority : Int, reason : String) -> RoutingDecision

#
RoutingDecision::summary

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

#
ScaleEvidence

source
pub struct ScaleEvidence {
  short_score : Double
  medium_score : Double
  long_score : Double
  consensus : Double
  changed : Bool
}

Evidence at multiple temporal scales.

#
ScaleEvidence::empty

source

#
ScoreCalibrator

source
pub struct ScoreCalibrator {
  observations : Array[ScoreObservation]
  max_observations : Int
  positive_weight : Double
  negative_weight : Double
}

#
ScoreCalibrator::best

source
fn ScoreCalibrator::best(self : ScoreCalibrator, candidates : Array[Double]) -> ThresholdReport

#
ScoreCalibrator::count

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

#
ScoreCalibrator::negative_weight

source
fn ScoreCalibrator::negative_weight(self : ScoreCalibrator) -> Double

#
ScoreCalibrator::new

source
fn ScoreCalibrator::new(max_observations? : Int) -> ScoreCalibrator

#
ScoreCalibrator::positive_weight

source
fn ScoreCalibrator::positive_weight(self : ScoreCalibrator) -> Double

#
ScoreCalibrator::push

source
fn ScoreCalibrator::push(self : ScoreCalibrator, score : Double, changed : Bool, weight? : Double) -> Unit

#
ScoreCalibrator::report

source
fn ScoreCalibrator::report(self : ScoreCalibrator, threshold : Double) -> ThresholdReport

#
ScoreObservation

source
pub struct ScoreObservation {
  score : Double
  changed : Bool
  weight : Double
}

Stores labeled detector scores for threshold selection.

#
ScoreObservation::new

source
fn ScoreObservation::new(score : Double, changed : Bool, weight? : Double) -> ScoreObservation

#
SeasonalAnomalyDetector

source
pub struct SeasonalAnomalyDetector {
  profile : SeasonalProfile
  threshold : Double
  index : Int
}

#
SeasonalAnomalyDetector::new

source
fn SeasonalAnomalyDetector::new(period : Int, threshold? : Double, alpha? : Double) -> SeasonalAnomalyDetector

#
SeasonalAnomalyDetector::update

source

#
SeasonalProfile

source
pub struct SeasonalProfile {
  period : Int
  levels : Array[Double]
  counts : Array[Int]
  alpha : Double
  index : Int
}

A lightweight seasonal profile updated online with exponential forgetting.

#
SeasonalProfile::baseline

source
fn SeasonalProfile::baseline(self : SeasonalProfile, index : Int) -> Double

#
SeasonalProfile::count

source
fn SeasonalProfile::count(self : SeasonalProfile, index : Int) -> Int

#
SeasonalProfile::levels

source
fn SeasonalProfile::levels(self : SeasonalProfile) -> Array[Double]

#
SeasonalProfile::new

source
fn SeasonalProfile::new(period : Int, alpha? : Double) -> SeasonalProfile

#
SeasonalProfile::period

source
fn SeasonalProfile::period(self : SeasonalProfile) -> Int

#
SeasonalProfile::update

source
fn SeasonalProfile::update(self : SeasonalProfile, value : Double) -> Double

#
SegmentQuality

source
pub struct SegmentQuality {
  count : Int
  mean : Double
  deviation : Double
  stability : Double
  completeness : Double
  score : Double
}

Segment-level diagnostics used to decide whether a change is actionable.

#
SegmentQuality::empty

source

#
SegmentRange

source
pub struct SegmentRange {
  start : Int
  end : Int
}

A half-open segment used by dynamic programming and binary segmentation.

#
SegmentRange::length

source
fn SegmentRange::length(self : SegmentRange) -> Int

#
SegmentRange::new

source
fn SegmentRange::new(start : Int, end : Int) -> SegmentRange

#
SignalPattern

source
pub(all) enum SignalPattern {
  Stable
  MeanShift
  VarianceShift
  Trend
  Spike
  MeanAndVarianceShift
}

#
SignalPoint

source
pub struct SignalPoint {
  timestamp : Int64
  value : Double
  sequence : Int
}

A point in a time series. Timestamps are integer ticks supplied by the caller.

#
SignalPoint::new

source
fn SignalPoint::new(timestamp : Int64, value : Double, sequence? : Int) -> SignalPoint

Creates a signal point.

#
SignalScenario

source
pub struct SignalScenario {
  name : String
  length : Int
  change_at : Int
  baseline : Double
  shift : Double
  noise : Double
  post_noise : Double
  trend : Double
  pattern : SignalPattern
  seed : Int64
}

A scenario definition shared by tests, examples, and benchmarks.

#
SignalScenario::mean_and_variance

source
fn SignalScenario::mean_and_variance(length? : Int, change_at? : Int, baseline? : Double, shift? : Double, noise? : Double, post_noise? : Double, seed? : Int64) -> SignalScenario

#
SignalScenario::mean_shift

source
fn SignalScenario::mean_shift(length? : Int, change_at? : Int, baseline? : Double, shift? : Double, noise? : Double, seed? : Int64) -> SignalScenario

#
SignalScenario::spike

source
fn SignalScenario::spike(length? : Int, spike_at? : Int, baseline? : Double, spike? : Double, noise? : Double, seed? : Int64) -> SignalScenario

#
SignalScenario::stable

source
fn SignalScenario::stable(length? : Int, baseline? : Double, noise? : Double, seed? : Int64) -> SignalScenario

#
SignalScenario::trend

source
fn SignalScenario::trend(length? : Int, change_at? : Int, baseline? : Double, trend? : Double, noise? : Double, seed? : Int64) -> SignalScenario

#
SignalScenario::variance_shift

source
fn SignalScenario::variance_shift(length? : Int, change_at? : Int, baseline? : Double, noise? : Double, post_noise? : Double, seed? : Int64) -> SignalScenario

#
SloReport

source
pub struct SloReport {
  window : SloWindow
  target : Double
  budget : Double
  burn : Double
  breached : Bool
  recommendation : String
}

#
SloReport::availability

source
fn SloReport::availability(self : SloReport) -> Double

#
SloReport::breached

source
fn SloReport::breached(self : SloReport) -> Bool

#
SloReport::budget

source
fn SloReport::budget(self : SloReport) -> Double

#
SloReport::burn

source
fn SloReport::burn(self : SloReport) -> Double

#
SloReport::summary

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

#
SloTracker

source
pub struct SloTracker {
  window : SloWindow
  target : Double
  burn_limit : Double
  periods : Int
}

#
SloTracker::close_period

source
fn SloTracker::close_period(self : SloTracker) -> SloReport

#
SloTracker::new

source
fn SloTracker::new(target? : Double, burn_limit? : Double) -> SloTracker

#
SloTracker::observe

source
fn SloTracker::observe(self : SloTracker, result : DetectionResult) -> Unit

#
SloTracker::periods

source
fn SloTracker::periods(self : SloTracker) -> Int

#
SloTracker::window

source
fn SloTracker::window(self : SloTracker) -> SloWindow

#
SloWindow

source
pub struct SloWindow {
  total : Int
  bad : Int
  changed : Int
  severe : Int
}

Service-level indicators derived from change-point evidence.

#
SloWindow::availability

source
fn SloWindow::availability(self : SloWindow) -> Double

#
SloWindow::bad

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

#
SloWindow::change_rate

source
fn SloWindow::change_rate(self : SloWindow) -> Double

#
SloWindow::changed

source
fn SloWindow::changed(self : SloWindow) -> Int

#
SloWindow::new

source
fn SloWindow::new() -> SloWindow

#
SloWindow::observe

source
fn SloWindow::observe(self : SloWindow, result : DetectionResult) -> Unit

#
SloWindow::severe

source
fn SloWindow::severe(self : SloWindow) -> Int

#
SloWindow::total

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

#
SquareMatrix

source
pub struct SquareMatrix {
  size : Int
  data : Array[Double]
}

Small dense matrix type used for low-dimensional covariance diagnostics.

#
SquareMatrix::add

source

#
SquareMatrix::determinant

source
fn SquareMatrix::determinant(self : SquareMatrix) -> Double

#
SquareMatrix::diagonal

source
fn SquareMatrix::diagonal(self : SquareMatrix) -> Array[Double]

#
SquareMatrix::get

source
fn SquareMatrix::get(self : SquareMatrix, row : Int, column : Int) -> Double

#
SquareMatrix::identity

source
fn SquareMatrix::identity(size : Int) -> SquareMatrix

#
SquareMatrix::multiply

source
fn SquareMatrix::multiply(self : SquareMatrix, other : SquareMatrix) -> SquareMatrix

#
SquareMatrix::new

source
fn SquareMatrix::new(size : Int, fill? : Double) -> SquareMatrix

#
SquareMatrix::quadratic_form

source
fn SquareMatrix::quadratic_form(self : SquareMatrix, vector : Array[Double]) -> Double

#
SquareMatrix::regularize

source
fn SquareMatrix::regularize(self : SquareMatrix, diagonal : Double) -> Unit

#
SquareMatrix::scale

source
fn SquareMatrix::scale(self : SquareMatrix, factor : Double) -> SquareMatrix

#
SquareMatrix::set

source
fn SquareMatrix::set(self : SquareMatrix, row : Int, column : Int, value : Double) -> Unit

#
SquareMatrix::size

source
fn SquareMatrix::size(self : SquareMatrix) -> Int

#
SquareMatrix::transpose

source
fn SquareMatrix::transpose(self : SquareMatrix) -> SquareMatrix

#
StatsSummary

source
pub struct StatsSummary {
  count : Int
  mean : Double
  variance : Double
  standard_deviation : Double
  minimum : Double
  maximum : Double
  median : Double
  first : Double
  last : Double
}

A compact summary of a numeric sample.

#
StatsSummary::empty

source
fn StatsSummary::empty() -> StatsSummary

Creates an empty summary.

#
StepChangeDetector

source
pub struct StepChangeDetector {
  reference : DoubleWindow
  current : DoubleWindow
  threshold : Double
  index : Int
}

Detects a persistent step change by comparing a reference and a current block.

#
StepChangeDetector::new

source
fn StepChangeDetector::new(window_size? : Int, threshold? : Double) -> StepChangeDetector

#
StepChangeDetector::update

source
fn StepChangeDetector::update(self : StepChangeDetector, value : Double) -> DetectionResult

#
StreamEngine

source
pub struct StreamEngine {
  reorder : ReorderBuffer
  tracker : WatermarkTracker
  aggregator : WindowAggregator
  pipeline : MetricPipeline
  processed : Int
  aggregates : Int
  alerts : Int
}

End-to-end stream state: reorder, aggregate, and detect.

#
StreamEngine::aggregate_count

source
fn StreamEngine::aggregate_count(self : StreamEngine) -> Int

#
StreamEngine::alert_count

source
fn StreamEngine::alert_count(self : StreamEngine) -> Int

#
StreamEngine::flush

source

#
StreamEngine::new

source
fn StreamEngine::new(metric : String, detector : PipelineDetector, window_size? : Int, lateness? : Int) -> StreamEngine

#
StreamEngine::process_point

source
fn StreamEngine::process_point(self : StreamEngine, point : SignalPoint) -> Array[AlertEvent]

#
StreamEngine::processed

source
fn StreamEngine::processed(self : StreamEngine) -> Int

#
ThresholdPoint

source
pub struct ThresholdPoint {
  index : Int
  threshold : Double
  score : Double
  accepted : Bool
}

Threshold schedules used when a service changes its noise profile over time.

#
ThresholdPoint::new

source
fn ThresholdPoint::new(index : Int, score : Double, threshold : Double) -> ThresholdPoint

#
ThresholdReport

source
pub struct ThresholdReport {
  threshold : Double
  true_positives : Int
  false_positives : Int
  true_negatives : Int
  false_negatives : Int
  precision : Double
  recall : Double
  f1 : Double
  expected_cost : Double
}

#
ThresholdReport::empty

source
fn ThresholdReport::empty(threshold : Double) -> ThresholdReport

#
TimeWindow

source
pub struct TimeWindow {
  start : Int64
  end : Int64
  ordinal : Int
}

Time-window planning utilities for batch and streaming consumers.

#
TimeWindow::contains

source
fn TimeWindow::contains(self : TimeWindow, timestamp : Int64) -> Bool

#
TimeWindow::duration

source
fn TimeWindow::duration(self : TimeWindow) -> Int64

#
TimeWindow::is_empty

source
fn TimeWindow::is_empty(self : TimeWindow) -> Bool

#
TimeWindow::new

source
fn TimeWindow::new(start : Int64, end : Int64, ordinal : Int) -> TimeWindow

#
TrendShiftDetector

source
pub struct TrendShiftDetector {
  window : DoubleWindow
  slope_threshold : Double
  persistence : Int
  consecutive : Int
  index : Int
}

Detects a sustained slope rather than a one-point spike.

#
TrendShiftDetector::new

source
fn TrendShiftDetector::new(window_size? : Int, slope_threshold? : Double, persistence? : Int) -> TrendShiftDetector

#
TrendShiftDetector::reset

source
fn TrendShiftDetector::reset(self : TrendShiftDetector) -> Unit

#
TrendShiftDetector::update

source
fn TrendShiftDetector::update(self : TrendShiftDetector, value : Double) -> DetectionResult

#
VarianceShiftDetector

source
pub struct VarianceShiftDetector {
  short_window : DoubleWindow
  long_window : DoubleWindow
  threshold : Double
  warmup : Int
  index : Int
}

Detects variance changes by comparing short and long rolling windows.

#
VarianceShiftDetector::new

source
fn VarianceShiftDetector::new(short_window? : Int, long_window? : Int, threshold? : Double) -> VarianceShiftDetector

#
VarianceShiftDetector::reset

source

#
VarianceShiftDetector::update

source
fn VarianceShiftDetector::update(self : VarianceShiftDetector, value : Double) -> DetectionResult

#
VectorPoint

source
pub struct VectorPoint {
  timestamp : Int64
  values : Array[Double]
  sequence : Int
}

A validated vector observation for multivariate streams.

#
VectorPoint::dimension

source
fn VectorPoint::dimension(self : VectorPoint) -> Int

#
VectorPoint::is_valid

source
fn VectorPoint::is_valid(self : VectorPoint) -> Bool

#
VectorPoint::new

source
fn VectorPoint::new(timestamp : Int64, values : Array[Double], sequence? : Int) -> VectorPoint

#
VoteRule

source
pub struct VoteRule {
  required : Int
  window : Array[Bool]
  size : Int
}

#
VoteRule::new

source
fn VoteRule::new(size? : Int, required? : Int) -> VoteRule

#
VoteRule::push

source
fn VoteRule::push(self : VoteRule, positive : Bool) -> Bool

#
VoteRule::votes

source
fn VoteRule::votes(self : VoteRule) -> Int

#
WatermarkTracker

source
pub struct WatermarkTracker {
  allowed_lateness : Int64
  maximum_seen : Int64
  accepted : Int
  dropped : Int
}

#
WatermarkTracker::accepted

source
fn WatermarkTracker::accepted(self : WatermarkTracker) -> Int

#
WatermarkTracker::dropped

source
fn WatermarkTracker::dropped(self : WatermarkTracker) -> Int

#
WatermarkTracker::new

source
fn WatermarkTracker::new(allowed_lateness? : Int64) -> WatermarkTracker

#
WatermarkTracker::observe

source
fn WatermarkTracker::observe(self : WatermarkTracker, timestamp : Int64) -> Bool

#
WatermarkTracker::watermark

source
fn WatermarkTracker::watermark(self : WatermarkTracker) -> Int64

#
WindowAggregate

source
pub struct WindowAggregate {
  start_timestamp : Int64
  end_timestamp : Int64
  count : Int
  value : Double
  summary : StatsSummary
}

#
WindowAggregator

source
pub struct WindowAggregator {
  size : Int
  kind : AggregationKind
  window : DoubleWindow
  start_timestamp : Int64
  end_timestamp : Int64
  count : Int
}

#
WindowAggregator::flush

source

#
WindowAggregator::new

source
fn WindowAggregator::new(size : Int, kind? : AggregationKind) -> WindowAggregator

#
WindowAggregator::push

source

#
WindowDiagnostic

source
pub struct WindowDiagnostic {
  before : StatsSummary
  after : StatsSummary
  mean_shift : Double
  variance_ratio : Double
  distribution_shift : Double
  severity : AlertSeverity
  actionable : Bool
}

Diagnostic comparison between two adjacent windows.

#
WindowDiagnostic::empty

source

#
WindowFeatures

source
pub struct WindowFeatures {
  count : Int
  mean : Double
  standard_deviation : Double
  median : Double
  mad : Double
  minimum : Double
  maximum : Double
  range : Double
  slope : Double
  autocorrelation : Double
  change_rate : Double
}

Features extracted from a bounded window for dashboards and model input.

#
WindowFeatures::empty

source

#
absolute

source
fn absolute(value : Double) -> Double

Returns the absolute value without exposing math implementation details.

#
absolute_change

source
fn absolute_change(baseline : Double, observed : Double) -> Double

#
actionable_diagnostics

source
fn actionable_diagnostics(diagnostics : Array[WindowDiagnostic]) -> Int

#
adaptive_threshold

source
fn adaptive_threshold(scores : Array[Double], false_positive_rate? : Double) -> Double

#
alerts_markdown

source
fn alerts_markdown(alerts : Array[AlertEvent]) -> String

#
align_by_timestamp

source
fn align_by_timestamp(left : Array[SignalPoint], right : Array[SignalPoint]) -> (Array[Double], Array[Double])

#
array_maximum

source
fn array_maximum(values : Array[Double]) -> Double

#
array_minimum

source
fn array_minimum(values : Array[Double]) -> Double

#
autocorrelation

source
fn autocorrelation(values : Array[Double], lag : Int) -> Double

#
average_pairwise_correlation

source
fn average_pairwise_correlation(series : Array[Array[Double]]) -> Double

#
baseline_strategy_name

source
fn baseline_strategy_name(strategy : ProductionBaselineStrategy) -> String

#
benchmark_cusum

source
fn benchmark_cusum(scenario : SignalScenario, rounds? : Int) -> BenchmarkResult

#
benchmark_ensemble

source
fn benchmark_ensemble(scenario : SignalScenario, rounds? : Int) -> BenchmarkResult

#
benchmark_markdown

source
fn benchmark_markdown(results : Array[BenchmarkResult]) -> String

#
benchmark_robust_z

source
fn benchmark_robust_z(scenario : SignalScenario, rounds? : Int) -> BenchmarkResult

#
benchmark_suite

source
fn benchmark_suite(rounds? : Int) -> Array[BenchmarkResult]

Runs the standard acceptance benchmark suite on a fixed synthetic scenario.

#
best_boundary

source
fn best_boundary(values : Array[Double], minimum_segment? : Int) -> Int

#
best_f1_threshold

source
fn best_f1_threshold(scores : Array[Double], labels : Array[Bool], candidates : Array[Double]) -> ThresholdPoint

#
best_lag

source
fn best_lag(left : Array[Double], right : Array[Double], maximum_lag : Int) -> Int

#
best_threshold

source
fn best_threshold(observations : Array[ScoreObservation], candidates : Array[Double], false_positive_cost? : Double, false_negative_cost? : Double) -> ThresholdReport

#
binary_segmentation

source
fn binary_segmentation(values : Array[Double], threshold? : Double, min_segment? : Int, max_changes? : Int) -> Array[OfflineChange]

Greedy binary segmentation for a small number of interpretable changes.

#
bootstrap_change_score

source
fn bootstrap_change_score(left : Array[Double], right : Array[Double], replicates? : Int, seed? : Int64) -> BootstrapEstimate

#
bootstrap_mean

source
fn bootstrap_mean(values : Array[Double], replicates? : Int, seed? : Int64) -> BootstrapEstimate

#
boundary_quality

source
fn boundary_quality(values : Array[Double], boundary : Int, minimum_segment? : Int) -> Double

#
bucket_timestamp

source
fn bucket_timestamp(timestamp : Int64, origin : Int64, width : Int64) -> Int64

#
burn_rate

source
fn burn_rate(window : SloWindow, target : Double) -> Double

#
calibration_bins

source
fn calibration_bins(observations : Array[ScoreObservation], bins? : Int) -> Array[Double]

#
catalog_markdown

source
fn catalog_markdown() -> String

#
change_direction_from_values

source
fn change_direction_from_values(baseline : Double, observed : Double) -> ChangeDirection

#
change_point_csv

source
fn change_point_csv(point : ChangePoint) -> String

#
change_point_csv_header

source
fn change_point_csv_header() -> String

#
changes_csv

source
fn changes_csv(points : Array[ChangePoint]) -> String

#
clamp_probability

source
fn clamp_probability(value : Double) -> Double

Clamps a probability-like number to the closed unit interval.

#
clip

source
fn clip(values : Array[Double], lower : Double, upper : Double) -> Array[Double]

#
clip_values

source
fn clip_values(values : Array[Double], minimum : Double, maximum : Double) -> Array[Double]

#
cluster_incidents

source
fn cluster_incidents(events : Array[AlertEvent], maximum_gap : Int64) -> Array[Incident]

#
combine_scores

source
fn combine_scores(scores : Array[Double], weights : Array[Double]) -> Double

#
compare_segment_quality

source
fn compare_segment_quality(left : Array[Double], right : Array[Double]) -> Double

#
consensus_score

source
fn consensus_score(results : Array[DetectionResult]) -> Double

#
contiguous_ranges

source
fn contiguous_ranges(points : Array[SignalPoint], maximum_gap : Int64) -> Array[SegmentRange]

#
cooldown_schedule

source
fn cooldown_schedule(plan : RecoveryPlan, attempts : Int) -> Array[Int]

#
correlated_change_score

source
fn correlated_change_score(before : Array[Array[Double]], after : Array[Array[Double]]) -> Double

#
correlation

source
fn correlation(left : Array[Double], right : Array[Double]) -> Double

#
correlation_alert

source
fn correlation_alert(before : Array[Array[Double]], after : Array[Array[Double]], threshold? : Double) -> DetectionResult

#
correlation_matrix

source
fn correlation_matrix(series : Array[Array[Double]]) -> SquareMatrix

#
cosine_similarity

source
fn cosine_similarity(left : Array[Double], right : Array[Double]) -> Double

#
covariance

source
fn covariance(left : Array[Double], right : Array[Double]) -> Double

#
covariance_matrix

source
fn covariance_matrix(series : Array[Array[Double]]) -> SquareMatrix

#
critical_incident_count

source
fn critical_incident_count(incidents : Array[Incident]) -> Int

#
cumulative_sum

source
fn cumulative_sum(values : Array[Double], initial? : Double) -> Array[Double]

#
cumulative_total

source
fn cumulative_total(values : Array[Double]) -> Array[Double]

#
deduplicate_events

source
fn deduplicate_events(events : Array[AlertEvent], minimum_gap : Int64) -> Array[AlertEvent]

#
deseasonalize

source
fn deseasonalize(values : Array[Double], period : Int) -> Array[Double]

#
detection_csv

source
fn detection_csv(result : DetectionResult) -> String

Converts a detection result to a stable CSV row.

#
detection_csv_header

source
fn detection_csv_header() -> String

#
detector_catalog

source
fn detector_catalog() -> Array[DetectorSpec]

#
detector_names

source
fn detector_names() -> Array[String]

#
detector_reliability

source
fn detector_reliability(results : Array[DetectionResult]) -> Double

#
diagnose_series

source
fn diagnose_series(values : Array[Double], split : Int, minimum_segment? : Int) -> WindowDiagnostic

#
diagnose_windows

source
fn diagnose_windows(before_values : Array[Double], after_values : Array[Double], shift_threshold? : Double, distribution_threshold? : Double) -> WindowDiagnostic

#
diagnostic_direction

source
fn diagnostic_direction(diagnostic : WindowDiagnostic) -> ChangeDirection

#
diagnostic_label

source
fn diagnostic_label(diagnostic : WindowDiagnostic) -> String

#
diagnostic_markdown

source
fn diagnostic_markdown(diagnostic : WindowDiagnostic) -> String

#
diagnostic_score

source
fn diagnostic_score(diagnostic : WindowDiagnostic) -> Double

#
diagnostics_batch

source
fn diagnostics_batch(values : Array[Double], splits : Array[Int]) -> Array[WindowDiagnostic]

#
diagonal_mahalanobis

source
fn diagonal_mahalanobis(vector : Array[Double], means : Array[Double], variances : Array[Double]) -> Double

#
difference

source
fn difference(values : Array[Double], lag? : Int) -> Array[Double]

#
direction_name

source
fn direction_name(direction : ChangeDirection) -> String

Returns a human-readable direction label.

#
distribution_change_score

source
fn distribution_change_score(left : Array[Double], right : Array[Double]) -> Double

#
distribution_overlap

source
fn distribution_overlap(left : Array[Double], right : Array[Double], bins? : Int) -> Double

#
downsample_mean

source
fn downsample_mean(values : Array[Double], factor : Int) -> Array[Double]

#
energy_distance

source
fn energy_distance(left : Array[Double], right : Array[Double]) -> Double

#
error_budget

source
fn error_budget(availability : Double, target : Double) -> Double

#
euclidean_distance

source
fn euclidean_distance(left : Array[Double], right : Array[Double]) -> Double

#
evaluate_change_points

source
fn evaluate_change_points(predicted : Array[Int], truth : Array[Int], tolerance? : Int) -> ChangePointMetrics

Matches a prediction to at most one truth within a tolerance window.

#
evaluate_slo

source
fn evaluate_slo(window : SloWindow, target? : Double, burn_limit? : Double) -> SloReport

#
evaluate_threshold

source
fn evaluate_threshold(observations : Array[ScoreObservation], threshold : Double, false_positive_cost? : Double, false_negative_cost? : Double) -> ThresholdReport

#
event_rate

source
fn event_rate(events : Array[AlertEvent], start : Int64, end : Int64) -> Double

#
evidence_strength

source
fn evidence_strength(score : Double, confidence : Double, deviation : Double) -> Double

#
expected_alert_cost

source
fn expected_alert_cost(false_positive_rate : Double, false_negative_rate : Double, false_positive_cost? : Double, false_negative_cost? : Double) -> Double

#
explain_batch

source
fn explain_batch(results : Array[DetectionResult], baseline : Double, values : Array[Double], detector : String) -> Array[DetectionExplanation]

#
explanation_alerts

source
fn explanation_alerts(explanations : Array[DetectionExplanation]) -> Int

#
explanation_csv

source
fn explanation_csv(explanation : DetectionExplanation) -> String

#
explanation_csv_header

source
fn explanation_csv_header() -> String

#
explanation_markdown

source
fn explanation_markdown(explanation : DetectionExplanation) -> String

#
explanation_strength

source
fn explanation_strength(explanation : DetectionExplanation) -> Double

#
exponential_smooth

source
fn exponential_smooth(values : Array[Double], alpha? : Double) -> Array[Double]

#
extract_features

source
fn extract_features(values : Array[Double]) -> WindowFeatures

#
feature_change_score

source
fn feature_change_score(left : Array[Double], right : Array[Double]) -> Double

#
feature_distance

source
fn feature_distance(left : WindowFeatures, right : WindowFeatures) -> Double

#
feature_names

source
fn feature_names() -> Array[String]

#
find_detector

source
fn find_detector(name : String) -> DetectorSpec?

#
first_difference

source
fn first_difference(values : Array[Double]) -> Array[Double]

#
forecast_mae

source
fn forecast_mae(actual : Array[Double], predicted : Array[Double]) -> Double

#
forecast_mape

source
fn forecast_mape(actual : Array[Double], predicted : Array[Double]) -> Double

#
forecast_rmse

source
fn forecast_rmse(actual : Array[Double], predicted : Array[Double]) -> Double

#
forward_fill

source
fn forward_fill(values : Array[Double], fallback? : Double) -> Array[Double]

#
generate_signal

source
fn generate_signal(scenario : SignalScenario) -> Array[Double]

Generates a deterministic signal and its known change indices.

#
hampel_filter

source
fn hampel_filter(values : Array[Double], window_size? : Int, threshold? : Double) -> Array[Double]

#
highest_priority

source
fn highest_priority(decisions : Array[RoutingDecision]) -> Int

#
histogram_distance

source
fn histogram_distance(left : Histogram, right : Histogram) -> Double

#
histogram_hellinger

source
fn histogram_hellinger(left : Histogram, right : Histogram) -> Double

#
incident_alert_count

source
fn incident_alert_count(incidents : Array[Incident]) -> Int

#
incident_rate

source
fn incident_rate(incidents : Array[Incident], start : Int64, end : Int64) -> Double

#
incidents_markdown

source
fn incidents_markdown(incidents : Array[Incident]) -> String

#
inspect_split

source
fn inspect_split(values : Array[Double], split : Int, min_segment? : Int) -> OfflineChange?

Returns a change record for a split, or None when the split is outside the valid range.

#
interpolate_missing

source
fn interpolate_missing(values : Array[Double]) -> Array[Double]

Linearly interpolates invalid observations while retaining valid endpoints.

#
interpolate_points

source
fn interpolate_points(points : Array[SignalPoint], step : Int64) -> Array[SignalPoint]

#
interquartile_range

source
fn interquartile_range(values : Array[Double]) -> Double

#
is_finite

source
fn is_finite(value : Double) -> Bool

Returns whether a value is finite enough for detector state.

#
ks_statistic

source
fn ks_statistic(left : Array[Double], right : Array[Double]) -> Double

Kolmogorov-Smirnov distance between two samples.

#
lag_points

source
fn lag_points(points : Array[SignalPoint], lag : Int64) -> Array[SignalPoint]

#
lag_values

source
fn lag_values(values : Array[Double], lag : Int) -> Array[Double]

#
lagged_correlation

source
fn lagged_correlation(left : Array[Double], right : Array[Double], lag : Int) -> Double

#
linear_slope

source
fn linear_slope(values : Array[Double]) -> Double

#
locate_time_window

source
fn locate_time_window(windows : Array[TimeWindow], timestamp : Int64) -> Int

#
make_explanation

source
fn make_explanation(result : DetectionResult, baseline : Double, observed : Double, detector : String) -> DetectionExplanation

#
make_time_windows

source
fn make_time_windows(start : Int64, end : Int64, width : Int64, step? : Int64) -> Array[TimeWindow]

#
mann_whitney_u

source
fn mann_whitney_u(left : Array[Double], right : Array[Double]) -> Double

#
mask_every

source
fn mask_every(values : Array[Double], period : Int, offset? : Int) -> Array[Double]

Applies deterministic missingness without changing the length of the sample.

#
mean

source
fn mean(values : Array[Double]) -> Double

#
mean_absolute_difference

source
fn mean_absolute_difference(values : Array[Double]) -> Double

#
mean_shift_score

source
fn mean_shift_score(values : Array[Double], split : Int, min_segment? : Int) -> Double

Standardized mean difference between two adjacent segments.

#
median

source
fn median(values : Array[Double]) -> Double

#
median_absolute_deviation

source
fn median_absolute_deviation(values : Array[Double]) -> Double

#
merge_nearby_changes

source
fn merge_nearby_changes(changes : Array[OfflineChange], minimum_distance : Int) -> Array[OfflineChange]

Removes candidates closer than minimum_distance, preserving the highest score.

#
metrics_markdown

source
fn metrics_markdown(metrics : ChangePointMetrics) -> String

#
missing_value_strategy_name

source
fn missing_value_strategy_name(strategy : MissingValueStrategy) -> String

#
moving_average

source
fn moving_average(values : Array[Double], window_size : Int) -> Array[Double]

#
moving_median

source
fn moving_median(values : Array[Double], window_size : Int) -> Array[Double]

#
normalize_minmax

source
fn normalize_minmax(values : Array[Double]) -> Array[Double]

#
normalize_range

source
fn normalize_range(values : Array[Double], minimum? : Double, maximum? : Double) -> Array[Double]

#
normalize_scores

source
fn normalize_scores(scores : Array[Double]) -> Array[Double]

#
normalize_zscore

source
fn normalize_zscore(values : Array[Double]) -> Array[Double]

#
online_detector_count

source
fn online_detector_count() -> Int

#
optimal_changepoints

source
fn optimal_changepoints(values : Array[Double], penalty? : Double, min_segment? : Int, max_changes? : Int) -> Array[Int]

Penalized dynamic programming for minimum-description-length style segmentation.

#
outlier_mask

source
fn outlier_mask(values : Array[Double], threshold? : Double) -> Array[Bool]

#
page_count

source
fn page_count(decisions : Array[RoutingDecision]) -> Int

#
percentile

source
fn percentile(values : Array[Double], percent : Double) -> Double

#
piecewise_constant_error

source
fn piecewise_constant_error(values : Array[Double], changes : Array[Int]) -> Double

Computes a reconstruction error when each segment is represented by its mean.

#
production_autocorrelation_profile

source
fn production_autocorrelation_profile(values : Array[Double], maximum_lag? : Int) -> Array[Double]

#
production_backpressure_policy_name

source
fn production_backpressure_policy_name(policy : ProductionBackpressurePolicy) -> String

#
production_bootstrap_difference

source
fn production_bootstrap_difference(left : Array[Double], right : Array[Double], replicates? : Int, confidence? : Double, seed? : Int64) -> ProductionConfidenceInterval

#
production_bootstrap_interval

source
fn production_bootstrap_interval(values : Array[Double], replicates? : Int, confidence? : Double, seed? : Int64) -> ProductionConfidenceInterval

#
production_brier_score

source
fn production_brier_score(probabilities : Array[Double], labels : Array[Bool]) -> Double

Brier score for probabilistic change likelihoods.

#
production_calibrate_result

source
fn production_calibrate_result(calibrator : ProductionOnlineCalibrator, result : DetectionResult) -> DetectionResult

Converts a detector score into a calibrated detection result.

#
production_calibration_bins

source
fn production_calibration_bins(probabilities : Array[Double], labels : Array[Bool], bins? : Int) -> Array[ProductionCalibrationBin]

#
production_calibration_markdown

source
fn production_calibration_markdown(bins : Array[ProductionCalibrationBin]) -> String

#
production_calibration_mode_name

source
fn production_calibration_mode_name(mode : ProductionCalibrationMode) -> String

#
production_center_scale

source
fn production_center_scale(values : Array[Double]) -> Array[Double]

#
production_checkpoint_csv

source
fn production_checkpoint_csv(checkpoint : ProductionMonitorCheckpoint) -> String

#
production_clip_percentiles

source
fn production_clip_percentiles(values : Array[Double], lower? : Double, upper? : Double) -> Array[Double]

#
production_config_issues_summary

source
fn production_config_issues_summary(issues : Array[ProductionConfigIssue]) -> String

#
production_config_lines

source
fn production_config_lines(config : ProductionMonitorConfig) -> Array[String]

A stable line-oriented representation used in deployment logs.

#
production_contract_checksum

source
fn production_contract_checksum(rule : ProductionContractRule) -> String

Stable, order-sensitive checksum for a contract definition.

#
production_contract_distinct_labels

source
fn production_contract_distinct_labels(labels : Array[String]) -> Int

#
production_contract_field_kind_name

source
fn production_contract_field_kind_name(kind : ProductionContractFieldKind) -> String

#
production_contract_largest_gap

source
fn production_contract_largest_gap(timestamps : Array[Int64]) -> Int64

Returns the largest time gap in a timestamp series.

#
production_contract_report_json

source
fn production_contract_report_json(report : ProductionContractReport) -> String

#
production_contract_severity_name

source
fn production_contract_severity_name(severity : ProductionContractSeverity) -> String

#
production_contract_summary_markdown

source
fn production_contract_summary_markdown(summary : ProductionContractSummary) -> String

#
production_contract_violation_code_name

source
fn production_contract_violation_code_name(code : ProductionContractViolationCode) -> String

#
production_control_limits

source
fn production_control_limits(baseline : Array[Double], sigma_multiplier? : Double) -> (Double, Double)

#
production_dashboard_csv

source
fn production_dashboard_csv(series : ProductionDashboardSeries) -> String

#
production_dashboard_series

source
fn production_dashboard_series(name : String, events : Array[ProductionMonitorEvent], maximum_rows? : Int) -> ProductionDashboardSeries

Produces a bounded dashboard-friendly time series from monitor events.

#
production_decisions_markdown

source
fn production_decisions_markdown(decisions : Array[ProductionDeliveryDecision]) -> String

#
production_delivery_channel_name

source
fn production_delivery_channel_name(channel : ProductionDeliveryChannel) -> String

#
production_detector_kind_name

source
fn production_detector_kind_name(kind : ProductionDetectorKind) -> String

#
production_drift_markdown

source
fn production_drift_markdown(report : ProductionDriftReport) -> String

#
production_effect_size

source
fn production_effect_size(left : Array[Double], right : Array[Double]) -> Double

#
production_export_checksum

source
fn production_export_checksum(payload : String) -> String

#
production_export_field_name

source
fn production_export_field_name(field : ProductionExportField) -> String

#
production_export_format_name

source
fn production_export_format_name(format : ProductionExportFormat) -> String

#
production_export_group_by_metric

source
fn production_export_group_by_metric(records : Array[ProductionExportRecord]) -> Array[String]

#
production_export_manifest

source
fn production_export_manifest(options : ProductionExportOptions) -> String

Produce a manifest describing the selected export schema.

#
production_export_merge_batches

source
fn production_export_merge_batches(left : ProductionExportBatch, right : ProductionExportBatch) -> ProductionExportBatch

#
production_export_metric_count

source
fn production_export_metric_count(records : Array[ProductionExportRecord], metric : String) -> Int

#
production_export_metric_mean

source
fn production_export_metric_mean(records : Array[ProductionExportRecord], metric : String) -> Double

#
production_export_normalize_metric_name

source
fn production_export_normalize_metric_name(metric : String) -> String

#
production_export_record_csv

source
fn production_export_record_csv(record : ProductionExportRecord, delimiter? : String) -> String

#
production_export_record_json

source
fn production_export_record_json(record : ProductionExportRecord, pretty? : Bool) -> String

#
production_export_record_markdown

source
fn production_export_record_markdown(record : ProductionExportRecord) -> String

#
production_export_record_prometheus

source
fn production_export_record_prometheus(record : ProductionExportRecord, options : ProductionExportOptions) -> String

#
production_export_validate_metric_name

source
fn production_export_validate_metric_name(metric : String) -> Bool

#
production_feature_contributions

source
fn production_feature_contributions(vector : ProductionFeatureVector, weights : Array[Double]) -> Array[EvidenceContribution]

Builds a compact feature-to-score summary used for explanations.

#
production_feature_kind_name

source
fn production_feature_kind_name(kind : ProductionFeatureKind) -> String

#
production_features_csv

source
fn production_features_csv(vector : ProductionFeatureVector) -> String

#
production_features_csv_header

source
fn production_features_csv_header() -> String

#
production_fleet_health_label

source
fn production_fleet_health_label(score : Double) -> String

#
production_fleet_health_score

source
fn production_fleet_health_score(snapshots : Array[ProductionMonitorSnapshot]) -> Double

Aggregates multiple monitor snapshots into a fleet health score.

#
production_forecast_kind_name

source
fn production_forecast_kind_name(kind : ProductionForecastKind) -> String

#
production_forecast_score

source
fn production_forecast_score(actual : Array[Double], predictions : Array[ProductionForecastInterval]) -> ProductionForecastScore

#
production_forecast_scores_markdown

source
fn production_forecast_scores_markdown(scores : Array[ProductionForecastScore]) -> String

#
production_frame_change_score

source
fn production_frame_change_score(before : ProductionMetricFrame, after : ProductionMetricFrame) -> Double

Computes vector-level changes over synchronized frames.

#
production_guardrail_action_is_failure

source
fn production_guardrail_action_is_failure(action : ProductionGuardrailAction) -> Bool

#
production_guardrail_action_is_terminal

source
fn production_guardrail_action_is_terminal(action : ProductionGuardrailAction) -> Bool

#
production_guardrail_action_name

source
fn production_guardrail_action_name(action : ProductionGuardrailAction) -> String

#
production_guardrail_decisions_json

source
fn production_guardrail_decisions_json(decisions : Array[ProductionGuardrailDecision]) -> String

#
production_guardrail_direction_name

source
fn production_guardrail_direction_name(direction : ProductionGuardrailDirection) -> String

#
production_guardrail_health_from_actions

source
fn production_guardrail_health_from_actions(actions : Array[ProductionGuardrailAction]) -> Double

#
production_guardrail_metric_name

source
fn production_guardrail_metric_name(metric : ProductionGuardrailMetricKind) -> String

#
production_health_state_name

source
fn production_health_state_name(state : ProductionHealthState) -> String

#
production_impute_values

source
fn production_impute_values(values : Array[Double], strategy : MissingValueStrategy) -> Array[Double]

Returns a copy with invalid values replaced according to a production policy.

#
production_incident_rate_markdown

source
fn production_incident_rate_markdown(incidents : Array[ProductionIncident], start : Int64, end : Int64) -> String

#
production_incident_state_name

source
fn production_incident_state_name(state : ProductionIncidentState) -> String

#
production_incidents_markdown

source
fn production_incidents_markdown(incidents : Array[ProductionIncident]) -> String

#
production_join_series

source
fn production_join_series(series : Array[ProductionMetricSeries], tolerance : Int64) -> Array[ProductionMetricFrame]

Builds frames by joining series at the nearest timestamp within a tolerance.

#
production_log_loss

source
fn production_log_loss(probabilities : Array[Double], labels : Array[Bool]) -> Double

Numerically stable binary log loss.

#
production_mean_difference

source
fn production_mean_difference(left : Array[Double], right : Array[Double]) -> Double

#
production_mean_shift_test

source
fn production_mean_shift_test(left : Array[Double], right : Array[Double], alpha? : Double, replicates? : Int) -> ProductionStatTestResult

Runs a mean-shift evidence test with a bootstrap interval and permutation p-value.

#
production_median_difference

source
fn production_median_difference(left : Array[Double], right : Array[Double]) -> Double

#
production_median_shift_test

source
fn production_median_shift_test(left : Array[Double], right : Array[Double], alpha? : Double, replicates? : Int) -> ProductionStatTestResult

Runs a median-shift evidence test for heavy-tailed telemetry.

#
production_mode_name

source
fn production_mode_name(mode : ProductionMonitorMode) -> String

Returns the enum value as a stable configuration token.

#
production_monitor_event_name

source
fn production_monitor_event_name(kind : ProductionMonitorEventKind) -> String

#
production_monitor_events_csv

source
fn production_monitor_events_csv(events : Array[ProductionMonitorEvent]) -> String

#
production_monitor_events_csv_header

source
fn production_monitor_events_csv_header() -> String

#
production_monitor_signal

source
fn production_monitor_signal(monitor : ProductionMonitor, points : Array[SignalPoint]) -> ProductionMonitorSnapshot

Runs a monitor over a sorted signal and returns its final snapshot.

#
production_normalize_range

source
fn production_normalize_range(values : Array[Double], lower? : Double, upper? : Double) -> Array[Double]

#
production_observations_csv

source
fn production_observations_csv(observations : Array[ProductionReplayObservation]) -> String

#
production_observations_csv_header

source
fn production_observations_csv_header() -> String

#
production_out_of_control_count

source
fn production_out_of_control_count(values : Array[Double], lower : Double, upper : Double) -> Int

#
production_percent_changes

source
fn production_percent_changes(values : Array[Double]) -> Array[Double]

Computes a bounded rolling percentage change series.

#
production_permutation_shift_score

source
fn production_permutation_shift_score(left : Array[Double], right : Array[Double], permutations? : Int, seed? : Int64) -> Double

#
production_precision_recall_curve

source
fn production_precision_recall_curve(scores : Array[Double], labels : Array[Bool], steps? : Int) -> Array[ProductionCurvePoint]

#
production_quantile_profile

source
fn production_quantile_profile(values : Array[Double], probabilities? : Array[Double]) -> Array[Double]

#
production_query_results_markdown

source
fn production_query_results_markdown(results : Array[ProductionQueryResult]) -> String

#
production_query_rollup

source
fn production_query_rollup(series : ProductionMetricSeries, start : Int64, end : Int64, step : Int64, function? : ProductionWindowFunction) -> Array[ProductionQueryResult]

#
production_replay_mode_name

source
fn production_replay_mode_name(mode : ProductionReplayMode) -> String

#
production_report_format_name

source
fn production_report_format_name(format : ProductionReportFormat) -> String

#
production_residuals_from_trend

source
fn production_residuals_from_trend(values : Array[Double]) -> Array[Double]

#
production_roc_curve

source
fn production_roc_curve(scores : Array[Double], labels : Array[Bool], steps? : Int) -> Array[ProductionCurvePoint]

#
production_rolling_ranges

source
fn production_rolling_ranges(values : Array[Double], width? : Int) -> Array[Double]

Calculates a rolling range without exposing mutable window state.

#
production_rolling_volatility

source
fn production_rolling_volatility(values : Array[Double], width? : Int) -> Array[Double]

Computes rolling volatility using a population standard deviation.

#
production_run_batch

source
fn production_run_batch(batch_id : String, monitor : ProductionMonitor, samples : Array[ProductionSample]) -> ProductionBatchResult

#
production_sample_quality

source
fn production_sample_quality(samples : Array[ProductionSample]) -> (Int, Int, Int)

Counts samples by late-data and imputation flags for quality dashboards.

#
production_scenario_points

source
fn production_scenario_points(scenario : SignalScenario, start_timestamp? : Int64, step? : Int64) -> Array[SignalPoint]

Creates sorted points from a deterministic scenario for benchmark harnesses.

#
production_select_cost_threshold

source
fn production_select_cost_threshold(scores : Array[Double], labels : Array[Bool], cost? : ProductionThresholdCost, steps? : Int) -> ProductionThresholdSelection

#
production_select_f1_threshold

source
fn production_select_f1_threshold(scores : Array[Double], labels : Array[Bool], steps? : Int) -> ProductionThresholdSelection

#
production_service_status_name

source
fn production_service_status_name(status : ProductionServiceStatus) -> String

#
production_slo_reports_markdown

source
fn production_slo_reports_markdown(reports : Array[ProductionSloReport]) -> String

#
production_slo_window_name

source
fn production_slo_window_name(kind : ProductionSloWindowKind) -> String

#
production_smoothed_values

source
fn production_smoothed_values(values : Array[Double], width? : Int) -> Array[Double]

#
production_snapshot_csv

source
fn production_snapshot_csv(snapshot : ProductionMonitorSnapshot) -> String

#
production_snapshots_csv

source
fn production_snapshots_csv(snapshots : Array[ProductionMonitorSnapshot]) -> String

#
production_snapshots_csv_header

source
fn production_snapshots_csv_header() -> String

Exports monitor snapshots as a stable CSV schema.

#
production_startup_report

source
fn production_startup_report(config : ProductionMonitorConfig, initial_values : Array[Double]) -> ProductionReadinessReport

#
production_stat_test_kind_name

source
fn production_stat_test_kind_name(kind : ProductionStatTestKind) -> String

#
production_stream_metrics_markdown

source
fn production_stream_metrics_markdown(metrics : ProductionStreamMetrics, elapsed : Int64) -> String

#
production_stream_process_points

source
fn production_stream_process_points(processor : ProductionStreamProcessor, points : Array[SignalPoint]) -> Array[ProductionMonitorEvent]

#
production_stream_status_name

source
fn production_stream_status_name(status : ProductionStreamStatus) -> String

#
production_threshold_grid

source
fn production_threshold_grid(scores : Array[Double], steps? : Int) -> Array[Double]

#
production_top_changes

source
fn production_top_changes(values : Array[Double], maximum? : Int) -> Array[Int]

Returns the largest absolute changes in a numeric series.

#
production_transform_kind_name

source
fn production_transform_kind_name(kind : ProductionTransformKind) -> String

#
production_transform_values

source
fn production_transform_values(values : Array[Double], specs : Array[ProductionTransformSpec], missing? : MissingValueStrategy) -> Array[Double]

#
production_validate_monotonic_timestamps

source
fn production_validate_monotonic_timestamps(timestamps : Array[Int64]) -> Bool

Returns whether a timestamp series is non-decreasing.

#
production_values_checksum

source
fn production_values_checksum(values : Array[Double]) -> Double

Computes a stable hash-like checksum over a numeric output series.

#
production_variance_ratio

source
fn production_variance_ratio(left : Array[Double], right : Array[Double]) -> Double

#
production_window_feature_distance

source
fn production_window_feature_distance(left : Array[Double], right : Array[Double], config? : ProductionFeatureConfig) -> Double

Computes a robustly scaled distance between two production windows.

#
production_window_function_name

source
fn production_window_function_name(kind : ProductionWindowFunction) -> String

#
quality_gate

source
fn quality_gate(values : Array[Double], minimum_score? : Double) -> Bool

#
quality_score

source
fn quality_score(report : QualityReport) -> Double

#
quantile

source
fn quantile(values : Array[Double], probability : Double) -> Double

#
quantile_shift_score

source
fn quantile_shift_score(left : Array[Double], right : Array[Double]) -> Double

#
rank_biserial_effect

source
fn rank_biserial_effect(left : Array[Double], right : Array[Double]) -> Double

#
ranks

source
fn ranks(values : Array[Double]) -> Array[Double]

fn recommended_detector(multivariate : Bool, offline : Bool, robust : Bool) -> String

#
recovery_action_name

source
fn recovery_action_name(action : RecoveryAction) -> String

#
recovery_message

source
fn recovery_message(plan : RecoveryPlan) -> String

#
recovery_priority

source
fn recovery_priority(result : DetectionResult) -> Int

#
recovery_report

source
fn recovery_report(plans : Array[RecoveryPlan]) -> String

#
relative_change

source
fn relative_change(baseline : Double, observed : Double) -> Double

#
remove_invalid

source
fn remove_invalid(values : Array[Double]) -> Array[Double]

#
reorder_periodic

source
fn reorder_periodic(points : Array[SignalPoint], period : Int) -> Array[SignalPoint]

Reorders every period-th point to model a small late-data burst.

#
replace_invalid

source
fn replace_invalid(values : Array[Double], replacement? : Double) -> Array[Double]

#
replay_changed_indices

source
fn replay_changed_indices(records : Array[ReplayRecord]) -> Array[Int]

#
replay_checksum

source
fn replay_checksum(records : Array[ReplayRecord]) -> Double

#
replay_latency_percentile

source
fn replay_latency_percentile(records : Array[ReplayRecord], probability : Double) -> Int64

#
replay_summary_markdown

source
fn replay_summary_markdown(summary : ReplaySummary) -> String

#
replay_values

source
fn replay_values(records : Array[ReplayRecord]) -> Array[Double]

#
replay_window

source
fn replay_window(records : Array[ReplayRecord], start : Int, end : Int) -> Array[ReplayRecord]

#
resample_linear

source
fn resample_linear(points : Array[SignalPoint], step : Int64) -> Array[SignalPoint]

#
results_csv

source
fn results_csv(results : Array[DetectionResult]) -> String

#
robust_detector_count

source
fn robust_detector_count() -> Int

#
robust_scale

source
fn robust_scale(values : Array[Double]) -> Double

#
robust_z_score

source
fn robust_z_score(value : Double, center : Double, scale : Double) -> Double

#
robust_z_scores

source
fn robust_z_scores(values : Array[Double]) -> Array[Double]

#
rolling_correlation

source
fn rolling_correlation(left : Array[Double], right : Array[Double], window_size : Int) -> Array[Double]

#
rolling_mean

source
fn rolling_mean(values : Array[Double], window_size : Int) -> Array[Double]

#
rolling_origins

source
fn rolling_origins(length : Int, train_size : Int, horizon : Int, step? : Int) -> Array[SegmentRange]

#
rolling_quantile

source
fn rolling_quantile(values : Array[Double], window_size : Int, probability : Double) -> Array[Double]

#
rolling_slope

source
fn rolling_slope(values : Array[Double], window_size : Int) -> Array[Double]

#
rolling_standard_deviation

source
fn rolling_standard_deviation(values : Array[Double], window_size : Int) -> Array[Double]

#
route_alert

source
fn route_alert(alert : AlertEvent) -> RoutingDecision

#
route_alerts

source
fn route_alerts(alerts : Array[AlertEvent]) -> Array[RoutingDecision]

#
routing_summary

source
fn routing_summary(decisions : Array[RoutingDecision]) -> String

#
runs_test_score

source
fn runs_test_score(values : Array[Double]) -> Double

#
safe_correlation

source
fn safe_correlation(left : Array[Double], right : Array[Double]) -> Double

Cross-series relationship helpers for multivariate monitoring.

#
scale_profile

source
fn scale_profile(values : Array[Double], sizes : Array[Int]) -> Array[ScaleEvidence]

#
scenario_truth

source
fn scenario_truth(scenario : SignalScenario) -> Array[Int]

#
score_f1

source
fn score_f1(scores : Array[Double], labels : Array[Bool], threshold : Double) -> Double

#
score_margin

source
fn score_margin(score : Double, threshold : Double) -> Double

#
score_precision

source
fn score_precision(scores : Array[Double], labels : Array[Bool], threshold : Double) -> Double

#
score_recall

source
fn score_recall(scores : Array[Double], labels : Array[Bool], threshold : Double) -> Double

#
score_to_confidence

source
fn score_to_confidence(score : Double, threshold : Double) -> Double

#
seasonal_naive_forecast

source
fn seasonal_naive_forecast(values : Array[Double], period : Int, horizon : Int) -> Array[Double]

#
seasonal_strength

source
fn seasonal_strength(values : Array[Double], period : Int) -> Double

#
second_difference

source
fn second_difference(values : Array[Double]) -> Array[Double]

#
segment_means

source
fn segment_means(values : Array[Double], boundaries : Array[Int]) -> Array[Double]

#
segment_profile

source
fn segment_profile(values : Array[Double], boundaries : Array[Int]) -> Array[StatsSummary]

#
segment_quality

source
fn segment_quality(values : Array[Double]) -> SegmentQuality

#
segment_variances

source
fn segment_variances(values : Array[Double], boundaries : Array[Int]) -> Array[Double]

#
severity_from_score

source
fn severity_from_score(score : Double) -> AlertSeverity

Converts a score into a stable three-level severity.

#
severity_name

source
fn severity_name(severity : AlertSeverity) -> String

Returns a human-readable severity label.

#
should_escalate

source
fn should_escalate(plan : RecoveryPlan, score : Double) -> Bool

#
sigmoid_score

source
fn sigmoid_score(value : Double) -> Double

#
sign

source
fn sign(value : Double) -> Int

Returns the sign of a number.

#
sign_change_rate

source
fn sign_change_rate(values : Array[Double]) -> Double

#
signal_checksum

source
fn signal_checksum(values : Array[Double]) -> Double

Returns a deterministic checksum useful for detecting accidental benchmark dead-code elimination.

#
slope_confidence

source
fn slope_confidence(values : Array[Double]) -> Double

#
sorted_copy

source
fn sorted_copy(values : Array[Double]) -> Array[Double]

Returns a sorted copy using insertion sort. It is stable and allocation-bounded for small windows.

#
spearman_correlation

source
fn spearman_correlation(left : Array[Double], right : Array[Double]) -> Double

#
split_train_test

source
fn split_train_test(values : Array[Double], train_fraction? : Double) -> (Array[Double], Array[Double])

#
standard_deviation

source
fn standard_deviation(values : Array[Double]) -> Double

#
stratified_counts

source
fn stratified_counts(values : Array[Double], bins : Int) -> Array[Int]

#
strongest_contribution

source
fn strongest_contribution(explanation : DetectionExplanation) -> EvidenceContribution?

#
sum

source
fn sum(values : Array[Double]) -> Double

#
summarize_replay

source
fn summarize_replay(records : Array[ReplayRecord]) -> ReplaySummary

#
summary_markdown

source
fn summary_markdown(summary : StatsSummary) -> String

#
tail_confidence

source
fn tail_confidence(score : Double, scale? : Double) -> Double

#
threshold_for_false_positive

source
fn threshold_for_false_positive(scores : Array[Double], target_rate : Double) -> Double

#
threshold_from_mad

source
fn threshold_from_mad(scores : Array[Double], multiplier? : Double) -> Double

#
threshold_from_mean

source
fn threshold_from_mean(scores : Array[Double], standard_deviations? : Double) -> Double

#
threshold_from_quantile

source
fn threshold_from_quantile(scores : Array[Double], false_positive_rate : Double) -> Double

#
threshold_grid

source
fn threshold_grid(minimum : Double, maximum : Double, steps : Int) -> Array[Double]

#
threshold_points

source
fn threshold_points(scores : Array[Double], threshold : Double) -> Array[ThresholdPoint]

#
time_window_csv

source
fn time_window_csv(windows : Array[TimeWindow], counts : Array[Int]) -> String

#
timestamped_signal

source
fn timestamped_signal(values : Array[Double], start? : Int64, step? : Int64) -> Array[SignalPoint]

Converts a signal to timestamped points.

#
trimmed_mean

source
fn trimmed_mean(values : Array[Double], trim_fraction : Double) -> Double

#
validate_points

source
fn validate_points(points : Array[SignalPoint], maximum_gap? : Int64?) -> QualityReport

#
validate_values

source
fn validate_values(values : Array[Double], lower? : Double?, upper? : Double?) -> QualityReport

#
variance

source
fn variance(values : Array[Double]) -> Double

#
vector_dot

source
fn vector_dot(left : Array[Double], right : Array[Double]) -> Double

#
vector_norm

source
fn vector_norm(values : Array[Double]) -> Double

Computes the Euclidean norm of a vector.

#
weighted_consensus

source
fn weighted_consensus(results : Array[DetectionResult], weights : Array[Double], quorum : Double) -> DetectionResult

#
weighted_mean

source
fn weighted_mean(values : Array[Double], weights : Array[Double]) -> Double

#
window_change_scores

source
fn window_change_scores(values : Array[Double], min_segment? : Int) -> Array[Double]

Scans every valid split and returns a score for each index.

#
window_counts

source
fn window_counts(points : Array[SignalPoint], windows : Array[TimeWindow]) -> Array[Int]

#
window_means

source
fn window_means(points : Array[SignalPoint], windows : Array[TimeWindow]) -> Array[Double]

#
window_summaries

source
fn window_summaries(points : Array[SignalPoint], windows : Array[TimeWindow]) -> Array[StatsSummary]

#
winsorize

source
fn winsorize(values : Array[Double], lower_probability? : Double, upper_probability? : Double) -> Array[Double]

#
winsorize_robust

source
fn winsorize_robust(values : Array[Double], lower_probability : Double, upper_probability : Double) -> Array[Double]

Robust preprocessing helpers for production telemetry.

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io