log

package module
v0.1.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 28, 2026 License: BSD-3-Clause Imports: 33 Imported by: 0

README

log

Hanzo Log

A high-performance, zero-allocation structured logging library for the Hanzo ecosystem. Based on zerolog with additional geth-style API support.

Features

  • Blazing fast: ~8ns/op for empty log, zero allocations
  • Zero allocation: Uses sync.Pool for Event recycling
  • Two logging styles: Chaining API + traditional API (geth-compatible)
  • Structured logging: Type-safe field constructors
  • Leveled logging: Trace, Debug, Info, Warn, Error, Fatal, Panic
  • Contextual fields: Pre-set fields via With()
  • Pretty console output: Colorized human-readable format
  • Sampling: Reduce log volume in production
  • Hooks: Custom processing for log events

Installation

go get github.com/hanzoai/log

Quick Start

Chaining API
import "github.com/hanzoai/log"

// Simple logging
log.Info().Msg("hello world")

// With fields
log.Info().
    Str("user", "alice").
    Int("attempt", 3).
    Msg("login successful")

// With timestamp
log.Logger = log.Output(os.Stdout).With().Timestamp().Logger()
Traditional API (geth-compatible)
import "github.com/hanzoai/log"

// Simple logging
log.Info("hello world")

// With fields
log.Info("login successful",
    log.String("user", "alice"),
    log.Int("attempt", 3),
)

// Error with stack
log.Error("operation failed", log.Err(err))

Performance

Zero-allocation design using sync.Pool:

BenchmarkLogEmpty-10        161256609     8.443 ns/op    0 B/op   0 allocs/op
BenchmarkLogFields-10        32669988    40.22 ns/op     0 B/op   0 allocs/op
BenchmarkLogFieldType/Str    95961300    11.68 ns/op     0 B/op   0 allocs/op
BenchmarkLogFieldType/Int    89553908    11.75 ns/op     0 B/op   0 allocs/op
BenchmarkLogFieldType/Bool   94231278    12.02 ns/op     0 B/op   0 allocs/op
BenchmarkLogFieldType/Time   69632661    18.13 ns/op     0 B/op   0 allocs/op

Comparison with other loggers:

Library Time Bytes Allocs
hanzoai/log 8 ns/op 0 B/op 0 allocs/op
zerolog 19 ns/op 0 B/op 0 allocs/op
zap 236 ns/op 0 B/op 0 allocs/op
logrus 1244 ns/op 1505 B/op 27 allocs/op

Log Levels

const (
    TraceLevel Level = -1
    DebugLevel Level = 0
    InfoLevel  Level = 1
    WarnLevel  Level = 2
    ErrorLevel Level = 3
    FatalLevel Level = 4
    PanicLevel Level = 5
)
Setting Level
// Global level
log.SetGlobalLevel(log.WarnLevel)

// Per-logger level
l := log.New(os.Stdout).Level(log.InfoLevel)

Field Types

Chaining API (on Event)
event.Str("key", "value")
event.Int("key", 42)
event.Float64("key", 3.14)
event.Bool("key", true)
event.Err(err)
event.Time("key", time.Now())
event.Dur("key", time.Second)
event.Interface("key", obj)
event.Bytes("key", []byte{})
event.Strs("key", []string{})
event.Ints("key", []int{})
Traditional API (Field constructors)
log.String("key", "value")  // or log.Str("key", "value")
log.Int("key", 42)
log.Float64("key", 3.14)
log.Bool("key", true)
log.Err(err)
log.Time("key", time.Now())
log.Duration("key", time.Second)  // or log.Dur("key", time.Second)
log.Any("key", obj)
log.Binary("key", []byte{})

Context Logger

Pre-set fields for all log messages:

// Chaining API
l := log.New(os.Stdout).With().
    Str("service", "api").
    Str("version", "1.0.0").
    Logger()

l.Info().Msg("request") // includes service and version

// Traditional API
log.SetDefault(l)
log.Info("request") // includes service and version

Pretty Console Output

output := log.ConsoleWriter{Out: os.Stdout}
l := log.New(output)

l.Info().Str("foo", "bar").Msg("Hello World")
// Output: 3:04pm INF Hello World foo=bar

Sampling

Reduce log volume:

sampled := l.Sample(&log.BasicSampler{N: 10})
sampled.Info().Msg("logged every 10 messages")

Hooks

type SeverityHook struct{}

func (h SeverityHook) Run(e *log.Event, level log.Level, msg string) {
    if level != log.NoLevel {
        e.Str("severity", level.String())
    }
}

l := log.New(os.Stdout).Hook(SeverityHook{})

Sub-packages

  • github.com/hanzoai/log - Core package with chaining + traditional API
  • github.com/hanzoai/log/level - Level constants for compatibility

License

See LICENSE file for details.

Documentation

Overview

Package log provides a high-performance structured logging library.

This package supports two logging styles:

1. Geth-style variadic logging (recommended for compatibility): 

log := log.New("component", "myapp")
log.Info("server started", "port", 8080)
log.Debug("processing request", "id", reqID, "user", userID)

2. Method chaining (zero-allocation): 

log := log.NewWriter(os.Stderr).With().Str("component", "myapp").Logger()
log.Info().Str("port", "8080").Msg("server started")

Both styles can be mixed. The geth-style methods internally use the zero-allocation Event system for high performance.

Index

Constants

View Source 
const (
	// TimeFormatUnix defines a time format that makes time fields to be
	// serialized as Unix timestamp integers.
	TimeFormatUnix = ""

	// TimeFormatUnixMs defines a time format that makes time fields to be
	// serialized as Unix timestamp integers in milliseconds.
	TimeFormatUnixMs = "UNIXMS"

	// TimeFormatUnixMicro defines a time format that makes time fields to be
	// serialized as Unix timestamp integers in microseconds.
	TimeFormatUnixMicro = "UNIXMICRO"

	// TimeFormatUnixNano defines a time format that makes time fields to be
	// serialized as Unix timestamp integers in nanoseconds.
	TimeFormatUnixNano = "UNIXNANO"

	// DurationFormatFloat defines a format for Duration fields that makes duration fields to be
	// serialized as floating point numbers.
	DurationFormatFloat = "float"
	// DurationFormatInt defines a format for Duration fields that makes duration fields to be
	// serialized as integers.
	DurationFormatInt = "int"
	// DurationFormatString defines a format for Duration fields that makes duration fields to be
	// serialized as string.
	DurationFormatString = "string"
)
View Source 
const (

	// Exported slog.Level constants for use with Logger.Enabled()
	SlogLevelTrace slog.Level = slogLevelTrace
	SlogLevelDebug            = slogLevelDebug
	SlogLevelInfo             = slogLevelInfo
	SlogLevelWarn             = slogLevelWarn
	SlogLevelError            = slogLevelError
	SlogLevelCrit             = slogLevelCrit
)

slog.Level constants for slog-based handlers

Variables

