🥮 mooncakes.io
    Sign in

    MoonLogTrace

    Pure MoonBit structured logging and tracing library with safe formatters, replay, query, and retention utilities.

    logging
    tracing
    structured-logging
    span
    debug
    syslog
    metrics
    pipeline
    Download zip
    Version
    0.1.4
    License
    Apache-2.0
    Repository
    Last updated
    2 months ago
    Downloads
    38
    # CCllff-jpg/MoonLogTrace

    Pure MoonBit structured logging and lightweight tracing library with bounded in-memory appenders, replay, safe string formatters, structured queries, retention policies, contexts, spans, and test utilities.

    Install with moon add CCllff-jpg/MoonLogTrace@0.1.3. See README.md for usage, quality gates, and documented limitations.

    AlertManager

    source
    pub(all) struct AlertManager {
      rules : Array[AlertRule]
    }

    AlertManager::add_rule

    source
    fn AlertManager::add_rule(self : AlertManager, rule : AlertRule) -> AlertManager

    AlertManager::check_all

    source
    fn AlertManager::check_all(self : AlertManager, logger : Logger) -> (AlertManager, Array[String])

    AlertManager::new

    source

    AlertRule

    source
    pub(all) struct AlertRule {
      name : String
      min_level : Level
      max_count : Int
      window_size : Int
    }

    AlertRule::evaluate

    source
    fn AlertRule::evaluate(self : AlertRule, logger : Logger) -> Bool

    AlertRule::new

    source
    fn AlertRule::new(name : String, min_level : Level, max_count : Int, window_size : Int) -> AlertRule

    AllowListFilter

    source
    pub(all) struct AllowListFilter {
      allowed : Array[Level]
    }

    AllowListFilter::check

    source
    fn AllowListFilter::check(self : AllowListFilter, level : Level) -> Bool

    AllowListFilter::new

    source

    BatchLogger

    source
    pub(all) struct BatchLogger {
      logger : Logger
      buffer : Array[LogRecord]
      batch_size : Int
    }

    BatchLogger::debug

    source
    fn BatchLogger::debug(self : BatchLogger, msg : String, fields : Array[(String, String)]) -> BatchLogger

    BatchLogger::error

    source
    fn BatchLogger::error(self : BatchLogger, msg : String, fields : Array[(String, String)]) -> BatchLogger

    BatchLogger::flush

    source
    fn BatchLogger::flush(self : BatchLogger) -> BatchLogger

    BatchLogger::info

    source
    fn BatchLogger::info(self : BatchLogger, msg : String, fields : Array[(String, String)]) -> BatchLogger

    BatchLogger::log

    source
    fn BatchLogger::log(self : BatchLogger, lvl : Level, msg : String, fields : Array[(String, String)]) -> BatchLogger

    BatchLogger::new

    source
    fn BatchLogger::new(logger : Logger, batch_size : Int) -> BatchLogger

    BatchLogger::pending

    source
    fn BatchLogger::pending(self : BatchLogger) -> Int

    BatchLogger::trace

    source
    fn BatchLogger::trace(self : BatchLogger, msg : String, fields : Array[(String, String)]) -> BatchLogger

    BatchLogger::warn

    source
    fn BatchLogger::warn(self : BatchLogger, msg : String, fields : Array[(String, String)]) -> BatchLogger

    BurstSampler

    source
    pub(all) struct BurstSampler {
      max_burst : Int
      sustained_rate : Int
      window_size : Int
      bucket : Int
      last_refill : Int
    }

    BurstSampler::allow

    source
    fn BurstSampler::allow(self : BurstSampler, tick : Int) -> (BurstSampler, Bool)

    BurstSampler::new

    source
    fn BurstSampler::new(max_burst : Int, sustained_rate : Int, window_size : Int) -> BurstSampler

    ConsoleAppender

    source
    pub(all) struct ConsoleAppender {
      use_json : Bool
    }

    ConsoleAppender::append

    source
    fn ConsoleAppender::append(self : ConsoleAppender, record : LogRecord) -> String

    ConsoleAppender::json

    source

    ConsoleAppender::new

    source

    CorrelationId

    source
    pub(all) struct CorrelationId {
      id : String
      sequence : Int
    }

    CorrelationId::generate

    source
    fn CorrelationId::generate(prefix : String, seq : Int) -> CorrelationId

    CorrelationId::new

    source
    fn CorrelationId::new(id : String) -> CorrelationId

    CorrelationId::next

    source

    CorrelationId::to_field

    source
    fn CorrelationId::to_field(self : CorrelationId, key : String) -> (String, String)

    Counter

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

    Counter::add

    source
    fn Counter::add(self : Counter, n : Int) -> Counter

    Counter::increment

    source
    fn Counter::increment(self : Counter) -> Counter

    Counter::new

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

    Counter::read

    source
    fn Counter::read(self : Counter) -> Int

    DenyListFilter

    source
    pub(all) struct DenyListFilter {
      denied : Array[Level]
    }

    DenyListFilter::check

    source
    fn DenyListFilter::check(self : DenyListFilter, level : Level) -> Bool

    DenyListFilter::new

    source

    EventMeter

    source
    pub(all) struct EventMeter {
      name : String
      events : Array[Int]
      window_size : Int
    }

    EventMeter::count

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

    EventMeter::new

    source
    fn EventMeter::new(name : String, window_size : Int) -> EventMeter

    EventMeter::rate

    source
    fn EventMeter::rate(self : EventMeter) -> Int

    EventMeter::record

    source
    fn EventMeter::record(self : EventMeter, ts : Int) -> EventMeter

    FieldFilter

    source
    pub(all) struct FieldFilter {
      key : String
      value : String
    }

    FieldFilter::check

    source
    fn FieldFilter::check(self : FieldFilter, record : LogRecord) -> Bool

    FieldFilter::new

    source
    fn FieldFilter::new(key : String, value : String) -> FieldFilter

    FieldValue

    source
    pub(all) enum FieldValue {
      Str(String)
      IntVal(Int)
      FloatVal(Float)
      BoolVal(Bool)
    }

    Histogram

    source
    pub(all) struct Histogram {
      name : String
      values : Array[Int]
    }

    Histogram::avg

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

    Histogram::count

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

    Histogram::max_val

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

    Histogram::min_val

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

    Histogram::new

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

    Histogram::record

    source
    fn Histogram::record(self : Histogram, value : Int) -> Histogram

    Histogram::sum

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

    Level

    source
    pub(all) enum Level {
      TRACE
      DEBUG
      INFO
      WARN
      ERROR
    }

    LevelFilter

    source
    pub(all) struct LevelFilter {
      threshold : Level
    }

    LevelFilter::check

    source
    fn LevelFilter::check(self : LevelFilter, level : Level) -> Bool

    LevelFilter::new

    source
    fn LevelFilter::new(threshold : Level) -> LevelFilter

    LogContext

    source
    pub(all) struct LogContext {
      pairs : Array[(String, String)]
    }

    LogContext::add

    source
    fn LogContext::add(self : LogContext, key : String, value : String) -> LogContext

    LogContext::merge

    source
    fn LogContext::merge(self : LogContext, fields : Array[(String, String)]) -> Array[(String, String)]

    LogContext::new

    source
    fn LogContext::new() -> LogContext

    LogQuery

    source
    pub(all) struct LogQuery {
      minimum_level : Level?
      maximum_level : Level?
      message_fragment : String?
      required_field_key : String?
      required_field_value : String?
      start_timestamp : Int?
      end_timestamp : Int?
      result_limit : Int?
    }

    LogQuery::count

    source
    fn LogQuery::count(self : LogQuery, records : Array[LogRecord]) -> Int

    LogQuery::execute

    source
    fn LogQuery::execute(self : LogQuery, records : Array[LogRecord]) -> Array[LogRecord]

    LogQuery::field_equals

    source
    fn LogQuery::field_equals(self : LogQuery, key : String, value : String) -> LogQuery

    LogQuery::field_exists

    source
    fn LogQuery::field_exists(self : LogQuery, key : String) -> LogQuery

    LogQuery::first

    source
    fn LogQuery::first(self : LogQuery, records : Array[LogRecord]) -> LogRecord?

    LogQuery::limit

    source
    fn LogQuery::limit(self : LogQuery, count : Int) -> LogQuery

    LogQuery::matches

    source
    fn LogQuery::matches(self : LogQuery, record : LogRecord) -> Bool

    LogQuery::max_level

    source
    fn LogQuery::max_level(self : LogQuery, level : Level) -> LogQuery

    LogQuery::message_contains

    source
    fn LogQuery::message_contains(self : LogQuery, fragment : String) -> LogQuery

    LogQuery::min_level

    source
    fn LogQuery::min_level(self : LogQuery, level : Level) -> LogQuery

    LogQuery::new

    source
    fn LogQuery::new() -> LogQuery

    LogQuery::since

    source
    fn LogQuery::since(self : LogQuery, timestamp : Int) -> LogQuery

    LogQuery::until

    source
    fn LogQuery::until(self : LogQuery, timestamp : Int) -> LogQuery

    LogRecord

    source
    pub(all) struct LogRecord {
      level : Level
      message : String
      fields : Array[(String, String)]
      timestamp : Int
    }

    LogRecord::copy

    source
    fn LogRecord::copy(self : LogRecord) -> LogRecord

    LogRecord::new

    source
    fn LogRecord::new(level : Level, message : String, fields : Array[(String, String)], timestamp : Int) -> LogRecord

    LogReplay

    source
    pub(all) struct LogReplay {
      records : Array[LogRecord]
      position : Int
    }

    LogReplay::current_position

    source
    fn LogReplay::current_position(self : LogReplay) -> Int

    LogReplay::from_logger

    source
    fn LogReplay::from_logger(logger : Logger) -> LogReplay

    LogReplay::from_records

    source
    fn LogReplay::from_records(records : Array[LogRecord]) -> LogReplay

    LogReplay::has_more

    source
    fn LogReplay::has_more(self : LogReplay) -> Bool

    LogReplay::next

    source
    fn LogReplay::next(self : LogReplay) -> (LogReplay, LogRecord)

    LogReplay::next_record

    source
    fn LogReplay::next_record(self : LogReplay) -> (LogReplay, LogRecord?)

    LogReplay::peek

    source
    fn LogReplay::peek(self : LogReplay) -> LogRecord?

    LogReplay::remaining

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

    LogReplay::replay_into

    source
    fn LogReplay::replay_into(self : LogReplay, logger : Logger) -> (LogReplay, Logger)

    LogReplay::reset

    source
    fn LogReplay::reset(self : LogReplay) -> LogReplay

    LogReplay::seek

    source
    fn LogReplay::seek(self : LogReplay, position : Int) -> LogReplay

    LogReplay::total

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

    LogRouter

    source
    pub(all) struct LogRouter {
      memory_all : MemoryAppender
      memory_errors : MemoryAppender
      logger : Logger
    }

    LogRouter::all_count

    source
    fn LogRouter::all_count(self : LogRouter) -> Int

    LogRouter::all_logs

    source
    fn LogRouter::all_logs(self : LogRouter) -> Array[String]

    LogRouter::dispatch

    source
    fn LogRouter::dispatch(self : LogRouter, lvl : Level, msg : String, fields : Array[(String, String)]) -> LogRouter

    LogRouter::error_count

    source
    fn LogRouter::error_count(self : LogRouter) -> Int

    LogRouter::error_logs

    source
    fn LogRouter::error_logs(self : LogRouter) -> Array[String]

    LogRouter::new

    source
    fn LogRouter::new(logger : Logger) -> LogRouter

    LogSummary

    source
    pub(all) struct LogSummary {
      total : Int
      by_level : Array[Int]
    }

    LogSummary::error_rate

    source
    fn LogSummary::error_rate(self : LogSummary) -> Int

    LogSummary::warn_rate

    source
    fn LogSummary::warn_rate(self : LogSummary) -> Int

    Logger

    source
    pub(all) struct Logger {
      level : Level
      has_console : Bool
      console_json : Bool
      memory : MemoryAppender
      seq : Int
      context : LogContext
      console_json_enabled : Bool
    }

    Logger::add_context

    source
    fn Logger::add_context(self : Logger, key : String, value : String) -> Logger

    Logger::apply_retention

    source
    fn Logger::apply_retention(self : Logger, policy : RetentionPolicy, current_timestamp : Int) -> RetentionResult

    Logger::build

    source
    fn Logger::build(self : Logger) -> Logger

    Logger::console

    source
    fn Logger::console(self : Logger) -> Logger

    Logger::console_json

    source
    fn Logger::console_json(self : Logger) -> Logger

    Logger::debug

    source
    fn Logger::debug(self : Logger, msg : String, fields : Array[(String, String)]) -> Logger

    Logger::error

    source
    fn Logger::error(self : Logger, msg : String, fields : Array[(String, String)]) -> Logger

    Logger::info

    source
    fn Logger::info(self : Logger, msg : String, fields : Array[(String, String)]) -> Logger

    Logger::level

    source
    fn Logger::level(self : Logger, l : Level) -> Logger

    Logger::log_count

    source
    fn Logger::log_count(self : Logger) -> Int

    Logger::logs

    source
    fn Logger::logs(self : Logger) -> Array[String]

    Logger::new

    source
    fn Logger::new() -> Logger

    Logger::query

    source
    fn Logger::query(self : Logger, query : LogQuery) -> Array[LogRecord]

    Logger::records

    source
    fn Logger::records(self : Logger) -> Array[LogRecord]

    Logger::trace

    source
    fn Logger::trace(self : Logger, msg : String, fields : Array[(String, String)]) -> Logger

    Logger::warn

    source
    fn Logger::warn(self : Logger, msg : String, fields : Array[(String, String)]) -> Logger

    LoggerConfig

    source
    pub(all) struct LoggerConfig {
      level : Level
      enable_console : Bool
      console_json : Bool
      context_keys : Array[String]
      context_values : Array[String]
    }

    LoggerConfig::add_context

    source
    fn LoggerConfig::add_context(self : LoggerConfig, key : String, value : String) -> LoggerConfig

    LoggerConfig::build_logger

    source
    fn LoggerConfig::build_logger(self : LoggerConfig) -> Logger

    LoggerConfig::enable_console

    source
    fn LoggerConfig::enable_console(self : LoggerConfig) -> LoggerConfig

    LoggerConfig::enable_console_json

    source
    fn LoggerConfig::enable_console_json(self : LoggerConfig) -> LoggerConfig

    LoggerConfig::new

    source

    LoggerConfig::set_level

    source
    fn LoggerConfig::set_level(self : LoggerConfig, l : Level) -> LoggerConfig

    MemoryAppender

    source
    pub(all) struct MemoryAppender {
      records : Array[String]
      entries : Array[LogRecord]
    }

    MemoryAppender::append

    source
    fn MemoryAppender::append(self : MemoryAppender, record : LogRecord) -> MemoryAppender

    MemoryAppender::count

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

    MemoryAppender::get_logs

    source
    fn MemoryAppender::get_logs(self : MemoryAppender) -> Array[String]

    MemoryAppender::get_records

    source
    fn MemoryAppender::get_records(self : MemoryAppender) -> Array[LogRecord]

    MemoryAppender::new

    source

    MessageFilter

    source
    pub(all) struct MessageFilter {
      substring : String
    }

    MessageFilter::check

    source
    fn MessageFilter::check(self : MessageFilter, record : LogRecord) -> Bool

    MessageFilter::new

    source
    fn MessageFilter::new(substring : String) -> MessageFilter

    PercentSampler

    source
    pub(all) struct PercentSampler {
      rate : Int
      counter : Int
    }

    PercentSampler::new

    source
    fn PercentSampler::new(rate : Int) -> PercentSampler

    PercentSampler::sample

    source
    fn PercentSampler::sample(self : PercentSampler) -> (PercentSampler, Bool)

    Pipeline

    source
    pub(all) struct Pipeline {
      add_field_keys : Array[String]
      add_field_values : Array[String]
      prefix_message : String
      redact_keys : Array[String]
    }

    Pipeline::add_field

    source
    fn Pipeline::add_field(self : Pipeline, key : String, value : String) -> Pipeline

    Pipeline::apply

    source
    fn Pipeline::apply(self : Pipeline, record : LogRecord) -> LogRecord

    Pipeline::new

    source
    fn Pipeline::new() -> Pipeline

    Pipeline::prepend_msg

    source
    fn Pipeline::prepend_msg(self : Pipeline, prefix : String) -> Pipeline

    Pipeline::redact

    source
    fn Pipeline::redact(self : Pipeline, key : String) -> Pipeline

    Pipeline::transform_count

    source
    fn Pipeline::transform_count(self : Pipeline) -> Int

    RateLimiter

    source
    pub(all) struct RateLimiter {
      max_per_window : Int
      meter : EventMeter
    }

    RateLimiter::allow

    source
    fn RateLimiter::allow(self : RateLimiter, ts : Int) -> (RateLimiter, Bool)

    RateLimiter::new

    source
    fn RateLimiter::new(max_per_window : Int, window_size : Int) -> RateLimiter

    RateSampler

    source
    pub(all) struct RateSampler {
      max_per_window : Int
      window_size : Int
      events : Array[Int]
    }

    RateSampler::allow

    source
    fn RateSampler::allow(self : RateSampler, tick : Int) -> (RateSampler, Bool)

    RateSampler::count

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

    RateSampler::new

    source
    fn RateSampler::new(max_per_window : Int, window_size : Int) -> RateSampler

    RequestContext

    source
    pub(all) struct RequestContext {
      context : LogContext
      correlation : CorrelationId
      logger : Logger
    }

    RequestContext::error

    source
    fn RequestContext::error(self : RequestContext, msg : String, fields : Array[(String, String)]) -> RequestContext

    RequestContext::finish

    source
    fn RequestContext::finish(self : RequestContext) -> Logger

    RequestContext::info

    source
    fn RequestContext::info(self : RequestContext, msg : String, fields : Array[(String, String)]) -> RequestContext

    RequestContext::new

    source
    fn RequestContext::new(logger : Logger, request_id : String) -> RequestContext

    RequestContext::warn

    source
    fn RequestContext::warn(self : RequestContext, msg : String, fields : Array[(String, String)]) -> RequestContext

    RequestContext::with_field

    source
    fn RequestContext::with_field(self : RequestContext, key : String, value : String) -> RequestContext

    RetentionPolicy

    source
    pub(all) struct RetentionPolicy {
      minimum_level : Level?
      maximum_age : Int?
      maximum_count : Int?
    }

    RetentionPolicy::apply

    source
    fn RetentionPolicy::apply(self : RetentionPolicy, records : Array[LogRecord], current_timestamp : Int) -> RetentionResult

    RetentionPolicy::max_age

    source
    fn RetentionPolicy::max_age(self : RetentionPolicy, age : Int) -> RetentionPolicy

    RetentionPolicy::max_count

    source
    fn RetentionPolicy::max_count(self : RetentionPolicy, count : Int) -> RetentionPolicy

    RetentionPolicy::min_level

    source
    fn RetentionPolicy::min_level(self : RetentionPolicy, level : Level) -> RetentionPolicy

    RetentionPolicy::new

    source

    RetentionResult

    source
    pub(all) struct RetentionResult {
      records : Array[LogRecord]
      dropped_by_level : Int
      dropped_by_age : Int
      dropped_by_capacity : Int
    }

    RetentionResult::dropped_count

    source
    fn RetentionResult::dropped_count(self : RetentionResult) -> Int

    RetentionResult::get_records

    source
    fn RetentionResult::get_records(self : RetentionResult) -> Array[LogRecord]

    RetentionResult::kept_count

    source
    fn RetentionResult::kept_count(self : RetentionResult) -> Int

    RollingAppender

    source
    pub(all) struct RollingAppender {
      records : Array[String]
      entries : Array[LogRecord]
      max_count : Int
      dropped_count : Int
    }

    RollingAppender::append

    source

    RollingAppender::capacity

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

    RollingAppender::clear

    source

    RollingAppender::count

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

    RollingAppender::dropped

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

    RollingAppender::get_logs

    source
    fn RollingAppender::get_logs(self : RollingAppender) -> Array[String]

    RollingAppender::get_records

    source
    fn RollingAppender::get_records(self : RollingAppender) -> Array[LogRecord]

    RollingAppender::is_full

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

    RollingAppender::new

    source
    fn RollingAppender::new(max_count : Int) -> RollingAppender

    RotationPolicy

    source
    pub(all) struct RotationPolicy {
      max_entries : Int
      rotation_count : Int
      current_index : Int
    }

    RotationPolicy::generation

    source
    fn RotationPolicy::generation(self : RotationPolicy) -> Int

    RotationPolicy::new

    source
    fn RotationPolicy::new(max_entries : Int) -> RotationPolicy

    RotationPolicy::rotate

    source

    RotationPolicy::should_rotate

    source
    fn RotationPolicy::should_rotate(self : RotationPolicy, current_count : Int) -> Bool

    SizeRotationPolicy

    source
    pub(all) struct SizeRotationPolicy {
      max_bytes : Int
      current_bytes : Int
      rotation_count : Int
    }

    SizeRotationPolicy::count

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

    SizeRotationPolicy::new

    source
    fn SizeRotationPolicy::new(max_bytes : Int) -> SizeRotationPolicy

    SizeRotationPolicy::record

    source
    fn SizeRotationPolicy::record(self : SizeRotationPolicy, bytes : Int) -> SizeRotationPolicy

    SizeRotationPolicy::reset

    source

    SizeRotationPolicy::should_rotate

    source
    fn SizeRotationPolicy::should_rotate(self : SizeRotationPolicy) -> Bool

    Span

    source
    pub(all) struct Span {
      name : String
      fields : Array[(String, String)]
      start_seq : Int
    }

    Span::enter

    source
    fn Span::enter(logger : Logger, name : String, fields : Array[(String, String)]) -> (Logger, Span)

    Span::exit

    source
    fn Span::exit(self : Span, logger : Logger) -> Logger

    TagSet

    source
    pub(all) struct TagSet {
      tags : Array[String]
    }

    TagSet::add

    source
    fn TagSet::add(self : TagSet, tag : String) -> TagSet

    TagSet::count

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

    TagSet::has

    source
    fn TagSet::has(self : TagSet, tag : String) -> Bool

    TagSet::new

    source
    fn TagSet::new() -> TagSet

    TagSet::to_fields

    source
    fn TagSet::to_fields(self : TagSet) -> Array[(String, String)]

    TaggedLogger

    source
    pub(all) struct TaggedLogger {
      logger : Logger
      tags : TagSet
    }

    TaggedLogger::error

    source
    fn TaggedLogger::error(self : TaggedLogger, msg : String, fields : Array[(String, String)]) -> TaggedLogger

    TaggedLogger::get_logger

    source
    fn TaggedLogger::get_logger(self : TaggedLogger) -> Logger

    TaggedLogger::info

    source
    fn TaggedLogger::info(self : TaggedLogger, msg : String, fields : Array[(String, String)]) -> TaggedLogger

    TaggedLogger::new

    source
    fn TaggedLogger::new(logger : Logger) -> TaggedLogger

    TaggedLogger::warn

    source
    fn TaggedLogger::warn(self : TaggedLogger, msg : String, fields : Array[(String, String)]) -> TaggedLogger

    TaggedLogger::with_tag

    source
    fn TaggedLogger::with_tag(self : TaggedLogger, tag : String) -> TaggedLogger

    ThroughputCounter

    source
    pub(all) struct ThroughputCounter {
      name : String
      total : Int
      first_ts : Int
      last_ts : Int
    }

    ThroughputCounter::avg_rate

    source
    fn ThroughputCounter::avg_rate(self : ThroughputCounter) -> Int

    ThroughputCounter::new

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

    ThroughputCounter::record

    source
    fn ThroughputCounter::record(self : ThroughputCounter, ts : Int) -> ThroughputCounter

    ThroughputCounter::total_count

    source
    fn ThroughputCounter::total_count(self : ThroughputCounter) -> Int

    TimeRotationPolicy

    source
    pub(all) struct TimeRotationPolicy {
      max_ticks : Int
      last_rotate_tick : Int
      rotation_count : Int
    }

    TimeRotationPolicy::check

    source
    fn TimeRotationPolicy::check(self : TimeRotationPolicy, current_tick : Int) -> (TimeRotationPolicy, Bool)

    TimeRotationPolicy::count

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

    TimeRotationPolicy::new

    source
    fn TimeRotationPolicy::new(max_ticks : Int) -> TimeRotationPolicy

    Timer

    source
    pub(all) struct Timer {
      name : String
      start_seq : Int
    }

    Timer::start

    source
    fn Timer::start(name : String, current_seq : Int) -> Timer

    Timer::stop

    source
    fn Timer::stop(self : Timer, current_seq : Int) -> (String, Int)

    TypedField

    source
    pub(all) struct TypedField {
      key : String
      value : FieldValue
    }

    TypedField::new_bool

    source
    fn TypedField::new_bool(key : String, v : Bool) -> TypedField

    TypedField::new_float

    source
    fn TypedField::new_float(key : String, v : Float) -> TypedField

    TypedField::new_int

    source
    fn TypedField::new_int(key : String, v : Int) -> TypedField

    TypedField::new_str

    source
    fn TypedField::new_str(key : String, v : String) -> TypedField

    TypedField::to_pair

    source
    fn TypedField::to_pair(self : TypedField) -> (String, String)

    assert_log_contains

    source
    fn assert_log_contains(logger : Logger, substring : String) -> Bool

    assert_log_count

    source
    fn assert_log_count(logger : Logger, expected : Int) -> Bool

    assert_log_level_count

    source
    fn assert_log_level_count(logger : Logger, level : Level) -> Int

    create_dev_logger

    source
    fn create_dev_logger() -> Logger

    create_prod_logger

    source
    fn create_prod_logger() -> Logger

    create_test_logger

    source
    fn create_test_logger() -> Logger

    extract_json_like

    source
    fn extract_json_like(message : String) -> Array[(String, String)]

    extract_key_value_pairs

    source
    fn extract_key_value_pairs(message : String) -> Array[(String, String)]

    field_value_to_string

    source
    fn field_value_to_string(v : FieldValue) -> String

    format_color

    source
    fn format_color(record : LogRecord) -> String

    format_compact

    source
    fn format_compact(record : LogRecord) -> String

    format_csv

    source
    fn format_csv(record : LogRecord) -> String

    format_gelf

    source
    fn format_gelf(record : LogRecord, host : String) -> String

    format_json

    source
    fn format_json(record : LogRecord) -> String

    format_logfmt

    source
    fn format_logfmt(record : LogRecord) -> String

    format_ndjson

    source
    fn format_ndjson(record : LogRecord) -> String

    format_pattern

    source
    fn format_pattern(record : LogRecord, pattern : String) -> String

    format_plain

    source
    fn format_plain(record : LogRecord) -> String

    format_syslog

    source
    fn format_syslog(record : LogRecord, app_name : String) -> String

    format_text

    source
    fn format_text(record : LogRecord) -> String

    format_timestamp

    source
    fn format_timestamp(ts : Int) -> String

    format_xml

    source
    fn format_xml(record : LogRecord) -> String

    is_valid_level

    source
    fn is_valid_level(s : String) -> Bool

    level_names

    source
    fn level_names() -> Array[String]

    level_ordinal

    source
    fn level_ordinal(l : Level) -> Int

    level_to_string

    source
    fn level_to_string(l : Level) -> String

    parse_level

    source
    fn parse_level(s : String) -> Level

    should_log

    source
    fn should_log(msg_level : Level, threshold : Level) -> Bool

    summarize

    source
    fn summarize(logger : Logger) -> LogSummary

    typed_fields_to_pairs

    source
    fn typed_fields_to_pairs(fields : Array[TypedField], idx : Int, result : Array[(String, String)]) -> Array[(String, String)]

    with_correlation

    source
    fn with_correlation(fields : Array[(String, String)], corr : CorrelationId, key : String) -> Array[(String, String)]

    word_count

    source
    fn word_count(message : String) -> Int

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io