Add go 1.9 to travis file

- No performance section in README.md, change link to performance to benchmarks

.travis.yml

@@ -2,6 +2,7 @@ language: go
 go:
 - 1.7
 - 1.8
+- 1.9
 - tip
 matrix:
   allow_failures:

README.md

@@ -4,7 +4,7 @@
 
 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](#performance). Its unique chaining API allows zerolog to write JSON log events by avoiding allocations and reflection.
+Zerolog's API is designed to provide both a great developer experience and stunning [performance](#benchmarks). Its unique chaining API allows zerolog to write JSON log events by avoiding allocations and reflection.
 
 The uber's [zap](https://godoc.org/go.uber.org/zap) library pioneered this approach. Zerolog is taking this concept to the next level with simpler to use API and even better performance.
 
@@ -18,6 +18,7 @@ To keep the code base and the API simple, zerolog focuses on JSON logging only.
 * Low to zero allocation
 * Level logging
 * Sampling
+* Hooks
 * Contextual fields
 * `context.Context` integration
 * `net/http` helpers
@@ -185,6 +186,22 @@ sampled.Debug().Msg("hello world")
 // Output: {"time":1494567715,"level":"debug","message":"hello world"}
 ```
 
+### Hooks
+
+```go
+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
 

event.go

@@ -21,11 +21,11 @@ var eventPool = &sync.Pool{
 // Event represents a log event. It is instanced by one of the level method of
 // Logger and finalized by the Msg or Msgf method.
 type Event struct {
-	buf     []byte
-	w       LevelWriter
-	level   Level
-	enabled bool
-	done    func(msg string)
+	buf   []byte
+	w     LevelWriter
+	level Level
+	done  func(msg string)
+	h     []Hook
 }
 
 // LogObjectMarshaler provides a strongly-typed and encoding-agnostic interface
@@ -46,15 +46,15 @@ func newEvent(w LevelWriter, level Level, enabled bool) *Event {
 	}
 	e := eventPool.Get().(*Event)
 	e.buf = e.buf[:1]
+	e.h = e.h[:0]
 	e.buf[0] = '{'
 	e.w = w
 	e.level = level
-	e.enabled = true
 	return e
 }
 
 func (e *Event) write() (err error) {
-	if !e.enabled {
+	if e == nil {
 		return nil
 	}
 	e.buf = append(e.buf, '}', '\n')
@@ -66,7 +66,7 @@ func (e *Event) write() (err error) {
 // Enabled return false if the *Event is going to be filtered out by
 // log level or sampling.
 func (e *Event) Enabled() bool {
-	return e.enabled
+	return e != nil
 }
 
 // Msg sends the *Event with msg added as the message field if not empty.
@@ -74,9 +74,17 @@ func (e *Event) Enabled() bool {
 // NOTICE: once this method is called, the *Event should be disposed.
 // Calling Msg twice can have unexpected result.
 func (e *Event) Msg(msg string) {
-	if !e.enabled {
+	if e == nil {
 		return
 	}
+	if len(e.h) > 0 {
+		e.h[0].Run(e, e.level, msg)
+		if len(e.h) > 1 {
+			for _, hook := range e.h[1:] {
+				hook.Run(e, e.level, msg)
+			}
+		}
+	}
 	if msg != "" {
 		e.buf = json.AppendString(json.AppendKey(e.buf, MessageFieldName), msg)
 	}
@@ -93,24 +101,15 @@ func (e *Event) Msg(msg string) {
 // NOTICE: once this methid is called, the *Event should be disposed.
 // Calling Msg twice can have unexpected result.
 func (e *Event) Msgf(format string, v ...interface{}) {
-	if !e.enabled {
+	if e == nil {
 		return
 	}
-	msg := fmt.Sprintf(format, v...)
-	if msg != "" {
-		e.buf = json.AppendString(json.AppendKey(e.buf, MessageFieldName), msg)
-	}
-	if e.done != nil {
-		defer e.done(msg)
-	}
-	if err := e.write(); err != nil {
-		fmt.Fprintf(os.Stderr, "zerolog: could not write event: %v", err)
-	}
+	e.Msg(fmt.Sprintf(format, v...))
 }
 
 // Fields is a helper function to use a map to set fields using type assertion.
 func (e *Event) Fields(fields map[string]interface{}) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = appendFields(e.buf, fields)
@@ -120,7 +119,7 @@ func (e *Event) Fields(fields map[string]interface{}) *Event {
 // Dict adds the field key with a dict to the event context.
 // Use zerolog.Dict() to create the dictionary.
 func (e *Event) Dict(key string, dict *Event) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = append(append(json.AppendKey(e.buf, key), dict.buf...), '}')
@@ -139,7 +138,7 @@ func Dict() *Event {
 // Use zerolog.Arr() to create the array or pass a type that
 // implement the LogArrayMarshaler interface.
 func (e *Event) Array(key string, arr LogArrayMarshaler) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendKey(e.buf, key)
@@ -170,7 +169,7 @@ func (e *Event) appendObject(obj LogObjectMarshaler) {
 
 // Object marshals an object that implement the LogObjectMarshaler interface.
 func (e *Event) Object(key string, obj LogObjectMarshaler) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendKey(e.buf, key)
@@ -180,7 +179,7 @@ func (e *Event) Object(key string, obj LogObjectMarshaler) *Event {
 
 // Str adds the field key with val as a string to the *Event context.
 func (e *Event) Str(key, val string) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendString(json.AppendKey(e.buf, key), val)
@@ -189,7 +188,7 @@ func (e *Event) Str(key, val string) *Event {
 
 // Strs adds the field key with vals as a []string to the *Event context.
 func (e *Event) Strs(key string, vals []string) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendStrings(json.AppendKey(e.buf, key), vals)
@@ -201,7 +200,7 @@ func (e *Event) Strs(key string, vals []string) *Event {
 // Runes outside of normal ASCII ranges will be hex-encoded in the resulting
 // JSON.
 func (e *Event) Bytes(key string, val []byte) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendBytes(json.AppendKey(e.buf, key), val)
@@ -211,7 +210,7 @@ func (e *Event) Bytes(key string, val []byte) *Event {
 // AnErr adds the field key with err as a string to the *Event context.
 // If err is nil, no field is added.
 func (e *Event) AnErr(key string, err error) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	if err != nil {
@@ -223,7 +222,7 @@ func (e *Event) AnErr(key string, err 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 (e *Event) Errs(key string, errs []error) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendErrors(json.AppendKey(e.buf, key), errs)
@@ -234,7 +233,7 @@ func (e *Event) Errs(key string, errs []error) *Event {
 // If err is nil, no field is added.
 // To customize the key name, change zerolog.ErrorFieldName.
 func (e *Event) Err(err error) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	if err != nil {
@@ -245,7 +244,7 @@ func (e *Event) Err(err error) *Event {
 
 // Bool adds the field key with val as a bool to the *Event context.
 func (e *Event) Bool(key string, b bool) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendBool(json.AppendKey(e.buf, key), b)
@@ -254,7 +253,7 @@ func (e *Event) Bool(key string, b bool) *Event {
 
 // Bools adds the field key with val as a []bool to the *Event context.
 func (e *Event) Bools(key string, b []bool) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendBools(json.AppendKey(e.buf, key), b)
@@ -263,7 +262,7 @@ func (e *Event) Bools(key string, b []bool) *Event {
 
 // Int adds the field key with i as a int to the *Event context.
 func (e *Event) Int(key string, i int) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendInt(json.AppendKey(e.buf, key), i)
@@ -272,7 +271,7 @@ func (e *Event) Int(key string, i int) *Event {
 
 // Ints adds the field key with i as a []int to the *Event context.
 func (e *Event) Ints(key string, i []int) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendInts(json.AppendKey(e.buf, key), i)
@@ -281,7 +280,7 @@ func (e *Event) Ints(key string, i []int) *Event {
 
 // Int8 adds the field key with i as a int8 to the *Event context.
 func (e *Event) Int8(key string, i int8) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendInt8(json.AppendKey(e.buf, key), i)
@@ -290,7 +289,7 @@ func (e *Event) Int8(key string, i int8) *Event {
 
 // Ints8 adds the field key with i as a []int8 to the *Event context.
 func (e *Event) Ints8(key string, i []int8) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendInts8(json.AppendKey(e.buf, key), i)
@@ -299,7 +298,7 @@ func (e *Event) Ints8(key string, i []int8) *Event {
 
 // Int16 adds the field key with i as a int16 to the *Event context.
 func (e *Event) Int16(key string, i int16) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendInt16(json.AppendKey(e.buf, key), i)
@@ -308,7 +307,7 @@ func (e *Event) Int16(key string, i int16) *Event {
 
 // Ints16 adds the field key with i as a []int16 to the *Event context.
 func (e *Event) Ints16(key string, i []int16) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendInts16(json.AppendKey(e.buf, key), i)
@@ -317,7 +316,7 @@ func (e *Event) Ints16(key string, i []int16) *Event {
 
 // Int32 adds the field key with i as a int32 to the *Event context.
 func (e *Event) Int32(key string, i int32) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendInt32(json.AppendKey(e.buf, key), i)
@@ -326,7 +325,7 @@ func (e *Event) Int32(key string, i int32) *Event {
 
 // Ints32 adds the field key with i as a []int32 to the *Event context.
 func (e *Event) Ints32(key string, i []int32) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendInts32(json.AppendKey(e.buf, key), i)
@@ -335,7 +334,7 @@ func (e *Event) Ints32(key string, i []int32) *Event {
 
 // Int64 adds the field key with i as a int64 to the *Event context.
 func (e *Event) Int64(key string, i int64) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendInt64(json.AppendKey(e.buf, key), i)
@@ -344,7 +343,7 @@ func (e *Event) Int64(key string, i int64) *Event {
 
 // Ints64 adds the field key with i as a []int64 to the *Event context.
 func (e *Event) Ints64(key string, i []int64) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendInts64(json.AppendKey(e.buf, key), i)
@@ -353,7 +352,7 @@ func (e *Event) Ints64(key string, i []int64) *Event {
 
 // Uint adds the field key with i as a uint to the *Event context.
 func (e *Event) Uint(key string, i uint) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendUint(json.AppendKey(e.buf, key), i)
@@ -362,7 +361,7 @@ func (e *Event) Uint(key string, i uint) *Event {
 
 // Uints adds the field key with i as a []int to the *Event context.
 func (e *Event) Uints(key string, i []uint) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendUints(json.AppendKey(e.buf, key), i)
@@ -371,7 +370,7 @@ func (e *Event) Uints(key string, i []uint) *Event {
 
 // Uint8 adds the field key with i as a uint8 to the *Event context.
 func (e *Event) Uint8(key string, i uint8) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendUint8(json.AppendKey(e.buf, key), i)
@@ -380,7 +379,7 @@ func (e *Event) Uint8(key string, i uint8) *Event {
 
 // Uints8 adds the field key with i as a []int8 to the *Event context.
 func (e *Event) Uints8(key string, i []uint8) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendUints8(json.AppendKey(e.buf, key), i)
@@ -389,7 +388,7 @@ func (e *Event) Uints8(key string, i []uint8) *Event {
 
 // Uint16 adds the field key with i as a uint16 to the *Event context.
 func (e *Event) Uint16(key string, i uint16) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendUint16(json.AppendKey(e.buf, key), i)
@@ -398,7 +397,7 @@ func (e *Event) Uint16(key string, i uint16) *Event {
 
 // Uints16 adds the field key with i as a []int16 to the *Event context.
 func (e *Event) Uints16(key string, i []uint16) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendUints16(json.AppendKey(e.buf, key), i)
@@ -407,7 +406,7 @@ func (e *Event) Uints16(key string, i []uint16) *Event {
 
 // Uint32 adds the field key with i as a uint32 to the *Event context.
 func (e *Event) Uint32(key string, i uint32) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendUint32(json.AppendKey(e.buf, key), i)
@@ -416,7 +415,7 @@ func (e *Event) Uint32(key string, i uint32) *Event {
 
 // Uints32 adds the field key with i as a []int32 to the *Event context.
 func (e *Event) Uints32(key string, i []uint32) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendUints32(json.AppendKey(e.buf, key), i)
@@ -425,7 +424,7 @@ func (e *Event) Uints32(key string, i []uint32) *Event {
 
 // Uint64 adds the field key with i as a uint64 to the *Event context.
 func (e *Event) Uint64(key string, i uint64) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendUint64(json.AppendKey(e.buf, key), i)
@@ -434,7 +433,7 @@ func (e *Event) Uint64(key string, i uint64) *Event {
 
 // Uints64 adds the field key with i as a []int64 to the *Event context.
 func (e *Event) Uints64(key string, i []uint64) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendUints64(json.AppendKey(e.buf, key), i)
@@ -443,7 +442,7 @@ func (e *Event) Uints64(key string, i []uint64) *Event {
 
 // Float32 adds the field key with f as a float32 to the *Event context.
 func (e *Event) Float32(key string, f float32) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendFloat32(json.AppendKey(e.buf, key), f)
@@ -452,7 +451,7 @@ func (e *Event) Float32(key string, f float32) *Event {
 
 // Floats32 adds the field key with f as a []float32 to the *Event context.
 func (e *Event) Floats32(key string, f []float32) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendFloats32(json.AppendKey(e.buf, key), f)
@@ -461,7 +460,7 @@ func (e *Event) Floats32(key string, f []float32) *Event {
 
 // Float64 adds the field key with f as a float64 to the *Event context.
 func (e *Event) Float64(key string, f float64) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendFloat64(json.AppendKey(e.buf, key), f)
@@ -470,7 +469,7 @@ func (e *Event) Float64(key string, f float64) *Event {
 
 // Floats64 adds the field key with f as a []float64 to the *Event context.
 func (e *Event) Floats64(key string, f []float64) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendFloats64(json.AppendKey(e.buf, key), f)
@@ -480,7 +479,7 @@ func (e *Event) Floats64(key string, f []float64) *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 (e *Event) Timestamp() *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendTime(json.AppendKey(e.buf, TimestampFieldName), TimestampFunc(), TimeFieldFormat)
@@ -489,7 +488,7 @@ func (e *Event) Timestamp() *Event {
 
 // Time adds the field key with t formated as string using zerolog.TimeFieldFormat.
 func (e *Event) Time(key string, t time.Time) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendTime(json.AppendKey(e.buf, key), t, TimeFieldFormat)
@@ -498,7 +497,7 @@ func (e *Event) Time(key string, t time.Time) *Event {
 
 // Times adds the field key with t formated as string using zerolog.TimeFieldFormat.
 func (e *Event) Times(key string, t []time.Time) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendTimes(json.AppendKey(e.buf, key), t, TimeFieldFormat)
@@ -509,7 +508,7 @@ func (e *Event) Times(key string, t []time.Time) *Event {
 // If zerolog.DurationFieldInteger is true, durations are rendered as integer
 // instead of float.
 func (e *Event) Dur(key string, d time.Duration) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendDuration(json.AppendKey(e.buf, key), d, DurationFieldUnit, DurationFieldInteger)
@@ -520,7 +519,7 @@ func (e *Event) Dur(key string, d time.Duration) *Event {
 // If zerolog.DurationFieldInteger is true, durations are rendered as integer
 // instead of float.
 func (e *Event) Durs(key string, d []time.Duration) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	e.buf = json.AppendDurations(json.AppendKey(e.buf, key), d, DurationFieldUnit, DurationFieldInteger)
@@ -531,7 +530,7 @@ func (e *Event) Durs(key string, d []time.Duration) *Event {
 // If time t is not greater than start, duration will be 0.
 // Duration format follows the same principle as Dur().
 func (e *Event) TimeDiff(key string, t time.Time, start time.Time) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	var d time.Duration
@@ -544,7 +543,7 @@ func (e *Event) TimeDiff(key string, t time.Time, start time.Time) *Event {
 
 // Interface adds the field key with i marshaled using reflection.
 func (e *Event) Interface(key string, i interface{}) *Event {
-	if !e.enabled {
+	if e == nil {
 		return e
 	}
 	if obj, ok := i.(LogObjectMarshaler); ok {

hook.go

@@ -0,0 +1,51 @@
+package zerolog
+
+// Hook defines an interface to a log hook.
+type Hook interface {
+	// Run runs the hook with the event.
+	Run(e *Event, level Level, message string)
+}
+
+// LevelHook applies a different hook for each level.
+type LevelHook struct {
+	NoLevelHook, DebugHook, InfoHook, WarnHook, ErrorHook, FatalHook, PanicHook Hook
+}
+
+// Run implements the Hook interface.
+func (h LevelHook) Run(e *Event, level Level, message string) {
+	switch level {
+	case DebugLevel:
+		if h.DebugHook != nil {
+			h.DebugHook.Run(e, level, message)
+		}
+	case InfoLevel:
+		if h.InfoHook != nil {
+			h.InfoHook.Run(e, level, message)
+		}
+	case WarnLevel:
+		if h.WarnHook != nil {
+			h.WarnHook.Run(e, level, message)
+		}
+	case ErrorLevel:
+		if h.ErrorHook != nil {
+			h.ErrorHook.Run(e, level, message)
+		}
+	case FatalLevel:
+		if h.FatalHook != nil {
+			h.FatalHook.Run(e, level, message)
+		}
+	case PanicLevel:
+		if h.PanicHook != nil {
+			h.PanicHook.Run(e, level, message)
+		}
+	case NoLevel:
+		if h.NoLevelHook != nil {
+			h.NoLevelHook.Run(e, level, message)
+		}
+	}
+}
+
+// NewLevelHook returns a new LevelHook.
+func NewLevelHook() LevelHook {
+	return LevelHook{}
+}

hook_test.go

@@ -0,0 +1,236 @@
+package zerolog
+
+import (
+	"testing"
+	"bytes"
+	"io/ioutil"
+)
+
+type LevelNameHook struct{}
+
+func (h LevelNameHook) Run(e *Event, level Level, msg string) {
+	levelName := level.String()
+	if level == NoLevel {
+		levelName = "nolevel"
+	}
+	e.Str("level_name", levelName)
+}
+
+type SimpleHook struct{}
+
+func (h SimpleHook) Run(e *Event, level Level, msg string) {
+	e.Bool("has_level", level != NoLevel)
+	e.Str("test", "logged")
+}
+
+type CopyHook struct{}
+
+func (h CopyHook) Run(e *Event, level Level, msg string) {
+	hasLevel := level != NoLevel
+	e.Bool("copy_has_level", hasLevel)
+	if hasLevel {
+		e.Str("copy_level", level.String())
+	}
+	e.Str("copy_msg", msg)
+}
+
+type NopHook struct{}
+
+func (h NopHook) Run(e *Event, level Level, msg string) {
+}
+
+var (
+	levelNameHook LevelNameHook
+	simpleHook    SimpleHook
+	copyHook      CopyHook
+	nopHook       NopHook
+)
+
+func TestHook(t *testing.T) {
+	t.Run("Message", func(t *testing.T) {
+		out := &bytes.Buffer{}
+		log := New(out).Hook(levelNameHook)
+		log.Log().Msg("test message")
+		if got, want := out.String(), `{"level_name":"nolevel","message":"test message"}`+"\n"; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+	t.Run("NoLevel", func(t *testing.T) {
+		out := &bytes.Buffer{}
+		log := New(out).Hook(levelNameHook)
+		log.Log().Msg("")
+		if got, want := out.String(), `{"level_name":"nolevel"}`+"\n"; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+	t.Run("Print", func(t *testing.T) {
+		out := &bytes.Buffer{}
+		log := New(out).Hook(levelNameHook)
+		log.Print("")
+		if got, want := out.String(), `{"level":"debug","level_name":"debug"}`+"\n"; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+	t.Run("Error", func(t *testing.T) {
+		out := &bytes.Buffer{}
+		log := New(out).Hook(levelNameHook)
+		log.Error().Msg("")
+		if got, want := out.String(), `{"level":"error","level_name":"error"}`+"\n"; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+	t.Run("Copy/1", func(t *testing.T) {
+		out := &bytes.Buffer{}
+		log := New(out).Hook(copyHook)
+		log.Log().Msg("")
+		if got, want := out.String(), `{"copy_has_level":false,"copy_msg":""}`+"\n"; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+	t.Run("Copy/2", func(t *testing.T) {
+		out := &bytes.Buffer{}
+		log := New(out).Hook(copyHook)
+		log.Info().Msg("a message")
+		if got, want := out.String(), `{"level":"info","copy_has_level":true,"copy_level":"info","copy_msg":"a message","message":"a message"}`+"\n"; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+	t.Run("Multi", func(t *testing.T) {
+		out := &bytes.Buffer{}
+		log := New(out).Hook(levelNameHook).Hook(simpleHook)
+		log.Error().Msg("")
+		if got, want := out.String(), `{"level":"error","level_name":"error","has_level":true,"test":"logged"}`+"\n"; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+	t.Run("Multi/Message", func(t *testing.T) {
+		out := &bytes.Buffer{}
+		log := New(out).Hook(levelNameHook).Hook(simpleHook)
+		log.Error().Msg("a message")
+		if got, want := out.String(), `{"level":"error","level_name":"error","has_level":true,"test":"logged","message":"a message"}`+"\n"; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+	t.Run("Output/single/pre", func(t *testing.T) {
+		ignored := &bytes.Buffer{}
+		out := &bytes.Buffer{}
+		log := New(ignored).Hook(levelNameHook).Output(out)
+		log.Error().Msg("")
+		if got, want := out.String(), `{"level":"error","level_name":"error"}`+"\n"; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+	t.Run("Output/single/post", func(t *testing.T) {
+		ignored := &bytes.Buffer{}
+		out := &bytes.Buffer{}
+		log := New(ignored).Output(out).Hook(levelNameHook)
+		log.Error().Msg("")
+		if got, want := out.String(), `{"level":"error","level_name":"error"}`+"\n"; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+	t.Run("Output/multi/pre", func(t *testing.T) {
+		ignored := &bytes.Buffer{}
+		out := &bytes.Buffer{}
+		log := New(ignored).Hook(levelNameHook).Hook(simpleHook).Output(out)
+		log.Error().Msg("")
+		if got, want := out.String(), `{"level":"error","level_name":"error","has_level":true,"test":"logged"}`+"\n"; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+	t.Run("Output/multi/post", func(t *testing.T) {
+		ignored := &bytes.Buffer{}
+		out := &bytes.Buffer{}
+		log := New(ignored).Output(out).Hook(levelNameHook).Hook(simpleHook)
+		log.Error().Msg("")
+		if got, want := out.String(), `{"level":"error","level_name":"error","has_level":true,"test":"logged"}`+"\n"; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+	t.Run("Output/mixed", func(t *testing.T) {
+		ignored := &bytes.Buffer{}
+		out := &bytes.Buffer{}
+		log := New(ignored).Hook(levelNameHook).Output(out).Hook(simpleHook)
+		log.Error().Msg("")
+		if got, want := out.String(), `{"level":"error","level_name":"error","has_level":true,"test":"logged"}`+"\n"; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+	t.Run("With/single/pre", func(t *testing.T) {
+		out := &bytes.Buffer{}
+		log := New(out).Hook(levelNameHook).With().Str("with", "pre").Logger()
+		log.Error().Msg("")
+		if got, want := out.String(), `{"level":"error","with":"pre","level_name":"error"}`+"\n"; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+	t.Run("With/single/post", func(t *testing.T) {
+		out := &bytes.Buffer{}
+		log := New(out).With().Str("with", "post").Logger().Hook(levelNameHook)
+		log.Error().Msg("")
+		if got, want := out.String(), `{"level":"error","with":"post","level_name":"error"}`+"\n"; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+	t.Run("With/multi/pre", func(t *testing.T) {
+		out := &bytes.Buffer{}
+		log := New(out).Hook(levelNameHook).Hook(simpleHook).With().Str("with", "pre").Logger()
+		log.Error().Msg("")
+		if got, want := out.String(), `{"level":"error","with":"pre","level_name":"error","has_level":true,"test":"logged"}`+"\n"; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+	t.Run("With/multi/post", func(t *testing.T) {
+		out := &bytes.Buffer{}
+		log := New(out).With().Str("with", "post").Logger().Hook(levelNameHook).Hook(simpleHook)
+		log.Error().Msg("")
+		if got, want := out.String(), `{"level":"error","with":"post","level_name":"error","has_level":true,"test":"logged"}`+"\n"; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+	t.Run("With/mixed", func(t *testing.T) {
+		out := &bytes.Buffer{}
+		log := New(out).Hook(levelNameHook).With().Str("with", "mixed").Logger().Hook(simpleHook)
+		log.Error().Msg("")
+		if got, want := out.String(), `{"level":"error","with":"mixed","level_name":"error","has_level":true,"test":"logged"}`+"\n"; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+	t.Run("None", func(t *testing.T) {
+		out := &bytes.Buffer{}
+		log := New(out)
+		log.Error().Msg("")
+		if got, want := out.String(), `{"level":"error"}`+"\n"; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+}
+
+func BenchmarkHooks(b *testing.B) {
+	logger := New(ioutil.Discard)
+	b.ResetTimer()
+	b.Run("Nop/Single", func(b *testing.B) {
+		log := logger.Hook(nopHook)
+		b.RunParallel(func(pb *testing.PB) {
+			for pb.Next() {
+				log.Log().Msg("")
+			}
+		})
+	})
+	b.Run("Nop/Multi", func(b *testing.B) {
+		log := logger.Hook(nopHook).Hook(nopHook)
+		b.RunParallel(func(pb *testing.PB) {
+			for pb.Next() {
+				log.Log().Msg("")
+			}
+		})
+	})
+	b.Run("Simple", func(b *testing.B) {
+		log := logger.Hook(simpleHook)
+		b.RunParallel(func(pb *testing.PB) {
+			for pb.Next() {
+				log.Log().Msg("")
+			}
+		})
+	})
+}

log.go

@@ -65,6 +65,23 @@
 //     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"}
+//
 package zerolog
 
 import (
@@ -93,6 +110,8 @@ const (
 	FatalLevel
 	// PanicLevel defines panic log level.
 	PanicLevel
+	// NoLevel defines an absent log level.
+	NoLevel
 	// Disabled disables the logger.
 	Disabled
 )
@@ -111,12 +130,12 @@ func (l Level) String() string {
 		return "fatal"
 	case PanicLevel:
 		return "panic"
+	case NoLevel:
+		return ""
 	}
 	return ""
 }
 
-var disabledEvent = newEvent(levelWriterAdapter{ioutil.Discard}, 0, false)
-
 // 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
@@ -127,6 +146,7 @@ type Logger struct {
 	level   Level
 	sampler Sampler
 	context []byte
+	hooks   []Hook
 }
 
 // New creates a root logger with given output writer. If the output writer implements
@@ -157,8 +177,13 @@ func (l Logger) Output(w io.Writer) Logger {
 	l2 := New(w)
 	l2.level = l.level
 	l2.sampler = l.sampler
-	l2.context = make([]byte, len(l.context), cap(l.context))
-	copy(l2.context, l.context)
+	if len(l.hooks) > 0 {
+		l2.hooks = append(l2.hooks, l.hooks...)
+	}
+	if l.context != nil {
+		l2.context = make([]byte, len(l.context), cap(l.context))
+		copy(l2.context, l.context)
+	}
 	return l2
 }
 
@@ -201,54 +226,60 @@ func (l Logger) Sample(s Sampler) Logger {
 	return l
 }
 
+// Hook returns a logger with the h Hook.
+func (l Logger) Hook(h Hook) Logger {
+	l.hooks = append(l.hooks, h)
+	return l
+}
+
 // Debug starts a new message with debug level.
 //
 // You must call Msg on the returned event in order to send the event.
-func (l Logger) Debug() *Event {
-	return l.newEvent(DebugLevel, true, nil)
+func (l *Logger) Debug() *Event {
+	return l.newEvent(DebugLevel, nil)
 }
 
 // Info starts a new message with info level.
 //
 // You must call Msg on the returned event in order to send the event.
-func (l Logger) Info() *Event {
-	return l.newEvent(InfoLevel, true, nil)
+func (l *Logger) Info() *Event {
+	return l.newEvent(InfoLevel, nil)
 }
 
 // Warn starts a new message with warn level.
 //
 // You must call Msg on the returned event in order to send the event.
-func (l Logger) Warn() *Event {
-	return l.newEvent(WarnLevel, true, nil)
+func (l *Logger) Warn() *Event {
+	return l.newEvent(WarnLevel, nil)
 }
 
 // Error starts a new message with error level.
 //
 // You must call Msg on the returned event in order to send the event.
-func (l Logger) Error() *Event {
-	return l.newEvent(ErrorLevel, true, nil)
+func (l *Logger) Error() *Event {
+	return l.newEvent(ErrorLevel, nil)
 }
 
 // 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 (l Logger) Fatal() *Event {
-	return l.newEvent(FatalLevel, true, func(msg string) { os.Exit(1) })
+func (l *Logger) Fatal() *Event {
+	return l.newEvent(FatalLevel, func(msg string) { os.Exit(1) })
 }
 
 // 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 (l Logger) Panic() *Event {
-	return l.newEvent(PanicLevel, true, func(msg string) { panic(msg) })
+func (l *Logger) Panic() *Event {
+	return l.newEvent(PanicLevel, func(msg string) { panic(msg) })
 }
 
 // WithLevel starts a new message with level.
 //
 // You must call Msg on the returned event in order to send the event.
-func (l Logger) WithLevel(level Level) *Event {
+func (l *Logger) WithLevel(level Level) *Event {
 	switch level {
 	case DebugLevel:
 		return l.Debug()
@@ -262,8 +293,10 @@ func (l Logger) WithLevel(level Level) *Event {
 		return l.Fatal()
 	case PanicLevel:
 		return l.Panic()
+	case NoLevel:
+		return l.Log()
 	case Disabled:
-		return disabledEvent
+		return nil
 	default:
 		panic("zerolog: WithLevel(): invalid level: " + strconv.Itoa(int(level)))
 	}
@@ -273,15 +306,13 @@ func (l Logger) WithLevel(level Level) *Event {
 // will still disable events produced by this method.
 //
 // You must call Msg on the returned event in order to send the event.
-func (l Logger) Log() *Event {
-	// We use panic level with addLevelField=false to make Log passthrough all
-	// levels except Disabled.
-	return l.newEvent(PanicLevel, false, nil)
+func (l *Logger) Log() *Event {
+	return l.newEvent(NoLevel, nil)
 }
 
 // Print sends a log event using debug level and no extra field.
 // Arguments are handled in the manner of fmt.Print.
-func (l Logger) Print(v ...interface{}) {
+func (l *Logger) Print(v ...interface{}) {
 	if e := l.Debug(); e.Enabled() {
 		e.Msg(fmt.Sprint(v...))
 	}
@@ -289,7 +320,7 @@ func (l Logger) Print(v ...interface{}) {
 
 // Printf sends a log event using debug level and no extra field.
 // Arguments are handled in the manner of fmt.Printf.
-func (l Logger) Printf(format string, v ...interface{}) {
+func (l *Logger) Printf(format string, v ...interface{}) {
 	if e := l.Debug(); e.Enabled() {
 		e.Msg(fmt.Sprintf(format, v...))
 	}
@@ -307,22 +338,18 @@ func (l Logger) Write(p []byte) (n int, err error) {
 	return
 }
 
-func (l Logger) newEvent(level Level, addLevelField bool, done func(string)) *Event {
+func (l *Logger) newEvent(level Level, done func(string)) *Event {
 	enabled := l.should(level)
 	if !enabled {
-		return disabledEvent
+		return nil
 	}
-	lvl := InfoLevel
-	if addLevelField {
-		lvl = level
-	}
-	e := newEvent(l.w, lvl, true)
+	e := newEvent(l.w, level, true)
 	e.done = done
 	if l.context != nil && len(l.context) > 0 && l.context[0] > 0 {
 		// first byte of context is ts flag
 		e.buf = json.AppendTime(json.AppendKey(e.buf, TimestampFieldName), TimestampFunc(), TimeFieldFormat)
 	}
-	if addLevelField {
+	if level != NoLevel {
 		e.Str(LevelFieldName, level.String())
 	}
 	if l.context != nil && len(l.context) > 1 {
@@ -331,11 +358,14 @@ func (l Logger) newEvent(level Level, addLevelField bool, done func(string)) *Ev
 		}
 		e.buf = append(e.buf, l.context[1:]...)
 	}
+	if len(l.hooks) > 0 {
+		e.h = append(e.h, l.hooks...)
+	}
 	return e
 }
 
 // should returns true if the log event should be logged.
-func (l Logger) should(lvl Level) bool {
+func (l *Logger) should(lvl Level) bool {
 	if lvl < l.level || lvl < globalLevel() {
 		return false
 	}

log/log.go

@@ -32,6 +32,11 @@ func Sample(s zerolog.Sampler) zerolog.Logger {
 	return Logger.Sample(s)
 }
 
+// Hook returns a logger with the h Hook.
+func Hook(h zerolog.Hook) zerolog.Logger {
+	return Logger.Hook(h)
+}
+
 // Debug starts a new message with debug level.
 //
 // You must call Msg on the returned event in order to send the event.
@@ -76,6 +81,13 @@ func Panic() *zerolog.Event {
 	return Logger.Panic()
 }
 
+// WithLevel starts a new message with level.
+//
+// You must call Msg on the returned event in order to send the event.
+func WithLevel(level zerolog.Level) *zerolog.Event {
+	return Logger.WithLevel(level)
+}
+
 // Log starts a new message with no level. Setting zerolog.GlobalLevel to
 // zerlog.Disabled will still disable events produced by this method.
 //

log_example_test.go

@@ -49,6 +49,33 @@ func ExampleLogger_Sample() {
 	// {"level":"info","message":"message 4"}
 }
 
+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 ExampleLogger_Hook() {
+	var levelNameHook LevelNameHook
+	var messageHook MessageHook = "The message"
+
+	log := zerolog.New(os.Stdout).Hook(levelNameHook).Hook(messageHook)
+
+	log.Info().Msg("hello world")
+
+	// Output: {"level":"info","level_name":"info","the_message":"hello world","message":"hello world"}
+}
+
 func ExampleLogger_Print() {
 	log := zerolog.New(os.Stdout)
 

log_test.go

@@ -273,7 +273,8 @@ func TestFieldsDisabled(t *testing.T) {
 
 func TestMsgf(t *testing.T) {
 	out := &bytes.Buffer{}
-	New(out).Log().Msgf("one %s %.1f %d %v", "two", 3.4, 5, errors.New("six"))
+	log := New(out)
+	log.Log().Msgf("one %s %.1f %d %v", "two", 3.4, 5, errors.New("six"))
 	if got, want := out.String(), `{"message":"one two 3.4 5 six"}`+"\n"; got != want {
 		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
 	}
@@ -298,6 +299,42 @@ func TestLevel(t *testing.T) {
 		}
 	})
 
+	t.Run("NoLevel/Disabled", func(t *testing.T) {
+		out := &bytes.Buffer{}
+		log := New(out).Level(Disabled)
+		log.Log().Msg("test")
+		if got, want := out.String(), ""; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+
+	t.Run("NoLevel/Info", func(t *testing.T) {
+		out := &bytes.Buffer{}
+		log := New(out).Level(InfoLevel)
+		log.Log().Msg("test")
+		if got, want := out.String(), `{"message":"test"}`+"\n"; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+
+	t.Run("NoLevel/Panic", func(t *testing.T) {
+		out := &bytes.Buffer{}
+		log := New(out).Level(PanicLevel)
+		log.Log().Msg("test")
+		if got, want := out.String(), `{"message":"test"}`+"\n"; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+
+	t.Run("NoLevel/WithLevel", func(t *testing.T) {
+		out := &bytes.Buffer{}
+		log := New(out).Level(InfoLevel)
+		log.WithLevel(NoLevel).Msg("test")
+		if got, want := out.String(), `{"message":"test"}`+"\n"; got != want {
+			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+		}
+	})
+
 	t.Run("Info", func(t *testing.T) {
 		out := &bytes.Buffer{}
 		log := New(out).Level(InfoLevel)
@@ -351,10 +388,12 @@ func TestLevelWriter(t *testing.T) {
 	log.Info().Msg("2")
 	log.Warn().Msg("3")
 	log.Error().Msg("4")
+	log.Log().Msg("nolevel-1")
 	log.WithLevel(DebugLevel).Msg("5")
 	log.WithLevel(InfoLevel).Msg("6")
 	log.WithLevel(WarnLevel).Msg("7")
 	log.WithLevel(ErrorLevel).Msg("8")
+	log.WithLevel(NoLevel).Msg("nolevel-2")
 
 	want := []struct {
 		l Level
@@ -364,10 +403,12 @@ func TestLevelWriter(t *testing.T) {
 		{InfoLevel, `{"level":"info","message":"2"}` + "\n"},
 		{WarnLevel, `{"level":"warn","message":"3"}` + "\n"},
 		{ErrorLevel, `{"level":"error","message":"4"}` + "\n"},
+		{NoLevel, `{"message":"nolevel-1"}` + "\n"},
 		{DebugLevel, `{"level":"debug","message":"5"}` + "\n"},
 		{InfoLevel, `{"level":"info","message":"6"}` + "\n"},
 		{WarnLevel, `{"level":"warn","message":"7"}` + "\n"},
 		{ErrorLevel, `{"level":"error","message":"8"}` + "\n"},
+		{NoLevel, `{"message":"nolevel-2"}` + "\n"},
 	}
 	if got := lw.ops; !reflect.DeepEqual(got, want) {
 		t.Errorf("invalid ops:\ngot:\n%v\nwant:\n%v", got, want)
@@ -405,3 +446,31 @@ func TestEventTimestamp(t *testing.T) {
 		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
 	}
 }
+
+func TestOutputWithoutTimestamp(t *testing.T) {
+	ignoredOut := &bytes.Buffer{}
+	out := &bytes.Buffer{}
+	log := New(ignoredOut).Output(out).With().Str("foo", "bar").Logger()
+	log.Log().Msg("hello world")
+
+	if got, want := out.String(), `{"foo":"bar","message":"hello world"}`+"\n"; got != want {
+		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+	}
+}
+
+func TestOutputWithTimestamp(t *testing.T) {
+	TimestampFunc = func() time.Time {
+		return time.Date(2001, time.February, 3, 4, 5, 6, 7, time.UTC)
+	}
+	defer func() {
+		TimestampFunc = time.Now
+	}()
+	ignoredOut := &bytes.Buffer{}
+	out := &bytes.Buffer{}
+	log := New(ignoredOut).Output(out).With().Timestamp().Str("foo", "bar").Logger()
+	log.Log().Msg("hello world")
+
+	if got, want := out.String(), `{"time":"2001-02-03T04:05:06Z","foo":"bar","message":"hello world"}`+"\n"; got != want {
+		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
+	}
+}

sampler.go

@@ -31,10 +31,8 @@ func (s RandomSampler) Sample(lvl Level) bool {
 	if s <= 0 {
 		return false
 	}
-	if s > 0 {
-		if rand.Intn(int(s)) != 0 {
-			return false
-		}
+	if rand.Intn(int(s)) != 0 {
+		return false
 	}
 	return true
 }
@@ -70,7 +68,7 @@ type BurstSampler struct {
 
 // Sample implements the Sampler interface.
 func (s *BurstSampler) Sample(lvl Level) bool {
-	if s.Burst > 9 && s.Period > 0 {
+	if s.Burst > 0 && s.Period > 0 {
 		if s.inc() <= s.Burst {
 			return true
 		}

syslog.go

@@ -44,6 +44,8 @@ func (sw syslogWriter) WriteLevel(level Level, p []byte) (n int, err error) {
 		err = sw.w.Emerg(string(p))
 	case PanicLevel:
 		err = sw.w.Crit(string(p))
+	case NoLevel:
+		err = sw.w.Info(string(p))
 	default:
 		panic("invalid level")
 	}

syslog_test.go

@@ -1,3 +1,5 @@
+// +build !windows
+
 package zerolog
 
 import "testing"
@@ -46,11 +48,13 @@ func TestSyslogWriter(t *testing.T) {
 	log.Info().Msg("info")
 	log.Warn().Msg("warn")
 	log.Error().Msg("error")
+	log.Log().Msg("nolevel")
 	want := []syslogEvent{
 		{"Debug", `{"level":"debug","message":"debug"}` + "\n"},
 		{"Info", `{"level":"info","message":"info"}` + "\n"},
 		{"Warning", `{"level":"warn","message":"warn"}` + "\n"},
 		{"Err", `{"level":"error","message":"error"}` + "\n"},
+		{"Info", `{"message":"nolevel"}` + "\n"},
 	}
 	if got := sw.events; !reflect.DeepEqual(got, want) {
 		t.Errorf("Invalid syslog message routing: want %v, got %v", want, got)

writer_test.go

@@ -1,3 +1,5 @@
+// +build !windows
+
 package zerolog
 
 import (
@@ -12,11 +14,13 @@ func TestMultiSyslogWriter(t *testing.T) {
 	log.Info().Msg("info")
 	log.Warn().Msg("warn")
 	log.Error().Msg("error")
+	log.Log().Msg("nolevel")
 	want := []syslogEvent{
 		{"Debug", `{"level":"debug","message":"debug"}` + "\n"},
 		{"Info", `{"level":"info","message":"info"}` + "\n"},
 		{"Warning", `{"level":"warn","message":"warn"}` + "\n"},
 		{"Err", `{"level":"error","message":"error"}` + "\n"},
+		{"Info", `{"message":"nolevel"}` + "\n"},
 	}
 	if got := sw.events; !reflect.DeepEqual(got, want) {
 		t.Errorf("Invalid syslog message routing: want %v, got %v", want, got)