View Source 
var (
	// TimestampFieldName is the field name used for the timestamp field.
	TimestampFieldName = "time"

	// LevelFieldName is the field name used for the level field.
	LevelFieldName = "level"

	// LevelTraceValue is the value used for the trace level field.
	LevelTraceValue = "trace"
	// LevelDebugValue is the value used for the debug level field.
	LevelDebugValue = "debug"
	// LevelInfoValue is the value used for the info level field.
	LevelInfoValue = "info"
	// LevelWarnValue is the value used for the warn level field.
	LevelWarnValue = "warn"
	// LevelErrorValue is the value used for the error level field.
	LevelErrorValue = "error"
	// LevelFatalValue is the value used for the fatal level field.
	LevelFatalValue = "fatal"
	// LevelPanicValue is the value used for the panic level field.
	LevelPanicValue = "panic"

	// LevelFieldMarshalFunc allows customization of global level field marshaling.
	LevelFieldMarshalFunc = func(l Level) string {
		return l.String()
	}

	// MessageFieldName is the field name used for the message field.
	MessageFieldName = "message"

	// ErrorFieldName is the field name used for error fields.
	ErrorFieldName = "error"

	// CallerFieldName is the field name used for caller field.
	CallerFieldName = "caller"

	// CallerSkipFrameCount is the number of stack frames to skip to find the caller.
	CallerSkipFrameCount = 2

	// CallerMarshalFunc allows customization of global caller marshaling
	CallerMarshalFunc = func(pc uintptr, file string, line int) string {
		return file + ":" + strconv.Itoa(line)
	}

	// ErrorStackFieldName is the field name used for error stacks.
	ErrorStackFieldName = "stack"

	// ErrorStackMarshaler extract the stack from err if any.
	ErrorStackMarshaler func(err error) interface{}

	// ErrorMarshalFunc allows customization of global error marshaling
	ErrorMarshalFunc = func(err error) interface{} {
		return err
	}

	// InterfaceMarshalFunc allows customization of interface marshaling.
	// Default: "encoding/json.Marshal" with disabled HTML escaping
	InterfaceMarshalFunc = func(v interface{}) ([]byte, error) {
		var buf bytes.Buffer
		encoder := json.NewEncoder(&buf)
		encoder.SetEscapeHTML(false)
		err := encoder.Encode(v)
		if err != nil {
			return nil, err
		}
		b := buf.Bytes()
		if len(b) > 0 {

			return b[:len(b)-1], nil
		}
		return b, nil
	}

	// TimeFieldFormat defines the time format of the Time field type. If set to
	// TimeFormatUnix, TimeFormatUnixMs, TimeFormatUnixMicro or TimeFormatUnixNano, the time is formatted as a UNIX
	// timestamp as integer.
	TimeFieldFormat = time.RFC3339

	// TimestampFunc defines the function called to generate a timestamp.
	TimestampFunc = time.Now

	// DurationFieldFormat defines the format of the Duration field type.
	DurationFieldFormat = DurationFormatFloat

	// DurationFieldUnit defines the unit for time.Duration type fields added
	// using the Dur method.
	DurationFieldUnit = time.Millisecond

	// DurationFieldInteger renders Dur fields as integer instead of float if
	// set to true.
	// Deprecated: use DurationFieldFormat with DurationFormatInt instead.
	DurationFieldInteger = false

	// ErrorHandler is called whenever logger fails to write an event on its
	// output. If not set, an error is printed on the stderr. This handler must
	// be thread safe and non-blocking.
	ErrorHandler func(err error)

	// DefaultContextLogger is returned from Ctx() if there is no logger associated
	// with the context.
	DefaultContextLogger Logger

	// LevelColors are used by ConsoleWriter's consoleDefaultFormatLevel to color
	// log levels.
	LevelColors = map[Level]int{
		TraceLevel: colorBlue,
		DebugLevel: colorMagenta,
		InfoLevel:  colorGreen,
		WarnLevel:  colorYellow,
		ErrorLevel: colorRed,
		FatalLevel: colorRed,
		PanicLevel: colorRed,
	}

	// FormattedLevels are used by ConsoleWriter's consoleDefaultFormatLevel
	// for a short level name.
	FormattedLevels = map[Level]string{
		TraceLevel: "trace",
		DebugLevel: "debug",
		InfoLevel:  "info",
		WarnLevel:  "warn",
		ErrorLevel: "error",
		FatalLevel: "fatal",
		PanicLevel: "panic",
	}

	// TriggerLevelWriterBufferReuseLimit is a limit in bytes that a buffer is dropped
	// from the TriggerLevelWriter buffer pool if the buffer grows above the limit.
	TriggerLevelWriterBufferReuseLimit = 64 * 1024

	// FloatingPointPrecision, if set to a value other than -1, controls the number
	// of digits when formatting float numbers in JSON. See strconv.FormatFloat for
	// more details.
	FloatingPointPrecision = -1
)
View Source 
var (
	// Often samples log every ~ 10 events.
	Often = RandomSampler(10)
	// Sometimes samples log every ~ 100 events.
	Sometimes = RandomSampler(100)
	// Rarely samples log every ~ 1000 events.
	Rarely = RandomSampler(1000)
)
View Source 
var ErrUnknownLevel = errors.New("unknown log level")

ErrUnknownLevel is returned when parsing an unknown log level string.

Functions

func ConsoleTestWriter 

func ConsoleTestWriter(t TestingLog) func(w *ConsoleWriter)

ConsoleTestWriter creates an option that correctly sets the file frame depth for testing.TB log.

func Crit 

func Crit(msg string, ctx ...interface{})

Crit is an alias for Fatal (geth compatibility)

func Debug 

func Debug(msg string, ctx ...interface{})

Debug logs at debug level with geth-style context

func DisableSampling 

func DisableSampling(v bool)

DisableSampling will disable sampling in all Loggers if true.

func DiscardHandler 

func DiscardHandler() slog.Handler

DiscardHandler returns a no-op handler.

func Error 

func Error(msg string, ctx ...interface{})

Error logs at error level with geth-style context

func Fatal 

func Fatal(msg string, ctx ...interface{})

Fatal logs at fatal level with geth-style context and exits

func FormatLogfmtUint64 

func FormatLogfmtUint64(n uint64) string

FormatLogfmtUint64 formats a uint64 as a compact logfmt string.

func FormatSlogValue 

func FormatSlogValue(v slog.Value, tmp []byte) (result []byte)

FormatSlogValue formats a slog.Value for serialization to terminal.

func FromLegacyLevel 

func FromLegacyLevel(lvl int) slog.Level

FromLegacyLevel converts old geth verbosity level to slog.Level.

func Info 

func Info(msg string, ctx ...interface{})

Info logs at info level with geth-style context

func IsInternalPackage 

func IsInternalPackage(pkg string) bool

func JSONHandler 

func JSONHandler(wr io.Writer) slog.Handler

JSONHandler returns a handler which prints records in JSON format.

func JSONHandlerWithLevel 

func JSONHandlerWithLevel(wr io.Writer, level slog.Leveler) slog.Handler

JSONHandlerWithLevel returns a JSON handler with level filtering.

func LevelAlignedString 

func LevelAlignedString(l slog.Level) string

LevelAlignedString returns a 5-character string containing the name of a level.

func LevelString 

func LevelString(l slog.Level) string

LevelString returns a string containing the name of a level.

func Log 

func Log(level Level, msg string, ctx ...interface{})

Log logs at the specified level with geth-style context

func LogfmtHandler 

func LogfmtHandler(wr io.Writer) slog.Handler

LogfmtHandler returns a handler which prints records in logfmt format.

func LogfmtHandlerWithLevel 

func LogfmtHandlerWithLevel(wr io.Writer, level slog.Leveler) slog.Handler

LogfmtHandlerWithLevel returns a logfmt handler with level filtering.

func LvlFromString 

func LvlFromString(lvlString string) (slog.Level, error)

LvlFromString returns the appropriate level from a string name.

func RegisterInternalPackages 

func RegisterInternalPackages(packages ...string)

func SetDefault 

func SetDefault(l Logger)

SetDefault sets the default logger for geth-style functions

func SetGlobalLevel 

func SetGlobalLevel(l Level)

SetGlobalLevel sets the global override for log level. If this values is raised, all Loggers will use at least this value.

To globally disable logs, set GlobalLevel to Disabled.

func SetSlogDefault 

func SetSlogDefault(l SlogLogger)

SetSlogDefault sets the default slog-based logger.

func SyncWriter 

func SyncWriter(w io.Writer) io.Writer

SyncWriter wraps w so that each call to Write is synchronized with a mutex. This syncer can be used to wrap the call to writer's Write method if it is not thread safe. Note that you do not need this wrapper for os.File Write operations on POSIX and Windows systems as they are already thread-safe.

func Trace 

func Trace(msg string, ctx ...interface{})

Trace logs at trace level with geth-style context

func Warn 

func Warn(msg string, ctx ...interface{})

Warn logs at warn level with geth-style context

func WithContext 

func WithContext(ctx context.Context, l Logger) context.Context

WithContext returns a copy of ctx with the logger attached. The Logger attached to the provided Context (if any) will not be affected.

Note: to modify the existing Logger attached to a Context (instead of replacing it in a new Context), use UpdateContext with the following notation: 

ctx := r.Context()
l := logger.Ctx(ctx)
l.UpdateContext(func(c Context) Context {
    return c.Str("bar", "baz")
})

Types

type Array 

type Array struct {
	// contains filtered or unexported fields
}

Array is used to prepopulate an array of items which can be re-used to add to log messages.

func Arr 

func Arr() *Array

Arr creates an array to be added to an Event or Context. WARNING: This function is deprecated because it does not preserve the stack, hooks, and context from the parent event. Deprecated: Use Event.CreateArray or Context.CreateArray instead.

func (*Array) Bool 

func (a *Array) Bool(b bool) *Array

Bool appends the val as a bool to the array.

func (*Array) Bytes 

func (a *Array) Bytes(val []byte) *Array

Bytes appends the val as a string to the array.

func (*Array) Dict 

func (a *Array) Dict(dict *Event) *Array

Dict adds the dict Event to the array

func (*Array) Dur 

func (a *Array) Dur(d time.Duration) *Array

Dur appends d to the array.

func (*Array) Err 

func (a *Array) Err(err error) *Array

Err serializes and appends the err to the array.

func (*Array) Errs 

func (a *Array) Errs(errs []error) *Array

Errs serializes and appends errors to the array.

func (*Array) Float32 

func (a *Array) Float32(f float32) *Array

Float32 appends f as a float32 to the array.

func (*Array) Float64 

func (a *Array) Float64(f float64) *Array

Float64 appends f as a float64 to the array.

func (*Array) Hex 

func (a *Array) Hex(val []byte) *Array

Hex appends the val as a hex string to the array.

func (*Array) IPAddr 

func (a *Array) IPAddr(ip net.IP) *Array

