README
Zero Allocation JSON Logger
The zerolog package provides a fast and simple logger dedicated to JSON output.
Zerolog's API is designed to provide both a great developer experience and stunning performance. Its unique chaining API allows zerolog to write JSON (or CBOR) log events by avoiding allocations and reflection.
Uber's zap library pioneered this approach. Zerolog is taking this concept to the next level with a simpler to use API and even better performance.
To keep the code base and the API simple, zerolog focuses on efficient structured logging only. Pretty logging on the console is made possible using the provided (but inefficient) zerolog.ConsoleWriter
.
Who uses zerolog
Find out who uses zerolog and add your company / project to the list.
Features
- Blazing fast
- Low to zero allocation
- Level logging
- Sampling
- Hooks
- Contextual fields
context.Context
integrationnet/http
helpers- JSON and CBOR encoding formats
- Pretty logging for development
Installation
go get -u github.com/rs/zerolog/log
Getting Started
Simple Logging Example
For simple logging, import the global logger package github.com/rs/zerolog/log
package main
import (
"github.com/rs/zerolog"
"github.com/rs/zerolog/log"
)
func main() {
// UNIX Time is faster and smaller than most timestamps
// If you set zerolog.TimeFieldFormat to an empty string,
// logs will write with UNIX time
zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
log.Print("hello world")
}
// Output: {"time":1516134303,"level":"debug","message":"hello world"}
Note: By default log writes to
os.Stderr
Note: The default log level forlog.Print
is debug
Contextual Logging
zerolog allows data to be added to log messages in the form of key:value pairs. The data added to the message adds "context" about the log event that can be critical for debugging as well as myriad other purposes. An example of this is below:
package main
import (
"github.com/rs/zerolog"
"github.com/rs/zerolog/log"
)
func main() {
zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
log.Debug().
Str("Scale", "833 cents").
Float64("Interval", 833.09).
Msg("Fibonacci is everywhere")
log.Debug().
Str("Name", "Tom").
Send()
}
// Output: {"level":"debug","Scale":"833 cents","Interval":833.09,"time":1562212768,"message":"Fibonacci is everywhere"}
// Output: {"level":"debug","Name":"Tom","time":1562212768}
You'll note in the above example that when adding contextual fields, the fields are strongly typed. You can find the full list of supported fields here
Leveled Logging
Simple Leveled Logging Example
package main
import (
"github.com/rs/zerolog"
"github.com/rs/zerolog/log"
)
func main() {
zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
log.Info().Msg("hello world")
}
// Output: {"time":1516134303,"level":"info","message":"hello world"}
It is very important to note that when using the zerolog chaining API, as shown above (
log.Info().Msg("hello world"
), the chain must have either theMsg
orMsgf
method call. If you forget to add either of these, the log will not occur and there is no compile time error to alert you of this.
zerolog allows for logging at the following levels (from highest to lowest):
- panic (
zerolog.PanicLevel
, 5) - fatal (
zerolog.FatalLevel
, 4) - error (
zerolog.ErrorLevel
, 3) - warn (
zerolog.WarnLevel
, 2) - info (
zerolog.InfoLevel
, 1) - debug (
zerolog.DebugLevel
, 0) - trace (
zerolog.TraceLevel
, -1)
You can set the Global logging level to any of these options using the SetGlobalLevel
function in the zerolog package, passing in one of the given constants above, e.g. zerolog.InfoLevel
would be the "info" level. Whichever level is chosen, all logs with a level greater than or equal to that level will be written. To turn off logging entirely, pass the zerolog.Disabled
constant.
Setting Global Log Level
This example uses command-line flags to demonstrate various outputs depending on the chosen log level.
package main
import (
"flag"
"github.com/rs/zerolog"
"github.com/rs/zerolog/log"
)
func main() {
zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
debug := flag.Bool("debug", false, "sets log level to debug")
flag.Parse()
// Default level for this example is info, unless debug flag is present
zerolog.SetGlobalLevel(zerolog.InfoLevel)
if *debug {
zerolog.SetGlobalLevel(zerolog.DebugLevel)
}
log.Debug().Msg("This message appears only when log level set to Debug")
log.Info().Msg("This message appears when log level set to Debug or Info")
if e := log.Debug(); e.Enabled() {
// Compute log output only if enabled.
value := "bar"
e.Str("foo", value).Msg("some debug message")
}
}
Info Output (no flag)
$ ./logLevelExample
{"time":1516387492,"level":"info","message":"This message appears when log level set to Debug or Info"}
Debug Output (debug flag set)
$ ./logLevelExample -debug
{"time":1516387573,"level":"debug","message":"This message appears only when log level set to Debug"}
{"time":1516387573,"level":"info","message":"This message appears when log level set to Debug or Info"}
{"time":1516387573,"level":"debug","foo":"bar","message":"some debug message"}
Logging without Level or Message
You may choose to log without a specific level by using the Log
method. You may also write without a message by setting an empty string in the msg string
parameter of the Msg
method. Both are demonstrated in the example below.
package main
import (
"github.com/rs/zerolog"
"github.com/rs/zerolog/log"
)
func main() {
zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
log.Log().
Str("foo", "bar").
Msg("")
}
// Output: {"time":1494567715,"foo":"bar"}
Logging Fatal Messages
package main
import (
"errors"
"github.com/rs/zerolog"
"github.com/rs/zerolog/log"
)
func main() {
err := errors.New("A repo man spends his life getting into tense situations")
service := "myservice"
zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
log.Fatal().
Err(err).
Str("service", service).
Msgf("Cannot start %s", service)
}
// Output: {"time":1516133263,"level":"fatal","error":"A repo man spends his life getting into tense situations","service":"myservice","message":"Cannot start myservice"}
// exit status 1
NOTE: Using
Msgf
generates one allocation even when the logger is disabled.
Create logger instance to manage different outputs
logger := zerolog.New(os.Stderr).With().Timestamp().Logger()
logger.Info().Str("foo", "bar").Msg("hello world")
// Output: {"level":"info","time":1494567715,"message":"hello world","foo":"bar"}
Sub-loggers let you chain loggers with additional context
sublogger := log.With().
Str("component", "foo").
Logger()
sublogger.Info().Msg("hello world")
// Output: {"level":"info","time":1494567715,"message":"hello world","component":"foo"}
Pretty logging
To log a human-friendly, colorized output, use zerolog.ConsoleWriter
:
log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stderr})
log.Info().Str("foo", "bar").Msg("Hello world")
// Output: 3:04PM INF Hello World foo=bar
To customize the configuration and formatting:
output := zerolog.ConsoleWriter{Out: os.Stdout, TimeFormat: time.RFC3339}
output.FormatLevel = func(i interface{}) string {
return strings.ToUpper(fmt.Sprintf("| %-6s|", i))
}
output.FormatMessage = func(i interface{}) string {
return fmt.Sprintf("***%s****", i)
}
output.FormatFieldName = func(i interface{}) string {
return fmt.Sprintf("%s:", i)
}
output.FormatFieldValue = func(i interface{}) string {
return strings.ToUpper(fmt.Sprintf("%s", i))
}
log := zerolog.New(output).With().Timestamp().Logger()
log.Info().Str("foo", "bar").Msg("Hello World")
// Output: 2006-01-02T15:04:05Z07:00 | INFO | ***Hello World**** foo:BAR
Sub dictionary
log.Info().
Str("foo", "bar").
Dict("dict", zerolog.Dict().
Str("bar", "baz").
Int("n", 1),
).Msg("hello world")
// Output: {"level":"info","time":1494567715,"foo":"bar","dict":{"bar":"baz","n":1},"message":"hello world"}
Customize automatic field names
zerolog.TimestampFieldName = "t"
zerolog.LevelFieldName = "l"
zerolog.MessageFieldName = "m"
log.Info().Msg("hello world")
// Output: {"l":"info","t":1494567715,"m":"hello world"}
Add contextual fields to the global logger
log.Logger = log.With().Str("foo", "bar").Logger()
Add file and line number to log
log.Logger = log.With().Caller().Logger()
log.Info().Msg("hello world")
// Output: {"level": "info", "message": "hello world", "caller": "/go/src/your_project/some_file:21"}
Thread-safe, lock-free, non-blocking writer
If your writer might be slow or not thread-safe and you need your log producers to never get slowed down by a slow writer, you can use a diode.Writer
as follow:
wr := diode.NewWriter(os.Stdout, 1000, 10*time.Millisecond, func(missed int) {
fmt.Printf("Logger Dropped %d messages", missed)
})
log := zerolog.New(wr)
log.Print("test")
You will need to install code.cloudfoundry.org/go-diodes
to use this feature.
Log Sampling
sampled := log.Sample(&zerolog.BasicSampler{N: 10})
sampled.Info().Msg("will be logged every 10 messages")
// Output: {"time":1494567715,"level":"info","message":"will be logged every 10 messages"}
More advanced sampling:
// Will let 5 debug messages per period of 1 second.
// Over 5 debug message, 1 every 100 debug messages are logged.
// Other levels are not sampled.
sampled := log.Sample(zerolog.LevelSampler{
DebugSampler: &zerolog.BurstSampler{
Burst: 5,
Period: 1*time.Second,
NextSampler: &zerolog.BasicSampler{N: 100},
},
})
sampled.Debug().Msg("hello world")
// Output: {"time":1494567715,"level":"debug","message":"hello world"}
Hooks
type SeverityHook struct{}
func (h SeverityHook) Run(e *zerolog.Event, level zerolog.Level, msg string) {
if level != zerolog.NoLevel {
e.Str("severity", level.String())
}
}
hooked := log.Hook(SeverityHook{})
hooked.Warn().Msg("")
// Output: {"level":"warn","severity":"warn"}
Pass a sub-logger by context
ctx := log.With().Str("component", "module").Logger().WithContext(ctx)
log.Ctx(ctx).Info().Msg("hello world")
// Output: {"component":"module","level":"info","message":"hello world"}
Set as standard logger output
log := zerolog.New(os.Stdout).With().
Str("foo", "bar").
Logger()
stdlog.SetFlags(0)
stdlog.SetOutput(log)
stdlog.Print("hello world")
// Output: {"foo":"bar","message":"hello world"}
Integration with net/http
The github.com/rs/zerolog/hlog
package provides some helpers to integrate zerolog with http.Handler
.
In this example we use alice to install logger for better readability.
log := zerolog.New(os.Stdout).With().
Timestamp().
Str("role", "my-service").
Str("host", host).
Logger()
c := alice.New()
// Install the logger handler with default output on the console
c = c.Append(hlog.NewHandler(log))
// Install some provided extra handler to set some request's context fields.
// Thanks to that handler, all our logs will come with some prepopulated fields.
c = c.Append(hlog.AccessHandler(func(r *http.Request, status, size int, duration time.Duration) {
hlog.FromRequest(r).Info().
Str("method", r.Method).
Stringer("url", r.URL).
Int("status", status).
Int("size", size).
Dur("duration", duration).
Msg("")
}))
c = c.Append(hlog.RemoteAddrHandler("ip"))
c = c.Append(hlog.UserAgentHandler("user_agent"))
c = c.Append(hlog.RefererHandler("referer"))
c = c.Append(hlog.RequestIDHandler("req_id", "Request-Id"))
// Here is your final handler
h := c.Then(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Get the logger from the request's context. You can safely assume it
// will be always there: if the handler is removed, hlog.FromRequest
// will return a no-op logger.
hlog.FromRequest(r).Info().
Str("user", "current user").
Str("status", "ok").
Msg("Something happened")
// Output: {"level":"info","time":"2001-02-03T04:05:06Z","role":"my-service","host":"local-hostname","req_id":"b4g0l5t6tfid6dtrapu0","user":"current user","status":"ok","message":"Something happened"}
}))
http.Handle("/", h)
if err := http.ListenAndServe(":8080", nil); err != nil {
log.Fatal().Err(err).Msg("Startup failed")
}
Multiple Log Output
zerolog.MultiLevelWriter
may be used to send the log message to multiple outputs.
In this example, we send the log message to both os.Stdout
and the in-built ConsoleWriter.
func main() {
consoleWriter := zerolog.ConsoleWriter{Out: os.Stdout}
multi := zerolog.MultiLevelWriter(consoleWriter, os.Stdout)
logger := zerolog.New(multi).With().Timestamp().Logger()
logger.Info().Msg("Hello World!")
}
// Output (Line 1: Console; Line 2: Stdout)
// 12:36PM INF Hello World!
// {"level":"info","time":"2019-11-07T12:36:38+03:00","message":"Hello World!"}
Global Settings
Some settings can be changed and will by applied to all loggers:
log.Logger
: You can set this value to customize the global logger (the one used by package level methods).zerolog.SetGlobalLevel
: Can raise the minimum level of all loggers. Call this withzerolog.Disabled
to disable logging altogether (quiet mode).zerolog.DisableSampling
: If argument istrue
, all sampled loggers will stop sampling and issue 100% of their log events.zerolog.TimestampFieldName
: Can be set to customizeTimestamp
field name.zerolog.LevelFieldName
: Can be set to customize level field name.zerolog.MessageFieldName
: Can be set to customize message field name.zerolog.ErrorFieldName
: Can be set to customizeErr
field name.zerolog.TimeFieldFormat
: Can be set to customizeTime
field value formatting. If set withzerolog.TimeFormatUnix
,zerolog.TimeFormatUnixMs
orzerolog.TimeFormatUnixMicro
, times are formated as UNIX timestamp.zerolog.DurationFieldUnit
: Can be set to customize the unit for time.Duration type fields added byDur
(default:time.Millisecond
).zerolog.DurationFieldInteger
: If set totrue
,Dur
fields are formatted as integers instead of floats (default:false
).zerolog.ErrorHandler
: Called whenever zerolog 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.
Field Types
Standard Types
Str
Bool
Int
,Int8
,Int16
,Int32
,Int64
Uint
,Uint8
,Uint16
,Uint32
,Uint64
Float32
,Float64
Advanced Fields
Err
: Takes anerror
and renders it as a string using thezerolog.ErrorFieldName
field name.Timestamp
: Inserts a timestamp field withzerolog.TimestampFieldName
field name, formatted usingzerolog.TimeFieldFormat
.Time
: Adds a field with time formatted withzerolog.TimeFieldFormat
.Dur
: Adds a field withtime.Duration
.Dict
: Adds a sub-key/value as a field of the event.RawJSON
: Adds a field with an already encoded JSON ([]byte
)Hex
: Adds a field with value formatted as a hexadecimal string ([]byte
)Interface
: Uses reflection to marshal the type.
Most fields are also available in the slice format (Strs
for []string
, Errs
for []error
etc.)
Binary Encoding
In addition to the default JSON encoding, zerolog
can produce binary logs using CBOR encoding. The choice of encoding can be decided at compile time using the build tag binary_log
as follows:
go build -tags binary_log .
To Decode binary encoded log files you can use any CBOR decoder. One has been tested to work with zerolog library is CSD.
Related Projects
- grpc-zerolog: Implementation of
grpclog.LoggerV2
interface usingzerolog
Benchmarks
See logbench for more comprehensive and up-to-date benchmarks.
All operations are allocation free (those numbers include JSON encoding):
BenchmarkLogEmpty-8 100000000 19.1 ns/op 0 B/op 0 allocs/op
BenchmarkDisabled-8 500000000 4.07 ns/op 0 B/op 0 allocs/op
BenchmarkInfo-8 30000000 42.5 ns/op 0 B/op 0 allocs/op
BenchmarkContextFields-8 30000000 44.9 ns/op 0 B/op 0 allocs/op
BenchmarkLogFields-8 10000000 184 ns/op 0 B/op 0 allocs/op
There are a few Go logging benchmarks and comparisons that include zerolog.
Using Uber's zap comparison benchmark:
Log a message and 10 fields:
Library | Time | Bytes Allocated | Objects Allocated |
---|---|---|---|
zerolog | 767 ns/op | 552 B/op | 6 allocs/op |
⚡ zap | 848 ns/op | 704 B/op | 2 allocs/op |
⚡ zap (sugared) | 1363 ns/op | 1610 B/op | 20 allocs/op |
go-kit | 3614 ns/op | 2895 B/op | 66 allocs/op |
lion | 5392 ns/op | 5807 B/op | 63 allocs/op |
logrus | 5661 ns/op | 6092 B/op | 78 allocs/op |
apex/log | 15332 ns/op | 3832 B/op | 65 allocs/op |
log15 | 20657 ns/op | 5632 B/op | 93 allocs/op |
Log a message with a logger that already has 10 fields of context:
Library | Time | Bytes Allocated | Objects Allocated |
---|---|---|---|
zerolog | 52 ns/op | 0 B/op | 0 allocs/op |
⚡ zap | 283 ns/op | 0 B/op | 0 allocs/op |
⚡ zap (sugared) | 337 ns/op | 80 B/op | 2 allocs/op |
lion | 2702 ns/op | 4074 B/op | 38 allocs/op |
go-kit | 3378 ns/op | 3046 B/op | 52 allocs/op |
logrus | 4309 ns/op | 4564 B/op | 63 allocs/op |
apex/log | 13456 ns/op | 2898 B/op | 51 allocs/op |
log15 | 14179 ns/op | 2642 B/op | 44 allocs/op |
Log a static string, without any context or printf
-style templating:
Library | Time | Bytes Allocated | Objects Allocated |
---|---|---|---|
zerolog | 50 ns/op | 0 B/op | 0 allocs/op |
⚡ zap | 236 ns/op | 0 B/op | 0 allocs/op |
standard library | 453 ns/op | 80 B/op | 2 allocs/op |
⚡ zap (sugared) | 337 ns/op | 80 B/op | 2 allocs/op |
go-kit | 508 ns/op | 656 B/op | 13 allocs/op |
lion | 771 ns/op | 1224 B/op | 10 allocs/op |
logrus | 1244 ns/op | 1505 B/op | 27 allocs/op |
apex/log | 2751 ns/op | 584 B/op | 11 allocs/op |
log15 | 5181 ns/op | 1592 B/op | 26 allocs/op |
Caveats
Note that zerolog does no de-duplication of fields. Using the same key multiple times creates multiple keys in final JSON:
logger := zerolog.New(os.Stderr).With().Timestamp().Logger()
logger.Info().
Timestamp().
Msg("dup")
// Output: {"level":"info","time":1494567715,"time":1494567715,"message":"dup"}
In this case, many consumers will take the last value, but this is not guaranteed; check yours if in doubt.
Documentation
Overview ¶
Package zerolog provides a lightweight logging library dedicated to JSON logging.
A global Logger can be use for simple logging:
import "github.com/rs/zerolog/log" log.Info().Msg("hello world") // Output: {"time":1494567715,"level":"info","message":"hello world"}
NOTE: To import the global logger, import the "log" subpackage "github.com/rs/zerolog/log".
Fields can be added to log messages:
log.Info().Str("foo", "bar").Msg("hello world") // Output: {"time":1494567715,"level":"info","message":"hello world","foo":"bar"}
Create logger instance to manage different outputs:
logger := zerolog.New(os.Stderr).With().Timestamp().Logger() logger.Info(). Str("foo", "bar"). Msg("hello world") // Output: {"time":1494567715,"level":"info","message":"hello world","foo":"bar"}
Sub-loggers let you chain loggers with additional context:
sublogger := log.With().Str("component": "foo").Logger() sublogger.Info().Msg("hello world") // Output: {"time":1494567715,"level":"info","message":"hello world","component":"foo"}
Level logging
zerolog.SetGlobalLevel(zerolog.InfoLevel) log.Debug().Msg("filtered out message") log.Info().Msg("routed message") if e := log.Debug(); e.Enabled() { // Compute log output only if enabled. value := compute() e.Str("foo": value).Msg("some debug message") } // Output: {"level":"info","time":1494567715,"routed message"}
Customize automatic field names:
log.TimestampFieldName = "t" log.LevelFieldName = "p" log.MessageFieldName = "m" log.Info().Msg("hello world") // Output: {"t":1494567715,"p":"info","m":"hello world"}
Log with no level and message:
log.Log().Str("foo","bar").Msg("") // Output: {"time":1494567715,"foo":"bar"}
Add contextual fields to global Logger:
log.Logger = log.With().Str("foo", "bar").Logger()
Sample logs:
sampled := log.Sample(&zerolog.BasicSampler{N: 10}) sampled.Info().Msg("will be logged every 10 messages")
Log with contextual hooks:
// Create the hook: type SeverityHook struct{} func (h SeverityHook) Run(e *zerolog.Event, level zerolog.Level, msg string) { if level != zerolog.NoLevel { e.Str("severity", level.String()) } } // And use it: var h SeverityHook log := zerolog.New(os.Stdout).Hook(h) log.Warn().Msg("") // Output: {"level":"warn","severity":"warn"}
Caveats ¶
There is no fields deduplication out-of-the-box. Using the same key multiple times creates new key in final JSON each time.
logger := zerolog.New(os.Stderr).With().Timestamp().Logger() logger.Info(). Timestamp(). Msg("dup") // Output: {"level":"info","time":1494567715,"time":1494567715,"message":"dup"}
In this case, many consumers will take the last value, but this is not guaranteed; check yours if in doubt.
Index ¶
- Constants
- Variables
- func DisableSampling(v bool)
- func SetGlobalLevel(l Level)
- func SyncWriter(w io.Writer) io.Writer
- type Array
- func (a *Array) Bool(b bool) *Array
- func (a *Array) Bytes(val []byte) *Array
- func (a *Array) Dur(d time.Duration) *Array
- func (a *Array) Err(err error) *Array
- func (a *Array) Float32(f float32) *Array
- func (a *Array) Float64(f float64) *Array
- func (a *Array) Hex(val []byte) *Array
- func (a *Array) IPAddr(ip net.IP) *Array
- func (a *Array) IPPrefix(pfx net.IPNet) *Array
- func (a *Array) Int(i int) *Array
- func (a *Array) Int16(i int16) *Array
- func (a *Array) Int32(i int32) *Array
- func (a *Array) Int64(i int64) *Array
- func (a *Array) Int8(i int8) *Array
- func (a *Array) Interface(i interface{}) *Array
- func (a *Array) MACAddr(ha net.HardwareAddr) *Array
- func (*Array) MarshalZerologArray(*Array)
- func (a *Array) Object(obj LogObjectMarshaler) *Array
- func (a *Array) RawJSON(val []byte) *Array
- func (a *Array) Str(val string) *Array
- func (a *Array) Time(t time.Time) *Array
- func (a *Array) Uint(i uint) *Array
- func (a *Array) Uint16(i uint16) *Array
- func (a *Array) Uint32(i uint32) *Array
- func (a *Array) Uint64(i uint64) *Array
- func (a *Array) Uint8(i uint8) *Array
- type BasicSampler
- type BurstSampler
- type ConsoleWriter
- type Context
- func (c Context) AnErr(key string, err error) Context
- func (c Context) Array(key string, arr LogArrayMarshaler) Context
- func (c Context) Bool(key string, b bool) Context
- func (c Context) Bools(key string, b []bool) Context
- func (c Context) Bytes(key string, val []byte) Context
- func (c Context) Caller() Context
- func (c Context) CallerWithSkipFrameCount(skipFrameCount int) Context
- func (c Context) Dict(key string, dict *Event) Context
- func (c Context) Dur(key string, d time.Duration) Context
- func (c Context) Durs(key string, d []time.Duration) Context
- func (c Context) EmbedObject(obj LogObjectMarshaler) Context
- func (c Context) Err(err error) Context
- func (c Context) Errs(key string, errs []error) Context
- func (c Context) Fields(fields map[string]interface{}) Context
- func (c Context) Float32(key string, f float32) Context
- func (c Context) Float64(key string, f float64) Context
- func (c Context) Floats32(key string, f []float32) Context
- func (c Context) Floats64(key string, f []float64) Context
- func (c Context) Hex(key string, val []byte) Context
- func (c Context) IPAddr(key string, ip net.IP) Context
- func (c Context) IPPrefix(key string, pfx net.IPNet) Context
- func (c Context) Int(key string, i int) Context
- func (c Context) Int16(key string, i int16) Context
- func (c Context) Int32(key string, i int32) Context
- func (c Context) Int64(key string, i int64) Context
- func (c Context) Int8(key string, i int8) Context
- func (c Context) Interface(key string, i interface{}) Context
- func (c Context) Ints(key string, i []int) Context
- func (c Context) Ints16(key string, i []int16) Context
- func (c Context) Ints32(key string, i []int32) Context
- func (c Context) Ints64(key string, i []int64) Context
- func (c Context) Ints8(key string, i []int8) Context
- func (c Context) Logger() Logger
- func (c Context) MACAddr(key string, ha net.HardwareAddr) Context
- func (c Context) Object(key string, obj LogObjectMarshaler) Context
- func (c Context) RawJSON(key string, b []byte) Context
- func (c Context) Stack() Context
- func (c Context) Str(key, val string) Context
- func (c Context) Stringer(key string, val fmt.Stringer) Context
- func (c Context) Strs(key string, vals []string) Context
- func (c Context) Time(key string, t time.Time) Context
- func (c Context) Times(key string, t []time.Time) Context
- func (c Context) Timestamp() Context
- func (c Context) Uint(key string, i uint) Context
- func (c Context) Uint16(key string, i uint16) Context
- func (c Context) Uint32(key string, i uint32) Context
- func (c Context) Uint64(key string, i uint64) Context
- func (c Context) Uint8(key string, i uint8) Context
- func (c Context) Uints(key string, i []uint) Context
- func (c Context) Uints16(key string, i []uint16) Context
- func (c Context) Uints32(key string, i []uint32) Context
- func (c Context) Uints64(key string, i []uint64) Context
- func (c Context) Uints8(key string, i []uint8) Context
- type Event
- func (e *Event) AnErr(key string, err error) *Event
- func (e *Event) Array(key string, arr LogArrayMarshaler) *Event
- func (e *Event) Bool(key string, b bool) *Event
- func (e *Event) Bools(key string, b []bool) *Event
- func (e *Event) Bytes(key string, val []byte) *Event
- func (e *Event) Caller(skip ...int) *Event
- func (e *Event) Dict(key string, dict *Event) *Event
- func (e *Event) Discard() *Event
- func (e *Event) Dur(key string, d time.Duration) *Event
- func (e *Event) Durs(key string, d []time.Duration) *Event
- func (e *Event) EmbedObject(obj LogObjectMarshaler) *Event
- func (e *Event) Enabled() bool
- func (e *Event) Err(err error) *Event
- func (e *Event) Errs(key string, errs []error) *Event
- func (e *Event) Fields(fields map[string]interface{}) *Event
- func (e *Event) Float32(key string, f float32) *Event
- func (e *Event) Float64(key string, f float64) *Event
- func (e *Event) Floats32(key string, f []float32) *Event
- func (e *Event) Floats64(key string, f []float64) *Event
- func (e *Event) Hex(key string, val []byte) *Event
- func (e *Event) IPAddr(key string, ip net.IP) *Event
- func (e *Event) IPPrefix(key string, pfx net.IPNet) *Event
- func (e *Event) Int(key string, i int) *Event
- func (e *Event) Int16(key string, i int16) *Event
- func (e *Event) Int32(key string, i int32) *Event
- func (e *Event) Int64(key string, i int64) *Event
- func (e *Event) Int8(key string, i int8) *Event
- func (e *Event) Interface(key string, i interface{}) *Event
- func (e *Event) Ints(key string, i []int) *Event
- func (e *Event) Ints16(key string, i []int16) *Event
- func (e *Event) Ints32(key string, i []int32) *Event
- func (e *Event) Ints64(key string, i []int64) *Event
- func (e *Event) Ints8(key string, i []int8) *Event
- func (e *Event) MACAddr(key string, ha net.HardwareAddr) *Event
- func (e *Event) Msg(msg string)
- func (e *Event) Msgf(format string, v ...interface{})
- func (e *Event) Object(key string, obj LogObjectMarshaler) *Event
- func (e *Event) RawJSON(key string, b []byte) *Event
- func (e *Event) Send()
- func (e *Event) Stack() *Event
- func (e *Event) Str(key, val string) *Event
- func (e *Event) Stringer(key string, val fmt.Stringer) *Event
- func (e *Event) Strs(key string, vals []string) *Event
- func (e *Event) Time(key string, t time.Time) *Event
- func (e *Event) TimeDiff(key string, t time.Time, start time.Time) *Event
- func (e *Event) Times(key string, t []time.Time) *Event
- func (e *Event) Timestamp() *Event
- func (e *Event) Uint(key string, i uint) *Event
- func (e *Event) Uint16(key string, i uint16) *Event
- func (e *Event) Uint32(key string, i uint32) *Event
- func (e *Event) Uint64(key string, i uint64) *Event
- func (e *Event) Uint8(key string, i uint8) *Event
- func (e *Event) Uints(key string, i []uint) *Event
- func (e *Event) Uints16(key string, i []uint16) *Event
- func (e *Event) Uints32(key string, i []uint32) *Event
- func (e *Event) Uints64(key string, i []uint64) *Event
- func (e *Event) Uints8(key string, i []uint8) *Event
- type Formatter
- type Hook
- type HookFunc
- type Level
- type LevelHook
- type LevelSampler
- type LevelWriter
- type LogArrayMarshaler
- type LogObjectMarshaler
- type Logger
- func (l *Logger) Debug() *Event
- func (l *Logger) Err(err error) *Event
- func (l *Logger) Error() *Event
- func (l *Logger) Fatal() *Event
- func (l Logger) GetLevel() Level
- func (l Logger) Hook(h Hook) Logger
- func (l *Logger) Info() *Event
- func (l Logger) Level(lvl Level) Logger
- func (l *Logger) Log() *Event
- func (l Logger) Output(w io.Writer) Logger
- func (l *Logger) Panic() *Event
- func (l *Logger) Print(v ...interface{})
- func (l *Logger) Printf(format string, v ...interface{})
- func (l Logger) Sample(s Sampler) Logger
- func (l *Logger) Trace() *Event
- func (l *Logger) UpdateContext(update func(c Context) Context)
- func (l *Logger) Warn() *Event
- func (l Logger) With() Context
- func (l *Logger) WithContext(ctx context.Context) context.Context
- func (l *Logger) WithLevel(level Level) *Event
- func (l Logger) Write(p []byte) (n int, err error)
- type RandomSampler
- type Sampler
- type SyslogWriter
Examples ¶
- ConsoleWriter
- ConsoleWriter (CustomFormatters)
- Context.Array
- Context.Array (Object)
- Context.Dict
- Context.Dur
- Context.Durs
- Context.EmbedObject
- Context.IPAddr
- Context.IPPrefix
- Context.Interface
- Context.Object
- Event.Array
- Event.Array (Object)
- Event.Dict
- Event.Dur
- Event.Durs
- Event.EmbedObject
- Event.Interface
- Event.Object
- Logger.Debug
- Logger.Error
- Logger.Hook
- Logger.Info
- Logger.Level
- Logger.Log
- Logger.Print
- Logger.Printf
- Logger.Sample
- Logger.Trace
- Logger.Warn
- Logger.With
- Logger.WithLevel
- Logger.Write
- New
- NewConsoleWriter
- NewConsoleWriter (CustomFormatters)
Constants ¶
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" )
Variables ¶
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" // 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(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 } // TimeFieldFormat defines the time format of the Time field type. If set to // TimeFormatUnix, TimeFormatUnixMs or TimeFormatUnixMicro, the time is formatted as an UNIX // timestamp as integer. TimeFieldFormat = time.RFC3339 // TimestampFunc defines the function called to generate a timestamp. TimestampFunc = time.Now // 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. DurationFieldInteger = false // ErrorHandler is called whenever zerolog 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) )
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) )
Functions ¶
func DisableSampling ¶
func DisableSampling(v bool)
DisableSampling will disable sampling in all Loggers if true.
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 SyncWriter ¶
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.
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 (*Array) MACAddr ¶
func (a *Array) MACAddr(ha net.HardwareAddr) *Array
MACAddr adds a MAC (Ethernet) address to the array
func (*Array) MarshalZerologArray ¶
MarshalZerologArray 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 append append it 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 there 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 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 // PartsOrder defines the order of parts in output. PartsOrder []string FormatTimestamp Formatter FormatLevel Formatter FormatCaller Formatter FormatMessage Formatter FormatFieldName Formatter FormatFieldValue Formatter FormatErrFieldName Formatter FormatErrFieldValue Formatter }
ConsoleWriter parses the JSON input and writes it in an (optionally) colorized, human-friendly format to Out.
Example ¶
Code:
package main import ( "os" "github.com/rs/zerolog" ) func main() { log := zerolog.New(zerolog.ConsoleWriter{Out: os.Stdout, NoColor: true}) log.Info().Str("foo", "bar").Msg("Hello World") }
<nil> INF Hello World foo=bar
Example (CustomFormatters) ¶
Code:
package main import ( "fmt" "os" "strings" "github.com/rs/zerolog" ) func main() { out := zerolog.ConsoleWriter{Out: os.Stdout, NoColor: true} out.FormatLevel = func(i interface{}) string { return strings.ToUpper(fmt.Sprintf("%-6s|", i)) } out.FormatFieldName = func(i interface{}) string { return fmt.Sprintf("%s:", i) } out.FormatFieldValue = func(i interface{}) string { return strings.ToUpper(fmt.Sprintf("%s", i)) } log := zerolog.New(out) log.Info().Str("foo", "bar").Msg("Hello World") }
<nil> INFO | Hello World foo:BAR
func NewConsoleWriter ¶
func NewConsoleWriter(options ...func(w *ConsoleWriter)) ConsoleWriter
NewConsoleWriter creates and initializes a new ConsoleWriter.
Example ¶
Code:
package main
import (
"github.com/rs/zerolog"
)
func main() {
out := zerolog.NewConsoleWriter()
out.NoColor = true // For testing purposes only
log := zerolog.New(out)
log.Debug().Str("foo", "bar").Msg("Hello World")
}
<nil> DBG Hello World foo=bar
Example (CustomFormatters) ¶
Code:
package main import ( "fmt" "strings" "time" "github.com/rs/zerolog" ) func main() { out := zerolog.NewConsoleWriter( func(w *zerolog.ConsoleWriter) { // Customize time format w.TimeFormat = time.RFC822 // Customize level formatting w.FormatLevel = func(i interface{}) string { return strings.ToUpper(fmt.Sprintf("[%-5s]", i)) } }, ) out.NoColor = true // For testing purposes only log := zerolog.New(out) log.Info().Str("foo", "bar").Msg("Hello World") }
<nil> [INFO ] Hello World foo=bar
type Context ¶
type Context struct {
// contains filtered or unexported fields
}
Context configures a new sub-logger with contextual fields.
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 zerolog.Arr() to create the array or pass a type that implement the LogArrayMarshaler interface.
Example ¶
Code:
package main import ( "os" "github.com/rs/zerolog" ) func main() { log := zerolog.New(os.Stdout).With(). Str("foo", "bar"). Array("array", zerolog.Arr(). Str("baz"). Int(1), ).Logger() log.Log().Msg("hello world") }
{"foo":"bar","array":["baz",1],"message":"hello world"}
Example (Object) ¶
Code:
package main
import (
"os"
"time"
"github.com/rs/zerolog"
)
type User struct {
Name string
Age int
Created time.Time
}
func (u User) MarshalZerologObject(e *zerolog.Event) {
e.Str("name", u.Name).
Int("age", u.Age).
Time("created", u.Created)
}
type Users []User
func (uu Users) MarshalZerologArray(a *zerolog.Array) {
for _, u := range uu {
a.Object(u)
}
}
func main() {
// Users implements zerolog.LogArrayMarshaler
u := Users{
User{"John", 35, time.Time{}},
User{"Bob", 55, time.Time{}},
}
log := zerolog.New(os.Stdout).With().
Str("foo", "bar").
Array("users", u).
Logger()
log.Log().Msg("hello world")
}
{"foo":"bar","users":[{"name":"John","age":35,"created":"0001-01-01T00:00:00Z"},{"name":"Bob","age":55,"created":"0001-01-01T00:00:00Z"}],"message":"hello world"}
func (Context) Caller ¶
Caller adds the file:line of the caller with the zerolog.CallerFieldName key.
func (Context) CallerWithSkipFrameCount ¶
CallerWithSkipFrameCount adds the file:line of the caller with the zerolog.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) Dict ¶
Dict adds the field key with the dict to the logger context.
Example ¶
Code:
package main import ( "os" "github.com/rs/zerolog" ) func main() { log := zerolog.New(os.Stdout).With(). Str("foo", "bar"). Dict("dict", zerolog.Dict(). Str("bar", "baz"). Int("n", 1), ).Logger() log.Log().Msg("hello world") }
{"foo":"bar","dict":{"bar":"baz","n":1},"message":"hello world"}
func (Context) Dur ¶
Dur adds the fields key with d divided by unit and stored as a float.
Example ¶
Code:
package main import ( "os" "time" "github.com/rs/zerolog" ) func main() { d := time.Duration(10 * time.Second) log := zerolog.New(os.Stdout).With(). Str("foo", "bar"). Dur("dur", d). Logger() log.Log().Msg("hello world") }
{"foo":"bar","dur":10000,"message":"hello world"}
func (Context) Durs ¶
Durs adds the fields key with d divided by unit and stored as a float.
Example ¶
Code:
package main import ( "os" "time" "github.com/rs/zerolog" ) func main() { d := []time.Duration{ time.Duration(10 * time.Second), time.Duration(20 * time.Second), } log := zerolog.New(os.Stdout).With(). Str("foo", "bar"). Durs("durs", d). Logger() log.Log().Msg("hello world") }
{"foo":"bar","durs":[10000,20000],"message":"hello world"}
func (Context) EmbedObject ¶
func (c Context) EmbedObject(obj LogObjectMarshaler) Context
EmbedObject marshals and Embeds an object that implement the LogObjectMarshaler interface.
Example ¶
Code:
package main import ( "fmt" "os" "github.com/rs/zerolog" ) type Price struct { val uint64 prec int unit string } func (p Price) MarshalZerologObject(e *zerolog.Event) { denom := uint64(1) for i := 0; i < p.prec; i++ { denom *= 10 } result := []byte(p.unit) result = append(result, fmt.Sprintf("%d.%d", p.val/denom, p.val%denom)...) e.Str("price", string(result)) } func main() { price := Price{val: 6449, prec: 2, unit: "$"} log := zerolog.New(os.Stdout).With(). Str("foo", "bar"). EmbedObject(price). Logger() log.Log().Msg("hello world") }
{"foo":"bar","price":"$64.49","message":"hello world"}
func (Context) Errs ¶
Errs adds the field key with errs as an array of serialized errors to the logger context.
func (Context) Fields ¶
Fields is a helper function to use a map to set fields using type assertion.
func (Context) IPAddr ¶
IPAddr adds IPv4 or IPv6 Address to the context
Example ¶
Code:
package main import ( "net" "os" "github.com/rs/zerolog" ) func main() { hostIP := net.IP{192, 168, 0, 100} log := zerolog.New(os.Stdout).With(). IPAddr("HostIP", hostIP). Logger() log.Log().Msg("hello world") }
{"HostIP":"192.168.0.100","message":"hello world"}
func (Context) IPPrefix ¶
IPPrefix adds IPv4 or IPv6 Prefix (address and mask) to the context
Example ¶
Code:
package main import ( "net" "os" "github.com/rs/zerolog" ) func main() { route := net.IPNet{IP: net.IP{192, 168, 0, 0}, Mask: net.CIDRMask(24, 32)} log := zerolog.New(os.Stdout).With(). IPPrefix("Route", route). Logger() log.Log().Msg("hello world") }
{"Route":"192.168.0.0/24","message":"hello world"}
func (Context) Interface ¶
Interface adds the field key with obj marshaled using reflection.
Example ¶
Code:
package main import ( "os" "github.com/rs/zerolog" ) func main() { obj := struct { Name string `json:"name"` }{ Name: "john", } log := zerolog.New(os.Stdout).With(). Str("foo", "bar"). Interface("obj", obj). Logger() log.Log().Msg("hello world") }
{"foo":"bar","obj":{"name":"john"},"message":"hello world"}
func (Context) MACAddr ¶
func (c Context) MACAddr(key string, ha net.HardwareAddr) Context
MACAddr adds 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.
Example ¶
Code:
package main
import (
"os"
"time"
"github.com/rs/zerolog"
)
type User struct {
Name string
Age int
Created time.Time
}
func (u User) MarshalZerologObject(e *zerolog.Event) {
e.Str("name", u.Name).
Int("age", u.Age).
Time("created", u.Created)
}
func main() {
// User implements zerolog.LogObjectMarshaler
u := User{"John", 35, time.Time{}}
log := zerolog.New(os.Stdout).With().
Str("foo", "bar").
Object("user", u).
Logger()
log.Log().Msg("hello world")
}
{"foo":"bar","user":{"name":"John","age":35,"created":"0001-01-01T00:00:00Z"},"message":"hello world"}
func (Context) RawJSON ¶
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) Stringer ¶
Stringer adds the field key with val.String() (or null if val is nil) to the logger context.
func (Context) Time ¶
Time adds the field key with t formated as string using zerolog.TimeFieldFormat.
func (Context) Times ¶
Times adds the field key with t formated as string using zerolog.TimeFieldFormat.
func (Context) Timestamp ¶
Timestamp adds the current local time as UNIX timestamp to the logger context with the "time" key. To customize the key name, change zerolog.TimestampFieldName.
NOTE: It won't dedupe the "time" key if the *Context has one already.
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.
func (*Event) AnErr ¶
AnErr adds the field key with serialized err to the *Event context. If err is nil, no field is added.
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 zerolog.Arr() to create the array or pass a type that implement the LogArrayMarshaler interface.
Example ¶
Code:
package main import ( "os" "github.com/rs/zerolog" ) func main() { log := zerolog.New(os.Stdout) log.Log(). Str("foo", "bar"). Array("array", zerolog.Arr(). Str("baz"). Int(1), ). Msg("hello world") }
{"foo":"bar","array":["baz",1],"message":"hello world"}
Example (Object) ¶
Code:
package main
import (
"os"
"time"
"github.com/rs/zerolog"
)
type User struct {
Name string
Age int
Created time.Time
}
func (u User) MarshalZerologObject(e *zerolog.Event) {
e.Str("name", u.Name).
Int("age", u.Age).
Time("created", u.Created)
}
type Users []User
func (uu Users) MarshalZerologArray(a *zerolog.Array) {
for _, u := range uu {
a.Object(u)
}
}
func main() {
log := zerolog.New(os.Stdout)
// Users implements zerolog.LogArrayMarshaler
u := Users{
User{"John", 35, time.Time{}},
User{"Bob", 55, time.Time{}},
}
log.Log().
Str("foo", "bar").
Array("users", u).
Msg("hello world")
}
{"foo":"bar","users":[{"name":"John","age":35,"created":"0001-01-01T00:00:00Z"},{"name":"Bob","age":55,"created":"0001-01-01T00:00:00Z"}],"message":"hello world"}
func (*Event) Bytes ¶
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 ¶
Caller adds the file:line of the caller with the zerolog.CallerFieldName key. The argument skip is the number of stack frames to ascend Skip If not passed, use the global variable CallerSkipFrameCount
func (*Event) Dict ¶
Dict adds the field key with a dict to the event context. Use zerolog.Dict() to create the dictionary.
Example ¶
Code:
package main import ( "os" "github.com/rs/zerolog" ) func main() { log := zerolog.New(os.Stdout) log.Log(). Str("foo", "bar"). Dict("dict", zerolog.Dict(). Str("bar", "baz"). Int("n", 1), ). Msg("hello world") }
{"foo":"bar","dict":{"bar":"baz","n":1},"message":"hello world"}
func (*Event) Dur ¶
Dur adds the field key with duration d stored as zerolog.DurationFieldUnit. If zerolog.DurationFieldInteger is true, durations are rendered as integer instead of float.
Example ¶
Code:
package main import ( "os" "time" "github.com/rs/zerolog" ) func main() { d := time.Duration(10 * time.Second) log := zerolog.New(os.Stdout) log.Log(). Str("foo", "bar"). Dur("dur", d). Msg("hello world") }
{"foo":"bar","dur":10000,"message":"hello world"}
func (*Event) Durs ¶
Durs adds the field key with duration d stored as zerolog.DurationFieldUnit. If zerolog.DurationFieldInteger is true, durations are rendered as integer instead of float.
Example ¶
Code:
package main import ( "os" "time" "github.com/rs/zerolog" ) func main() { d := []time.Duration{ time.Duration(10 * time.Second), time.Duration(20 * time.Second), } log := zerolog.New(os.Stdout) log.Log(). Str("foo", "bar"). Durs("durs", d). Msg("hello world") }
{"foo":"bar","durs":[10000,20000],"message":"hello world"}
func (*Event) EmbedObject ¶
func (e *Event) EmbedObject(obj LogObjectMarshaler) *Event
EmbedObject marshals an object that implement the LogObjectMarshaler interface.
Example ¶
Code:
package main import ( "fmt" "os" "github.com/rs/zerolog" ) type Price struct { val uint64 prec int unit string } func (p Price) MarshalZerologObject(e *zerolog.Event) { denom := uint64(1) for i := 0; i < p.prec; i++ { denom *= 10 } result := []byte(p.unit) result = append(result, fmt.Sprintf("%d.%d", p.val/denom, p.val%denom)...) e.Str("price", string(result)) } func main() { log := zerolog.New(os.Stdout) price := Price{val: 6449, prec: 2, unit: "$"} log.Log(). Str("foo", "bar"). EmbedObject(price). Msg("hello world") }
{"foo":"bar","price":"$64.49","message":"hello world"}
func (*Event) Enabled ¶
Enabled return false if the *Event is going to be filtered out by log level or sampling.
func (*Event) Err ¶
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 zerolog.ErrorFieldName.
If Stack() has been called before and zerolog.ErrorStackMarshaler is defined, the err is passed to ErrorStackMarshaler and the result is appended to the zerolog.ErrorStackFieldName.
func (*Event) Errs ¶
Errs adds the field key with errs as an array of serialized errors to the *Event context.
func (*Event) Interface ¶
Interface adds the field key with i marshaled using reflection.
Example ¶
Code:
package main import ( "os" "github.com/rs/zerolog" ) func main() { log := zerolog.New(os.Stdout) obj := struct { Name string `json:"name"` }{ Name: "john", } log.Log(). Str("foo", "bar"). Interface("obj", obj). Msg("hello world") }
{"foo":"bar","obj":{"name":"john"},"message":"hello world"}
func (*Event) MACAddr ¶
func (e *Event) MACAddr(key string, ha net.HardwareAddr) *Event
MACAddr adds MAC address to the event
func (*Event) Msg ¶
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) Msgf ¶
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.
Example ¶
Code:
package main
import (
"os"
"time"
"github.com/rs/zerolog"
)
type User struct {
Name string
Age int
Created time.Time
}
func (u User) MarshalZerologObject(e *zerolog.Event) {
e.Str("name", u.Name).
Int("age", u.Age).
Time("created", u.Created)
}
func main() {
log := zerolog.New(os.Stdout)
// User implements zerolog.LogObjectMarshaler
u := User{"John", 35, time.Time{}}
log.Log().
Str("foo", "bar").
Object("user", u).
Msg("hello world")
}
{"foo":"bar","user":{"name":"John","age":35,"created":"0001-01-01T00:00:00Z"},"message":"hello world"}
func (*Event) RawJSON ¶
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 ¶
Stack enables stack trace printing for the error passed to Err().
ErrorStackMarshaler must be set for this method to do something.
func (*Event) Stringer ¶
Stringer adds the field key with val.String() (or null if val is nil) to the *Event context.
func (*Event) Time ¶
Time adds the field key with t formated as string using zerolog.TimeFieldFormat.
func (*Event) TimeDiff ¶
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 ¶
Times adds the field key with t formated as string using zerolog.TimeFieldFormat.
func (*Event) Timestamp ¶
Timestamp adds the current local time as UNIX timestamp to the *Event context with the "time" key. To customize the key name, change zerolog.TimestampFieldName.
NOTE: It won't dedupe the "time" key if the *Event (or *Context) has one already.
type Formatter ¶
type Formatter func(interface{}) string
Formatter transforms the input into a formatted string.
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 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 log level. TraceLevel Level = -1 )
func ParseLevel ¶
ParseLevel converts a level string into a zerolog Level value. returns an error if the input string does not match known values.
type LevelHook ¶
type LevelHook struct {
NoLevelHook, TraceHook, DebugHook, InfoHook, WarnHook, ErrorHook, FatalHook, PanicHook Hook
}
LevelHook applies a different hook for each level.
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 ¶
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.
func SyslogLevelWriter ¶
func SyslogLevelWriter(w SyslogWriter) LevelWriter
SyslogLevelWriter wraps a SyslogWriter and call the right syslog level method matching the zerolog level.
type LogArrayMarshaler ¶
type LogArrayMarshaler interface {
MarshalZerologArray(a *Array)
}
LogArrayMarshaler provides a strongly-typed and encoding-agnostic interface to be implemented by types used with Event/Context's Array methods.
type LogObjectMarshaler ¶
type LogObjectMarshaler interface {
MarshalZerologObject(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 struct {
// contains filtered or unexported fields
}
A Logger represents an active logging object that generates lines of JSON output to an io.Writer. Each logging operation makes a single call to the Writer's Write method. There is no guarantee on access serialization to the Writer. If your Writer is not thread safe, you may consider a sync wrapper.
func Ctx ¶
Ctx returns the Logger associated with the ctx. If no logger is associated, a disabled logger is returned.
func New ¶
New creates a root logger with given output writer. If the output writer implements the LevelWriter interface, the WriteLevel method will be called instead of the Write one.
Each logging operation makes a single call to the Writer's Write method. There is no guarantee on access serialization to the Writer. If your Writer is not thread safe, you may consider using sync wrapper.
Example ¶
Code:
package main import ( "os" "github.com/rs/zerolog" ) func main() { log := zerolog.New(os.Stdout) log.Info().Msg("hello world") }
{"level":"info","message":"hello world"}
func (*Logger) Debug ¶
Debug starts a new message with debug level.
You must call Msg on the returned event in order to send the event.
Example ¶
Code:
package main import ( "os" "github.com/rs/zerolog" ) func main() { log := zerolog.New(os.Stdout) log.Debug(). Str("foo", "bar"). Int("n", 123). Msg("hello world") }
{"level":"debug","foo":"bar","n":123,"message":"hello world"}
func (*Logger) Err ¶
Err starts a new message with error level with err as a field if not nil or with info level if err is nil.
You must call Msg on the returned event in order to send the event.
func (*Logger) Error ¶
Error starts a new message with error level.
You must call Msg on the returned event in order to send the event.
Example ¶
Code:
package main import ( "errors" "os" "github.com/rs/zerolog" ) func main() { log := zerolog.New(os.Stdout) log.Error(). Err(errors.New("some error")). Msg("error doing something") }
{"level":"error","error":"some error","message":"error doing something"}
func (*Logger) Fatal ¶
Fatal starts a new message with fatal level. The os.Exit(1) function is called by the Msg method, which terminates the program immediately.
You must call Msg on the returned event in order to send the event.
func (Logger) Hook ¶
Hook returns a logger with the h Hook.
Example ¶
Code:
package main import ( "os" "github.com/rs/zerolog" ) type LevelNameHook struct{} func (h LevelNameHook) Run(e *zerolog.Event, l zerolog.Level, msg string) { if l != zerolog.NoLevel { e.Str("level_name", l.String()) } else { e.Str("level_name", "NoLevel") } } type MessageHook string func (h MessageHook) Run(e *zerolog.Event, l zerolog.Level, msg string) { e.Str("the_message", msg) } func main() { var levelNameHook LevelNameHook var messageHook MessageHook = "The message" log := zerolog.New(os.Stdout).Hook(levelNameHook).Hook(messageHook) log.Info().Msg("hello world") }
{"level":"info","level_name":"info","the_message":"hello world","message":"hello world"}
func (*Logger) Info ¶
Info starts a new message with info level.
You must call Msg on the returned event in order to send the event.
Example ¶
Code:
package main import ( "os" "github.com/rs/zerolog" ) func main() { log := zerolog.New(os.Stdout) log.Info(). Str("foo", "bar"). Int("n", 123). Msg("hello world") }
{"level":"info","foo":"bar","n":123,"message":"hello world"}
func (Logger) Level ¶
Level creates a child logger with the minimum accepted level set to level.
Example ¶
Code:
package main import ( "os" "github.com/rs/zerolog" ) func main() { log := zerolog.New(os.Stdout).Level(zerolog.WarnLevel) log.Info().Msg("filtered out message") log.Error().Msg("kept message") }
{"level":"error","message":"kept message"}
func (*Logger) Log ¶
Log starts a new message with no level. Setting GlobalLevel to Disabled will still disable events produced by this method.
You must call Msg on the returned event in order to send the event.
Example ¶
Code:
package main import ( "os" "github.com/rs/zerolog" ) func main() { log := zerolog.New(os.Stdout) log.Log(). Str("foo", "bar"). Str("bar", "baz"). Msg("") }
{"foo":"bar","bar":"baz"}
func (*Logger) Panic ¶
Panic starts a new message with panic level. The panic() function is called by the Msg method, which stops the ordinary flow of a goroutine.
You must call Msg on the returned event in order to send the event.
func (*Logger) Print ¶
func (l *Logger) Print(v ...interface{})
Print sends a log event using debug level and no extra field. Arguments are handled in the manner of fmt.Print.
Example ¶
Code:
package main import ( "os" "github.com/rs/zerolog" ) func main() { log := zerolog.New(os.Stdout) log.Print("hello world") }
{"level":"debug","message":"hello world"}
func (*Logger) Printf ¶
Printf sends a log event using debug level and no extra field. Arguments are handled in the manner of fmt.Printf.
Example ¶
Code:
package main import ( "os" "github.com/rs/zerolog" ) func main() { log := zerolog.New(os.Stdout) log.Printf("hello %s", "world") }
{"level":"debug","message":"hello world"}
func (Logger) Sample ¶
Sample returns a logger with the s sampler.
Example ¶
Code:
package main import ( "os" "github.com/rs/zerolog" ) func main() { log := zerolog.New(os.Stdout).Sample(&zerolog.BasicSampler{N: 2}) log.Info().Msg("message 1") log.Info().Msg("message 2") log.Info().Msg("message 3") log.Info().Msg("message 4") }
{"level":"info","message":"message 1"} {"level":"info","message":"message 3"}
func (*Logger) Trace ¶
Trace starts a new message with trace level.
You must call Msg on the returned event in order to send the event.
Example ¶
Code:
package main import ( "os" "github.com/rs/zerolog" ) func main() { log := zerolog.New(os.Stdout) log.Trace(). Str("foo", "bar"). Int("n", 123). Msg("hello world") }
{"level":"trace","foo":"bar","n":123,"message":"hello world"}
func (*Logger) UpdateContext ¶
UpdateContext updates the internal logger's context.
Use this method with caution. If unsure, prefer the With method.
func (*Logger) Warn ¶
Warn starts a new message with warn level.
You must call Msg on the returned event in order to send the event.
Example ¶
Code:
package main import ( "os" "github.com/rs/zerolog" ) func main() { log := zerolog.New(os.Stdout) log.Warn(). Str("foo", "bar"). Msg("a warning message") }
{"level":"warn","foo":"bar","message":"a warning message"}
func (Logger) With ¶
With creates a child logger with the field added to its context.
Example ¶
Code:
package main import ( "os" "github.com/rs/zerolog" ) func main() { log := zerolog.New(os.Stdout). With(). Str("foo", "bar"). Logger() log.Info().Msg("hello world") }
{"level":"info","foo":"bar","message":"hello world"}
func (*Logger) WithContext ¶
WithContext returns a copy of ctx with l associated. If an instance of Logger is already in the context, the context is not updated.
For instance, to add a field to an existing logger in the context, use this notation:
ctx := r.Context() l := zerolog.Ctx(ctx) l.UpdateContext(func(c Context) Context { return c.Str("bar", "baz") })
func (*Logger) WithLevel ¶
WithLevel starts a new message with level. Unlike Fatal and Panic methods, WithLevel does not terminate the program or stop the ordinary flow of a gourotine when used with their respective levels.
You must call Msg on the returned event in order to send the event.
Example ¶
Code:
package main import ( "os" "github.com/rs/zerolog" ) func main() { log := zerolog.New(os.Stdout) log.WithLevel(zerolog.InfoLevel). Msg("hello world") }
{"level":"info","message":"hello world"}
func (Logger) Write ¶
Write implements the io.Writer interface. This is useful to set as a writer for the standard library log.
Example ¶
Code:
package main import ( stdlog "log" "os" "github.com/rs/zerolog" ) func main() { log := zerolog.New(os.Stdout).With(). Str("foo", "bar"). Logger() stdlog.SetFlags(0) stdlog.SetOutput(log) stdlog.Print("hello world") }
{"foo":"bar","message":"hello world"}
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.
Source Files
Directories
Path | Synopsis |
---|---|
cmd
|
|
Package diode provides a thread-safe, lock-free, non-blocking io.Writer wrapper.
|
Package diode provides a thread-safe, lock-free, non-blocking io.Writer wrapper. |
Package hlog provides a set of http.Handler helpers for zerolog.
|
Package hlog provides a set of http.Handler helpers for zerolog. |
internal/mutil
Package mutil contains various functions that are helpful when writing http middleware.
|
Package mutil contains various functions that are helpful when writing http middleware. |
internal
|
|
cbor
Package cbor provides primitives for storing different data in the CBOR (binary) format.
|
Package cbor provides primitives for storing different data in the CBOR (binary) format. |
Package log provides a global logger for zerolog.
|
Package log provides a global logger for zerolog. |