🥮 mooncakes.io

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
moon add CCllff-jpg/MoonLogTrace@0.1.4
Download zip
Version
0.1.4
License
Apache-2.0
Repository
Last updated
16 days ago
Downloads
24
README
# 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