IPAddr adds a net.IP IPv4 or IPv6 address to the array

func (*Array) IPPrefix 

func (a *Array) IPPrefix(pfx net.IPNet) *Array

IPPrefix adds a net.IPNet IPv4 or IPv6 Prefix (IP + mask) to the array

func (*Array) Int 

func (a *Array) Int(i int) *Array

Int appends i as a int to the array.

func (*Array) Int8 

func (a *Array) Int8(i int8) *Array

Int8 appends i as a int8 to the array.

func (*Array) Int16 

func (a *Array) Int16(i int16) *Array

Int16 appends i as a int16 to the array.

func (*Array) Int32 

func (a *Array) Int32(i int32) *Array

Int32 appends i as a int32 to the array.

func (*Array) Int64 

func (a *Array) Int64(i int64) *Array

Int64 appends i as a int64 to the array.

func (*Array) Interface 

func (a *Array) Interface(i interface{}) *Array

Interface appends i marshaled using reflection.

func (*Array) MACAddr 

func (a *Array) MACAddr(ha net.HardwareAddr) *Array

MACAddr adds a net.HardwareAddr MAC (Ethernet) address to the array

func (*Array) MarshalLogArray 

func (*Array) MarshalLogArray(*Array)

MarshalLogArray method here is no-op - since data is already in the needed format.

func (*Array) Object 

func (a *Array) Object(obj LogObjectMarshaler) *Array

Object marshals an object that implement the LogObjectMarshaler interface and appends it to the array.

func (*Array) RawJSON 

func (a *Array) RawJSON(val []byte) *Array

RawJSON adds already encoded JSON to the array.

func (*Array) Str 

func (a *Array) Str(val string) *Array

Str appends the val as a string to the array.

func (*Array) Time 

func (a *Array) Time(t time.Time) *Array

Time appends t formatted as string using logger.TimeFieldFormat.

func (*Array) Type 

func (a *Array) Type(val interface{}) *Array

Type adds the val's type using reflection to the array.

func (*Array) Uint 

func (a *Array) Uint(i uint) *Array

Uint appends i as a uint to the array.

func (*Array) Uint8 

func (a *Array) Uint8(i uint8) *Array

Uint8 appends i as a uint8 to the array.

func (*Array) Uint16 

func (a *Array) Uint16(i uint16) *Array

Uint16 appends i as a uint16 to the array.

func (*Array) Uint32 

func (a *Array) Uint32(i uint32) *Array

Uint32 appends i as a uint32 to the array.

func (*Array) Uint64 

func (a *Array) Uint64(i uint64) *Array

Uint64 appends i as a uint64 to the array.

type BasicSampler 

type BasicSampler struct {
	N uint32
	// contains filtered or unexported fields
}

BasicSampler is a sampler that will send every Nth events, regardless of their level.

func (*BasicSampler) Sample 

func (s *BasicSampler) Sample(lvl Level) bool

Sample implements the Sampler interface.

type BurstSampler 

type BurstSampler struct {
	// Burst is the maximum number of event per period allowed before calling
	// NextSampler.
	Burst uint32
	// Period defines the burst period. If 0, NextSampler is always called.
	Period time.Duration
	// NextSampler is the sampler used after the burst is reached. If nil,
	// events are always rejected after the burst.
	NextSampler Sampler
	// contains filtered or unexported fields
}

BurstSampler lets Burst events pass per Period then pass the decision to NextSampler. If Sampler is not set, all subsequent events are rejected.

func (*BurstSampler) Sample 

func (s *BurstSampler) Sample(lvl Level) bool

Sample implements the Sampler interface.

type Color 

type Color int

Color represents an ANSI color code for terminal output 

const (
	Reset       Color = 0
	Bold        Color = 1
	Black       Color = 30
	Red         Color = 31
	Green       Color = 32
	Yellow      Color = 33
	Blue        Color = 34
	Purple      Color = 35
	Cyan        Color = 36
	LightGray   Color = 37
	DarkGray    Color = 90
	LightRed    Color = 91
	LightGreen  Color = 92
	LightYellow Color = 93
	LightBlue   Color = 94
	LightPurple Color = 95
	LightCyan   Color = 96
	White       Color = 97
	Orange      Color = 208 // 256-color mode orange
)

Color constants for terminal output

func (Color) Wrap 

func (c Color) Wrap(s string) string

Wrap wraps the given string with ANSI color codes

type Config 

type Config struct {
	RotatingWriterConfig

	LogLevel                Level
	DisplayLevel            Level
	LogFormat               LogFormat
	DisableWriterDisplaying bool
}

Config represents the logging configuration.

type ConsoleWriter 

type ConsoleWriter struct {
	// Out is the output destination.
	Out io.Writer

	// NoColor disables the colorized output.
	NoColor bool

	// TimeFormat specifies the format for timestamp in output.
	TimeFormat string

	// TimeLocation tells ConsoleWriter’s default FormatTimestamp
	// how to localize the time.
	TimeLocation *time.Location

	// PartsOrder defines the order of parts in output.
	PartsOrder []string

	// PartsExclude defines parts to not display in output.
	PartsExclude []string

	// FieldsOrder defines the order of contextual fields in output.
	FieldsOrder []string

	// FieldsExclude defines contextual fields to not display in output.
	FieldsExclude []string

	FormatTimestamp     Formatter
	FormatLevel         Formatter
	FormatCaller        Formatter
	FormatMessage       Formatter
	FormatFieldName     Formatter
	FormatFieldValue    Formatter
	FormatErrFieldName  Formatter
	FormatErrFieldValue Formatter
	// If this is configured it is used for "part" values and
	// has precedence on FormatFieldValue
	FormatPartValueByName FormatterByFieldName

	FormatExtra func(map[string]interface{}, *bytes.Buffer) error

	FormatPrepare func(map[string]interface{}) error
	// contains filtered or unexported fields
}

ConsoleWriter parses the JSON input and writes it in an (optionally) colorized, human-friendly format to Out.

func NewConsoleWriter 

func NewConsoleWriter(options ...func(w *ConsoleWriter)) ConsoleWriter

NewConsoleWriter creates and initializes a new ConsoleWriter.

func (ConsoleWriter) Close 

func (w ConsoleWriter) Close() error

Call the underlying writer's Close method if it is an io.Closer. Otherwise does nothing.

func (ConsoleWriter) Write 

func (w ConsoleWriter) Write(p []byte) (n int, err error)

Write transforms the JSON input with formatters and appends to w.Out.

type Context 

type Context struct {
	// contains filtered or unexported fields
}

Context configures a new sub-logger with contextual fields.

func (Context) AnErr 

func (c Context) AnErr(key string, err error) Context

AnErr adds the field key with serialized err to the logger context. If err is nil, no field is added.

func (Context) Any 

func (c Context) Any(key string, i interface{}) Context

Any is a wrapper around Context.Interface.

func (Context) Array 

func (c Context) Array(key string, arr LogArrayMarshaler) Context

Array adds the field key with an array to the event context. Use c.CreateArray() to create the array or pass a type that implement the LogArrayMarshaler interface.

func (Context) Bool 

func (c Context) Bool(key string, b bool) Context

Bool adds the field key with val as a bool to the logger context.

func (Context) Bools 

func (c Context) Bools(key string, b []bool) Context

Bools adds the field key with val as a []bool to the logger context.

func (Context) Bytes 

func (c Context) Bytes(key string, val []byte) Context

Bytes adds the field key with val as a []byte to the logger context.

func (Context) Caller 

func (c Context) Caller() Context

Caller adds the file:line of the caller with the logger.CallerFieldName key.

func (Context) CallerWithSkipFrameCount 

func (c Context) CallerWithSkipFrameCount(skipFrameCount int) Context

CallerWithSkipFrameCount adds the file:line of the caller with the logger.CallerFieldName key. The specified skipFrameCount int will override the global CallerSkipFrameCount for this context's respective logger. If set to -1 the global CallerSkipFrameCount will be used.

func (Context) CreateArray 

func (c Context) CreateArray() *Array

CreateArray creates an Array to be used with the Context.Array method. It preserves the stack, hooks, and context from the logger. Call usual field methods like Str, Int etc to add elements to this array and give it as argument the Context.Array method.

func (Context) CreateDict 

func (c Context) CreateDict() *Event

CreateDict creates an Event to be used with the Context.Dict method. It preserves the stack, hooks, and context from the logger. Call usual field methods like Str, Int etc to add fields to this event and give it as argument the Context.Dict method.

func (Context) Ctx 

func (c Context) Ctx(ctx context.Context) Context

Ctx adds the context.Context to the logger context. The context.Context is not rendered in the error message, but is made available for hooks to use. A typical use case is to extract tracing information from the context.Context.

func (Context) Dict 

func (c Context) Dict(key string, dict *Event) Context

Dict adds the field key with the dict to the logger context.

func (Context) Dur 

func (c Context) Dur(key string, d time.Duration) Context

