🥮 mooncakes.io

    moonsignalkit

    Streaming telemetry statistics and change detection for MoonBit.

    signal
    timeseries
    streaming
    telemetry
    cusum
    anomaly-detection
    Download zip
    Author
    Version
    0.3.0
    License
    Apache-2.0
    Repository
    Last updated
    2 months ago
    Downloads
    27

    #MoonSignalKit

    MoonSignalKit supplies portable time-series and streaming telemetry primitives for MoonBit: batch summaries, bounded rolling quantiles, filters, CSV interchange, online moments, timestamp monitoring, and two-sided CUSUM.

    #Add to a project

    moon add cn-wn/moonsignalkit

    ///|
    test {
      let monitor = TimestampMonitor::new(10)
      let _first = monitor.observe(Sample::new(100, 1.0))
      let observation = monitor.observe(Sample::new(115, 1.0))
      assert_true(observation.is_gap)
    }

    The package has no filesystem, network, browser, or FFI dependency, so its API is shared by Native, JavaScript, Wasm, and Wasm-GC targets. For full examples, quality gates, scope, and related work, see the repository README.

    ChangeDirection

    source
    pub(all) enum ChangeDirection {
      Rising
      Falling
    } derive(Eq, 
    Debug    )

    ChangePoint

    source
    pub(all) struct ChangePoint {
      sample : Sample
      direction : ChangeDirection
      magnitude : Double
      observation : Int
    } derive(
    Debug    )

    A sustained level shift reported by CusumDetector.

    ChangePoint::to_json

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

    CsvError

    source
    pub(all) enum CsvError {
      EmptyInput
      MissingColumns(Int)
      InvalidTime(Int)
      InvalidValue(Int)
    } derive(Eq, 
    Debug    )

    Errors reported by the intentionally small, dependency-free telemetry CSV reader.

    The format is two columns: time,value. Quoted fields and locale-specific numeric formats are intentionally out of scope for a portable core library.

    CusumDetector

    source
    pub(all) struct CusumDetector {
      target : Double
      drift : Double
      threshold : Double
      positive_sum : Double
      negative_sum : Double
      observations : Int
    } derive(
    Debug    )

    Stateful two-sided CUSUM detector for streaming telemetry.

    target is the expected process level, drift suppresses ordinary noise, and threshold controls how much cumulative evidence triggers an event.

    CusumDetector::new

    source
    fn CusumDetector::new(target : Double, drift : Double, threshold : Double) -> CusumDetector

    CusumDetector::push

    source
    fn CusumDetector::push(self : CusumDetector, sample : Sample) -> ChangePoint?

    Processes one sample in O(1) time and returns an event only on a level shift.

    CusumDetector::reset_evidence

    source
    fn CusumDetector::reset_evidence(self : CusumDetector) -> Unit

    Clears accumulated evidence while preserving configuration and count.

    EwmaFilter

    source
    pub(all) struct EwmaFilter {
      alpha : Double
      has_value : Bool
      value : Double
    } derive(
    Debug    )

    O(1)-memory exponentially weighted moving-average filter.

    EwmaFilter::new

    source
    fn EwmaFilter::new(alpha_per_mille : Int) -> EwmaFilter

    EwmaFilter::push

    source
    fn EwmaFilter::push(self : EwmaFilter, sample : Sample) -> Sample

    EwmaFilter::reset

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

    EwmaFilter::value

    source
    fn EwmaFilter::value(self : EwmaFilter) -> Double?

    MedianFilter

    source
    pub(all) struct MedianFilter {
      window : RollingWindow
    } derive(
    Debug    )

    A bounded median filter for suppressing isolated telemetry spikes.

    MedianFilter::new

    source
    fn MedianFilter::new(window : Int) -> MedianFilter

    MedianFilter::push

    source
    fn MedianFilter::push(self : MedianFilter, sample : Sample) -> Sample

    MedianFilter::reset

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

    OnlineMoments

    source
    pub(all) struct OnlineMoments {
      count : Int
      mean : Double
      m2 : Double
      min : Double
      max : Double
    } derive(
    Debug    )

    Numerically stable online statistics using Welford's algorithm.

    Each sample is processed in O(1) time and O(1) memory, so the accumulator can be used for unbounded telemetry streams without retaining raw samples.

    OnlineMoments::new

    source

    OnlineMoments::push

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

    Adds one observation using a stable one-pass update.

    OnlineMoments::std_dev

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

    OnlineMoments::summary

    source
    fn OnlineMoments::summary(self : OnlineMoments) -> Summary

    Takes an immutable summary without resetting the accumulator.

    OnlineMoments::variance

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

    RollingWindow

    source
    pub(all) struct RollingWindow {
      capacity : Int
      values : Array[Sample]
      size : Int
      next : Int
    } derive(
    Debug    )

    A bounded chronological telemetry window.

    Appending a sample is O(1). Summaries and quantiles deliberately inspect the bounded window, so their cost is O(window_size) and does not grow with the lifetime of a stream.

    RollingWindow::capacity

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

    RollingWindow::is_ready

    source
    fn RollingWindow::is_ready(self : RollingWindow) -> Bool

    RollingWindow::length

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

    RollingWindow::median

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

    RollingWindow::new

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

    RollingWindow::push

    source
    fn RollingWindow::push(self : RollingWindow, sample : Sample) -> Unit

    Adds one sample, evicting the oldest sample after the capacity is reached.

    RollingWindow::quantile

    source
    fn RollingWindow::quantile(self : RollingWindow, permille : Int) -> Double

    Returns an exact nearest-rank quantile over the retained values.

    permille is clamped to the inclusive range 0..1000, making 500 the median.

    RollingWindow::reset

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

    RollingWindow::samples

    source
    fn RollingWindow::samples(self : RollingWindow) -> Array[Sample]

    Returns retained samples from oldest to newest.

    RollingWindow::summary

    source
    fn RollingWindow::summary(self : RollingWindow) -> Summary

    Computes a numerically stable summary over the current bounded window.

    Sample

    source
    pub(all) struct Sample {
      time : Int
      value : Double
    } derive(
    Debug    )

    Sample::new

    source
    fn Sample::new(time : Int, value : Double) -> Sample

    Series

    source
    pub(all) struct Series {
      name : String
      samples : Array[Sample]
    } derive(
    Debug    )

    Series::difference

    source
    fn Series::difference(self : Series, name? : String) -> Series

    Series::exponential_smoothing

    source
    fn Series::exponential_smoothing(self : Series, alpha_per_mille : Int, name? : String) -> Series

    Series::from_csv

    source
    fn Series::from_csv(name : String, csv : String, has_header? : Bool) -> Result[Series, CsvError]

    Imports a two-column time,value CSV document.

    Empty lines are ignored. The first non-empty row is treated as a header when has_header is true, which is the default and matches Series::to_csv.

    Series::is_empty

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

    Series::length

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

    Series::max_value

    source
    fn Series::max_value(self : Series) -> Double

    Series::mean

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

    Series::min_value

    source
    fn Series::min_value(self : Series) -> Double

    Series::moving_average

    source
    fn Series::moving_average(self : Series, window : Int, name? : String) -> Series

    Series::new

    source
    fn Series::new(name : String, samples : Array[Sample]) -> Series

    Series::normalize_minmax

    source
    fn Series::normalize_minmax(self : Series, name? : String) -> Series

    Series::outliers

    source
    fn Series::outliers(self : Series, z_threshold : Double) -> Array[Sample]

    Series::peak_count

    source
    fn Series::peak_count(self : Series, threshold : Double) -> Int

    Series::peaks

    source
    fn Series::peaks(self : Series, threshold : Double) -> Array[Sample]

    Series::range

    source
    fn Series::range(self : Series) -> Double

    Series::rate_of_change

    source
    fn Series::rate_of_change(self : Series, name? : String) -> Series

    Series::sum

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

    Series::summary

    source
    fn Series::summary(self : Series) -> Summary

    Series::summary_json

    source
    fn Series::summary_json(self : Series) -> String

    Series::to_csv

    source
    fn Series::to_csv(self : Series) -> String

    Exports a series as portable UTF-8 CSV with a time,value header.

    Series::variance

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

    Summary

    source
    pub(all) struct Summary {
      count : Int
      min : Double
      max : Double
      mean : Double
      range : Double
      variance : Double
      std_dev : Double
    } derive(
    Debug    )

    Summary::to_json

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

    TimestampMonitor

    source
    pub(all) struct TimestampMonitor {
      max_gap : Int
      last_time : Int?
    } derive(
    Debug    )

    Detects late samples and excessive timestamp gaps without retaining a stream. The latest in-order timestamp is never moved backwards, making observations deterministic for out-of-order telemetry.

    TimestampMonitor::new

    source
    fn TimestampMonitor::new(max_gap : Int) -> TimestampMonitor

    TimestampMonitor::observe

    source

    TimestampMonitor::reset

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

    TimingObservation

    source
    pub(all) struct TimingObservation {
      previous_time : Int?
      time : Int
      delta : Int
      is_late : Bool
      is_gap : Bool
    } derive(
    Debug    )

    Timing quality observed while accepting one telemetry sample.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io