zerolog – github.com/rs/zerolog Index | Examples | Files | Directories

package zerolog

import "github.com/rs/zerolog"

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(10)
sampled.Info().Msg("will be logged every 10 messages")

Index

Examples

Constants 

const (
	// Often samples log every 10 events.
	Often = 10
	// Sometimes samples log every 100 events.
	Sometimes = 100
	// Rarely samples log every 1000 events.
	Rarely = 1000
)

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"

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

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

	// SampleFieldName is the name of the field used to report sampling.
	SampleFieldName = "sample"

	// TimeFieldFormat defines the time format of the Time field type.
	// If set to an empty string, 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
)

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 

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 the call to writer's Write method is not thread safe. Note that os.File Write operation is using write() syscall which is supposed to be thread-safe on POSIX systems. So there is no need to use this with os.File on such systems as zerolog guaranties to issue a single Write call per log event.

Types

type Array 

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

func Arr 

func Arr() *Array

Arr creates an array to be added to an Event or Context.

func (*Array) Bool 

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

Bool append the val as a bool to the array.

func (*Array) Bytes 

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

Bytes append the val as a string to the array.

func (*Array) Dur 

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

Dur append d to the array.

func (*Array) Err 

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

Err append the err as a string to the array.

func (*Array) Float32 

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

Float32 append f as a float32 to the array.

func (*Array) Float64 

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

Float64 append f as a float64 to the array.

func (*Array) Int 

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

Int append i as a int to the array.

func (*Array) Int16 

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

Int16 append i as a int16 to the array.

func (*Array) Int32 

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

Int32 append i as a int32 to the array.

func (*Array) Int64 

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

Int64 append i as a int64 to the array.

func (*Array) Int8 

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

Int8 append i as a int8 to the array.

func (*Array) Interface 

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

Interface append i marshaled using reflection.

func (*Array) MarshalZerologArray 

func (*Array) MarshalZerologArray(*Array)

func (*Array) Object 

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

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

func (*Array) Str 

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

Str append the val as a string to the array.

func (*Array) Time 

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

Time append t formated as string using zerolog.TimeFieldFormat.

func (*Array) Uint 

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

Uint append i as a uint to the array.

func (*Array) Uint16 

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

Uint16 append i as a uint16 to the array.

func (*Array) Uint32 

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

Uint32 append i as a uint32 to the array.

func (*Array) Uint64 

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

Uint64 append i as a uint64 to the array.

func (*Array) Uint8 

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

Uint8 append i as a uint8 to the array.

type ConsoleWriter 

type ConsoleWriter struct {
	Out     io.Writer
	NoColor bool
}

ConsoleWriter reads a JSON object per write operation and output an optionally colored human readable version on the Out writer.

func (ConsoleWriter) Write 

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

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 err as a string to the logger context.

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:play  

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")

}

Output:

{"foo":"bar","array":["baz",1],"message":"hello world"}
Example (Object)

Code:play  

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")

}

Output:

{"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) 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) Dict 

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

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

Example

Code:play  

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")

}

Output:

{"foo":"bar","dict":{"bar":"baz","n":1},"message":"hello world"}

func (Context) Dur 

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

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

Example

Code:play  

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")

}

Output:

{"foo":"bar","dur":10000,"message":"hello world"}

func (Context) Durs 

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

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

Example

Code:play  

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")

}

Output:

{"foo":"bar","durs":[10000,20000],"message":"hello world"}

func (Context) Err 

func (c Context) Err(err error) Context

Err adds the field "error" with err as a string to the logger context. To customize the key name, change zerolog.ErrorFieldName.

func (Context) Errs 

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

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

func (Context) Fields 

func (c Context) Fields(fields map[string]interface{}) Context

Fields is a helper function to use a map to set fields using type assertion.

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) 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) 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) 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) Interface 

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

Interface adds the field key with obj marshaled using reflection.

Example

Code:play  

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")

}

Output:

{"foo":"bar","obj":{"name":"john"},"message":"hello world"}

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) 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) 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) Logger 

func (c Context) Logger() Logger

Logger returns the logger with the context previously set.

func (Context) Object 

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

Object marshals an object that implement the LogObjectMarshaler interface.

Example

Code:play  

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")

}

Output:

{"foo":"bar","user":{"name":"John","age":35,"created":"0001-01-01T00:00:00Z"},"message":"hello world"}

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) 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 formated as string using zerolog.TimeFieldFormat.

func (Context) Times 

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

Times adds the field key with t formated as string using zerolog.TimeFieldFormat.

func (Context) Timestamp 

func (c Context) Timestamp() Context

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.

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) 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) 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) 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) 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.

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.

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 

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

AnErr adds the field key with err as a string 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:play  

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")

}

Output:

{"foo":"bar","array":["baz",1],"message":"hello world"}
Example (Object)

Code:play  

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")

}

Output:

{"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) 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) Dict 

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

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

Example

Code:play  

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")

}

Output:

{"foo":"bar","dict":{"bar":"baz","n":1},"message":"hello world"}

func (*Event) Dur 

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

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:play  

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")

}

Output:

{"foo":"bar","dur":10000,"message":"hello world"}

func (*Event) Durs 

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

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:play  

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")

}

Output:

{"foo":"bar","durs":[10000,20000],"message":"hello world"}

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 err as a string to the *Event context. If err is nil, no field is added. To customize the key name, change zerolog.ErrorFieldName.

func (*Event) Errs 

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

Errs adds the field key with errs as an array of strings to the *Event context. If err is nil, no field is added.

func (*Event) Fields 

func (e *Event) Fields(fields map[string]interface{}) *Event

Fields is a helper function to use a map to set fields using type assertion.

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) 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) 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) 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) Interface 

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

Interface adds the field key with i marshaled using reflection.

Example

Code:play  

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")

}

Output:

{"foo":"bar","obj":{"name":"john"},"message":"hello world"}

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) 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) 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) 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) Msgf 

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

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

NOTICE: once this methid is called, the *Event should be disposed. Calling Msg 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:play  

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")

}

Output:

{"foo":"bar","user":{"name":"John","age":35,"created":"0001-01-01T00:00:00Z"},"message":"hello world"}

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) 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 formated as string using zerolog.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 formated as string using zerolog.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 zerolog.TimestampFieldName.

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) 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) 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) 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) 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.

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.

type Level 

type Level uint8

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
	// Disabled disables the logger.
	Disabled
)

func (Level) String 

func (l Level) String() string

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.

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 guaranty on access serialization to the Writer. If your Writer is not thread safe, you may consider a sync wrapper.

func Ctx 

func Ctx(ctx context.Context) Logger

Ctx returns the Logger associated with the ctx. If no logger is associated, a disabled logger is returned.

func New 

func New(w io.Writer) Logger

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 guaranty on access serialization to the Writer. If your Writer is not thread safe, you may consider using sync wrapper.

Example

Code:play  

package main

import (
	"os"

	"github.com/rs/zerolog"
)

func main() {
	log := zerolog.New(os.Stdout)

	log.Info().Msg("hello world")

}

Output:

{"level":"info","message":"hello world"}

func Nop 

func Nop() Logger

Nop returns a disabled logger for which all operation are no-op.

func (Logger) Debug 

func (l Logger) Debug() *Event

Debug starts a new message with debug level.

You must call Msg on the returned event in order to send the event.

Example

Code:play  

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")

}

Output:

{"level":"debug","foo":"bar","n":123,"message":"hello world"}

func (Logger) Error 

func (l Logger) Error() *Event

Error starts a new message with error level.

You must call Msg on the returned event in order to send the event.

Example

Code:play  

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")

}

Output:

{"level":"error","error":"some error","message":"error doing something"}

func (Logger) Fatal 

func (l Logger) Fatal() *Event

Fatal starts a new message with fatal level. The os.Exit(1) function is called by the Msg method.