Dur adds the field key with d divided by unit and stored as a float.

func (Context) Durs 

func (c Context) Durs(key string, d []time.Duration) Context

Durs adds the field key with d divided by unit and stored as a float.

func (Context) EmbedObject 

func (c Context) EmbedObject(obj LogObjectMarshaler) Context

EmbedObject marshals and Embeds an object that implement the LogObjectMarshaler interface.

func (Context) Err 

func (c Context) Err(err error) Context

Err adds the field "error" with serialized err to the logger context.

func (Context) Errs 

func (c Context) Errs(key string, errs []error) Context

Errs adds the field key with errs as an array of serialized errors to the logger context.

func (Context) Fields 

func (c Context) Fields(fields interface{}) Context

Fields is a helper function to use a map or slice to set fields using type assertion. Only map[string]interface{} and []interface{} are accepted. []interface{} must alternate string keys and arbitrary values, and extraneous ones are ignored.

func (Context) Float32 

func (c Context) Float32(key string, f float32) Context

Float32 adds the field key with f as a float32 to the logger context.

func (Context) Float64 

func (c Context) Float64(key string, f float64) Context

Float64 adds the field key with f as a float64 to the logger context.

func (Context) Floats32 

func (c Context) Floats32(key string, f []float32) Context

Floats32 adds the field key with f as a []float32 to the logger context.

func (Context) Floats64 

func (c Context) Floats64(key string, f []float64) Context

Floats64 adds the field key with f as a []float64 to the logger context.

func (Context) Hex 

func (c Context) Hex(key string, val []byte) Context

Hex adds the field key with val as a hex string to the logger context.

func (Context) IPAddr 

func (c Context) IPAddr(key string, ip net.IP) Context

IPAddr adds adds the field key with ip as a net.IP IPv4 or IPv6 Address to the context

func (Context) IPAddrs 

func (c Context) IPAddrs(key string, ip []net.IP) Context

IPAddrs adds the field key with ip as a []net.IP array of IPv4 or IPv6 Address to the context

func (Context) IPPrefix 

func (c Context) IPPrefix(key string, pfx net.IPNet) Context

IPPrefix adds adds the field key with pfx as a []net.IPNet IPv4 or IPv6 Prefix (address and mask) to the context

func (Context) IPPrefixes 

func (c Context) IPPrefixes(key string, pfx []net.IPNet) Context

IPPrefix adds adds the field key with pfx as a []net.IPNet array of IPv4 or IPv6 Prefix (address and mask) to the context

func (Context) Int 

func (c Context) Int(key string, i int) Context

Int adds the field key with i as a int to the logger context.

func (Context) Int8 

func (c Context) Int8(key string, i int8) Context

Int8 adds the field key with i as a int8 to the logger context.

func (Context) Int16 

func (c Context) Int16(key string, i int16) Context

Int16 adds the field key with i as a int16 to the logger context.

func (Context) Int32 

func (c Context) Int32(key string, i int32) Context

Int32 adds the field key with i as a int32 to the logger context.

func (Context) Int64 

func (c Context) Int64(key string, i int64) Context

Int64 adds the field key with i as a int64 to the logger context.

func (Context) Interface 

func (c Context) Interface(key string, i interface{}) Context

Interface adds the field key with obj marshaled using reflection.

func (Context) Ints 

func (c Context) Ints(key string, i []int) Context

Ints adds the field key with i as a []int to the logger context.

func (Context) Ints8 

func (c Context) Ints8(key string, i []int8) Context

Ints8 adds the field key with i as a []int8 to the logger context.

func (Context) Ints16 

func (c Context) Ints16(key string, i []int16) Context

Ints16 adds the field key with i as a []int16 to the logger context.

func (Context) Ints32 

func (c Context) Ints32(key string, i []int32) Context

Ints32 adds the field key with i as a []int32 to the logger context.

func (Context) Ints64 

func (c Context) Ints64(key string, i []int64) Context

Ints64 adds the field key with i as a []int64 to the logger context.

func (Context) Logger 

func (c Context) Logger() Logger

Logger returns the logger with the context previously set.

func (Context) MACAddr 

func (c Context) MACAddr(key string, ha net.HardwareAddr) Context

MACAddr adds adds the field key with ha as a net.HardwareAddr MAC address to the context

func (Context) Object 

func (c Context) Object(key string, obj LogObjectMarshaler) Context

Object marshals an object that implement the LogObjectMarshaler interface.

func (Context) Objects 

func (c Context) Objects(key string, objs []LogObjectMarshaler) Context

Object marshals an object that implement the LogObjectMarshaler interface.

func (Context) RawJSON 

func (c Context) RawJSON(key string, b []byte) Context

RawJSON adds already encoded JSON to context.

No sanity check is performed on b; it must not contain carriage returns and be valid JSON.

func (Context) Reset 

func (c Context) Reset() Context

Reset removes all the context fields.

func (Context) Stack 

func (c Context) Stack() Context

Stack enables stack trace printing for the error passed to Err().

func (Context) Str 

func (c Context) Str(key, val string) Context

Str adds the field key with val as a string to the logger context.

func (Context) Stringer 

func (c Context) Stringer(key string, val fmt.Stringer) Context

Stringer adds the field key with val.String() (or null if val is nil) to the logger context.

func (Context) Stringers 

func (c Context) Stringers(key string, vals []fmt.Stringer) Context

Stringers adds the field key with vals as an array of strings by calling .String() on each entry to the logger context.

func (Context) Strs 

func (c Context) Strs(key string, vals []string) Context

Strs adds the field key with val as a string to the logger context.

func (Context) Time 

func (c Context) Time(key string, t time.Time) Context

Time adds the field key with t formatted as string using logger.TimeFieldFormat.

func (Context) Times 

func (c Context) Times(key string, t []time.Time) Context

Times adds the field key with t formatted as string using logger.TimeFieldFormat.

func (Context) Timestamp 

func (c Context) Timestamp() Context

Timestamp adds the current local time to the logger context with the "time" key, formatted using logger.TimeFieldFormat. To customize the key name, change logger.TimestampFieldName. To customize the time format, change logger.TimeFieldFormat.

NOTE: It won't dedupe the "time" key if the *Context has one already.

func (Context) Type 

func (c Context) Type(key string, val interface{}) Context

Type adds the field key with val's type using reflection.

func (Context) Uint 

func (c Context) Uint(key string, i uint) Context

Uint adds the field key with i as a uint to the logger context.

func (Context) Uint8 

func (c Context) Uint8(key string, i uint8) Context

Uint8 adds the field key with i as a uint8 to the logger context.

func (Context) Uint16 

func (c Context) Uint16(key string, i uint16) Context

Uint16 adds the field key with i as a uint16 to the logger context.

func (Context) Uint32 

func (c Context) Uint32(key string, i uint32) Context

Uint32 adds the field key with i as a uint32 to the logger context.

func (Context) Uint64 

func (c Context) Uint64(key string, i uint64) Context

Uint64 adds the field key with i as a uint64 to the logger context.

func (Context) Uints 

func (c Context) Uints(key string, i []uint) Context

Uints adds the field key with i as a []uint to the logger context.

func (Context) Uints8 

func (c Context) Uints8(key string, i []uint8) Context

Uints8 adds the field key with i as a []uint8 to the logger context.

func (Context) Uints16 

func (c Context) Uints16(key string, i []uint16) Context

Uints16 adds the field key with i as a []uint16 to the logger context.

func (Context) Uints32 

func (c Context) Uints32(key string, i []uint32) Context

Uints32 adds the field key with i as a []uint32 to the logger context.

func (Context) Uints64 

func (c Context) Uints64(key string, i []uint64) Context

Uints64 adds the field key with i as a []uint64 to the logger context.

type DedupSampler 

type DedupSampler struct {
	// Window is the deduplication time window. Defaults to 1 minute.
	Window time.Duration
	// MaxKeys is the maximum number of unique messages to track. Defaults to 1000.
	MaxKeys int
	// contains filtered or unexported fields
}

DedupSampler suppresses duplicate log messages within a time window. After the window expires, it emits a summary of suppressed messages.

func NewDedupSampler 

func NewDedupSampler(window time.Duration) *DedupSampler

NewDedupSampler creates a dedup sampler with the given window.

func (*DedupSampler) GetSuppressedCount 

func (s *DedupSampler) GetSuppressedCount(lvl Level, msg string) int64

GetSuppressedCount returns the count of suppressed messages for a key.

func (*DedupSampler) Sample 

func (s *DedupSampler) Sample(lvl Level) bool

Sample implements the Sampler interface (always returns true for non-dedup use).

func (*DedupSampler) SampleMsg 

func (s *DedupSampler) SampleMsg(lvl Level, msg string) bool

SampleMsg returns true if this message should be logged. It tracks message hashes and suppresses duplicates within the window.

func (*DedupSampler) SampleMsgWithKey 

func (s *DedupSampler) SampleMsgWithKey(lvl Level, msg, key string) bool

