Sign in

    moonbitstack/moonzero/logx does not have a README file

    LogLevel

    pub(all) enum LogLevel {
    Debug
    Info
    Error
    Severe
    } derive(Compare, Eq,
    Debug
    )

    Log verbosity (← go-zero's LogConf.Level), ordered from most to least verbose. Compare follows that order so thresholds can be tested directly.

    LogLevel::as_level

    The moonlog level this one records as. go-zero's ladder has four rungs and moonlog's has six, so the map is one-way: Severe records as Fatal, and [level_name] writes it back out as severe.

    LogLevel::compare

    fn LogLevel::compare(LogLevel, LogLevel) -> Int

    LogLevel::equal

    fn LogLevel::equal(LogLevel, LogLevel) -> Bool

    LogLevel::not_equal

    fn LogLevel::not_equal(x : LogLevel, y : LogLevel) -> Bool

    LogLevel::op_ge

    fn LogLevel::op_ge(x : LogLevel, y : LogLevel) -> Bool

    LogLevel::op_gt

    fn LogLevel::op_gt(x : LogLevel, y : LogLevel) -> Bool

    LogLevel::op_le

    fn LogLevel::op_le(x : LogLevel, y : LogLevel) -> Bool

    LogLevel::op_lt

    fn LogLevel::op_lt(x : LogLevel, y : LogLevel) -> Bool

    LogLevel::parse

    fn LogLevel::parse(s : String) -> LogLevel

    Parse a level name, falling back to Info for anything unrecognised — the same lenient default go-zero applies to a missing/empty level.

    LogLevel::to_repr

    LogLevel::to_string

    fn LogLevel::to_string(self : LogLevel) -> String

    The canonical lowercase name go-zero uses on the wire.

    LogState

    type LogState

    The bits of a logger that are shared by every view derived from it, so set_level on the process logger is seen by a with_duration view taken before it (← logx's package-level level and writer).

    Logger

    pub struct Logger {
    state : LogState
    clock :
    Clock

    duration_ms : Int64?
    }

    A leveled, structured logger (← go-zero's logx): entries below the configured level are dropped without being rendered, and everything else reaches the sink as one record carrying @timestamp, level, content, an optional duration, and any extra fields.

    The timestamp is milliseconds from the injected Clock, not a formatted calendar time: MoonBit has no portable date formatter, and the clock is already how every other timed layer here reads the time.

    Logger::debug

    fn Logger::debug(self : Logger, content : String, fields? : Array[(String, Json)]) -> Unit

    Write a debug entry.

    Logger::enabled

    fn Logger::enabled(self : Logger, level : LogLevel) -> Bool

    Whether an entry at level would be written.

    Logger::error

    fn Logger::error(self : Logger, content : String, fields? : Array[(String, Json)]) -> Unit

    Write an error entry.

    Logger::info

    fn Logger::info(self : Logger, content : String, fields? : Array[(String, Json)]) -> Unit

    Write an info entry.

    Logger::level

    fn Logger::level(self : Logger) -> LogLevel

    The level below which entries are dropped.

    Logger::log

    fn Logger::log(self : Logger, level : LogLevel, content : String, fields? : Array[(String, Json)]) -> Unit

    Render and write one entry, unless level is below the threshold.

    Logger::new

    A logger writing to sink at level and above.

    The default sink prints one [entry] per line. Logger::new(clock,sink=@moonlog.Discard::{ }) is how a test silences one.

    Logger::set_level

    fn Logger::set_level(self : Logger, level : LogLevel) -> Unit

    Raise or lower the threshold (← logx.SetLevel), for this logger and every view derived from it.

    Logger::set_sink

    fn Logger::set_sink(self : Logger, sink : &
    Sink
    ) -> Unit

    Send entries to another sink, for this logger and every view derived from it — a file, a collector client, a buffer under test.

    Logger::set_writer

    fn Logger::set_writer(self : Logger, writer : (String) -> Unit) -> Unit

    Send entries somewhere other than stdout (← logx.SetWriter), keeping go-zero's line format. [Logger::set_sink] changes the format too.

    Logger::severe

    fn Logger::severe(self : Logger, content : String, fields? : Array[(String, Json)]) -> Unit

    Write a severe entry.

    Logger::with_duration

    fn Logger::with_duration(self : Logger, ms : Int64) -> Logger

    A view of this logger that stamps duration on every entry (← logx.WithDuration), sharing the level and sink with the original.

    duration_key

    let duration_key : String

    The key the elapsed time is written under.

    entry

    fn entry(record :
    Record
    ) -> String

    One entry as the single-line JSON object go-zero emits: @timestamp, level, content, then whatever else the entry carries.

    This is the default sink's format, not a rule — hand Logger::new another moonlog sink and the same records are rendered that sink's way.

    level_name

    fn level_name(level :
    Level
    ) -> String

    go-zero's name for a level. Fatal reads as severe, which is what go-zero calls its top level and what its collectors filter on.

    logx

    let logx : Logger

    The process-wide logger (← logx's package-level logger): what the middlewares write to when no logger is handed to them, on the system clock at info. RestEngine::new points its level at the loaded Log.Level.

    message_key

    let message_key : String

    The key the message is written under (← go-zero's logx.content, where zap and slog would write msg).

    set_log_level

    fn set_log_level(level : LogLevel) -> Unit

    Set the process logger's level (← logx.SetLevel).

    set_log_sink

    fn set_log_sink(sink : &
    Sink
    ) -> Unit

    Send the process logger's entries to sink.

    set_log_writer

    fn set_log_writer(writer : (String) -> Unit) -> Unit

    Send the process logger's entries to writer (← logx.SetWriter).

    stamp_key

    let stamp_key : String

    The key the entry's time is written under (← go-zero's logx, which names it for Elasticsearch's own field).

    Source Files