You must call Msg on the returned event in order to send the event.

func (Logger) Info 

func (l Logger) Info() *Event

Info starts a new message with info level.

You must call Msg on the returned event in order to send the event.

Example

Code:play  

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")

}

Output:

{"level":"info","foo":"bar","n":123,"message":"hello world"}

func (Logger) Level 

func (l Logger) Level(lvl Level) Logger

Level creates a child logger with the minimum accepted level set to level.

Example

Code:play  

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")

}

Output:

{"level":"error","message":"kept message"}

func (Logger) Log 

func (l Logger) Log() *Event

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:play  

package main

import (
	"os"

	"github.com/rs/zerolog"
)

func main() {
	log := zerolog.New(os.Stdout)

	log.Log().
		Str("foo", "bar").
		Str("bar", "baz").
		Msg("")

}

Output:

{"foo":"bar","bar":"baz"}

func (Logger) Output 

func (l Logger) Output(w io.Writer) Logger

Output duplicates the current logger and sets w as its output.

func (Logger) Panic 

func (l Logger) Panic() *Event

Panic starts a new message with panic level. The message is also sent to the panic function.

You must call Msg on the returned event in order to send the event.

func (Logger) Sample 

func (l Logger) Sample(every int) Logger

Sample returns a logger that only let one message out of every to pass thru.

Example

Code:play  

package main

import (
	"os"

	"github.com/rs/zerolog"
)

func main() {
	log := zerolog.New(os.Stdout).Sample(2)

	log.Info().Msg("message 1")
	log.Info().Msg("message 2")
	log.Info().Msg("message 3")
	log.Info().Msg("message 4")

}

Output:

{"level":"info","sample":2,"message":"message 2"}
{"level":"info","sample":2,"message":"message 4"}

func (Logger) Warn 

func (l Logger) Warn() *Event

Warn starts a new message with warn level.

You must call Msg on the returned event in order to send the event.

Example

Code:play  

package main

import (
	"os"

	"github.com/rs/zerolog"
)

func main() {
	log := zerolog.New(os.Stdout)

	log.Warn().
		Str("foo", "bar").
		Msg("a warning message")

}

Output:

{"level":"warn","foo":"bar","message":"a warning message"}

func (Logger) With 

func (l Logger) With() Context

With creates a child logger with the field added to its context.

Example

Code:play  

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")

}

Output:

{"level":"info","foo":"bar","message":"hello world"}

func (Logger) WithContext 

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

WithContext returns a copy of ctx with l associated.

func (Logger) WithLevel 

func (l Logger) WithLevel(level Level) *Event

WithLevel starts a new message with level.

You must call Msg on the returned event in order to send the event.

Example

Code:play  

package main

import (
	"os"

	"github.com/rs/zerolog"
)

func main() {
	log := zerolog.New(os.Stdout)

	log.WithLevel(zerolog.InfoLevel).
		Msg("hello world")

}

Output:

{"level":"info","message":"hello world"}

func (Logger) Write 

func (l Logger) Write(p []byte) (n int, err error)

Write implements the io.Writer interface. This is useful to set as a writer for the standard library log.

Example

Code:play  

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")

}

Output:

{"foo":"bar","message":"hello world"}

type SyslogWriter 

type SyslogWriter interface {
	io.Writer
	Debug(m string) error
	Info(m string) error
	Warning(m string) error
	Err(m string) error
	Emerg(m string) error
	Crit(m string) error
}

SyslogWriter is an interface matching a syslog.Writer struct.

Source Files

array.go console.go context.go ctx.go event.go fields.go globals.go log.go syslog.go writer.go

Directories

PathSynopsis
hlogPackage hlog provides a set of http.Handler helpers for zerolog.
internal
logPackage log provides a global logger for zerolog.
Version
v1.2.1
Published
Aug 6, 2017
Platform
js/wasm
Imports
14 packages
Last checked
1 day ago –

Tools for package owners.