SampleMsgWithKey allows specifying a custom dedup key instead of using msg.

type Event 

type Event struct {
	// contains filtered or unexported fields
}

Event represents a log event. It is instanced by one of the level method of Logger and finalized by the Msg or Msgf method.

func Dict 

func Dict() *Event

Dict creates an Event to be used with the *Event.Dict method. Call usual field methods like Str, Int etc to add fields to this event and give it as argument the *Event.Dict method. NOTE: This function is deprecated because it does not preserve the stack, hooks, and context from the parent event. Deprecated: Use Event.CreateDict instead.

func (*Event) AnErr 

func (e *Event) AnErr(key string, err error) *Event

AnErr adds the field key with serialized err to the *Event context. If err is nil, no field is added.

func (*Event) Any 

func (e *Event) Any(key string, i interface{}) *Event

Any is a wrapper around Event.Interface.

func (*Event) Array 

func (e *Event) Array(key string, arr LogArrayMarshaler) *Event

Array adds the field key with an array to the event context. Use e.CreateArray() to create the array or pass a type that implement the LogArrayMarshaler interface.

func (*Event) Bool 

func (e *Event) Bool(key string, b bool) *Event

Bool adds the field key with val as a bool to the *Event context.

func (*Event) Bools 

func (e *Event) Bools(key string, b []bool) *Event

Bools adds the field key with val as a []bool to the *Event context.

func (*Event) Bytes 

func (e *Event) Bytes(key string, val []byte) *Event

Bytes adds the field key with val as a string to the *Event context.

Runes outside of normal ASCII ranges will be hex-encoded in the resulting JSON.

func (*Event) Caller 

func (e *Event) Caller(skip ...int) *Event

Caller adds the file:line of the caller with the logger.CallerFieldName key. The argument skip is the number of stack frames to ascend Skip If not passed, use the global variable CallerSkipFrameCount

func (*Event) CallerSkipFrame 

func (e *Event) CallerSkipFrame(skip int) *Event

CallerSkipFrame instructs any future Caller calls to skip the specified number of frames. This includes those added via hooks from the context.

func (*Event) CreateArray 

func (e *Event) CreateArray() *Array

CreateArray creates an Array to be used with the *Event.Array method. It preserves the stack, hooks, and context from the parent event. Call usual field methods like Str, Int etc to add elements to this array and give it as argument the *Event.Array method.

func (*Event) CreateDict 

func (e *Event) CreateDict() *Event

CreateDict creates an Event to be used with the *Event.Dict method. It preserves the stack, hooks, and context from the parent event. Call usual field methods like Str, Int etc to add fields to this event and give it as argument the *Event.Dict method.

func (*Event) Ctx 

func (e *Event) Ctx(ctx context.Context) *Event

Ctx adds the Go Context to the *Event context. The context is not rendered in the output message, but is available to hooks and to Func() calls via the GetCtx() accessor. A typical use case is to extract tracing information from the Go Ctx.

func (*Event) Dict 

func (e *Event) Dict(key string, dict *Event) *Event

Dict adds the field key with a dict to the event context. Use e.CreateDict() to create the dictionary.

func (*Event) Discard 

func (e *Event) Discard() *Event

Discard disables the event so Msg(f) won't print it.

func (*Event) Dur 

func (e *Event) Dur(key string, d time.Duration) *Event

Dur adds the field key with duration d stored as logger.DurationFieldUnit. If logger.DurationFieldInteger is true, durations are rendered as integer instead of float.

func (*Event) Durs 

func (e *Event) Durs(key string, d []time.Duration) *Event

Durs adds the field key with duration d stored as logger.DurationFieldUnit. If logger.DurationFieldInteger is true, durations are rendered as integer instead of float.

func (*Event) EmbedObject 

func (e *Event) EmbedObject(obj LogObjectMarshaler) *Event

EmbedObject marshals an object that implement the LogObjectMarshaler interface.

func (*Event) Enabled 

func (e *Event) Enabled() bool

Enabled return false if the *Event is going to be filtered out by log level or sampling.

func (*Event) Err 

func (e *Event) Err(err error) *Event

Err adds the field "error" with serialized err to the *Event context. If err is nil, no field is added.

To customize the key name, change logger.ErrorFieldName.

If Stack() has been called before and logger.ErrorStackMarshaler is defined, the err is passed to ErrorStackMarshaler and the result is appended to the logger.ErrorStackFieldName.

func (*Event) Errs 

func (e *Event) Errs(key string, errs []error) *Event

Errs adds the field key with errs as an array of serialized errors to the *Event context.

func (*Event) Fields 

func (e *Event) Fields(fields interface{}) *Event

Fields is a helper function to use a map or slice to set fields using type assertion. Only map[string]interface{} and []interface{} are accepted. []interface{} must alternate string keys and arbitrary values, and extraneous ones are ignored.

func (*Event) Float32 

func (e *Event) Float32(key string, f float32) *Event

Float32 adds the field key with f as a float32 to the *Event context.

func (*Event) Float64 

func (e *Event) Float64(key string, f float64) *Event

Float64 adds the field key with f as a float64 to the *Event context.

func (*Event) Floats32 

func (e *Event) Floats32(key string, f []float32) *Event

Floats32 adds the field key with f as a []float32 to the *Event context.

func (*Event) Floats64 

func (e *Event) Floats64(key string, f []float64) *Event

Floats64 adds the field key with f as a []float64 to the *Event context.

func (*Event) Func 

func (e *Event) Func(f func(e *Event)) *Event

Func allows an anonymous func to run only if the event is enabled.

func (*Event) GetCtx 

func (e *Event) GetCtx() context.Context

GetCtx retrieves the Go context.Context which is optionally stored in the Event. This allows Hooks and functions passed to Func() to retrieve values which are stored in the context.Context. This can be useful in tracing, where span information is commonly propagated in the context.Context.

func (*Event) Hex 

func (e *Event) Hex(key string, val []byte) *Event

Hex adds the field key with val as a hex string to the *Event context.

func (*Event) IPAddr 

func (e *Event) IPAddr(key string, ip net.IP) *Event

IPAddr adds the field key with ip as a net.IP IPv4 or IPv6 Address to the event

func (*Event) IPAddrs 

func (e *Event) IPAddrs(key string, ip []net.IP) *Event

IPAddrs adds the field key with ip as a net.IP array of IPv4 or IPv6 Address to the event

func (*Event) IPPrefix 

func (e *Event) IPPrefix(key string, pfx net.IPNet) *Event

IPPrefix adds the field key with pfx as a net.IPNet IPv4 or IPv6 Prefix (address and mask) to the event

func (*Event) IPPrefixes 

func (e *Event) IPPrefixes(key string, pfx []net.IPNet) *Event

IPPrefixes the field key with pfx as a net.IPNet array of IPv4 or IPv6 Prefixes (address and mask) to the event

func (*Event) Int 

func (e *Event) Int(key string, i int) *Event

Int adds the field key with i as a int to the *Event context.

func (*Event) Int8 

func (e *Event) Int8(key string, i int8) *Event

Int8 adds the field key with i as a int8 to the *Event context.

func (*Event) Int16 

func (e *Event) Int16(key string, i int16) *Event

Int16 adds the field key with i as a int16 to the *Event context.

func (*Event) Int32 

func (e *Event) Int32(key string, i int32) *Event

Int32 adds the field key with i as a int32 to the *Event context.

func (*Event) Int64 

func (e *Event) Int64(key string, i int64) *Event

Int64 adds the field key with i as a int64 to the *Event context.

func (*Event) Interface 

func (e *Event) Interface(key string, i interface{}) *Event

Interface adds the field key with i marshaled using reflection.

func (*Event) Ints 

func (e *Event) Ints(key string, i []int) *Event

Ints adds the field key with i as a []int to the *Event context.

func (*Event) Ints8 

func (e *Event) Ints8(key string, i []int8) *Event

Ints8 adds the field key with i as a []int8 to the *Event context.

func (*Event) Ints16 

func (e *Event) Ints16(key string, i []int16) *Event

Ints16 adds the field key with i as a []int16 to the *Event context.

func (*Event) Ints32 

func (e *Event) Ints32(key string, i []int32) *Event

Ints32 adds the field key with i as a []int32 to the *Event context.

func (*Event) Ints64 

func (e *Event) Ints64(key string, i []int64) *Event

Ints64 adds the field key with i as a []int64 to the *Event context.

func (*Event) MACAddr 

func (e *Event) MACAddr(key string, ha net.HardwareAddr) *Event

MACAddr the field key with ha as a net.HardwareAddr MAC address to the event

func (*Event) Msg 

func (e *Event) Msg(msg string)

Msg sends the *Event with msg added as the message field if not empty.

NOTICE: once this method is called, the *Event should be disposed. Calling Msg twice can have unexpected result.

func (*Event) MsgFunc 

func (e *Event) MsgFunc(createMsg func() string)

