🥮 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
    Download zip
    Author
    Version
    0.3.1
    License
    Apache-2.0
    Repository
    Last updated
    2 months ago
    Downloads
    59

    No dependencies

    #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 on Mooncakes as Zy789kl/moon-change-point@0.3.1, 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 deterministic 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 issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io