func (*Event) Msgf 

func (e *Event) Msgf(format string, v ...interface{})

Msgf sends the event with formatted msg added as the message field if not empty.

NOTICE: once this method is called, the *Event should be disposed. Calling Msgf twice can have unexpected result.

func (*Event) Object 

func (e *Event) Object(key string, obj LogObjectMarshaler) *Event

Object marshals an object that implement the LogObjectMarshaler interface.

func (*Event) Objects 

func (e *Event) Objects(key string, objs []LogObjectMarshaler) *Event

Objects adds the field key with obj as an array of objects that implement the LogObjectMarshaler interface.

func (*Event) RawCBOR 

func (e *Event) RawCBOR(key string, b []byte) *Event

RawCBOR adds already encoded CBOR to the log line under key.

No sanity check is performed on b Note: The full featureset of CBOR is supported as data will not be mapped to json but stored as data-url

func (*Event) RawJSON 

func (e *Event) RawJSON(key string, b []byte) *Event

RawJSON adds already encoded JSON to the log line under key.

No sanity check is performed on b; it must not contain carriage returns and be valid JSON.

func (*Event) Send 

func (e *Event) Send()

Send is equivalent to calling Msg("").

NOTICE: once this method is called, the *Event should be disposed.

func (*Event) Stack 

func (e *Event) Stack() *Event

Stack enables stack trace printing for the error passed to Err().

ErrorStackMarshaler must be set for this method to do something.

func (*Event) Str 

func (e *Event) Str(key, val string) *Event

Str adds the field key with val as a string to the *Event context.

func (*Event) Stringer 

func (e *Event) Stringer(key string, val fmt.Stringer) *Event

Stringer adds the field key with val.String() (or null if val is nil) to the *Event context.

func (*Event) Stringers 

func (e *Event) Stringers(key string, vals []fmt.Stringer) *Event

Stringers adds the field key with vals where each individual val is used as val.String() (or null if val is empty) to the *Event context.

func (*Event) Strs 

func (e *Event) Strs(key string, vals []string) *Event

Strs adds the field key with vals as a []string to the *Event context.

func (*Event) Time 

func (e *Event) Time(key string, t time.Time) *Event

Time adds the field key with t formatted as string using logger.TimeFieldFormat.

func (*Event) TimeDiff 

func (e *Event) TimeDiff(key string, t time.Time, start time.Time) *Event

TimeDiff adds the field key with positive duration between time t and start. If time t is not greater than start, duration will be 0. Duration format follows the same principle as Dur().

func (*Event) Times 

func (e *Event) Times(key string, t []time.Time) *Event

Times adds the field key with t formatted as string using logger.TimeFieldFormat.

func (*Event) Timestamp 

func (e *Event) Timestamp() *Event

Timestamp adds the current local time as UNIX timestamp to the *Event context with the "time" key. To customize the key name, change logger.TimestampFieldName.

NOTE: It won't dedupe the "time" key if the *Event (or *Context) has one already.

func (*Event) Type 

func (e *Event) Type(key string, val interface{}) *Event

Type adds the field key with val's type using reflection.

func (*Event) Uint 

func (e *Event) Uint(key string, i uint) *Event

Uint adds the field key with i as a uint to the *Event context.

func (*Event) Uint8 

func (e *Event) Uint8(key string, i uint8) *Event

Uint8 adds the field key with i as a uint8 to the *Event context.

func (*Event) Uint16 

func (e *Event) Uint16(key string, i uint16) *Event

Uint16 adds the field key with i as a uint16 to the *Event context.

func (*Event) Uint32 

func (e *Event) Uint32(key string, i uint32) *Event

Uint32 adds the field key with i as a uint32 to the *Event context.

func (*Event) Uint64 

func (e *Event) Uint64(key string, i uint64) *Event

Uint64 adds the field key with i as a uint64 to the *Event context.

func (*Event) Uints 

func (e *Event) Uints(key string, i []uint) *Event

Uints adds the field key with i as a []int to the *Event context.

func (*Event) Uints8 

func (e *Event) Uints8(key string, i []uint8) *Event

Uints8 adds the field key with i as a []int8 to the *Event context.

func (*Event) Uints16 

func (e *Event) Uints16(key string, i []uint16) *Event

Uints16 adds the field key with i as a []int16 to the *Event context.

func (*Event) Uints32 

func (e *Event) Uints32(key string, i []uint32) *Event

Uints32 adds the field key with i as a []int32 to the *Event context.

func (*Event) Uints64 

func (e *Event) Uints64(key string, i []uint64) *Event

Uints64 adds the field key with i as a []int64 to the *Event context.

type Factory 

type Factory interface {
	// Make creates a new logger with the given name.
	Make(name string) (Logger, error)

	// MakeChain creates a logger for a blockchain with the given alias.
	MakeChain(alias string) (Logger, error)

	// MakeChainAndIndex creates loggers for a blockchain and its indexer.
	MakeChainAndIndex(alias string, index string) (Logger, Logger, error)

	// SetLogLevel sets the log level for a named logger.
	SetLogLevel(name string, level Level)

	// SetDisplayLevel sets the display level for a named logger.
	SetDisplayLevel(name string, level Level)

	// GetLogLevel returns the log level for a named logger.
	GetLogLevel(name string) (Level, error)

	// GetDisplayLevel returns the display level for a named logger.
	GetDisplayLevel(name string) (Level, error)

	// Close closes all log files.
	Close()
}

Factory creates loggers with shared configuration.

func NewFactory 

func NewFactory() Factory

NewFactory creates a new logger factory with default configuration.

func NewFactoryWithConfig 

func NewFactoryWithConfig(config Config) Factory

NewFactoryWithConfig creates a new logger factory with the given configuration.

type Field 

type Field struct {
	Key   string
	Value interface{}
}

Field represents a key-value pair for geth-style structured logging. This provides compatibility with go-ethereum's logging patterns.

func AnErr 

func AnErr(key string, err error) Field

func Any 

func Any(key string, val interface{}) Field

func Binary 

func Binary(key string, val []byte) Field

func Bool 

func Bool(key string, val bool) Field

func Bools 

func Bools(key string, val []bool) Field

func ByteString 

func ByteString(key string, val []byte) Field

func Dur 

func Dur(key string, val time.Duration) Field

func Duration 

func Duration(key string, val time.Duration) Field

func Durations 

func Durations(key string, val []time.Duration) Field

func Err 

func Err(err error) Field

func Float32 

func Float32(key string, val float32) Field

func Float64 

func Float64(key string, val float64) Field

func Float64s 

func Float64s(key string, val []float64) Field

func Int 

func Int(key string, val int) Field

func Int8 

func Int8(key string, val int8) Field

func Int16 

func Int16(key string, val int16) Field

func Int32 

func Int32(key string, val int32) Field

func Int64 

func Int64(key string, val int64) Field

func Int64s 

func Int64s(key string, val []int64) Field

func Ints 

func Ints(key string, val []int) Field

func NamedErr 

func NamedErr(key string, err error) Field

func Reflect 

func Reflect(key string, val interface{}) Field

Reflect returns a Field that uses reflection for complex types.

func Stack 

func Stack(key string) Field

Stack returns a Field with the current stack trace.

func Str 

func Str(key, val string) Field

Short-form aliases (matching chaining API style)

func String 

func String(key, val string) Field

Field constructors for geth-style logging

func Stringer 

func Stringer(key string, val fmt.Stringer) Field

func Strings 

func Strings(key string, val []string) Field

Slice field constructors

func Time 

func Time(key string, val time.Time) Field

func Times 

func Times(key string, val []time.Time) Field

func Uint 

func Uint(key string, val uint) Field

func Uint8 

func Uint8(key string, val uint8) Field

func Uint16 

func Uint16(key string, val uint16) Field

func Uint32 

func Uint32(key string, val uint32) Field

func Uint64 

func Uint64(key string, val uint64) Field

func Uint64s 

func Uint64s(key string, val []uint64) Field

func UserString 

func UserString(key, val string) Field

UserString returns a Field for user-provided string values. This is the same as String but semantically indicates user input.

type FilteredLevelWriter 

type FilteredLevelWriter struct {
	Writer LevelWriter
	Level  Level
}

FilteredLevelWriter writes only logs at Level or above to Writer.

It should be used only in combination with MultiLevelWriter when you want to write to multiple destinations at different levels. Otherwise you should just set the level on the logger and filter events early. When using MultiLevelWriter then you set the level on the logger to the lowest of the levels you use for writers.

func (*FilteredLevelWriter) Close 

func (w *FilteredLevelWriter) Close() error

Call the underlying writer's Close method if it is an io.Closer. Otherwise does nothing.

func (*FilteredLevelWriter) Write 

func (w *FilteredLevelWriter) Write(p []byte) (int, error)

Write writes to the underlying Writer.

func (*FilteredLevelWriter) WriteLevel 

func (w *FilteredLevelWriter) WriteLevel(level Level, p []byte) (int, error)

WriteLevel calls WriteLevel of the underlying Writer only if the level is equal or above the Level.

type Formatter 

type Formatter func(interface{}) string

Formatter transforms the input into a formatted string.

type FormatterByFieldName 

type FormatterByFieldName func(interface{}, string) string

FormatterByFieldName transforms the input into a formatted string, being able to differentiate formatting based on field name.

type GlogHandler 

type GlogHandler struct {
	// contains filtered or unexported fields
}

GlogHandler is a log handler that mimics glog behavior.

func NewGlogHandler 

func NewGlogHandler(h slog.Handler) *GlogHandler

NewGlogHandler creates a GlogHandler wrapping the given handler.

func (*GlogHandler) Enabled 

func (h *GlogHandler) Enabled(ctx context.Context, level slog.Level) bool

func (*GlogHandler) Handle 

func (h *GlogHandler) Handle(ctx context.Context, r slog.Record) error

func (*GlogHandler) Verbosity 

func (h *GlogHandler) Verbosity(level slog.Level)

Verbosity sets the global verbosity level.

func (*GlogHandler) Vmodule 

func (h *GlogHandler) Vmodule(pattern string) error

Vmodule sets per-module verbosity patterns.

func (*GlogHandler) WithAttrs 

func (h *GlogHandler) WithAttrs(attrs []slog.Attr) slog.Handler

func (*GlogHandler) WithGroup 

func (h *GlogHandler) WithGroup(name string) slog.Handler

type Hook 

type Hook interface {
	// Run runs the hook with the event.
	Run(e *Event, level Level, message string)
}

Hook defines an interface to a log hook.

type HookFunc 

type HookFunc func(e *Event, level Level, message string)

HookFunc is an adaptor to allow the use of an ordinary function as a Hook.

func (HookFunc) Run 

func (h HookFunc) Run(e *Event, level Level, message string)

Run implements the Hook interface.

type Level 

type Level int8

Level defines log levels. 

const (
	// DebugLevel defines debug log level.
	DebugLevel Level = iota
	// InfoLevel defines info log level.
	InfoLevel
	// WarnLevel defines warn log level.
	WarnLevel
	// ErrorLevel defines error log level.
	ErrorLevel
	// FatalLevel defines fatal log level.
	FatalLevel
	// PanicLevel defines panic log level.
	PanicLevel
	// NoLevel defines an absent log level.
	NoLevel
	// Disabled disables the logger.
	Disabled

	// TraceLevel defines trace level.
	TraceLevel Level = -1
)
const (
	LevelTrace Level = TraceLevel
	LevelDebug Level = DebugLevel
	LevelInfo  Level = InfoLevel
	LevelWarn  Level = WarnLevel
	LevelError Level = ErrorLevel
	LevelCrit  Level = FatalLevel

	// Aliases for backward compatibility
	LvlTrace = LevelTrace
	LvlInfo  = LevelInfo
	LvlDebug = LevelDebug
)

Level aliases for geth/logger compatibility. These are logger.Level type (int8) for use with Logger.Enabled().

func GlobalLevel 

func GlobalLevel() Level

GlobalLevel returns the current global log level

func ParseLevel 

func ParseLevel(levelStr string) (Level, error)

ParseLevel converts a level string into a logger Level value.

func ToLevel 

func ToLevel(s string) (Level, error)

ToLevel parses a level string and returns the corresponding Level.

func (Level) MarshalText 

func (l Level) MarshalText() ([]byte, error)

MarshalText implements encoding.TextMarshaler

func (Level) String 

func (l Level) String() string

func (*Level) UnmarshalText 

func (l *Level) UnmarshalText(text []byte) error

UnmarshalText implements encoding.TextUnmarshaler

type LevelHook 

type LevelHook struct {
	NoLevelHook, TraceHook, DebugHook, InfoHook, WarnHook, ErrorHook, FatalHook, PanicHook Hook
}

LevelHook applies a different hook for each level.

func NewLevelHook 

func NewLevelHook() LevelHook

NewLevelHook returns a new LevelHook.

func (LevelHook) Run 

func (h LevelHook) Run(e *Event, level Level, message string)

Run implements the Hook interface.

type LevelSampler 

type LevelSampler struct {
	TraceSampler, DebugSampler, InfoSampler, WarnSampler, ErrorSampler Sampler
}

LevelSampler applies a different sampler for each level.

func (LevelSampler) Sample 

func (s LevelSampler) Sample(lvl Level) bool

type LevelWriter 

type LevelWriter interface {
	io.Writer
	WriteLevel(level Level, p []byte) (n int, err error)
}

LevelWriter defines as interface a writer may implement in order to receive level information with payload.

func MultiLevelWriter 

func MultiLevelWriter(writers ...io.Writer) LevelWriter

MultiLevelWriter creates a writer that duplicates its writes to all the provided writers, similar to the Unix tee(1) command. If some writers implement LevelWriter, their WriteLevel method will be used instead of Write.

type LevelWriterAdapter 

type LevelWriterAdapter struct {
	io.Writer
}

LevelWriterAdapter adapts an io.Writer to support the LevelWriter interface.

func (LevelWriterAdapter) Close 

func (lw LevelWriterAdapter) Close() error

Call the underlying writer's Close method if it is an io.Closer. Otherwise does nothing.

func (LevelWriterAdapter) WriteLevel 

func (lw LevelWriterAdapter) WriteLevel(l Level, p []byte) (n int, err error)

WriteLevel simply writes everything to the adapted writer, ignoring the level.

type LogArrayMarshaler 

type LogArrayMarshaler interface {
	MarshalLogArray(a *Array)
}

LogArrayMarshaler provides a strongly-typed and encoding-agnostic interface to be implemented by types used with Event/Context's Array methods.

type LogFormat 

type LogFormat int

LogFormat represents the format of log output. 

const (
	// Plain is plain text format.
	Plain LogFormat = iota
	// JSON is JSON format.
	JSON
	// Auto detects terminal and uses colors if appropriate.
	Auto
	// Colors forces color output.
	Colors
)

func ToFormat 

func ToFormat(s string, fd uintptr) (LogFormat, error)

ToFormat parses a format string and returns the corresponding LogFormat. The fd parameter is reserved for future use (e.g., terminal detection).

type LogObjectMarshaler 

type LogObjectMarshaler interface {
	MarshalLogObject(e *Event)
}

LogObjectMarshaler provides a strongly-typed and encoding-agnostic interface to be implemented by types used with Event/Context's Object methods.

type Logger 

type Logger interface {
	// Geth-style variadic logging methods
	Trace(msg string, ctx ...interface{})
	Debug(msg string, ctx ...interface{})
	Info(msg string, ctx ...interface{})
	Warn(msg string, ctx ...interface{})
	Error(msg string, ctx ...interface{})
	Fatal(msg string, ctx ...interface{})
	Panic(msg string, ctx ...interface{})
	Crit(msg string, ctx ...interface{})
	Verbo(msg string, ctx ...interface{})
	Log(level Level, msg string, ctx ...interface{})

	// Context/child loggers
	With() Context
	New(ctx ...interface{}) Logger
	Output(w io.Writer) Logger

	// Level control
	Level(lvl Level) Logger
	GetLevel() Level
	Enabled(ctx context.Context, level slog.Level) bool

	// Zero-allocation event-based logging
	TraceEvent() *Event
	DebugEvent() *Event
	InfoEvent() *Event
	WarnEvent() *Event
	ErrorEvent() *Event
	FatalEvent() *Event
	PanicEvent() *Event
	Err(err error) *Event
	WithLevel(level Level) *Event
	LogEvent() *Event

	// Utilities
	Sample(s Sampler) Logger
	Hook(hooks ...Hook) Logger
	Print(v ...interface{})
	Printf(format string, v ...interface{})
	Write(p []byte) (n int, err error)

	// Configuration
	SetLogLevel(level string) error
	RecoverAndPanic(fn func())

	// IsZero returns true if the logger is disabled or uninitialized.
	IsZero() bool
}

Logger is the primary logging interface. All logging implementations satisfy this interface. Use == nil to check for uninitialized loggers.

func Ctx 

func Ctx(ctx context.Context) Logger

Ctx returns the Logger associated with the ctx. If no logger is associated, DefaultContextLogger is returned, unless DefaultContextLogger is nil, in which case a disabled logger is returned.

func Default 

func Default() Logger

Default returns the default logger (alias for Root)

func InitLogger 

func InitLogger(chainAlias string, logLevel string, jsonFormat bool, writer io.Writer) (Logger, error)

InitLogger creates a new logger with the specified configuration. This is used by EVM to initialize the VM logger.

func New 

func New(ctx ...interface{}) Logger

New creates a new logger with optional context key-value pairs. Usage: log.New("component", "myapp", "version", "1.0")

func NewNoOpLogger 

func NewNoOpLogger() Logger

NewNoOpLogger returns a disabled logger.

func NewTestLogger 

func NewTestLogger(level ...Level) Logger

NewTestLogger returns a logger suitable for testing. If a level is provided, the logger is set to that level.

func NewWriter 

func NewWriter(w io.Writer) Logger

NewWriter creates a logger with a specific output writer.

func Noop 

func Noop() Logger

Noop returns a disabled logger. Use this for optional logger parameters. Example: func DoWork(logger log.Logger) { if logger == nil { logger = log.Noop() } }

func Root 

func Root() Logger

Root returns the default logger

type NoLog 

type NoLog struct{}

NoLog is a no-op logger for use in tests or when logging is disabled.

func (NoLog) Crit 

func (NoLog) Crit(string, ...interface{})

func (NoLog) Debug 

func (NoLog) Debug(string, ...interface{})

func (NoLog) DebugEvent 

func (NoLog) DebugEvent() *Event

func (NoLog) Enabled 

func (NoLog) Enabled(context.Context, slog.Level) bool

func (NoLog) Err 

func (NoLog) Err(error) *Event

func (NoLog) Error 

func (NoLog) Error(string, ...interface{})

func (NoLog) ErrorEvent 

func (NoLog) ErrorEvent() *Event

func (NoLog) Fatal 

func (NoLog) Fatal(string, ...interface{})

func (NoLog) FatalEvent 

func (NoLog) FatalEvent() *Event

func (NoLog) GetLevel 

func (NoLog) GetLevel() Level

func (NoLog) Hook 

func (NoLog) Hook(...Hook) Logger

func (NoLog) Info 

func (NoLog) Info(string, ...interface{})

func (NoLog) InfoEvent 

func (NoLog) InfoEvent() *Event

func (NoLog) IsZero 

func (NoLog) IsZero() bool

func (NoLog) Level 

func (NoLog) Level(Level) Logger

func (NoLog) Log 

func (NoLog) Log(Level, string, ...interface{})

func (NoLog) LogEvent 

func (NoLog) LogEvent() *Event

func (NoLog) New 

func (NoLog) New(...interface{}) Logger

func (NoLog) Output 

func (NoLog) Output(io.Writer) Logger

func (NoLog) Panic 

func (NoLog) Panic(string, ...interface{})

func (NoLog) PanicEvent 

func (NoLog) PanicEvent() *Event

func (NoLog) Print 

func (NoLog) Print(...interface{})

func (NoLog) Printf 

func (NoLog) Printf(string, ...interface{})

func (NoLog) RecoverAndPanic 

func (NoLog) RecoverAndPanic(fn func())

func (NoLog) Sample 

func (NoLog) Sample(Sampler) Logger

func (NoLog) SetLogLevel 

func (NoLog) SetLogLevel(string) error

func (NoLog) Trace 

func (NoLog) Trace(string, ...interface{})

func (NoLog) TraceEvent 

func (NoLog) TraceEvent() *Event

func (NoLog) Verbo 

func (NoLog) Verbo(string, ...interface{})

func (NoLog) Warn 

func (NoLog) Warn(string, ...interface{})

func (NoLog) WarnEvent 

func (NoLog) WarnEvent() *Event

func (NoLog) With 

func (NoLog) With() Context

func (NoLog) WithLevel 

func (NoLog) WithLevel(Level) *Event

func (NoLog) Write 

func (NoLog) Write(p []byte) (int, error)

type RandomSampler 

type RandomSampler uint32

RandomSampler use a PRNG to randomly sample an event out of N events, regardless of their level.

func (RandomSampler) Sample 

func (s RandomSampler) Sample(lvl Level) bool

Sample implements the Sampler interface.

type RotatingWriterConfig 

type RotatingWriterConfig struct {
	Directory string // Directory to write log files
	MaxSize   int    // Maximum size in megabytes before rotating
	MaxFiles  int    // Maximum number of old log files to retain
	MaxAge    int    // Maximum number of days to retain old log files
	Compress  bool   // Whether to compress old log files
}

RotatingWriterConfig configures a rotating log file writer.

type Sampler 

type Sampler interface {
	// Sample returns true if the event should be part of the sample, false if
	// the event should be dropped.
	Sample(lvl Level) bool
}

Sampler defines an interface to a log sampler.

type SlogLogger 

type SlogLogger interface {
	With(ctx ...interface{}) SlogLogger
	New(ctx ...interface{}) SlogLogger
	Log(level slog.Level, msg string, ctx ...interface{})
	Trace(msg string, ctx ...interface{})
	Debug(msg string, ctx ...interface{})
	Info(msg string, ctx ...interface{})
	Warn(msg string, ctx ...interface{})
	Error(msg string, ctx ...interface{})
	Crit(msg string, ctx ...interface{})
	Write(level slog.Level, msg string, attrs ...interface{})
	Enabled(ctx context.Context, level slog.Level) bool
	Handler() slog.Handler
}

SlogLogger is a Logger interface that wraps slog for geth compatibility.

func NewLogger 

func NewLogger(h slog.Handler) SlogLogger

NewLogger creates a new SlogLogger with the given handler.

func NewLoggerFromHandler 

func NewLoggerFromHandler(h slog.Handler) SlogLogger

NewLoggerFromHandler creates a new SlogLogger from a slog.Handler.

func SetupTerminalLogger 

func SetupTerminalLogger(level slog.Level) SlogLogger

SetupTerminalLogger sets up a terminal logger with color support.

func SlogRoot 

func SlogRoot() SlogLogger

SlogRoot returns the root slog-based logger.

type TerminalHandler 

type TerminalHandler struct {
	Prefix func(r slog.Record) string
	// contains filtered or unexported fields
}

TerminalHandler formats log records for human readability on a terminal.

func NewTerminalHandler 

func NewTerminalHandler(wr io.Writer, useColor bool) *TerminalHandler

NewTerminalHandler returns a handler which formats log records for human readability.

func NewTerminalHandlerWithLevel 

func NewTerminalHandlerWithLevel(wr io.Writer, lvl slog.Leveler, useColor bool) *TerminalHandler

NewTerminalHandlerWithLevel returns a terminal handler with level filtering.

func (*TerminalHandler) Enabled 

func (h *TerminalHandler) Enabled(_ context.Context, level slog.Level) bool

func (*TerminalHandler) Handle 

func (h *TerminalHandler) Handle(_ context.Context, r slog.Record) error

func (*TerminalHandler) ResetFieldPadding 

func (h *TerminalHandler) ResetFieldPadding()

func (*TerminalHandler) WithAttrs 

func (h *TerminalHandler) WithAttrs(attrs []slog.Attr) slog.Handler

func (*TerminalHandler) WithGroup 

func (h *TerminalHandler) WithGroup(name string) slog.Handler

type TerminalStringer 

type TerminalStringer interface {
	TerminalString() string
}

TerminalStringer is an interface for custom terminal serialization.

type TestWriter 

type TestWriter struct {
	T TestingLog

	// Frame skips caller frames to capture the original file and line numbers.
	Frame int
}

TestWriter is a writer that writes to testing.TB.

func NewTestWriter 

func NewTestWriter(t TestingLog) TestWriter

NewTestWriter creates a writer that logs to the testing.TB.

func (TestWriter) Write 

func (t TestWriter) Write(p []byte) (n int, err error)

Write to testing.TB.

type TestingLog 

type TestingLog interface {
	Log(args ...interface{})
	Logf(format string, args ...interface{})
	Helper()
}

TestingLog is the logging interface of testing.TB.

type TriggerLevelWriter 

type TriggerLevelWriter struct {
	// Destination writer. If LevelWriter is provided (usually), its WriteLevel is used
	// instead of Write.
	io.Writer

	// ConditionalLevel is the level (and below) at which lines are buffered until
	// a trigger level (or higher) line is emitted. Usually this is set to DebugLevel.
	ConditionalLevel Level

	// TriggerLevel is the lowest level that triggers the sending of the conditional
	// level lines. Usually this is set to ErrorLevel.
	TriggerLevel Level
	// contains filtered or unexported fields
}

TriggerLevelWriter buffers log lines at the ConditionalLevel or below until a trigger level (or higher) line is emitted. Log lines with level higher than ConditionalLevel are always written out to the destination writer. If trigger never happens, buffered log lines are never written out.

It can be used to configure "log level per request".

func (*TriggerLevelWriter) Close 

func (w *TriggerLevelWriter) Close() error

Close closes the writer and returns the buffer to the pool.

func (*TriggerLevelWriter) Trigger 

func (w *TriggerLevelWriter) Trigger() error

Trigger forces flushing the buffer and change the trigger state to triggered, if the writer has not already been triggered before.

func (*TriggerLevelWriter) WriteLevel 

func (w *TriggerLevelWriter) WriteLevel(l Level, p []byte) (n int, err error)

Source Files

View all Source files

Directories

Path Synopsis
internal
json
Package level provides log level constants for compatibility with existing code.
 Package level provides log level constants for compatibility with existing code.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.