Embed the diode lib to avoid test dependencies

This commit introduces a breaking change in the diode API in order to
hide the diodes package interface. This removes a good number of
dependencies introduced by the test framework used by the diodes
package.

README.md

@@ -10,7 +10,7 @@ Uber's [zap](https://godoc.org/go.uber.org/zap) library pioneered this approach.
 
 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`.
 
-![](pretty.png)
+![Pretty Logging Image](pretty.png)
 
 ## Who uses zerolog
 
@@ -34,32 +34,61 @@ Find out [who uses zerolog](https://github.com/rs/zerolog/wiki/Who-uses-zerolog)
 ```go
 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**
+
 ```go
 package main
 
 import (
-	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
+    "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 = ""
+    // 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 = ""
 
-	log.Print("hello world")
+    log.Print("hello world")
 }
 
 // Output: {"time":1516134303,"level":"debug","message":"hello world"}
 ```
+
 > Note: The default log level for `log.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:
+
+```go
+package main
+
+import (
+    "github.com/rs/zerolog"
+    "github.com/rs/zerolog/log"
+)
+
+func main() {
+    zerolog.TimeFieldFormat = ""
+
+    log.Debug().
+        Str("Scale", "833 cents").
+        Float64("Interval", 833.09).
+        Msg("Fibonacci is everywhere")
+}
+
+// Output: {"time":1524104936,"level":"debug","Scale":"833 cents","Interval":833.09,"message":"Fibonacci is everywhere"}
+```
+
+> 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](#standard-types)
+
 ### Leveled Logging
 
 #### Simple Leveled Logging Example
@@ -68,26 +97,29 @@ func main() {
 package main
 
 import (
-	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
+    "github.com/rs/zerolog"
+    "github.com/rs/zerolog/log"
 )
 
 func main() {
-	zerolog.TimeFieldFormat = ""
+    zerolog.TimeFieldFormat = ""
 
-	log.Info().Msg("hello world")
+    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 the `Msg` or `Msgf` 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)
+
+* panic (`zerolog.PanicLevel`, 5)
+* fatal (`zerolog.FatalLevel`, 4)
+* error (`zerolog.ErrorLevel`, 3)
+* warn (`zerolog.WarnLevel`, 2)
+* info (`zerolog.InfoLevel`, 1)
+* debug (`zerolog.DebugLevel`, 0)
 
 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.
 
@@ -99,41 +131,44 @@ This example uses command-line flags to demonstrate various outputs depending on
 package main
 
 import (
-	"flag"
+    "flag"
 
-	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
+    "github.com/rs/zerolog"
+    "github.com/rs/zerolog/log"
 )
 
 func main() {
-	zerolog.TimeFieldFormat = ""
-	debug := flag.Bool("debug", false, "sets log level to debug")
+    zerolog.TimeFieldFormat = ""
+    debug := flag.Bool("debug", false, "sets log level to debug")
 
-	flag.Parse()
+    flag.Parse()
 
-	// Default level for this example is info, unless debug flag is present
-	zerolog.SetGlobalLevel(zerolog.InfoLevel)
-	if *debug {
-		zerolog.SetGlobalLevel(zerolog.DebugLevel)
-	}
+    // 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")
+    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")
-	}
+    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)
+
 ```bash
 $ ./logLevelExample
 {"time":1516387492,"level":"info","message":"This message appears when log level set to Debug or Info"}
 ```
 
 Debug Output (debug flag set)
+
 ```bash
 $ ./logLevelExample -debug
 {"time":1516387573,"level":"debug","message":"This message appears only when log level set to Debug"}
@@ -141,48 +176,59 @@ $ ./logLevelExample -debug
 {"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.
+
+```go
+package main
+
+import (
+    "github.com/rs/zerolog"
+    "github.com/rs/zerolog/log"
+)
+
+func main() {
+    zerolog.TimeFieldFormat = ""
+
+    log.Log().
+        Str("foo", "bar").
+        Msg("")
+}
+
+// Output: {"time":1494567715,"foo":"bar"}
+```
+
 #### Logging Fatal Messages
 
 ```go
 package main
 
 import (
-	"errors"
+    "errors"
 
-	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
+    "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"
+    err := errors.New("A repo man spends his life getting into tense situations")
+    service := "myservice"
 
-	zerolog.TimeFieldFormat = ""
+    zerolog.TimeFieldFormat = ""
 
-	log.Fatal().
-		Err(err).
-		Str("service", service).
-		Msgf("Cannot start %s", service)
+    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.
 
-### Contextual Logging
-
-#### Fields can be added to log messages
-
-```go
-log.Info().
-    Str("foo", "bar").
-    Int("n", 123).
-    Msg("hello world")
-
-// Output: {"level":"info","time":1494567715,"foo":"bar","n":123,"message":"hello world"}
-```
-
 ### Create logger instance to manage different outputs
 
 ```go
@@ -223,7 +269,7 @@ log.Info().
     Str("foo", "bar").
     Dict("dict", zerolog.Dict().
         Str("bar", "baz").
-        Int("n", 1)
+        Int("n", 1),
     ).Msg("hello world")
 
 // Output: {"level":"info","time":1494567715,"foo":"bar","dict":{"bar":"baz","n":1},"message":"hello world"}
@@ -241,14 +287,6 @@ log.Info().Msg("hello world")
 // Output: {"l":"info","t":1494567715,"m":"hello world"}
 ```
 
-### Log with no level nor message
-
-```go
-log.Log().Str("foo","bar").Msg("")
-
-// Output: {"time":1494567715,"foo":"bar"}
-```
-
 ### Add contextual fields to the global logger
 
 ```go
@@ -404,8 +442,8 @@ Some settings can be changed and will by applied to all loggers:
 * `zerolog.MessageFieldName`: Can be set to customize message field name.
 * `zerolog.ErrorFieldName`: Can be set to customize `Err` field name.
 * `zerolog.TimeFieldFormat`: Can be set to customize `Time` field value formatting. If set with an empty string, times are formated as UNIX timestamp.
-	// DurationFieldUnit defines the unit for time.Duration type fields added
-	// using the Dur method.
+    // DurationFieldUnit defines the unit for time.Duration type fields added
+    // using the Dur method.
 * `DurationFieldUnit`: Sets the unit of the fields added by `Dur` (default: `time.Millisecond`).
 * `DurationFieldInteger`: If set to true, `Dur` fields are formatted as integers instead of floats.
 
@@ -430,28 +468,35 @@ Some settings can be changed and will by applied to all loggers:
 
 ## Binary Encoding
 
-In addition to the default JSON encoding, `zerolog` can produce binary logs using the [cbor](http://cbor.io) encoding. The choice of encoding can be decided at compile time using the build tag `binary_log` as follow:
+In addition to the default JSON encoding, `zerolog` can produce binary logs using [CBOR](http://cbor.io) encoding. The choice of encoding can be decided at compile time using the build tag `binary_log` as follows:
 
-```
+```bash
 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](https://github.com/toravir/csd/).
+
+## Related Projects
+
+* [grpc-zerolog](https://github.com/cheapRoc/grpc-zerolog): Implementation of `grpclog.LoggerV2` interface using `zerolog`
+
 ## 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
+```text
+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.
 
-- [imkira/go-loggers-bench](https://github.com/imkira/go-loggers-bench)
-- [uber-common/zap](https://github.com/uber-go/zap#performance)
+* [imkira/go-loggers-bench](https://github.com/imkira/go-loggers-bench)
+* [uber-common/zap](https://github.com/uber-go/zap#performance)
 
 Using Uber's zap comparison benchmark:
 

array.go

@@ -1,6 +1,7 @@
 package zerolog
 
 import (
+	"net"
 	"sync"
 	"time"
 )
@@ -32,145 +33,163 @@ func (*Array) MarshalZerologArray(*Array) {
 }
 
 func (a *Array) write(dst []byte) []byte {
-	dst = appendArrayStart(dst)
+	dst = enc.AppendArrayStart(dst)
 	if len(a.buf) > 0 {
 		dst = append(append(dst, a.buf...))
 	}
-	dst = appendArrayEnd(dst)
+	dst = enc.AppendArrayEnd(dst)
 	arrayPool.Put(a)
 	return dst
 }
 
 // Object marshals an object that implement the LogObjectMarshaler
-// interface and append it to the array.
+// interface and append append it to the array.
 func (a *Array) Object(obj LogObjectMarshaler) *Array {
 	e := Dict()
 	obj.MarshalZerologObject(e)
-	e.buf = appendEndMarker(e.buf)
-	a.buf = append(appendArrayDelim(a.buf), e.buf...)
+	e.buf = enc.AppendEndMarker(e.buf)
+	a.buf = append(enc.AppendArrayDelim(a.buf), e.buf...)
 	eventPool.Put(e)
 	return a
 }
 
-// Str append the val as a string to the array.
+// Str append append the val as a string to the array.
 func (a *Array) Str(val string) *Array {
-	a.buf = appendString(appendArrayDelim(a.buf), val)
+	a.buf = enc.AppendString(enc.AppendArrayDelim(a.buf), val)
 	return a
 }
 
-// Bytes append the val as a string to the array.
+// Bytes append append the val as a string to the array.
 func (a *Array) Bytes(val []byte) *Array {
-	a.buf = appendBytes(appendArrayDelim(a.buf), val)
+	a.buf = enc.AppendBytes(enc.AppendArrayDelim(a.buf), val)
 	return a
 }
 
-// Hex append the val as a hex string to the array.
+// Hex append append the val as a hex string to the array.
 func (a *Array) Hex(val []byte) *Array {
-	a.buf = appendHex(appendArrayDelim(a.buf), val)
+	a.buf = enc.AppendHex(enc.AppendArrayDelim(a.buf), val)
 	return a
 }
 
-// Err append the err as a string to the array.
+// Err append append the err as a string to the array.
 func (a *Array) Err(err error) *Array {
-	a.buf = appendError(appendArrayDelim(a.buf), err)
+	a.buf = enc.AppendError(enc.AppendArrayDelim(a.buf), err)
 	return a
 }
 
-// Bool append the val as a bool to the array.
+// Bool append append the val as a bool to the array.
 func (a *Array) Bool(b bool) *Array {
-	a.buf = appendBool(appendArrayDelim(a.buf), b)
+	a.buf = enc.AppendBool(enc.AppendArrayDelim(a.buf), b)
 	return a
 }
 
-// Int append i as a int to the array.
+// Int append append i as a int to the array.
 func (a *Array) Int(i int) *Array {
-	a.buf = appendInt(appendArrayDelim(a.buf), i)
+	a.buf = enc.AppendInt(enc.AppendArrayDelim(a.buf), i)
 	return a
 }
 
-// Int8 append i as a int8 to the array.
+// Int8 append append i as a int8 to the array.
 func (a *Array) Int8(i int8) *Array {
-	a.buf = appendInt8(appendArrayDelim(a.buf), i)
+	a.buf = enc.AppendInt8(enc.AppendArrayDelim(a.buf), i)
 	return a
 }
 
-// Int16 append i as a int16 to the array.
+// Int16 append append i as a int16 to the array.
 func (a *Array) Int16(i int16) *Array {
-	a.buf = appendInt16(appendArrayDelim(a.buf), i)
+	a.buf = enc.AppendInt16(enc.AppendArrayDelim(a.buf), i)
 	return a
 }
 
-// Int32 append i as a int32 to the array.
+// Int32 append append i as a int32 to the array.
 func (a *Array) Int32(i int32) *Array {
-	a.buf = appendInt32(appendArrayDelim(a.buf), i)
+	a.buf = enc.AppendInt32(enc.AppendArrayDelim(a.buf), i)
 	return a
 }
 
-// Int64 append i as a int64 to the array.
+// Int64 append append i as a int64 to the array.
 func (a *Array) Int64(i int64) *Array {
-	a.buf = appendInt64(appendArrayDelim(a.buf), i)
+	a.buf = enc.AppendInt64(enc.AppendArrayDelim(a.buf), i)
 	return a
 }
 
-// Uint append i as a uint to the array.
+// Uint append append i as a uint to the array.
 func (a *Array) Uint(i uint) *Array {
-	a.buf = appendUint(appendArrayDelim(a.buf), i)
+	a.buf = enc.AppendUint(enc.AppendArrayDelim(a.buf), i)
 	return a
 }
 
-// Uint8 append i as a uint8 to the array.
+// Uint8 append append i as a uint8 to the array.
 func (a *Array) Uint8(i uint8) *Array {
-	a.buf = appendUint8(appendArrayDelim(a.buf), i)
+	a.buf = enc.AppendUint8(enc.AppendArrayDelim(a.buf), i)
 	return a
 }
 
-// Uint16 append i as a uint16 to the array.
+// Uint16 append append i as a uint16 to the array.
 func (a *Array) Uint16(i uint16) *Array {
-	a.buf = appendUint16(appendArrayDelim(a.buf), i)
+	a.buf = enc.AppendUint16(enc.AppendArrayDelim(a.buf), i)
 	return a
 }
 
-// Uint32 append i as a uint32 to the array.
+// Uint32 append append i as a uint32 to the array.
 func (a *Array) Uint32(i uint32) *Array {
-	a.buf = appendUint32(appendArrayDelim(a.buf), i)
+	a.buf = enc.AppendUint32(enc.AppendArrayDelim(a.buf), i)
 	return a
 }
 
-// Uint64 append i as a uint64 to the array.
+// Uint64 append append i as a uint64 to the array.
 func (a *Array) Uint64(i uint64) *Array {
-	a.buf = appendUint64(appendArrayDelim(a.buf), i)
+	a.buf = enc.AppendUint64(enc.AppendArrayDelim(a.buf), i)
 	return a
 }
 
-// Float32 append f as a float32 to the array.
+// Float32 append append f as a float32 to the array.
 func (a *Array) Float32(f float32) *Array {
-	a.buf = appendFloat32(appendArrayDelim(a.buf), f)
+	a.buf = enc.AppendFloat32(enc.AppendArrayDelim(a.buf), f)
 	return a
 }
 
-// Float64 append f as a float64 to the array.
+// Float64 append append f as a float64 to the array.
 func (a *Array) Float64(f float64) *Array {
-	a.buf = appendFloat64(appendArrayDelim(a.buf), f)
+	a.buf = enc.AppendFloat64(enc.AppendArrayDelim(a.buf), f)
 	return a
 }
 
-// Time append t formated as string using zerolog.TimeFieldFormat.
+// Time append append t formated as string using zerolog.TimeFieldFormat.
 func (a *Array) Time(t time.Time) *Array {
-	a.buf = appendTime(appendArrayDelim(a.buf), t, TimeFieldFormat)
+	a.buf = enc.AppendTime(enc.AppendArrayDelim(a.buf), t, TimeFieldFormat)
 	return a
 }
 
-// Dur append d to the array.
+// Dur append append d to the array.
 func (a *Array) Dur(d time.Duration) *Array {
-	a.buf = appendDuration(appendArrayDelim(a.buf), d, DurationFieldUnit, DurationFieldInteger)
+	a.buf = enc.AppendDuration(enc.AppendArrayDelim(a.buf), d, DurationFieldUnit, DurationFieldInteger)
 	return a
 }
 
-// Interface append i marshaled using reflection.
+// Interface append append i marshaled using reflection.
 func (a *Array) Interface(i interface{}) *Array {
 	if obj, ok := i.(LogObjectMarshaler); ok {
 		return a.Object(obj)
 	}
-	a.buf = appendInterface(appendArrayDelim(a.buf), i)
+	a.buf = enc.AppendInterface(enc.AppendArrayDelim(a.buf), i)
+	return a
+}
+
+// IPAddr adds IPv4 or IPv6 address to the array
+func (a *Array) IPAddr(ip net.IP) *Array {
+	a.buf = enc.AppendIPAddr(enc.AppendArrayDelim(a.buf), ip)
+	return a
+}
+
+// IPPrefix adds IPv4 or IPv6 Prefix (IP + mask) to the array
+func (a *Array) IPPrefix(pfx net.IPNet) *Array {
+	a.buf = enc.AppendIPPrefix(enc.AppendArrayDelim(a.buf), pfx)
+	return a
+}
+
+// MACAddr adds a MAC (Ethernet) address to the array
+func (a *Array) MACAddr(ha net.HardwareAddr) *Array {
+	a.buf = enc.AppendMACAddr(enc.AppendArrayDelim(a.buf), ha)
 	return a
 }

array_test.go

@@ -1,6 +1,7 @@
 package zerolog
 
 import (
+	"net"
 	"testing"
 	"time"
 )
@@ -18,14 +19,15 @@ func TestArray(t *testing.T) {
 		Uint16(8).
 		Uint32(9).
 		Uint64(10).
-		Float32(11).
-		Float64(12).
+		Float32(11.98122).
+		Float64(12.987654321).
 		Str("a").
 		Bytes([]byte("b")).
 		Hex([]byte{0x1f}).
 		Time(time.Time{}).
+		IPAddr(net.IP{192, 168, 0, 10}).
 		Dur(0)
-	want := `[true,1,2,3,4,5,6,7,8,9,10,11,12,"a","b","1f","0001-01-01T00:00:00Z",0]`
+	want := `[true,1,2,3,4,5,6,7,8,9,10,11.98122,12.987654321,"a","b","1f","0001-01-01T00:00:00Z","192.168.0.10",0]`
 	if got := decodeObjectToStr(a.write([]byte{})); got != want {
 		t.Errorf("Array.write()\ngot:  %s\nwant: %s", got, want)
 	}

binary_test.go

@@ -283,6 +283,21 @@ func ExampleEvent_Object() {
 	// Output: {"foo":"bar","user":{"name":"John","age":35,"created":"0001-01-01T00:00:00Z"},"message":"hello world"}
 }
 
+func ExampleEvent_EmbedObject() {
+	price := Price{val: 6449, prec: 2, unit: "$"}
+
+	dst := bytes.Buffer{}
+	log := New(&dst)
+
+	log.Log().
+		Str("foo", "bar").
+		EmbedObject(price).
+		Msg("hello world")
+
+	fmt.Println(decodeIfBinaryToString(dst.Bytes()))
+	// Output: {"foo":"bar","price":"$64.49","message":"hello world"}
+}
+
 func ExampleEvent_Interface() {
 	dst := bytes.Buffer{}
 	log := New(&dst)
@@ -384,6 +399,36 @@ func ExampleContext_Array_object() {
 	// 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"}
 }
 
+type Price struct {
+	val  uint64
+	prec int
+	unit string
+}
+
+func (p Price) MarshalZerologObject(e *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 ExampleContext_EmbedObject() {
+	price := Price{val: 6449, prec: 2, unit: "$"}
+
+	dst := bytes.Buffer{}
+	log := New(&dst).With().
+		Str("foo", "bar").
+		EmbedObject(price).
+		Logger()
+
+	log.Log().Msg("hello world")
+
+	fmt.Println(decodeIfBinaryToString(dst.Bytes()))
+	// Output: {"foo":"bar","price":"$64.49","message":"hello world"}
+}
 func ExampleContext_Object() {
 	// User implements LogObjectMarshaler
 	u := User{"John", 35, time.Time{}}

console.go

@@ -9,6 +9,7 @@ import (
 	"strconv"
 	"strings"
 	"sync"
+	"time"
 )
 
 const (
@@ -40,7 +41,9 @@ type ConsoleWriter struct {
 func (w ConsoleWriter) Write(p []byte) (n int, err error) {
 	var event map[string]interface{}
 	p = decodeIfBinaryToBytes(p)
-	err = json.Unmarshal(p, &event)
+	d := json.NewDecoder(bytes.NewReader(p))
+	d.UseNumber()
+	err = d.Decode(&event)
 	if err != nil {
 		return
 	}
@@ -55,7 +58,7 @@ func (w ConsoleWriter) Write(p []byte) (n int, err error) {
 		level = strings.ToUpper(l)[0:4]
 	}
 	fmt.Fprintf(buf, "%s |%s| %s",
-		colorize(event[TimestampFieldName], cDarkGray, !w.NoColor),
+		colorize(formatTime(event[TimestampFieldName]), cDarkGray, !w.NoColor),
 		colorize(level, lvlColor, !w.NoColor),
 		colorize(event[MessageFieldName], cReset, !w.NoColor))
 	fields := make([]string, 0, len(event))
@@ -76,7 +79,7 @@ func (w ConsoleWriter) Write(p []byte) (n int, err error) {
 			} else {
 				buf.WriteString(value)
 			}
-		case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64:
+		case json.Number:
 			fmt.Fprint(buf, value)
 		default:
 			b, err := json.Marshal(value)
@@ -93,6 +96,17 @@ func (w ConsoleWriter) Write(p []byte) (n int, err error) {
 	return
 }
 
+func formatTime(t interface{}) string {
+	switch t := t.(type) {
+	case string:
+		return t
+	case json.Number:
+		u, _ := t.Int64()
+		return time.Unix(u, 0).Format(time.RFC3339)
+	}
+	return "<nil>"
+}
+
 func colorize(s interface{}, color int, enabled bool) string {
 	if !enabled {
 		return fmt.Sprintf("%v", s)

console_test.go

@@ -1,7 +1,10 @@
 package zerolog_test
 
 import (
+	"bytes"
 	"os"
+	"strings"
+	"testing"
 
 	"github.com/rs/zerolog"
 )
@@ -12,3 +15,16 @@ func ExampleConsoleWriter_Write() {
 	log.Info().Msg("hello world")
 	// Output: <nil> |INFO| hello world
 }
+
+func TestConsoleWriterNumbers(t *testing.T) {
+	buf := &bytes.Buffer{}
+	log := zerolog.New(zerolog.ConsoleWriter{Out: buf, NoColor: true})
+	log.Info().
+		Float64("float", 1.23).
+		Uint64("small", 123).
+		Uint64("big", 1152921504606846976).
+		Msg("msg")
+	if got, want := strings.TrimSpace(buf.String()), "<nil> |INFO| msg big=1152921504606846976 float=1.23 small=123"; got != want {
+		t.Errorf("\ngot:\n%s\nwant:\n%s", got, want)
+	}
+}

context.go

@@ -2,6 +2,7 @@ package zerolog
 
 import (
 	"io/ioutil"
+	"net"
 	"time"
 )
 
@@ -23,8 +24,8 @@ func (c Context) Fields(fields map[string]interface{}) Context {
 
 // Dict adds the field key with the dict to the logger context.
 func (c Context) Dict(key string, dict *Event) Context {
-	dict.buf = appendEndMarker(dict.buf)
-	c.l.context = append(appendKey(c.l.context, key), dict.buf...)
+	dict.buf = enc.AppendEndMarker(dict.buf)
+	c.l.context = append(enc.AppendKey(c.l.context, key), dict.buf...)
 	eventPool.Put(dict)
 	return c
 }
@@ -33,7 +34,7 @@ func (c Context) Dict(key string, dict *Event) Context {
 // Use zerolog.Arr() to create the array or pass a type that
 // implement the LogArrayMarshaler interface.
 func (c Context) Array(key string, arr LogArrayMarshaler) Context {
-	c.l.context = appendKey(c.l.context, key)
+	c.l.context = enc.AppendKey(c.l.context, key)
 	if arr, ok := arr.(*Array); ok {
 		c.l.context = arr.write(c.l.context)
 		return c
@@ -51,34 +52,43 @@ func (c Context) Array(key string, arr LogArrayMarshaler) Context {
 
 // Object marshals an object that implement the LogObjectMarshaler interface.
 func (c Context) Object(key string, obj LogObjectMarshaler) Context {
-	e := newEvent(levelWriterAdapter{ioutil.Discard}, 0, true)
+	e := newEvent(levelWriterAdapter{ioutil.Discard}, 0)
 	e.Object(key, obj)
-	c.l.context = appendObjectData(c.l.context, e.buf)
+	c.l.context = enc.AppendObjectData(c.l.context, e.buf)
+	eventPool.Put(e)
+	return c
+}
+
+// EmbedObject marshals and Embeds an object that implement the LogObjectMarshaler interface.
+func (c Context) EmbedObject(obj LogObjectMarshaler) Context {
+	e := newEvent(levelWriterAdapter{ioutil.Discard}, 0)
+	e.EmbedObject(obj)
+	c.l.context = enc.AppendObjectData(c.l.context, e.buf)
 	eventPool.Put(e)
 	return c
 }
 
 // Str adds the field key with val as a string to the logger context.
 func (c Context) Str(key, val string) Context {
-	c.l.context = appendString(appendKey(c.l.context, key), val)
+	c.l.context = enc.AppendString(enc.AppendKey(c.l.context, key), val)
 	return c
 }
 
 // Strs adds the field key with val as a string to the logger context.
 func (c Context) Strs(key string, vals []string) Context {
-	c.l.context = appendStrings(appendKey(c.l.context, key), vals)
+	c.l.context = enc.AppendStrings(enc.AppendKey(c.l.context, key), vals)
 	return c
 }
 
 // Bytes adds the field key with val as a []byte to the logger context.
 func (c Context) Bytes(key string, val []byte) Context {
-	c.l.context = appendBytes(appendKey(c.l.context, key), val)
+	c.l.context = enc.AppendBytes(enc.AppendKey(c.l.context, key), val)
 	return c
 }
 
 // Hex adds the field key with val as a hex string to the logger context.
 func (c Context) Hex(key string, val []byte) Context {
-	c.l.context = appendHex(appendKey(c.l.context, key), val)
+	c.l.context = enc.AppendHex(enc.AppendKey(c.l.context, key), val)
 	return c
 }
 
@@ -87,21 +97,21 @@ func (c Context) Hex(key string, val []byte) Context {
 // No sanity check is performed on b; it must not contain carriage returns and
 // be valid JSON.
 func (c Context) RawJSON(key string, b []byte) Context {
-	c.l.context = appendJSON(appendKey(c.l.context, key), b)
+	c.l.context = appendJSON(enc.AppendKey(c.l.context, key), b)
 	return c
 }
 
 // AnErr adds the field key with err as a string to the logger context.
 func (c Context) AnErr(key string, err error) Context {
 	if err != nil {
-		c.l.context = appendError(appendKey(c.l.context, key), err)
+		c.l.context = enc.AppendError(enc.AppendKey(c.l.context, key), err)
 	}
 	return c
 }
 
 // Errs adds the field key with errs as an array of strings to the logger context.
 func (c Context) Errs(key string, errs []error) Context {
-	c.l.context = appendErrors(appendKey(c.l.context, key), errs)
+	c.l.context = enc.AppendErrors(enc.AppendKey(c.l.context, key), errs)
 	return c
 }
 
@@ -109,164 +119,164 @@ func (c Context) Errs(key string, errs []error) Context {
 // To customize the key name, change zerolog.ErrorFieldName.
 func (c Context) Err(err error) Context {
 	if err != nil {
-		c.l.context = appendError(appendKey(c.l.context, ErrorFieldName), err)
+		c.l.context = enc.AppendError(enc.AppendKey(c.l.context, ErrorFieldName), err)
 	}
 	return c
 }
 
 // Bool adds the field key with val as a bool to the logger context.
 func (c Context) Bool(key string, b bool) Context {
-	c.l.context = appendBool(appendKey(c.l.context, key), b)
+	c.l.context = enc.AppendBool(enc.AppendKey(c.l.context, key), b)
 	return c
 }
 
 // Bools adds the field key with val as a []bool to the logger context.
 func (c Context) Bools(key string, b []bool) Context {
-	c.l.context = appendBools(appendKey(c.l.context, key), b)
+	c.l.context = enc.AppendBools(enc.AppendKey(c.l.context, key), b)
 	return c
 }
 
 // Int adds the field key with i as a int to the logger context.
 func (c Context) Int(key string, i int) Context {
-	c.l.context = appendInt(appendKey(c.l.context, key), i)
+	c.l.context = enc.AppendInt(enc.AppendKey(c.l.context, key), i)
 	return c
 }
 
 // Ints adds the field key with i as a []int to the logger context.
 func (c Context) Ints(key string, i []int) Context {
-	c.l.context = appendInts(appendKey(c.l.context, key), i)
+	c.l.context = enc.AppendInts(enc.AppendKey(c.l.context, key), i)
 	return c
 }
 
 // Int8 adds the field key with i as a int8 to the logger context.
 func (c Context) Int8(key string, i int8) Context {
-	c.l.context = appendInt8(appendKey(c.l.context, key), i)
+	c.l.context = enc.AppendInt8(enc.AppendKey(c.l.context, key), i)
 	return c
 }
 
 // Ints8 adds the field key with i as a []int8 to the logger context.
 func (c Context) Ints8(key string, i []int8) Context {
-	c.l.context = appendInts8(appendKey(c.l.context, key), i)
+	c.l.context = enc.AppendInts8(enc.AppendKey(c.l.context, key), i)
 	return c
 }
 
 // Int16 adds the field key with i as a int16 to the logger context.
 func (c Context) Int16(key string, i int16) Context {
-	c.l.context = appendInt16(appendKey(c.l.context, key), i)
+	c.l.context = enc.AppendInt16(enc.AppendKey(c.l.context, key), i)
 	return c
 }
 
 // Ints16 adds the field key with i as a []int16 to the logger context.
 func (c Context) Ints16(key string, i []int16) Context {
-	c.l.context = appendInts16(appendKey(c.l.context, key), i)
+	c.l.context = enc.AppendInts16(enc.AppendKey(c.l.context, key), i)
 	return c
 }
 
 // Int32 adds the field key with i as a int32 to the logger context.
 func (c Context) Int32(key string, i int32) Context {
-	c.l.context = appendInt32(appendKey(c.l.context, key), i)
+	c.l.context = enc.AppendInt32(enc.AppendKey(c.l.context, key), i)
 	return c
 }
 
 // Ints32 adds the field key with i as a []int32 to the logger context.
 func (c Context) Ints32(key string, i []int32) Context {
-	c.l.context = appendInts32(appendKey(c.l.context, key), i)
+	c.l.context = enc.AppendInts32(enc.AppendKey(c.l.context, key), i)
 	return c
 }
 
 // Int64 adds the field key with i as a int64 to the logger context.
 func (c Context) Int64(key string, i int64) Context {
-	c.l.context = appendInt64(appendKey(c.l.context, key), i)
+	c.l.context = enc.AppendInt64(enc.AppendKey(c.l.context, key), i)
 	return c
 }
 
 // Ints64 adds the field key with i as a []int64 to the logger context.
 func (c Context) Ints64(key string, i []int64) Context {
-	c.l.context = appendInts64(appendKey(c.l.context, key), i)
+	c.l.context = enc.AppendInts64(enc.AppendKey(c.l.context, key), i)
 	return c
 }
 
 // Uint adds the field key with i as a uint to the logger context.
 func (c Context) Uint(key string, i uint) Context {
-	c.l.context = appendUint(appendKey(c.l.context, key), i)
+	c.l.context = enc.AppendUint(enc.AppendKey(c.l.context, key), i)
 	return c
 }
 
 // Uints adds the field key with i as a []uint to the logger context.
 func (c Context) Uints(key string, i []uint) Context {
-	c.l.context = appendUints(appendKey(c.l.context, key), i)
+	c.l.context = enc.AppendUints(enc.AppendKey(c.l.context, key), i)
 	return c
 }
 
 // Uint8 adds the field key with i as a uint8 to the logger context.
 func (c Context) Uint8(key string, i uint8) Context {
-	c.l.context = appendUint8(appendKey(c.l.context, key), i)
+	c.l.context = enc.AppendUint8(enc.AppendKey(c.l.context, key), i)
 	return c
 }
 
 // Uints8 adds the field key with i as a []uint8 to the logger context.
 func (c Context) Uints8(key string, i []uint8) Context {
-	c.l.context = appendUints8(appendKey(c.l.context, key), i)
+	c.l.context = enc.AppendUints8(enc.AppendKey(c.l.context, key), i)
 	return c
 }
 
 // Uint16 adds the field key with i as a uint16 to the logger context.
 func (c Context) Uint16(key string, i uint16) Context {
-	c.l.context = appendUint16(appendKey(c.l.context, key), i)
+	c.l.context = enc.AppendUint16(enc.AppendKey(c.l.context, key), i)
 	return c
 }
 
 // Uints16 adds the field key with i as a []uint16 to the logger context.
 func (c Context) Uints16(key string, i []uint16) Context {
-	c.l.context = appendUints16(appendKey(c.l.context, key), i)
+	c.l.context = enc.AppendUints16(enc.AppendKey(c.l.context, key), i)
 	return c
 }
 
 // Uint32 adds the field key with i as a uint32 to the logger context.
 func (c Context) Uint32(key string, i uint32) Context {
-	c.l.context = appendUint32(appendKey(c.l.context, key), i)
+	c.l.context = enc.AppendUint32(enc.AppendKey(c.l.context, key), i)
 	return c
 }
 
 // Uints32 adds the field key with i as a []uint32 to the logger context.
 func (c Context) Uints32(key string, i []uint32) Context {
-	c.l.context = appendUints32(appendKey(c.l.context, key), i)
+	c.l.context = enc.AppendUints32(enc.AppendKey(c.l.context, key), i)
 	return c
 }
 
 // Uint64 adds the field key with i as a uint64 to the logger context.
 func (c Context) Uint64(key string, i uint64) Context {
-	c.l.context = appendUint64(appendKey(c.l.context, key), i)
+	c.l.context = enc.AppendUint64(enc.AppendKey(c.l.context, key), i)
 	return c
 }
 
 // Uints64 adds the field key with i as a []uint64 to the logger context.
 func (c Context) Uints64(key string, i []uint64) Context {
-	c.l.context = appendUints64(appendKey(c.l.context, key), i)
+	c.l.context = enc.AppendUints64(enc.AppendKey(c.l.context, key), i)
 	return c
 }
 
 // Float32 adds the field key with f as a float32 to the logger context.
 func (c Context) Float32(key string, f float32) Context {
-	c.l.context = appendFloat32(appendKey(c.l.context, key), f)
+	c.l.context = enc.AppendFloat32(enc.AppendKey(c.l.context, key), f)
 	return c
 }
 
 // Floats32 adds the field key with f as a []float32 to the logger context.
 func (c Context) Floats32(key string, f []float32) Context {
-	c.l.context = appendFloats32(appendKey(c.l.context, key), f)
+	c.l.context = enc.AppendFloats32(enc.AppendKey(c.l.context, key), f)
 	return c
 }
 
 // Float64 adds the field key with f as a float64 to the logger context.
 func (c Context) Float64(key string, f float64) Context {
-	c.l.context = appendFloat64(appendKey(c.l.context, key), f)
+	c.l.context = enc.AppendFloat64(enc.AppendKey(c.l.context, key), f)
 	return c
 }
 
 // Floats64 adds the field key with f as a []float64 to the logger context.
 func (c Context) Floats64(key string, f []float64) Context {
-	c.l.context = appendFloats64(appendKey(c.l.context, key), f)
+	c.l.context = enc.AppendFloats64(enc.AppendKey(c.l.context, key), f)
 	return c
 }
 
@@ -289,38 +299,39 @@ func (c Context) Timestamp() Context {
 
 // Time adds the field key with t formated as string using zerolog.TimeFieldFormat.
 func (c Context) Time(key string, t time.Time) Context {
-	c.l.context = appendTime(appendKey(c.l.context, key), t, TimeFieldFormat)
+	c.l.context = enc.AppendTime(enc.AppendKey(c.l.context, key), t, TimeFieldFormat)
 	return c
 }
 
 // Times adds the field key with t formated as string using zerolog.TimeFieldFormat.
 func (c Context) Times(key string, t []time.Time) Context {
-	c.l.context = appendTimes(appendKey(c.l.context, key), t, TimeFieldFormat)
+	c.l.context = enc.AppendTimes(enc.AppendKey(c.l.context, key), t, TimeFieldFormat)
 	return c
 }
 
 // Dur adds the fields key with d divided by unit and stored as a float.
 func (c Context) Dur(key string, d time.Duration) Context {
-	c.l.context = appendDuration(appendKey(c.l.context, key), d, DurationFieldUnit, DurationFieldInteger)
+	c.l.context = enc.AppendDuration(enc.AppendKey(c.l.context, key), d, DurationFieldUnit, DurationFieldInteger)
 	return c
 }
 
 // Durs adds the fields key with d divided by unit and stored as a float.
 func (c Context) Durs(key string, d []time.Duration) Context {
-	c.l.context = appendDurations(appendKey(c.l.context, key), d, DurationFieldUnit, DurationFieldInteger)
+	c.l.context = enc.AppendDurations(enc.AppendKey(c.l.context, key), d, DurationFieldUnit, DurationFieldInteger)
 	return c
 }
 
 // Interface adds the field key with obj marshaled using reflection.
 func (c Context) Interface(key string, i interface{}) Context {
-	c.l.context = appendInterface(appendKey(c.l.context, key), i)
+	c.l.context = enc.AppendInterface(enc.AppendKey(c.l.context, key), i)
 	return c
 }
 
 type callerHook struct{}
 
 func (ch callerHook) Run(e *Event, level Level, msg string) {
-	e.caller(4)
+        //Two extra frames to skip (added by hook infra).
+	e.caller(CallerSkipFrameCount+2)
 }
 
 var ch = callerHook{}
@@ -330,3 +341,21 @@ func (c Context) Caller() Context {
 	c.l = c.l.Hook(ch)
 	return c
 }
+
+// IPAddr adds IPv4 or IPv6 Address to the context
+func (c Context) IPAddr(key string, ip net.IP) Context {
+	c.l.context = enc.AppendIPAddr(enc.AppendKey(c.l.context, key), ip)
+	return c
+}
+
+// IPPrefix adds IPv4 or IPv6 Prefix (address and mask) to the context
+func (c Context) IPPrefix(key string, pfx net.IPNet) Context {
+	c.l.context = enc.AppendIPPrefix(enc.AppendKey(c.l.context, key), pfx)
+	return c
+}
+
+// MACAddr adds MAC address to the context
+func (c Context) MACAddr(key string, ha net.HardwareAddr) Context {
+	c.l.context = enc.AppendMACAddr(enc.AppendKey(c.l.context, key), ha)
+	return c
+}

diode/diode.go

@@ -8,7 +8,7 @@ import (
 	"sync"
 	"time"
 
-	diodes "code.cloudfoundry.org/go-diodes"
+	"github.com/rs/zerolog/diode/internal/diodes"
 )
 
 var bufPool = &sync.Pool{
@@ -17,6 +17,8 @@ var bufPool = &sync.Pool{
 	},
 }
 
+type Alerter func(missed int)
+
 // Writer is a io.Writer wrapper that uses a diode to make Write lock-free,
 // non-blocking and thread safe.
 type Writer struct {
@@ -33,19 +35,19 @@ type Writer struct {
 //
 // Use a diode.Writer when
 //
-//     d := diodes.NewManyToOne(1000, diodes.AlertFunc(func(missed int) {
+//     w := diode.NewWriter(w, 1000, 10 * time.Millisecond, func(missed int) {
 //         log.Printf("Dropped %d messages", missed)
-//     }))
-//     w := diode.NewWriter(w, d, 10 * time.Millisecond)
+//     })
 //     log := zerolog.New(w)
 //
 // See code.cloudfoundry.org/go-diodes for more info on diode.
-func NewWriter(w io.Writer, manyToOneDiode *diodes.ManyToOne, poolInterval time.Duration) Writer {
+func NewWriter(w io.Writer, size int, poolInterval time.Duration, f Alerter) Writer {
 	ctx, cancel := context.WithCancel(context.Background())
+	d := diodes.NewManyToOne(size, diodes.AlertFunc(f))
 	dw := Writer{
 		w: w,
-		d: manyToOneDiode,
-		p: diodes.NewPoller(manyToOneDiode,
+		d: d,
+		p: diodes.NewPoller(d,
 			diodes.WithPollingInterval(poolInterval),
 			diodes.WithPollingContext(ctx)),
 		c:    cancel,

diode/diode_example_test.go

@@ -7,16 +7,14 @@ import (
 	"os"
 	"time"
 
-	diodes "code.cloudfoundry.org/go-diodes"
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/diode"
 )
 
 func ExampleNewWriter() {
-	d := diodes.NewManyToOne(1000, diodes.AlertFunc(func(missed int) {
+	w := diode.NewWriter(os.Stdout, 1000, 10*time.Millisecond, func(missed int) {
 		fmt.Printf("Dropped %d messages\n", missed)
-	}))
-	w := diode.NewWriter(os.Stdout, d, 10*time.Millisecond)
+	})
 	log := zerolog.New(w)
 	log.Print("test")
 

diode/diode_test.go

@@ -9,18 +9,16 @@ import (
 	"testing"
 	"time"
 
-	diodes "code.cloudfoundry.org/go-diodes"
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/diode"
 	"github.com/rs/zerolog/internal/cbor"
 )
 
 func TestNewWriter(t *testing.T) {
-	d := diodes.NewManyToOne(1000, diodes.AlertFunc(func(missed int) {
-		fmt.Printf("Dropped %d messages\n", missed)
-	}))
 	buf := bytes.Buffer{}
-	w := diode.NewWriter(&buf, d, 10*time.Millisecond)
+	w := diode.NewWriter(&buf, 1000, 10*time.Millisecond, func(missed int) {
+		fmt.Printf("Dropped %d messages\n", missed)
+	})
 	log := zerolog.New(w)
 	log.Print("test")
 
@@ -35,8 +33,7 @@ func TestNewWriter(t *testing.T) {
 func Benchmark(b *testing.B) {
 	log.SetOutput(ioutil.Discard)
 	defer log.SetOutput(os.Stderr)
-	d := diodes.NewManyToOne(100000, nil)
-	w := diode.NewWriter(ioutil.Discard, d, 10*time.Millisecond)
+	w := diode.NewWriter(ioutil.Discard, 100000, 10*time.Millisecond, nil)
 	log := zerolog.New(w)
 	defer w.Close()
 

diode/internal/diodes/README

@@ -0,0 +1 @@
+Copied from https://github.com/cloudfoundry/go-diodes to avoid test dependencies.

diode/internal/diodes/many_to_one.go

@@ -0,0 +1,130 @@
+package diodes
+
+import (
+	"log"
+	"sync/atomic"
+	"unsafe"
+)
+
+// ManyToOne diode is optimal for many writers (go-routines B-n) and a single
+// reader (go-routine A). It is not thread safe for multiple readers.
+type ManyToOne struct {
+	buffer     []unsafe.Pointer
+	writeIndex uint64
+	readIndex  uint64
+	alerter    Alerter
+}
+
+// NewManyToOne creates a new diode (ring buffer). The ManyToOne diode
+// is optimzed for many writers (on go-routines B-n) and a single reader
+// (on go-routine A). The alerter is invoked on the read's go-routine. It is
+// called when it notices that the writer go-routine has passed it and wrote
+// over data. A nil can be used to ignore alerts.
+func NewManyToOne(size int, alerter Alerter) *ManyToOne {
+	if alerter == nil {
+		alerter = AlertFunc(func(int) {})
+	}
+
+	d := &ManyToOne{
+		buffer:  make([]unsafe.Pointer, size),
+		alerter: alerter,
+	}
+
+	// Start write index at the value before 0
+	// to allow the first write to use AddUint64
+	// and still have a beginning index of 0
+	d.writeIndex = ^d.writeIndex
+	return d
+}
+
+// Set sets the data in the next slot of the ring buffer.
+func (d *ManyToOne) Set(data GenericDataType) {
+	for {
+		writeIndex := atomic.AddUint64(&d.writeIndex, 1)
+		idx := writeIndex % uint64(len(d.buffer))
+		old := atomic.LoadPointer(&d.buffer[idx])
+
+		if old != nil &&
+			(*bucket)(old) != nil &&
+			(*bucket)(old).seq > writeIndex-uint64(len(d.buffer)) {
+			log.Println("Diode set collision: consider using a larger diode")
+			continue
+		}
+
+		newBucket := &bucket{
+			data: data,
+			seq:  writeIndex,
+		}
+
+		if !atomic.CompareAndSwapPointer(&d.buffer[idx], old, unsafe.Pointer(newBucket)) {
+			log.Println("Diode set collision: consider using a larger diode")
+			continue
+		}
+
+		return
+	}
+}
+
+// TryNext will attempt to read from the next slot of the ring buffer.
+// If there is not data available, it will return (nil, false).
+func (d *ManyToOne) TryNext() (data GenericDataType, ok bool) {
+	// Read a value from the ring buffer based on the readIndex.
+	idx := d.readIndex % uint64(len(d.buffer))
+	result := (*bucket)(atomic.SwapPointer(&d.buffer[idx], nil))
+
+	// When the result is nil that means the writer has not had the
+	// opportunity to write a value into the diode. This value must be ignored
+	// and the read head must not increment.
+	if result == nil {
+		return nil, false
+	}
+
+	// When the seq value is less than the current read index that means a
+	// value was read from idx that was previously written but has since has
+	// been dropped. This value must be ignored and the read head must not
+	// increment.
+	//
+	// The simulation for this scenario assumes the fast forward occurred as
+	// detailed below.
+	//
+	// 5. The reader reads again getting seq 5. It then reads again expecting
+	//    seq 6 but gets seq 2. This is a read of a stale value that was
+	//    effectively "dropped" so the read fails and the read head stays put.
+	//    `| 4 | 5 | 2 | 3 |` r: 7, w: 6
+	//
+	if result.seq < d.readIndex {
+		return nil, false
+	}
+
+	// When the seq value is greater than the current read index that means a
+	// value was read from idx that overwrote the value that was expected to
+	// be at this idx. This happens when the writer has lapped the reader. The
+	// reader needs to catch up to the writer so it moves its write head to
+	// the new seq, effectively dropping the messages that were not read in
+	// between the two values.
+	//
+	// Here is a simulation of this scenario:
+	//
+	// 1. Both the read and write heads start at 0.
+	//    `| nil | nil | nil | nil |` r: 0, w: 0
+	// 2. The writer fills the buffer.
+	//    `| 0 | 1 | 2 | 3 |` r: 0, w: 4
+	// 3. The writer laps the read head.
+	//    `| 4 | 5 | 2 | 3 |` r: 0, w: 6
+	// 4. The reader reads the first value, expecting a seq of 0 but reads 4,
+	//    this forces the reader to fast forward to 5.
+	//    `| 4 | 5 | 2 | 3 |` r: 5, w: 6
+	//
+	if result.seq > d.readIndex {
+		dropped := result.seq - d.readIndex
+		d.readIndex = result.seq
+		d.alerter.Alert(int(dropped))
+	}
+
+	// Only increment read index if a regular read occurred (where seq was
+	// equal to readIndex) or a value was read that caused a fast forward
+	// (where seq was greater than readIndex).
+	//
+	d.readIndex++
+	return result.data, true
+}

diode/internal/diodes/one_to_one.go

@@ -0,0 +1,129 @@
+package diodes
+
+import (
+	"sync/atomic"
+	"unsafe"
+)
+
+// GenericDataType is the data type the diodes operate on.
+type GenericDataType unsafe.Pointer
+
+// Alerter is used to report how many values were overwritten since the
+// last write.
+type Alerter interface {
+	Alert(missed int)
+}
+
+// AlertFunc type is an adapter to allow the use of ordinary functions as
+// Alert handlers.
+type AlertFunc func(missed int)
+
+// Alert calls f(missed)
+func (f AlertFunc) Alert(missed int) {
+	f(missed)
+}
+
+type bucket struct {
+	data GenericDataType
+	seq  uint64 // seq is the recorded write index at the time of writing
+}
+
+// OneToOne diode is meant to be used by a single reader and a single writer.
+// It is not thread safe if used otherwise.
+type OneToOne struct {
+	buffer     []unsafe.Pointer
+	writeIndex uint64
+	readIndex  uint64
+	alerter    Alerter
+}
+
+// NewOneToOne creates a new diode is meant to be used by a single reader and
+// a single writer. The alerter is invoked on the read's go-routine. It is
+// called when it notices that the writer go-routine has passed it and wrote
+// over data. A nil can be used to ignore alerts.
+func NewOneToOne(size int, alerter Alerter) *OneToOne {
+	if alerter == nil {
+		alerter = AlertFunc(func(int) {})
+	}
+
+	return &OneToOne{
+		buffer:  make([]unsafe.Pointer, size),
+		alerter: alerter,
+	}
+}
+
+// Set sets the data in the next slot of the ring buffer.
+func (d *OneToOne) Set(data GenericDataType) {
+	idx := d.writeIndex % uint64(len(d.buffer))
+
+	newBucket := &bucket{
+		data: data,
+		seq:  d.writeIndex,
+	}
+	d.writeIndex++
+
+	atomic.StorePointer(&d.buffer[idx], unsafe.Pointer(newBucket))
+}
+
+// TryNext will attempt to read from the next slot of the ring buffer.
+// If there is no data available, it will return (nil, false).
+func (d *OneToOne) TryNext() (data GenericDataType, ok bool) {
+	// Read a value from the ring buffer based on the readIndex.
+	idx := d.readIndex % uint64(len(d.buffer))
+	result := (*bucket)(atomic.SwapPointer(&d.buffer[idx], nil))
+
+	// When the result is nil that means the writer has not had the
+	// opportunity to write a value into the diode. This value must be ignored
+	// and the read head must not increment.
+	if result == nil {
+		return nil, false
+	}
+
+	// When the seq value is less than the current read index that means a
+	// value was read from idx that was previously written but has since has
+	// been dropped. This value must be ignored and the read head must not
+	// increment.
+	//
+	// The simulation for this scenario assumes the fast forward occurred as
+	// detailed below.
+	//
+	// 5. The reader reads again getting seq 5. It then reads again expecting
+	//    seq 6 but gets seq 2. This is a read of a stale value that was
+	//    effectively "dropped" so the read fails and the read head stays put.
+	//    `| 4 | 5 | 2 | 3 |` r: 7, w: 6
+	//
+	if result.seq < d.readIndex {
+		return nil, false
+	}
+
+	// When the seq value is greater than the current read index that means a
+	// value was read from idx that overwrote the value that was expected to
+	// be at this idx. This happens when the writer has lapped the reader. The
+	// reader needs to catch up to the writer so it moves its write head to
+	// the new seq, effectively dropping the messages that were not read in
+	// between the two values.
+	//
+	// Here is a simulation of this scenario:
+	//
+	// 1. Both the read and write heads start at 0.
+	//    `| nil | nil | nil | nil |` r: 0, w: 0
+	// 2. The writer fills the buffer.
+	//    `| 0 | 1 | 2 | 3 |` r: 0, w: 4
+	// 3. The writer laps the read head.
+	//    `| 4 | 5 | 2 | 3 |` r: 0, w: 6
+	// 4. The reader reads the first value, expecting a seq of 0 but reads 4,
+	//    this forces the reader to fast forward to 5.
+	//    `| 4 | 5 | 2 | 3 |` r: 5, w: 6
+	//
+	if result.seq > d.readIndex {
+		dropped := result.seq - d.readIndex
+		d.readIndex = result.seq
+		d.alerter.Alert(int(dropped))
+	}
+
+	// Only increment read index if a regular read occurred (where seq was
+	// equal to readIndex) or a value was read that caused a fast forward
+	// (where seq was greater than readIndex).
+	d.readIndex++
+	return result.data, true
+}

diode/internal/diodes/poller.go

@@ -0,0 +1,80 @@
+package diodes
+
+import (
+	"context"
+	"time"
+)
+
+// Diode is any implementation of a diode.
+type Diode interface {
+	Set(GenericDataType)
+	TryNext() (GenericDataType, bool)
+}
+
+// Poller will poll a diode until a value is available.
+type Poller struct {
+	Diode
+	interval time.Duration
+	ctx      context.Context
+}
+
+// PollerConfigOption can be used to setup the poller.
+type PollerConfigOption func(*Poller)
+
+// WithPollingInterval sets the interval at which the diode is queried
+// for new data. The default is 10ms.
+func WithPollingInterval(interval time.Duration) PollerConfigOption {
+	return PollerConfigOption(func(c *Poller) {
+		c.interval = interval
+	})
+}
+
+// WithPollingContext sets the context to cancel any retrieval (Next()). It
+// will not change any results for adding data (Set()). Default is
+// context.Background().
+func WithPollingContext(ctx context.Context) PollerConfigOption {
+	return PollerConfigOption(func(c *Poller) {
+		c.ctx = ctx
+	})
+}
+
+// NewPoller returns a new Poller that wraps the given diode.
+func NewPoller(d Diode, opts ...PollerConfigOption) *Poller {
+	p := &Poller{
+		Diode:    d,
+		interval: 10 * time.Millisecond,
+		ctx:      context.Background(),
+	}
+
+	for _, o := range opts {
+		o(p)
+	}
+
+	return p
+}
+
+// Next polls the diode until data is available or until the context is done.
+// If the context is done, then nil will be returned.
+func (p *Poller) Next() GenericDataType {
+	for {
+		data, ok := p.Diode.TryNext()
+		if !ok {
+			if p.isDone() {
+				return nil
+			}
+
+			time.Sleep(p.interval)
+			continue
+		}
+		return data
+	}
+}
+
+func (p *Poller) isDone() bool {
+	select {
+	case <-p.ctx.Done():
+		return true
+	default:
+		return false
+	}
+}

diode/internal/diodes/waiter.go

@@ -0,0 +1,83 @@
+package diodes
+
+import (
+	"context"
+	"sync"
+)
+
+// Waiter will use a conditional mutex to alert the reader to when data is
+// available.
+type Waiter struct {
+	Diode
+	mu  sync.Mutex
+	c   *sync.Cond
+	ctx context.Context
+}
+
+// WaiterConfigOption can be used to setup the waiter.
+type WaiterConfigOption func(*Waiter)
+
+// WithWaiterContext sets the context to cancel any retrieval (Next()). It
+// will not change any results for adding data (Set()). Default is
+// context.Background().
+func WithWaiterContext(ctx context.Context) WaiterConfigOption {
+	return WaiterConfigOption(func(c *Waiter) {
+		c.ctx = ctx
+	})
+}
+
+// NewWaiter returns a new Waiter that wraps the given diode.
+func NewWaiter(d Diode, opts ...WaiterConfigOption) *Waiter {
+	w := new(Waiter)
+	w.Diode = d
+	w.c = sync.NewCond(&w.mu)
+	w.ctx = context.Background()
+
+	for _, opt := range opts {
+		opt(w)
+	}
+
+	go func() {
+		<-w.ctx.Done()
+		w.c.Broadcast()
+	}()
+
+	return w
+}
+
+// Set invokes the wrapped diode's Set with the given data and uses Broadcast
+// to wake up any readers.
+func (w *Waiter) Set(data GenericDataType) {
+	w.Diode.Set(data)
+	w.c.Broadcast()
+}
+
+// Next returns the next data point on the wrapped diode. If there is not any
+// new data, it will Wait for set to be called or the context to be done.
+// If the context is done, then nil will be returned.
+func (w *Waiter) Next() GenericDataType {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+
+	for {
+		data, ok := w.Diode.TryNext()
+		if !ok {
+			if w.isDone() {
+				return nil
+			}
+
+			w.c.Wait()
+			continue
+		}
+		return data
+	}
+}
+
+func (w *Waiter) isDone() bool {
+	select {
+	case <-w.ctx.Done():
+		return true
+	default:
+		return false
+	}
+}

encoder.go

@@ -0,0 +1,58 @@
+package zerolog
+
+import (
+	"net"
+	"time"
+)
+
+type encoder interface {
+	AppendArrayDelim(dst []byte) []byte
+	AppendArrayEnd(dst []byte) []byte
+	AppendArrayStart(dst []byte) []byte
+	AppendBeginMarker(dst []byte) []byte
+	AppendBool(dst []byte, val bool) []byte
+	AppendBools(dst []byte, vals []bool) []byte
+	AppendBytes(dst, s []byte) []byte
+	AppendDuration(dst []byte, d time.Duration, unit time.Duration, useInt bool) []byte
+	AppendDurations(dst []byte, vals []time.Duration, unit time.Duration, useInt bool) []byte
+	AppendEndMarker(dst []byte) []byte
+	AppendError(dst []byte, err error) []byte
+	AppendErrors(dst []byte, errs []error) []byte
+	AppendFloat32(dst []byte, val float32) []byte
+	AppendFloat64(dst []byte, val float64) []byte
+	AppendFloats32(dst []byte, vals []float32) []byte
+	AppendFloats64(dst []byte, vals []float64) []byte
+	AppendHex(dst, s []byte) []byte
+	AppendIPAddr(dst []byte, ip net.IP) []byte
+	AppendIPPrefix(dst []byte, pfx net.IPNet) []byte
+	AppendInt(dst []byte, val int) []byte
+	AppendInt16(dst []byte, val int16) []byte
+	AppendInt32(dst []byte, val int32) []byte
+	AppendInt64(dst []byte, val int64) []byte
+	AppendInt8(dst []byte, val int8) []byte
+	AppendInterface(dst []byte, i interface{}) []byte
+	AppendInts(dst []byte, vals []int) []byte
+	AppendInts16(dst []byte, vals []int16) []byte
+	AppendInts32(dst []byte, vals []int32) []byte
+	AppendInts64(dst []byte, vals []int64) []byte
+	AppendInts8(dst []byte, vals []int8) []byte
+	AppendKey(dst []byte, key string) []byte
+	AppendLineBreak(dst []byte) []byte
+	AppendMACAddr(dst []byte, ha net.HardwareAddr) []byte
+	AppendNil(dst []byte) []byte
+	AppendObjectData(dst []byte, o []byte) []byte
+	AppendString(dst []byte, s string) []byte
+	AppendStrings(dst []byte, vals []string) []byte
+	AppendTime(dst []byte, t time.Time, format string) []byte
+	AppendTimes(dst []byte, vals []time.Time, format string) []byte
+	AppendUint(dst []byte, val uint) []byte
+	AppendUint16(dst []byte, val uint16) []byte
+	AppendUint32(dst []byte, val uint32) []byte
+	AppendUint64(dst []byte, val uint64) []byte
+	AppendUint8(dst []byte, val uint8) []byte
+	AppendUints(dst []byte, vals []uint) []byte
+	AppendUints16(dst []byte, vals []uint16) []byte
+	AppendUints32(dst []byte, vals []uint32) []byte
+	AppendUints64(dst []byte, vals []uint64) []byte
+	AppendUints8(dst []byte, vals []uint8) []byte
+}

encoder_cbor.go

@@ -5,202 +5,19 @@ package zerolog
 // This file contains bindings to do binary encoding.
 
 import (
-	"time"
-
 	"github.com/rs/zerolog/internal/cbor"
 )
 
-func appendInterface(dst []byte, i interface{}) []byte {
-	return cbor.AppendInterface(dst, i)
-}
+var (
+	_ encoder = (*cbor.Encoder)(nil)
 
-func appendKey(dst []byte, s string) []byte {
-	return cbor.AppendKey(dst, s)
-}
-
-func appendFloats64(dst []byte, f []float64) []byte {
-	return cbor.AppendFloats64(dst, f)
-}
-
-func appendFloat64(dst []byte, f float64) []byte {
-	return cbor.AppendFloat64(dst, f)
-}
-
-func appendFloats32(dst []byte, f []float32) []byte {
-	return cbor.AppendFloats32(dst, f)
-}
-
-func appendFloat32(dst []byte, f float32) []byte {
-	return cbor.AppendFloat32(dst, f)
-}
-
-func appendUints64(dst []byte, i []uint64) []byte {
-	return cbor.AppendUints64(dst, i)
-}
-
-func appendUint64(dst []byte, i uint64) []byte {
-	return cbor.AppendUint64(dst, i)
-}
-
-func appendUints32(dst []byte, i []uint32) []byte {
-	return cbor.AppendUints32(dst, i)
-}
-
-func appendUint32(dst []byte, i uint32) []byte {
-	return cbor.AppendUint32(dst, i)
-}
-
-func appendUints16(dst []byte, i []uint16) []byte {
-	return cbor.AppendUints16(dst, i)
-}
-
-func appendUint16(dst []byte, i uint16) []byte {
-	return cbor.AppendUint16(dst, i)
-}
-
-func appendUints8(dst []byte, i []uint8) []byte {
-	return cbor.AppendUints8(dst, i)
-}
-
-func appendUint8(dst []byte, i uint8) []byte {
-	return cbor.AppendUint8(dst, i)
-}
-
-func appendUints(dst []byte, i []uint) []byte {
-	return cbor.AppendUints(dst, i)
-}
-
-func appendUint(dst []byte, i uint) []byte {
-	return cbor.AppendUint(dst, i)
-}
-
-func appendInts64(dst []byte, i []int64) []byte {
-	return cbor.AppendInts64(dst, i)
-}
-
-func appendInt64(dst []byte, i int64) []byte {
-	return cbor.AppendInt64(dst, i)
-}
-
-func appendInts32(dst []byte, i []int32) []byte {
-	return cbor.AppendInts32(dst, i)
-}
-
-func appendInt32(dst []byte, i int32) []byte {
-	return cbor.AppendInt32(dst, i)
-}
-
-func appendInts16(dst []byte, i []int16) []byte {
-	return cbor.AppendInts16(dst, i)
-}
-
-func appendInt16(dst []byte, i int16) []byte {
-	return cbor.AppendInt16(dst, i)
-}
-
-func appendInts8(dst []byte, i []int8) []byte {
-	return cbor.AppendInts8(dst, i)
-}
-
-func appendInt8(dst []byte, i int8) []byte {
-	return cbor.AppendInt8(dst, i)
-}
-
-func appendInts(dst []byte, i []int) []byte {
-	return cbor.AppendInts(dst, i)
-}
-
-func appendInt(dst []byte, i int) []byte {
-	return cbor.AppendInt(dst, i)
-}
-
-func appendBools(dst []byte, b []bool) []byte {
-	return cbor.AppendBools(dst, b)
-}
-
-func appendBool(dst []byte, b bool) []byte {
-	return cbor.AppendBool(dst, b)
-}
-
-func appendError(dst []byte, e error) []byte {
-	return cbor.AppendError(dst, e)
-}
-
-func appendErrors(dst []byte, e []error) []byte {
-	return cbor.AppendErrors(dst, e)
-}
-
-func appendString(dst []byte, s string) []byte {
-	return cbor.AppendString(dst, s)
-}
-
-func appendStrings(dst []byte, s []string) []byte {
-	return cbor.AppendStrings(dst, s)
-}
-
-func appendDuration(dst []byte, t time.Duration, d time.Duration, fmt bool) []byte {
-	return cbor.AppendDuration(dst, t, d, fmt)
-}
-
-func appendDurations(dst []byte, t []time.Duration, d time.Duration, fmt bool) []byte {
-	return cbor.AppendDurations(dst, t, d, fmt)
-}
-
-func appendTimes(dst []byte, t []time.Time, fmt string) []byte {
-	return cbor.AppendTimes(dst, t, fmt)
-}
-
-func appendTime(dst []byte, t time.Time, fmt string) []byte {
-	return cbor.AppendTime(dst, t, fmt)
-}
-
-func appendEndMarker(dst []byte) []byte {
-	return cbor.AppendEndMarker(dst)
-}
-
-func appendLineBreak(dst []byte) []byte {
-	// No line breaks needed in binary format.
-	return dst
-}
-
-func appendBeginMarker(dst []byte) []byte {
-	return cbor.AppendBeginMarker(dst)
-}
-
-func appendBytes(dst []byte, b []byte) []byte {
-	return cbor.AppendBytes(dst, b)
-}
-
-func appendArrayStart(dst []byte) []byte {
-	return cbor.AppendArrayStart(dst)
-}
-
-func appendArrayEnd(dst []byte) []byte {
-	return cbor.AppendArrayEnd(dst)
-}
-
-func appendArrayDelim(dst []byte) []byte {
-	return cbor.AppendArrayDelim(dst)
-}
-
-func appendObjectData(dst []byte, src []byte) []byte {
-        // Map begin character is present in the src, which
-        // should not be copied when appending to existing data.
-	return cbor.AppendObjectData(dst, src[1:])
-}
+	enc = cbor.Encoder{}
+)
 
 func appendJSON(dst []byte, j []byte) []byte {
 	return cbor.AppendEmbeddedJSON(dst, j)
 }
 
-func appendNil(dst []byte) []byte {
-	return cbor.AppendNull(dst)
-}
-
-func appendHex(dst []byte, val []byte) []byte {
-	return cbor.AppendHex(dst, val)
-}
-
 // decodeIfBinaryToString - converts a binary formatted log msg to a
 // JSON formatted String Log message.
 func decodeIfBinaryToString(in []byte) string {

encoder_json.go

@@ -6,199 +6,19 @@ package zerolog
 // JSON encoded byte stream.
 
 import (
-	"strconv"
-	"time"
-
 	"github.com/rs/zerolog/internal/json"
 )
 
-func appendInterface(dst []byte, i interface{}) []byte {
-	return json.AppendInterface(dst, i)
-}
+var (
+	_ encoder = (*json.Encoder)(nil)
 
-func appendKey(dst []byte, s string) []byte {
-	return json.AppendKey(dst, s)
-}
-
-func appendFloats64(dst []byte, f []float64) []byte {
-	return json.AppendFloats64(dst, f)
-}
-
-func appendFloat64(dst []byte, f float64) []byte {
-	return json.AppendFloat64(dst, f)
-}
-
-func appendFloats32(dst []byte, f []float32) []byte {
-	return json.AppendFloats32(dst, f)
-}
-
-func appendFloat32(dst []byte, f float32) []byte {
-	return json.AppendFloat32(dst, f)
-}
-
-func appendUints64(dst []byte, i []uint64) []byte {
-	return json.AppendUints64(dst, i)
-}
-
-func appendUint64(dst []byte, i uint64) []byte {
-	return strconv.AppendUint(dst, uint64(i), 10)
-}
-
-func appendUints32(dst []byte, i []uint32) []byte {
-	return json.AppendUints32(dst, i)
-}
-
-func appendUint32(dst []byte, i uint32) []byte {
-	return strconv.AppendUint(dst, uint64(i), 10)
-}
-
-func appendUints16(dst []byte, i []uint16) []byte {
-	return json.AppendUints16(dst, i)
-}
-
-func appendUint16(dst []byte, i uint16) []byte {
-	return strconv.AppendUint(dst, uint64(i), 10)
-}
-
-func appendUints8(dst []byte, i []uint8) []byte {
-	return json.AppendUints8(dst, i)
-}
-
-func appendUint8(dst []byte, i uint8) []byte {
-	return strconv.AppendUint(dst, uint64(i), 10)
-}
-
-func appendUints(dst []byte, i []uint) []byte {
-	return json.AppendUints(dst, i)
-}
-
-func appendUint(dst []byte, i uint) []byte {
-	return strconv.AppendUint(dst, uint64(i), 10)
-}
-
-func appendInts64(dst []byte, i []int64) []byte {
-	return json.AppendInts64(dst, i)
-}
-
-func appendInt64(dst []byte, i int64) []byte {
-	return strconv.AppendInt(dst, int64(i), 10)
-}
-
-func appendInts32(dst []byte, i []int32) []byte {
-	return json.AppendInts32(dst, i)
-}
-
-func appendInt32(dst []byte, i int32) []byte {
-	return strconv.AppendInt(dst, int64(i), 10)
-}
-
-func appendInts16(dst []byte, i []int16) []byte {
-	return json.AppendInts16(dst, i)
-}
-
-func appendInt16(dst []byte, i int16) []byte {
-	return strconv.AppendInt(dst, int64(i), 10)
-}
-
-func appendInts8(dst []byte, i []int8) []byte {
-	return json.AppendInts8(dst, i)
-}
-
-func appendInt8(dst []byte, i int8) []byte {
-	return strconv.AppendInt(dst, int64(i), 10)
-}
-
-func appendInts(dst []byte, i []int) []byte {
-	return json.AppendInts(dst, i)
-}
-
-func appendInt(dst []byte, i int) []byte {
-	return strconv.AppendInt(dst, int64(i), 10)
-}
-
-func appendBools(dst []byte, b []bool) []byte {
-	return json.AppendBools(dst, b)
-}
-
-func appendBool(dst []byte, b bool) []byte {
-	return strconv.AppendBool(dst, b)
-}
-
-func appendError(dst []byte, e error) []byte {
-	return json.AppendError(dst, e)
-}
-
-func appendErrors(dst []byte, e []error) []byte {
-	return json.AppendErrors(dst, e)
-}
-
-func appendString(dst []byte, s string) []byte {
-	return json.AppendString(dst, s)
-}
-
-func appendStrings(dst []byte, s []string) []byte {
-	return json.AppendStrings(dst, s)
-}
-
-func appendDuration(dst []byte, t time.Duration, d time.Duration, fmt bool) []byte {
-	return json.AppendDuration(dst, t, d, fmt)
-}
-
-func appendDurations(dst []byte, t []time.Duration, d time.Duration, fmt bool) []byte {
-	return json.AppendDurations(dst, t, d, fmt)
-}
-
-func appendTimes(dst []byte, t []time.Time, fmt string) []byte {
-	return json.AppendTimes(dst, t, fmt)
-}
-
-func appendTime(dst []byte, t time.Time, fmt string) []byte {
-	return json.AppendTime(dst, t, fmt)
-}
-
-func appendEndMarker(dst []byte) []byte {
-	return append(dst, '}')
-}
-
-func appendLineBreak(dst []byte) []byte {
-	return append(dst, '\n')
-}
-
-func appendBeginMarker(dst []byte) []byte {
-	return append(dst, '{')
-}
-
-func appendBytes(dst []byte, b []byte) []byte {
-	return json.AppendBytes(dst, b)
-}
-
-func appendArrayStart(dst []byte) []byte {
-	return append(dst, '[')
-}
-
-func appendArrayEnd(dst []byte) []byte {
-	return append(dst, ']')
-}
-
-func appendArrayDelim(dst []byte) []byte {
-	if len(dst) > 0 {
-		return append(dst, ',')
-	}
-	return dst
-}
-
-func appendObjectData(dst []byte, src []byte) []byte {
-	return json.AppendObjectData(dst, src)
-}
+	enc = json.Encoder{}
+)
 
 func appendJSON(dst []byte, j []byte) []byte {
 	return append(dst, j...)
 }
 
-func appendNil(dst []byte) []byte {
-	return append(dst, "null"...)
-}
-
 func decodeIfBinaryToString(in []byte) string {
 	return string(in)
 }
@@ -210,7 +30,3 @@ func decodeObjectToStr(in []byte) string {
 func decodeIfBinaryToBytes(in []byte) []byte {
 	return in
 }
-
-func appendHex(in []byte, val []byte) []byte {
-    return json.AppendHex(in, val)
-}

event.go

@@ -2,6 +2,7 @@ package zerolog
 
 import (
 	"fmt"
+	"net"
 	"os"
 	"runtime"
 	"strconv"
@@ -40,14 +41,11 @@ type LogArrayMarshaler interface {
 	MarshalZerologArray(a *Array)
 }
 
-func newEvent(w LevelWriter, level Level, enabled bool) *Event {
-	if !enabled {
-		return &Event{}
-	}
+func newEvent(w LevelWriter, level Level) *Event {
 	e := eventPool.Get().(*Event)
 	e.buf = e.buf[:0]
 	e.h = e.h[:0]
-	e.buf = appendBeginMarker(e.buf)
+	e.buf = enc.AppendBeginMarker(e.buf)
 	e.w = w
 	e.level = level
 	return e
@@ -57,8 +55,8 @@ func (e *Event) write() (err error) {
 	if e == nil {
 		return nil
 	}
-	e.buf = appendEndMarker(e.buf)
-	e.buf = appendLineBreak(e.buf)
+	e.buf = enc.AppendEndMarker(e.buf)
+	e.buf = enc.AppendLineBreak(e.buf)
 	if e.w != nil {
 		_, err = e.w.WriteLevel(e.level, e.buf)
 	}
@@ -97,7 +95,7 @@ func (e *Event) Msg(msg string) {
 		}
 	}
 	if msg != "" {
-		e.buf = appendString(appendKey(e.buf, MessageFieldName), msg)
+		e.buf = enc.AppendString(enc.AppendKey(e.buf, MessageFieldName), msg)
 	}
 	if e.done != nil {
 		defer e.done(msg)
@@ -133,8 +131,8 @@ func (e *Event) Dict(key string, dict *Event) *Event {
 	if e == nil {
 		return e
 	}
-	dict.buf = appendEndMarker(dict.buf)
-	e.buf = append(appendKey(e.buf, key), dict.buf...)
+	dict.buf = enc.AppendEndMarker(dict.buf)
+	e.buf = append(enc.AppendKey(e.buf, key), dict.buf...)
 	eventPool.Put(dict)
 	return e
 }
@@ -143,7 +141,7 @@ func (e *Event) Dict(key string, dict *Event) *Event {
 // Call usual field methods like Str, Int etc to add fields to this
 // event and give it as argument the *Event.Dict method.
 func Dict() *Event {
-	return newEvent(nil, 0, true)
+	return newEvent(nil, 0)
 }
 
 // Array adds the field key with an array to the event context.
@@ -153,7 +151,7 @@ func (e *Event) Array(key string, arr LogArrayMarshaler) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendKey(e.buf, key)
+	e.buf = enc.AppendKey(e.buf, key)
 	var a *Array
 	if aa, ok := arr.(*Array); ok {
 		a = aa
@@ -166,9 +164,9 @@ func (e *Event) Array(key string, arr LogArrayMarshaler) *Event {
 }
 
 func (e *Event) appendObject(obj LogObjectMarshaler) {
-	e.buf = appendBeginMarker(e.buf)
+	e.buf = enc.AppendBeginMarker(e.buf)
 	obj.MarshalZerologObject(e)
-	e.buf = appendEndMarker(e.buf)
+	e.buf = enc.AppendEndMarker(e.buf)
 }
 
 // Object marshals an object that implement the LogObjectMarshaler interface.
@@ -176,17 +174,26 @@ func (e *Event) Object(key string, obj LogObjectMarshaler) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendKey(e.buf, key)
+	e.buf = enc.AppendKey(e.buf, key)
 	e.appendObject(obj)
 	return e
 }
 
+// Object marshals an object that implement the LogObjectMarshaler interface.
+func (e *Event) EmbedObject(obj LogObjectMarshaler) *Event {
+	if e == nil {
+		return e
+	}
+	obj.MarshalZerologObject(e)
+	return e
+}
+
 // Str adds the field key with val as a string to the *Event context.
 func (e *Event) Str(key, val string) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendString(appendKey(e.buf, key), val)
+	e.buf = enc.AppendString(enc.AppendKey(e.buf, key), val)
 	return e
 }
 
@@ -195,7 +202,7 @@ func (e *Event) Strs(key string, vals []string) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendStrings(appendKey(e.buf, key), vals)
+	e.buf = enc.AppendStrings(enc.AppendKey(e.buf, key), vals)
 	return e
 }
 
@@ -207,7 +214,7 @@ func (e *Event) Bytes(key string, val []byte) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendBytes(appendKey(e.buf, key), val)
+	e.buf = enc.AppendBytes(enc.AppendKey(e.buf, key), val)
 	return e
 }
 
@@ -216,7 +223,7 @@ func (e *Event) Hex(key string, val []byte) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendHex(appendKey(e.buf, key), val)
+	e.buf = enc.AppendHex(enc.AppendKey(e.buf, key), val)
 	return e
 }
 
@@ -228,7 +235,7 @@ func (e *Event) RawJSON(key string, b []byte) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendJSON(appendKey(e.buf, key), b)
+	e.buf = appendJSON(enc.AppendKey(e.buf, key), b)
 	return e
 }
 
@@ -239,7 +246,7 @@ func (e *Event) AnErr(key string, err error) *Event {
 		return e
 	}
 	if err != nil {
-		e.buf = appendError(appendKey(e.buf, key), err)
+		e.buf = enc.AppendError(enc.AppendKey(e.buf, key), err)
 	}
 	return e
 }
@@ -250,7 +257,7 @@ func (e *Event) Errs(key string, errs []error) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendErrors(appendKey(e.buf, key), errs)
+	e.buf = enc.AppendErrors(enc.AppendKey(e.buf, key), errs)
 	return e
 }
 
@@ -262,7 +269,7 @@ func (e *Event) Err(err error) *Event {
 		return e
 	}
 	if err != nil {
-		e.buf = appendError(appendKey(e.buf, ErrorFieldName), err)
+		e.buf = enc.AppendError(enc.AppendKey(e.buf, ErrorFieldName), err)
 	}
 	return e
 }
@@ -272,7 +279,7 @@ func (e *Event) Bool(key string, b bool) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendBool(appendKey(e.buf, key), b)
+	e.buf = enc.AppendBool(enc.AppendKey(e.buf, key), b)
 	return e
 }
 
@@ -281,7 +288,7 @@ func (e *Event) Bools(key string, b []bool) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendBools(appendKey(e.buf, key), b)
+	e.buf = enc.AppendBools(enc.AppendKey(e.buf, key), b)
 	return e
 }
 
@@ -290,7 +297,7 @@ func (e *Event) Int(key string, i int) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendInt(appendKey(e.buf, key), i)
+	e.buf = enc.AppendInt(enc.AppendKey(e.buf, key), i)
 	return e
 }
 
@@ -299,7 +306,7 @@ func (e *Event) Ints(key string, i []int) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendInts(appendKey(e.buf, key), i)
+	e.buf = enc.AppendInts(enc.AppendKey(e.buf, key), i)
 	return e
 }
 
@@ -308,7 +315,7 @@ func (e *Event) Int8(key string, i int8) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendInt8(appendKey(e.buf, key), i)
+	e.buf = enc.AppendInt8(enc.AppendKey(e.buf, key), i)
 	return e
 }
 
@@ -317,7 +324,7 @@ func (e *Event) Ints8(key string, i []int8) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendInts8(appendKey(e.buf, key), i)
+	e.buf = enc.AppendInts8(enc.AppendKey(e.buf, key), i)
 	return e
 }
 
@@ -326,7 +333,7 @@ func (e *Event) Int16(key string, i int16) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendInt16(appendKey(e.buf, key), i)
+	e.buf = enc.AppendInt16(enc.AppendKey(e.buf, key), i)
 	return e
 }
 
@@ -335,7 +342,7 @@ func (e *Event) Ints16(key string, i []int16) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendInts16(appendKey(e.buf, key), i)
+	e.buf = enc.AppendInts16(enc.AppendKey(e.buf, key), i)
 	return e
 }
 
@@ -344,7 +351,7 @@ func (e *Event) Int32(key string, i int32) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendInt32(appendKey(e.buf, key), i)
+	e.buf = enc.AppendInt32(enc.AppendKey(e.buf, key), i)
 	return e
 }
 
@@ -353,7 +360,7 @@ func (e *Event) Ints32(key string, i []int32) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendInts32(appendKey(e.buf, key), i)
+	e.buf = enc.AppendInts32(enc.AppendKey(e.buf, key), i)
 	return e
 }
 
@@ -362,7 +369,7 @@ func (e *Event) Int64(key string, i int64) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendInt64(appendKey(e.buf, key), i)
+	e.buf = enc.AppendInt64(enc.AppendKey(e.buf, key), i)
 	return e
 }
 
@@ -371,7 +378,7 @@ func (e *Event) Ints64(key string, i []int64) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendInts64(appendKey(e.buf, key), i)
+	e.buf = enc.AppendInts64(enc.AppendKey(e.buf, key), i)
 	return e
 }
 
@@ -380,7 +387,7 @@ func (e *Event) Uint(key string, i uint) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendUint(appendKey(e.buf, key), i)
+	e.buf = enc.AppendUint(enc.AppendKey(e.buf, key), i)
 	return e
 }
 
@@ -389,7 +396,7 @@ func (e *Event) Uints(key string, i []uint) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendUints(appendKey(e.buf, key), i)
+	e.buf = enc.AppendUints(enc.AppendKey(e.buf, key), i)
 	return e
 }
 
@@ -398,7 +405,7 @@ func (e *Event) Uint8(key string, i uint8) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendUint8(appendKey(e.buf, key), i)
+	e.buf = enc.AppendUint8(enc.AppendKey(e.buf, key), i)
 	return e
 }
 
@@ -407,7 +414,7 @@ func (e *Event) Uints8(key string, i []uint8) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendUints8(appendKey(e.buf, key), i)
+	e.buf = enc.AppendUints8(enc.AppendKey(e.buf, key), i)
 	return e
 }
 
@@ -416,7 +423,7 @@ func (e *Event) Uint16(key string, i uint16) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendUint16(appendKey(e.buf, key), i)
+	e.buf = enc.AppendUint16(enc.AppendKey(e.buf, key), i)
 	return e
 }
 
@@ -425,7 +432,7 @@ func (e *Event) Uints16(key string, i []uint16) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendUints16(appendKey(e.buf, key), i)
+	e.buf = enc.AppendUints16(enc.AppendKey(e.buf, key), i)
 	return e
 }
 
@@ -434,7 +441,7 @@ func (e *Event) Uint32(key string, i uint32) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendUint32(appendKey(e.buf, key), i)
+	e.buf = enc.AppendUint32(enc.AppendKey(e.buf, key), i)
 	return e
 }
 
@@ -443,7 +450,7 @@ func (e *Event) Uints32(key string, i []uint32) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendUints32(appendKey(e.buf, key), i)
+	e.buf = enc.AppendUints32(enc.AppendKey(e.buf, key), i)
 	return e
 }
 
@@ -452,7 +459,7 @@ func (e *Event) Uint64(key string, i uint64) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendUint64(appendKey(e.buf, key), i)
+	e.buf = enc.AppendUint64(enc.AppendKey(e.buf, key), i)
 	return e
 }
 
@@ -461,7 +468,7 @@ func (e *Event) Uints64(key string, i []uint64) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendUints64(appendKey(e.buf, key), i)
+	e.buf = enc.AppendUints64(enc.AppendKey(e.buf, key), i)
 	return e
 }
 
@@ -470,7 +477,7 @@ func (e *Event) Float32(key string, f float32) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendFloat32(appendKey(e.buf, key), f)
+	e.buf = enc.AppendFloat32(enc.AppendKey(e.buf, key), f)
 	return e
 }
 
@@ -479,7 +486,7 @@ func (e *Event) Floats32(key string, f []float32) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendFloats32(appendKey(e.buf, key), f)
+	e.buf = enc.AppendFloats32(enc.AppendKey(e.buf, key), f)
 	return e
 }
 
@@ -488,7 +495,7 @@ func (e *Event) Float64(key string, f float64) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendFloat64(appendKey(e.buf, key), f)
+	e.buf = enc.AppendFloat64(enc.AppendKey(e.buf, key), f)
 	return e
 }
 
@@ -497,7 +504,7 @@ func (e *Event) Floats64(key string, f []float64) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendFloats64(appendKey(e.buf, key), f)
+	e.buf = enc.AppendFloats64(enc.AppendKey(e.buf, key), f)
 	return e
 }
 
@@ -510,7 +517,7 @@ func (e *Event) Timestamp() *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendTime(appendKey(e.buf, TimestampFieldName), TimestampFunc(), TimeFieldFormat)
+	e.buf = enc.AppendTime(enc.AppendKey(e.buf, TimestampFieldName), TimestampFunc(), TimeFieldFormat)
 	return e
 }
 
@@ -519,7 +526,7 @@ func (e *Event) Time(key string, t time.Time) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendTime(appendKey(e.buf, key), t, TimeFieldFormat)
+	e.buf = enc.AppendTime(enc.AppendKey(e.buf, key), t, TimeFieldFormat)
 	return e
 }
 
@@ -528,7 +535,7 @@ func (e *Event) Times(key string, t []time.Time) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendTimes(appendKey(e.buf, key), t, TimeFieldFormat)
+	e.buf = enc.AppendTimes(enc.AppendKey(e.buf, key), t, TimeFieldFormat)
 	return e
 }
 
@@ -539,7 +546,7 @@ func (e *Event) Dur(key string, d time.Duration) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendDuration(appendKey(e.buf, key), d, DurationFieldUnit, DurationFieldInteger)
+	e.buf = enc.AppendDuration(enc.AppendKey(e.buf, key), d, DurationFieldUnit, DurationFieldInteger)
 	return e
 }
 
@@ -550,7 +557,7 @@ func (e *Event) Durs(key string, d []time.Duration) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendDurations(appendKey(e.buf, key), d, DurationFieldUnit, DurationFieldInteger)
+	e.buf = enc.AppendDurations(enc.AppendKey(e.buf, key), d, DurationFieldUnit, DurationFieldInteger)
 	return e
 }
 
@@ -565,7 +572,7 @@ func (e *Event) TimeDiff(key string, t time.Time, start time.Time) *Event {
 	if t.After(start) {
 		d = t.Sub(start)
 	}
-	e.buf = appendDuration(appendKey(e.buf, key), d, DurationFieldUnit, DurationFieldInteger)
+	e.buf = enc.AppendDuration(enc.AppendKey(e.buf, key), d, DurationFieldUnit, DurationFieldInteger)
 	return e
 }
 
@@ -577,13 +584,13 @@ func (e *Event) Interface(key string, i interface{}) *Event {
 	if obj, ok := i.(LogObjectMarshaler); ok {
 		return e.Object(key, obj)
 	}
-	e.buf = appendInterface(appendKey(e.buf, key), i)
+	e.buf = enc.AppendInterface(enc.AppendKey(e.buf, key), i)
 	return e
 }
 
 // Caller adds the file:line of the caller with the zerolog.CallerFieldName key.
 func (e *Event) Caller() *Event {
-	return e.caller(2)
+	return e.caller(CallerSkipFrameCount)
 }
 
 func (e *Event) caller(skip int) *Event {
@@ -594,6 +601,33 @@ func (e *Event) caller(skip int) *Event {
 	if !ok {
 		return e
 	}
-	e.buf = appendString(appendKey(e.buf, CallerFieldName), file+":"+strconv.Itoa(line))
+	e.buf = enc.AppendString(enc.AppendKey(e.buf, CallerFieldName), file+":"+strconv.Itoa(line))
+	return e
+}
+
+// IPAddr adds IPv4 or IPv6 Address to the event
+func (e *Event) IPAddr(key string, ip net.IP) *Event {
+	if e == nil {
+		return e
+	}
+	e.buf = enc.AppendIPAddr(enc.AppendKey(e.buf, key), ip)
+	return e
+}
+
+// IPPrefix adds IPv4 or IPv6 Prefix (address and mask) to the event
+func (e *Event) IPPrefix(key string, pfx net.IPNet) *Event {
+	if e == nil {
+		return e
+	}
+	e.buf = enc.AppendIPPrefix(enc.AppendKey(e.buf, key), pfx)
+	return e
+}
+
+// MACAddr adds MAC address to the event
+func (e *Event) MACAddr(key string, ha net.HardwareAddr) *Event {
+	if e == nil {
+		return e
+	}
+	e.buf = enc.AppendMACAddr(enc.AppendKey(e.buf, key), ha)
 	return e
 }

fields.go

@@ -1,6 +1,7 @@
 package zerolog
 
 import (
+	"net"
 	"sort"
 	"time"
 )
@@ -12,114 +13,129 @@ func appendFields(dst []byte, fields map[string]interface{}) []byte {
 	}
 	sort.Strings(keys)
 	for _, key := range keys {
-		dst = appendKey(dst, key)
-		switch val := fields[key].(type) {
+		dst = enc.AppendKey(dst, key)
+		val := fields[key]
+		if val, ok := val.(LogObjectMarshaler); ok {
+			e := newEvent(nil, 0)
+			e.buf = e.buf[:0]
+			e.appendObject(val)
+			dst = append(dst, e.buf...)
+			eventPool.Put(e)
+			continue
+		}
+		switch val := val.(type) {
 		case string:
-			dst = appendString(dst, val)
+			dst = enc.AppendString(dst, val)
 		case []byte:
-			dst = appendBytes(dst, val)
+			dst = enc.AppendBytes(dst, val)
 		case error:
-			dst = appendError(dst, val)
+			dst = enc.AppendError(dst, val)
 		case []error:
-			dst = appendErrors(dst, val)
+			dst = enc.AppendErrors(dst, val)
 		case bool:
-			dst = appendBool(dst, val)
+			dst = enc.AppendBool(dst, val)
 		case int:
-			dst = appendInt(dst, val)
+			dst = enc.AppendInt(dst, val)
 		case int8:
-			dst = appendInt8(dst, val)
+			dst = enc.AppendInt8(dst, val)
 		case int16:
-			dst = appendInt16(dst, val)
+			dst = enc.AppendInt16(dst, val)
 		case int32:
-			dst = appendInt32(dst, val)
+			dst = enc.AppendInt32(dst, val)
 		case int64:
-			dst = appendInt64(dst, val)
+			dst = enc.AppendInt64(dst, val)
 		case uint:
-			dst = appendUint(dst, val)
+			dst = enc.AppendUint(dst, val)
 		case uint8:
-			dst = appendUint8(dst, val)
+			dst = enc.AppendUint8(dst, val)
 		case uint16:
-			dst = appendUint16(dst, val)
+			dst = enc.AppendUint16(dst, val)
 		case uint32:
-			dst = appendUint32(dst, val)
+			dst = enc.AppendUint32(dst, val)
 		case uint64:
-			dst = appendUint64(dst, val)
+			dst = enc.AppendUint64(dst, val)
 		case float32:
-			dst = appendFloat32(dst, val)
+			dst = enc.AppendFloat32(dst, val)
 		case float64:
-			dst = appendFloat64(dst, val)
+			dst = enc.AppendFloat64(dst, val)
 		case time.Time:
-			dst = appendTime(dst, val, TimeFieldFormat)
+			dst = enc.AppendTime(dst, val, TimeFieldFormat)
 		case time.Duration:
-			dst = appendDuration(dst, val, DurationFieldUnit, DurationFieldInteger)
+			dst = enc.AppendDuration(dst, val, DurationFieldUnit, DurationFieldInteger)
 		case *string:
-			dst = appendString(dst, *val)
+			dst = enc.AppendString(dst, *val)
 		case *bool:
-			dst = appendBool(dst, *val)
+			dst = enc.AppendBool(dst, *val)
 		case *int:
-			dst = appendInt(dst, *val)
+			dst = enc.AppendInt(dst, *val)
 		case *int8:
-			dst = appendInt8(dst, *val)
+			dst = enc.AppendInt8(dst, *val)
 		case *int16:
-			dst = appendInt16(dst, *val)
+			dst = enc.AppendInt16(dst, *val)
 		case *int32:
-			dst = appendInt32(dst, *val)
+			dst = enc.AppendInt32(dst, *val)
 		case *int64:
-			dst = appendInt64(dst, *val)
+			dst = enc.AppendInt64(dst, *val)
 		case *uint:
-			dst = appendUint(dst, *val)
+			dst = enc.AppendUint(dst, *val)
 		case *uint8:
-			dst = appendUint8(dst, *val)
+			dst = enc.AppendUint8(dst, *val)
 		case *uint16:
-			dst = appendUint16(dst, *val)
+			dst = enc.AppendUint16(dst, *val)
 		case *uint32:
-			dst = appendUint32(dst, *val)
+			dst = enc.AppendUint32(dst, *val)
 		case *uint64:
-			dst = appendUint64(dst, *val)
+			dst = enc.AppendUint64(dst, *val)
 		case *float32:
-			dst = appendFloat32(dst, *val)
+			dst = enc.AppendFloat32(dst, *val)
 		case *float64:
-			dst = appendFloat64(dst, *val)
+			dst = enc.AppendFloat64(dst, *val)
 		case *time.Time:
-			dst = appendTime(dst, *val, TimeFieldFormat)
+			dst = enc.AppendTime(dst, *val, TimeFieldFormat)
 		case *time.Duration:
-			dst = appendDuration(dst, *val, DurationFieldUnit, DurationFieldInteger)
+			dst = enc.AppendDuration(dst, *val, DurationFieldUnit, DurationFieldInteger)
 		case []string:
-			dst = appendStrings(dst, val)
+			dst = enc.AppendStrings(dst, val)
 		case []bool:
-			dst = appendBools(dst, val)
+			dst = enc.AppendBools(dst, val)
 		case []int:
-			dst = appendInts(dst, val)
+			dst = enc.AppendInts(dst, val)
 		case []int8:
-			dst = appendInts8(dst, val)
+			dst = enc.AppendInts8(dst, val)
 		case []int16:
-			dst = appendInts16(dst, val)
+			dst = enc.AppendInts16(dst, val)
 		case []int32:
-			dst = appendInts32(dst, val)
+			dst = enc.AppendInts32(dst, val)
 		case []int64:
-			dst = appendInts64(dst, val)
+			dst = enc.AppendInts64(dst, val)
 		case []uint:
-			dst = appendUints(dst, val)
+			dst = enc.AppendUints(dst, val)
 		// case []uint8:
-		// 	dst = appendUints8(dst, val)
+		// 	dst = enc.AppendUints8(dst, val)
 		case []uint16:
-			dst = appendUints16(dst, val)
+			dst = enc.AppendUints16(dst, val)
 		case []uint32:
-			dst = appendUints32(dst, val)
+			dst = enc.AppendUints32(dst, val)
 		case []uint64:
-			dst = appendUints64(dst, val)
+			dst = enc.AppendUints64(dst, val)
 		case []float32:
-			dst = appendFloats32(dst, val)
+			dst = enc.AppendFloats32(dst, val)
 		case []float64:
-			dst = appendFloats64(dst, val)
+			dst = enc.AppendFloats64(dst, val)
 		case []time.Time:
-			dst = appendTimes(dst, val, TimeFieldFormat)
+			dst = enc.AppendTimes(dst, val, TimeFieldFormat)
 		case []time.Duration:
-			dst = appendDurations(dst, val, DurationFieldUnit, DurationFieldInteger)
+			dst = enc.AppendDurations(dst, val, DurationFieldUnit, DurationFieldInteger)
 		case nil:
-			dst = appendNil(dst)
+			dst = enc.AppendNil(dst)
+		case net.IP:
+			dst = enc.AppendIPAddr(dst, val)
+		case net.IPNet:
+			dst = enc.AppendIPPrefix(dst, val)
+		case net.HardwareAddr:
+			dst = enc.AppendMACAddr(dst, val)
 		default:
-			dst = appendInterface(dst, val)
+			dst = enc.AppendInterface(dst, val)
 		}
 	}
 	return dst

globals.go

@@ -19,6 +19,9 @@ var (
 	// 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
+
 	// 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.
@@ -49,7 +52,8 @@ func SetGlobalLevel(l Level) {
 	atomic.StoreUint32(gLevel, uint32(l))
 }
 
-func globalLevel() Level {
+// GlobalLevel returns the current global log level
+func GlobalLevel() Level {
 	return Level(atomic.LoadUint32(gLevel))
 }
 

go.mod

@@ -0,0 +1 @@
+module github.com/rs/zerolog

internal/cbor/README.md

@@ -1,74 +1,56 @@
-Reference:
-   CBOR Encoding is described in RFC7049 https://tools.ietf.org/html/rfc7049
+## Reference:
+   CBOR Encoding is described in [RFC7049](https://tools.ietf.org/html/rfc7049)
+
+## Comparison of JSON vs CBOR
+
+Two main areas of reduction are:
+
+1. CPU usage to write a log msg 
+2. Size (in bytes) of log messages.
 
 
-Tests and benchmark:
-
+CPU Usage savings are below:
 ```
-sprint @ cbor>go test -v -benchmem -bench=.                                                                               
-=== RUN   TestDecodeInteger                                                                                               
---- PASS: TestDecodeInteger (0.00s)                                                                                       
-=== RUN   TestDecodeString                                                                                                
---- PASS: TestDecodeString (0.00s)                                                                                        
-=== RUN   TestDecodeArray                                                                                                 
---- PASS: TestDecodeArray (0.00s)                                                                                         
-=== RUN   TestDecodeMap                                                                                                   
---- PASS: TestDecodeMap (0.00s)                                                                                           
-=== RUN   TestDecodeBool                                                                                                  
---- PASS: TestDecodeBool (0.00s)                                                                                          
-=== RUN   TestDecodeFloat                                                                                                 
---- PASS: TestDecodeFloat (0.00s)                                                                                         
-=== RUN   TestDecodeTimestamp                                                                                             
---- PASS: TestDecodeTimestamp (0.00s)                                                                                     
-=== RUN   TestDecodeCbor2Json                                                                                             
---- PASS: TestDecodeCbor2Json (0.00s)                                                                                     
-=== RUN   TestAppendString                                                                                                
---- PASS: TestAppendString (0.00s)                                                                                        
-=== RUN   TestAppendBytes                                                                                                 
---- PASS: TestAppendBytes (0.00s)                                                                                         
-=== RUN   TestAppendTimeNow                                                                                               
---- PASS: TestAppendTimeNow (0.00s)                                                                                       
-=== RUN   TestAppendTimePastPresentInteger                                                                                
---- PASS: TestAppendTimePastPresentInteger (0.00s)                                                                        
-=== RUN   TestAppendTimePastPresentFloat                                                                                  
---- PASS: TestAppendTimePastPresentFloat (0.00s)                                                                          
-=== RUN   TestAppendNull                                                                                                  
---- PASS: TestAppendNull (0.00s)                                                                                          
-=== RUN   TestAppendBool                                                                                                  
---- PASS: TestAppendBool (0.00s)                                                                                          
-=== RUN   TestAppendBoolArray
---- PASS: TestAppendBoolArray (0.00s)
-=== RUN   TestAppendInt
---- PASS: TestAppendInt (0.00s)
-=== RUN   TestAppendIntArray
---- PASS: TestAppendIntArray (0.00s)
-=== RUN   TestAppendFloat32
---- PASS: TestAppendFloat32 (0.00s)
-goos: linux
-goarch: amd64
-pkg: github.com/toravir/zerolog/internal/cbor
-BenchmarkAppendString/MultiBytesLast-4          30000000                43.3 ns/op             0 B/op          0 allocs/op
-BenchmarkAppendString/NoEncoding-4              30000000                48.2 ns/op             0 B/op          0 allocs/op
-BenchmarkAppendString/EncodingFirst-4           30000000                48.2 ns/op             0 B/op          0 allocs/op
-BenchmarkAppendString/EncodingMiddle-4          30000000                41.7 ns/op             0 B/op          0 allocs/op
-BenchmarkAppendString/EncodingLast-4            30000000                51.8 ns/op             0 B/op          0 allocs/op
-BenchmarkAppendString/MultiBytesFirst-4         50000000                38.0 ns/op             0 B/op          0 allocs/op
-BenchmarkAppendString/MultiBytesMiddle-4        50000000                38.0 ns/op             0 B/op          0 allocs/op
-BenchmarkAppendTime/Integer-4                   50000000                39.6 ns/op             0 B/op          0 allocs/op
-BenchmarkAppendTime/Float-4                     30000000                56.1 ns/op             0 B/op          0 allocs/op
-BenchmarkAppendInt/uint8-4                      50000000                29.1 ns/op             0 B/op          0 allocs/op
-BenchmarkAppendInt/uint16-4                     50000000                30.3 ns/op             0 B/op          0 allocs/op
-BenchmarkAppendInt/uint32-4                     50000000                37.1 ns/op             0 B/op          0 allocs/op
-BenchmarkAppendInt/int8-4                       100000000               21.5 ns/op             0 B/op          0 allocs/op
-BenchmarkAppendInt/int16-4                      50000000                25.8 ns/op             0 B/op          0 allocs/op
-BenchmarkAppendInt/int32-4                      50000000                26.7 ns/op             0 B/op          0 allocs/op
-BenchmarkAppendInt/int-Positive-4               100000000               21.5 ns/op             0 B/op          0 allocs/op
-BenchmarkAppendInt/int-Negative-4               100000000               20.7 ns/op             0 B/op          0 allocs/op
-BenchmarkAppendInt/uint64-4                     50000000                36.7 ns/op             0 B/op          0 allocs/op
-BenchmarkAppendInt/int64-4                      30000000                39.6 ns/op             0 B/op          0 allocs/op
-BenchmarkAppendFloat/Float32-4                  50000000                23.9 ns/op             0 B/op          0 allocs/op
-BenchmarkAppendFloat/Float64-4                  50000000                32.8 ns/op             0 B/op          0 allocs/op
-PASS
-ok      github.com/toravir/zerolog/internal/cbor        34.969s
-sprint @ cbor>
+name                                    JSON time/op    CBOR time/op   delta
+Info-32                                   15.3ns ± 1%    11.7ns ± 3%  -23.78%  (p=0.000 n=9+10)      
+ContextFields-32                          16.2ns ± 2%    12.3ns ± 3%  -23.97%  (p=0.000 n=9+9)       
+ContextAppend-32                          6.70ns ± 0%    6.20ns ± 0%   -7.44%  (p=0.000 n=9+9)       
+LogFields-32                              66.4ns ± 0%    24.6ns ± 2%  -62.89%  (p=0.000 n=10+9)      
+LogArrayObject-32                          911ns ±11%     768ns ± 6%  -15.64%  (p=0.000 n=10+10)     
+LogFieldType/Floats-32                    70.3ns ± 2%    29.5ns ± 1%  -57.98%  (p=0.000 n=10+10)     
+LogFieldType/Err-32                       14.0ns ± 3%    12.1ns ± 8%  -13.20%  (p=0.000 n=8+10)      
+LogFieldType/Dur-32                       17.2ns ± 2%    13.1ns ± 1%  -24.27%  (p=0.000 n=10+9)      
+LogFieldType/Object-32                    54.3ns ±11%    52.3ns ± 7%     ~     (p=0.239 n=10+10)     
+LogFieldType/Ints-32                      20.3ns ± 2%    15.1ns ± 2%  -25.50%  (p=0.000 n=9+10)      
+LogFieldType/Interfaces-32                 642ns ±11%     621ns ± 9%     ~     (p=0.118 n=10+10)     
+LogFieldType/Interface(Objects)-32         635ns ±13%     632ns ± 9%     ~     (p=0.592 n=10+10)     
+LogFieldType/Times-32                      294ns ± 0%      27ns ± 1%  -90.71%  (p=0.000 n=10+9)      
+LogFieldType/Durs-32                       121ns ± 0%      33ns ± 2%  -72.44%  (p=0.000 n=9+9)       
+LogFieldType/Interface(Object)-32         56.6ns ± 8%    52.3ns ± 8%   -7.54%  (p=0.007 n=10+10)     
+LogFieldType/Errs-32                      17.8ns ± 3%    16.1ns ± 2%   -9.71%  (p=0.000 n=10+9)      
+LogFieldType/Time-32                      40.5ns ± 1%    12.7ns ± 6%  -68.66%  (p=0.000 n=8+9)       
+LogFieldType/Bool-32                      12.0ns ± 5%    10.2ns ± 2%  -15.18%  (p=0.000 n=10+8)      
+LogFieldType/Bools-32                     17.2ns ± 2%    12.6ns ± 4%  -26.63%  (p=0.000 n=10+10)     
+LogFieldType/Int-32                       12.3ns ± 2%    11.2ns ± 4%   -9.27%  (p=0.000 n=9+10)      
+LogFieldType/Float-32                     16.7ns ± 1%    12.6ns ± 2%  -24.42%  (p=0.000 n=7+9)       
+LogFieldType/Str-32                       12.7ns ± 7%    11.3ns ± 7%  -10.88%  (p=0.000 n=10+9)      
+LogFieldType/Strs-32                      20.3ns ± 3%    18.2ns ± 3%  -10.25%  (p=0.000 n=9+10)      
+LogFieldType/Interface-32                  183ns ±12%     175ns ± 9%     ~     (p=0.078 n=10+10)     
 ```
+
+Log message size savings is greatly dependent on the number and type of fields in the log message.
+Assuming this log message (with an Integer, timestamp and string, in addition to level).
+
+`{"level":"error","Fault":41650,"time":"2018-04-01T15:18:19-07:00","message":"Some Message"}`
+
+Two measurements were done for the log file sizes - one without any compression, second
+using [compress/zlib](https://golang.org/pkg/compress/zlib/). 
+
+Results for 10,000 log messages:
+
+| Log Format |  Plain File Size (in KB) | Compressed File Size (in KB) |
+| :--- | :---: | :---: |
+| JSON | 920 | 28 |
+| CBOR | 550 | 28 |
+
+The example used to calculate the above data is available in [Examples](examples).

internal/cbor/base.go

@@ -1,43 +1,45 @@
 package cbor
 
+type Encoder struct{}
+
 // AppendKey adds a key (string) to the binary encoded log message
-func AppendKey(dst []byte, key string) []byte {
+func (e Encoder) AppendKey(dst []byte, key string) []byte {
 	if len(dst) < 1 {
-		dst = AppendBeginMarker(dst)
+		dst = e.AppendBeginMarker(dst)
 	}
-	return AppendString(dst, key)
+	return e.AppendString(dst, key)
 }
 
 // AppendError adds the Error to the log message if error is NOT nil
-func AppendError(dst []byte, err error) []byte {
+func (e Encoder) AppendError(dst []byte, err error) []byte {
 	if err == nil {
 		return append(dst, `null`...)
 	}
-	return AppendString(dst, err.Error())
+	return e.AppendString(dst, err.Error())
 }
 
 // AppendErrors when given an array of errors,
 // adds them to the log message if a specific error is nil, then
 // Nil is added, or else the error string is added.
-func AppendErrors(dst []byte, errs []error) []byte {
+func (e Encoder) AppendErrors(dst []byte, errs []error) []byte {
 	if len(errs) == 0 {
-		return AppendArrayEnd(AppendArrayStart(dst))
+		return e.AppendArrayEnd(e.AppendArrayStart(dst))
 	}
-	dst = AppendArrayStart(dst)
+	dst = e.AppendArrayStart(dst)
 	if errs[0] != nil {
-		dst = AppendString(dst, errs[0].Error())
+		dst = e.AppendString(dst, errs[0].Error())
 	} else {
-		dst = AppendNull(dst)
+		dst = e.AppendNil(dst)
 	}
 	if len(errs) > 1 {
 		for _, err := range errs[1:] {
 			if err == nil {
-				dst = AppendNull(dst)
+				dst = e.AppendNil(dst)
 				continue
 			}
-			dst = AppendString(dst, err.Error())
+			dst = e.AppendString(dst, err.Error())
 		}
 	}
-	dst = AppendArrayEnd(dst)
+	dst = e.AppendArrayEnd(dst)
 	return dst
 }

internal/cbor/cbor.go

@@ -7,25 +7,34 @@ import "time"
 const (
 	majorOffset   = 5
 	additionalMax = 23
-	//Non Values
+
+	// Non Values.
 	additionalTypeBoolFalse byte = 20
 	additionalTypeBoolTrue  byte = 21
 	additionalTypeNull      byte = 22
-	//Integer (+ve and -ve) Sub-types
+
+	// Integer (+ve and -ve) Sub-types.
 	additionalTypeIntUint8  byte = 24
 	additionalTypeIntUint16 byte = 25
 	additionalTypeIntUint32 byte = 26
 	additionalTypeIntUint64 byte = 27
-	//Float Sub-types
+
+	// Float Sub-types.
 	additionalTypeFloat16 byte = 25
 	additionalTypeFloat32 byte = 26
 	additionalTypeFloat64 byte = 27
 	additionalTypeBreak   byte = 31
-	//Tag Sub-types
-	additionalTypeTimestamp    byte = 01
-	additionalTypeEmbeddedJSON byte = 31
-        additionalTypeTagHexString uint16 = 262
-	//Unspecified number of elements
+
+	// Tag Sub-types.
+	additionalTypeTimestamp byte = 01
+
+	// Extended Tags - from https://www.iana.org/assignments/cbor-tags/cbor-tags.xhtml
+	additionalTypeTagNetworkAddr   uint16 = 260
+	additionalTypeTagNetworkPrefix uint16 = 261
+	additionalTypeEmbeddedJSON     uint16 = 262
+	additionalTypeTagHexString     uint16 = 263
+
+	// Unspecified number of elements.
 	additionalTypeInfiniteCount byte = 31
 )
 const (

internal/cbor/decode_stream.go

@@ -0,0 +1,614 @@
+package cbor
+
+// This file contains code to decode a stream of CBOR Data into JSON.
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"math"
+	"net"
+	"runtime"
+	"strconv"
+	"strings"
+	"time"
+	"unicode/utf8"
+)
+
+var decodeTimeZone *time.Location
+
+const hexTable = "0123456789abcdef"
+
+const isFloat32 = 4
+const isFloat64 = 8
+
+func readNBytes(src *bufio.Reader, n int) []byte {
+	ret := make([]byte, n)
+	for i := 0; i < n; i++ {
+		ch, e := src.ReadByte()
+		if e != nil {
+			panic(fmt.Errorf("Tried to Read %d Bytes.. But hit end of file", n))
+		}
+		ret[i] = ch
+	}
+	return ret
+}
+
+func readByte(src *bufio.Reader) byte {
+	b, e := src.ReadByte()
+	if e != nil {
+		panic(fmt.Errorf("Tried to Read 1 Byte.. But hit end of file"))
+	}
+	return b
+}
+
+func decodeIntAdditonalType(src *bufio.Reader, minor byte) int64 {
+	val := int64(0)
+	if minor <= 23 {
+		val = int64(minor)
+	} else {
+		bytesToRead := 0
+		switch minor {
+		case additionalTypeIntUint8:
+			bytesToRead = 1
+		case additionalTypeIntUint16:
+			bytesToRead = 2
+		case additionalTypeIntUint32:
+			bytesToRead = 4
+		case additionalTypeIntUint64:
+			bytesToRead = 8
+		default:
+			panic(fmt.Errorf("Invalid Additional Type: %d in decodeInteger (expected <28)", minor))
+		}
+		pb := readNBytes(src, bytesToRead)
+		for i := 0; i < bytesToRead; i++ {
+			val = val * 256
+			val += int64(pb[i])
+		}
+	}
+	return val
+}
+
+func decodeInteger(src *bufio.Reader) int64 {
+	pb := readByte(src)
+	major := pb & maskOutAdditionalType
+	minor := pb & maskOutMajorType
+	if major != majorTypeUnsignedInt && major != majorTypeNegativeInt {
+		panic(fmt.Errorf("Major type is: %d in decodeInteger!! (expected 0 or 1)", major))
+	}
+	val := decodeIntAdditonalType(src, minor)
+	if major == 0 {
+		return val
+	}
+	return (-1 - val)
+}
+
+func decodeFloat(src *bufio.Reader) (float64, int) {
+	pb := readByte(src)
+	major := pb & maskOutAdditionalType
+	minor := pb & maskOutMajorType
+	if major != majorTypeSimpleAndFloat {
+		panic(fmt.Errorf("Incorrect Major type is: %d in decodeFloat", major))
+	}
+
+	switch minor {
+	case additionalTypeFloat16:
+		panic(fmt.Errorf("float16 is not suppported in decodeFloat"))
+
+	case additionalTypeFloat32:
+		pb := readNBytes(src, 4)
+		switch string(pb) {
+		case float32Nan:
+			return math.NaN(), isFloat32
+		case float32PosInfinity:
+			return math.Inf(0), isFloat32
+		case float32NegInfinity:
+			return math.Inf(-1), isFloat32
+		}
+		n := uint32(0)
+		for i := 0; i < 4; i++ {
+			n = n * 256
+			n += uint32(pb[i])
+		}
+		val := math.Float32frombits(n)
+		return float64(val), isFloat32
+	case additionalTypeFloat64:
+		pb := readNBytes(src, 8)
+		switch string(pb) {
+		case float64Nan:
+			return math.NaN(), isFloat64
+		case float64PosInfinity:
+			return math.Inf(0), isFloat64
+		case float64NegInfinity:
+			return math.Inf(-1), isFloat64
+		}
+		n := uint64(0)
+		for i := 0; i < 8; i++ {
+			n = n * 256
+			n += uint64(pb[i])
+		}
+		val := math.Float64frombits(n)
+		return val, isFloat64
+	}
+	panic(fmt.Errorf("Invalid Additional Type: %d in decodeFloat", minor))
+}
+
+func decodeStringComplex(dst []byte, s string, pos uint) []byte {
+	i := int(pos)
+	start := 0
+
+	for i < len(s) {
+		b := s[i]
+		if b >= utf8.RuneSelf {
+			r, size := utf8.DecodeRuneInString(s[i:])
+			if r == utf8.RuneError && size == 1 {
+				// In case of error, first append previous simple characters to
+				// the byte slice if any and append a replacement character code
+				// in place of the invalid sequence.
+				if start < i {
+					dst = append(dst, s[start:i]...)
+				}
+				dst = append(dst, `\ufffd`...)
+				i += size
+				start = i
+				continue
+			}
+			i += size
+			continue
+		}
+		if b >= 0x20 && b <= 0x7e && b != '\\' && b != '"' {
+			i++
+			continue
+		}
+		// We encountered a character that needs to be encoded.
+		// Let's append the previous simple characters to the byte slice
+		// and switch our operation to read and encode the remainder
+		// characters byte-by-byte.
+		if start < i {
+			dst = append(dst, s[start:i]...)
+		}
+		switch b {
+		case '"', '\\':
+			dst = append(dst, '\\', b)
+		case '\b':
+			dst = append(dst, '\\', 'b')
+		case '\f':
+			dst = append(dst, '\\', 'f')
+		case '\n':
+			dst = append(dst, '\\', 'n')
+		case '\r':
+			dst = append(dst, '\\', 'r')
+		case '\t':
+			dst = append(dst, '\\', 't')
+		default:
+			dst = append(dst, '\\', 'u', '0', '0', hexTable[b>>4], hexTable[b&0xF])
+		}
+		i++
+		start = i
+	}
+	if start < len(s) {
+		dst = append(dst, s[start:]...)
+	}
+	return dst
+}
+
+func decodeString(src *bufio.Reader, noQuotes bool) []byte {
+	pb := readByte(src)
+	major := pb & maskOutAdditionalType
+	minor := pb & maskOutMajorType
+	if major != majorTypeByteString {
+		panic(fmt.Errorf("Major type is: %d in decodeString", major))
+	}
+	result := []byte{}
+	if !noQuotes {
+		result = append(result, '"')
+	}
+	length := decodeIntAdditonalType(src, minor)
+	len := int(length)
+	pbs := readNBytes(src, len)
+	result = append(result, pbs...)
+	if noQuotes {
+		return result
+	}
+	return append(result, '"')
+}
+
+func decodeUTF8String(src *bufio.Reader) []byte {
+	pb := readByte(src)
+	major := pb & maskOutAdditionalType
+	minor := pb & maskOutMajorType
+	if major != majorTypeUtf8String {
+		panic(fmt.Errorf("Major type is: %d in decodeUTF8String", major))
+	}
+	result := []byte{'"'}
+	length := decodeIntAdditonalType(src, minor)
+	len := int(length)
+	pbs := readNBytes(src, len)
+
+	for i := 0; i < len; i++ {
+		// Check if the character needs encoding. Control characters, slashes,
+		// and the double quote need json encoding. Bytes above the ascii
+		// boundary needs utf8 encoding.
+		if pbs[i] < 0x20 || pbs[i] > 0x7e || pbs[i] == '\\' || pbs[i] == '"' {
+			// We encountered a character that needs to be encoded. Switch
+			// to complex version of the algorithm.
+			dst := []byte{'"'}
+			dst = decodeStringComplex(dst, string(pbs), uint(i))
+			return append(dst, '"')
+		}
+	}
+	// The string has no need for encoding an therefore is directly
+	// appended to the byte slice.
+	result = append(result, pbs...)
+	return append(result, '"')
+}
+
+func array2Json(src *bufio.Reader, dst io.Writer) {
+	dst.Write([]byte{'['})
+	pb := readByte(src)
+	major := pb & maskOutAdditionalType
+	minor := pb & maskOutMajorType
+	if major != majorTypeArray {
+		panic(fmt.Errorf("Major type is: %d in array2Json", major))
+	}
+	len := 0
+	unSpecifiedCount := false
+	if minor == additionalTypeInfiniteCount {
+		unSpecifiedCount = true
+	} else {
+		length := decodeIntAdditonalType(src, minor)
+		len = int(length)
+	}
+	for i := 0; unSpecifiedCount || i < len; i++ {
+		if unSpecifiedCount {
+			pb, e := src.Peek(1)
+			if e != nil {
+				panic(e)
+			}
+			if pb[0] == byte(majorTypeSimpleAndFloat|additionalTypeBreak) {
+				readByte(src)
+				break
+			}
+		}
+		cbor2JsonOneObject(src, dst)
+		if unSpecifiedCount {
+			pb, e := src.Peek(1)
+			if e != nil {
+				panic(e)
+			}
+			if pb[0] == byte(majorTypeSimpleAndFloat|additionalTypeBreak) {
+				readByte(src)
+				break
+			}
+			dst.Write([]byte{','})
+		} else if i+1 < len {
+			dst.Write([]byte{','})
+		}
+	}
+	dst.Write([]byte{']'})
+}
+
+func map2Json(src *bufio.Reader, dst io.Writer) {
+	pb := readByte(src)
+	major := pb & maskOutAdditionalType
+	minor := pb & maskOutMajorType
+	if major != majorTypeMap {
+		panic(fmt.Errorf("Major type is: %d in map2Json", major))
+	}
+	len := 0
+	unSpecifiedCount := false
+	if minor == additionalTypeInfiniteCount {
+		unSpecifiedCount = true
+	} else {
+		length := decodeIntAdditonalType(src, minor)
+		len = int(length)
+	}
+	dst.Write([]byte{'{'})
+	for i := 0; unSpecifiedCount || i < len; i++ {
+		if unSpecifiedCount {
+			pb, e := src.Peek(1)
+			if e != nil {
+				panic(e)
+			}
+			if pb[0] == byte(majorTypeSimpleAndFloat|additionalTypeBreak) {
+				readByte(src)
+				break
+			}
+		}
+		cbor2JsonOneObject(src, dst)
+		if i%2 == 0 {
+			// Even position values are keys.
+			dst.Write([]byte{':'})
+		} else {
+			if unSpecifiedCount {
+				pb, e := src.Peek(1)
+				if e != nil {
+					panic(e)
+				}
+				if pb[0] == byte(majorTypeSimpleAndFloat|additionalTypeBreak) {
+					readByte(src)
+					break
+				}
+				dst.Write([]byte{','})
+			} else if i+1 < len {
+				dst.Write([]byte{','})
+			}
+		}
+	}
+	dst.Write([]byte{'}'})
+}
+
+func decodeTagData(src *bufio.Reader) []byte {
+	pb := readByte(src)
+	major := pb & maskOutAdditionalType
+	minor := pb & maskOutMajorType
+	if major != majorTypeTags {
+		panic(fmt.Errorf("Major type is: %d in decodeTagData", major))
+	}
+	switch minor {
+	case additionalTypeTimestamp:
+		return decodeTimeStamp(src)
+
+	// Tag value is larger than 256 (so uint16).
+	case additionalTypeIntUint16:
+		val := decodeIntAdditonalType(src, minor)
+
+		switch uint16(val) {
+		case additionalTypeEmbeddedJSON:
+			pb := readByte(src)
+			dataMajor := pb & maskOutAdditionalType
+			if dataMajor != majorTypeByteString {
+				panic(fmt.Errorf("Unsupported embedded Type: %d in decodeEmbeddedJSON", dataMajor))
+			}
+			src.UnreadByte()
+			return decodeString(src, true)
+
+		case additionalTypeTagNetworkAddr:
+			octets := decodeString(src, true)
+			ss := []byte{'"'}
+			switch len(octets) {
+			case 6: // MAC address.
+				ha := net.HardwareAddr(octets)
+				ss = append(append(ss, ha.String()...), '"')
+			case 4: // IPv4 address.
+				fallthrough
+			case 16: // IPv6 address.
+				ip := net.IP(octets)
+				ss = append(append(ss, ip.String()...), '"')
+			default:
+				panic(fmt.Errorf("Unexpected Network Address length: %d (expected 4,6,16)", len(octets)))
+			}
+			return ss
+
+		case additionalTypeTagNetworkPrefix:
+			pb := readByte(src)
+			if pb != byte(majorTypeMap|0x1) {
+				panic(fmt.Errorf("IP Prefix is NOT of MAP of 1 elements as expected"))
+			}
+			octets := decodeString(src, true)
+			val := decodeInteger(src)
+			ip := net.IP(octets)
+			var mask net.IPMask
+			pfxLen := int(val)
+			if len(octets) == 4 {
+				mask = net.CIDRMask(pfxLen, 32)
+			} else {
+				mask = net.CIDRMask(pfxLen, 128)
+			}
+			ipPfx := net.IPNet{IP: ip, Mask: mask}
+			ss := []byte{'"'}
+			ss = append(append(ss, ipPfx.String()...), '"')
+			return ss
+
+		case additionalTypeTagHexString:
+			octets := decodeString(src, true)
+			ss := []byte{'"'}
+			for _, v := range octets {
+				ss = append(ss, hexTable[v>>4], hexTable[v&0x0f])
+			}
+			return append(ss, '"')
+
+		default:
+			panic(fmt.Errorf("Unsupported Additional Tag Type: %d in decodeTagData", val))
+		}
+	}
+	panic(fmt.Errorf("Unsupported Additional Type: %d in decodeTagData", minor))
+}
+
+func decodeTimeStamp(src *bufio.Reader) []byte {
+	pb := readByte(src)
+	src.UnreadByte()
+	tsMajor := pb & maskOutAdditionalType
+	if tsMajor == majorTypeUnsignedInt || tsMajor == majorTypeNegativeInt {
+		n := decodeInteger(src)
+		t := time.Unix(n, 0)
+		if decodeTimeZone != nil {
+			t = t.In(decodeTimeZone)
+		} else {
+			t = t.In(time.UTC)
+		}
+		tsb := []byte{}
+		tsb = append(tsb, '"')
+		tsb = t.AppendFormat(tsb, IntegerTimeFieldFormat)
+		tsb = append(tsb, '"')
+		return tsb
+	} else if tsMajor == majorTypeSimpleAndFloat {
+		n, _ := decodeFloat(src)
+		secs := int64(n)
+		n -= float64(secs)
+		n *= float64(1e9)
+		t := time.Unix(secs, int64(n))
+		if decodeTimeZone != nil {
+			t = t.In(decodeTimeZone)
+		} else {
+			t = t.In(time.UTC)
+		}
+		tsb := []byte{}
+		tsb = append(tsb, '"')
+		tsb = t.AppendFormat(tsb, NanoTimeFieldFormat)
+		tsb = append(tsb, '"')
+		return tsb
+	}
+	panic(fmt.Errorf("TS format is neigther int nor float: %d", tsMajor))
+}
+
+func decodeSimpleFloat(src *bufio.Reader) []byte {
+	pb := readByte(src)
+	major := pb & maskOutAdditionalType
+	minor := pb & maskOutMajorType
+	if major != majorTypeSimpleAndFloat {
+		panic(fmt.Errorf("Major type is: %d in decodeSimpleFloat", major))
+	}
+	switch minor {
+	case additionalTypeBoolTrue:
+		return []byte("true")
+	case additionalTypeBoolFalse:
+		return []byte("false")
+	case additionalTypeNull:
+		return []byte("null")
+	case additionalTypeFloat16:
+		fallthrough
+	case additionalTypeFloat32:
+		fallthrough
+	case additionalTypeFloat64:
+		src.UnreadByte()
+		v, bc := decodeFloat(src)
+		ba := []byte{}
+		switch {
+		case math.IsNaN(v):
+			return []byte("\"NaN\"")
+		case math.IsInf(v, 1):
+			return []byte("\"+Inf\"")
+		case math.IsInf(v, -1):
+			return []byte("\"-Inf\"")
+		}
+		if bc == isFloat32 {
+			ba = strconv.AppendFloat(ba, v, 'f', -1, 32)
+		} else if bc == isFloat64 {
+			ba = strconv.AppendFloat(ba, v, 'f', -1, 64)
+		} else {
+			panic(fmt.Errorf("Invalid Float precision from decodeFloat: %d", bc))
+		}
+		return ba
+	default:
+		panic(fmt.Errorf("Invalid Additional Type: %d in decodeSimpleFloat", minor))
+	}
+}
+
+func cbor2JsonOneObject(src *bufio.Reader, dst io.Writer) {
+	pb, e := src.Peek(1)
+	if e != nil {
+		panic(e)
+	}
+	major := (pb[0] & maskOutAdditionalType)
+
+	switch major {
+	case majorTypeUnsignedInt:
+		fallthrough
+	case majorTypeNegativeInt:
+		n := decodeInteger(src)
+		dst.Write([]byte(strconv.Itoa(int(n))))
+
+	case majorTypeByteString:
+		s := decodeString(src, false)
+		dst.Write(s)
+
+	case majorTypeUtf8String:
+		s := decodeUTF8String(src)
+		dst.Write(s)
+
+	case majorTypeArray:
+		array2Json(src, dst)
+
+	case majorTypeMap:
+		map2Json(src, dst)
+
+	case majorTypeTags:
+		s := decodeTagData(src)
+		dst.Write(s)
+
+	case majorTypeSimpleAndFloat:
+		s := decodeSimpleFloat(src)
+		dst.Write(s)
+	}
+}
+
+func moreBytesToRead(src *bufio.Reader) bool {
+	_, e := src.ReadByte()
+	if e == nil {
+		src.UnreadByte()
+		return true
+	}
+	return false
+}
+
+// Cbor2JsonManyObjects decodes all the CBOR Objects read from src
+// reader. It keeps on decoding until reader returns EOF (error when reading).
+// Decoded string is written to the dst. At the end of every CBOR Object
+// newline is written to the output stream.
+//
+// Returns error (if any) that was encountered during decode.
+// The child functions will generate a panic when error is encountered and
+// this function will recover non-runtime Errors and return the reason as error.
+func Cbor2JsonManyObjects(src io.Reader, dst io.Writer) (err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			if _, ok := r.(runtime.Error); ok {
+				panic(r)
+			}
+			err = r.(error)
+		}
+	}()
+	bufRdr := bufio.NewReader(src)
+	for moreBytesToRead(bufRdr) {
+		cbor2JsonOneObject(bufRdr, dst)
+		dst.Write([]byte("\n"))
+	}
+	return nil
+}
+
+// Detect if the bytes to be printed is Binary or not.
+func binaryFmt(p []byte) bool {
+	if len(p) > 0 && p[0] > 0x7F {
+		return true
+	}
+	return false
+}
+
+func getReader(str string) *bufio.Reader {
+	return bufio.NewReader(strings.NewReader(str))
+}
+
+// DecodeIfBinaryToString converts a binary formatted log msg to a
+// JSON formatted String Log message - suitable for printing to Console/Syslog.
+func DecodeIfBinaryToString(in []byte) string {
+	if binaryFmt(in) {
+		var b bytes.Buffer
+		Cbor2JsonManyObjects(strings.NewReader(string(in)), &b)
+		return b.String()
+	}
+	return string(in)
+}
+
+// DecodeObjectToStr checks if the input is a binary format, if so,
+// it will decode a single Object and return the decoded string.
+func DecodeObjectToStr(in []byte) string {
+	if binaryFmt(in) {
+		var b bytes.Buffer
+		cbor2JsonOneObject(getReader(string(in)), &b)
+		return b.String()
+	}
+	return string(in)
+}
+
+// DecodeIfBinaryToBytes checks if the input is a binary format, if so,
+// it will decode all Objects and return the decoded string as byte array.
+func DecodeIfBinaryToBytes(in []byte) []byte {
+	if binaryFmt(in) {
+		var b bytes.Buffer
+		Cbor2JsonManyObjects(bytes.NewReader(in), &b)
+		return b.Bytes()
+	}
+	return in
+}

internal/cbor/decoder.go

@@ -1,548 +0,0 @@
-package cbor
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"math"
-	"strconv"
-	"time"
-	"unicode/utf8"
-)
-
-var decodeTimeZone *time.Location
-
-const hexTable = "0123456789abcdef"
-
-func decodeIntAdditonalType(src []byte, minor byte) (int64, uint, error) {
-	val := int64(0)
-	bytesRead := 0
-	if minor <= 23 {
-		val = int64(minor)
-		bytesRead = 0
-	} else {
-		switch minor {
-		case additionalTypeIntUint8:
-			bytesRead = 1
-		case additionalTypeIntUint16:
-			bytesRead = 2
-		case additionalTypeIntUint32:
-			bytesRead = 4
-		case additionalTypeIntUint64:
-			bytesRead = 8
-		default:
-			return 0, 0, fmt.Errorf("Invalid Additional Type: %d in decodeInteger (expected <28)", minor)
-		}
-		for i := 0; i < bytesRead; i++ {
-			val = val * 256
-			val += int64(src[i])
-		}
-	}
-	return val, uint(bytesRead), nil
-}
-
-func decodeInteger(src []byte) (int64, uint, error) {
-	major := src[0] & maskOutAdditionalType
-	minor := src[0] & maskOutMajorType
-	if major != majorTypeUnsignedInt && major != majorTypeNegativeInt {
-		return 0, 0, fmt.Errorf("Major type is: %d in decodeInteger!! (expected 0 or 1)", major)
-	}
-	val, bytesRead, err := decodeIntAdditonalType(src[1:], minor)
-	if err != nil {
-		return 0, 0, err
-	}
-	if major == 0 {
-		return val, 1 + bytesRead, nil
-	}
-	return (-1 - val), 1 + bytesRead, nil
-}
-
-func decodeFloat(src []byte) (float64, uint, error) {
-	major := (src[0] & maskOutAdditionalType)
-	minor := src[0] & maskOutMajorType
-	if major != majorTypeSimpleAndFloat {
-		return 0, 0, fmt.Errorf("Incorrect Major type is: %d in decodeFloat", major)
-	}
-
-	switch minor {
-	case additionalTypeFloat16:
-		return 0, 0, fmt.Errorf("float16 is not suppported in decodeFloat")
-	case additionalTypeFloat32:
-		switch string(src[1:5]) {
-		case float32Nan:
-			return math.NaN(), 5, nil
-		case float32PosInfinity:
-			return math.Inf(0), 5, nil
-		case float32NegInfinity:
-			return math.Inf(-1), 5, nil
-		}
-		n := uint32(0)
-		for i := 0; i < 4; i++ {
-			n = n * 256
-			n += uint32(src[i+1])
-		}
-		val := math.Float32frombits(n)
-		return float64(val), 5, nil
-	case additionalTypeFloat64:
-		switch string(src[1:9]) {
-		case float64Nan:
-			return math.NaN(), 9, nil
-		case float64PosInfinity:
-			return math.Inf(0), 9, nil
-		case float64NegInfinity:
-			return math.Inf(-1), 9, nil
-		}
-		n := uint64(0)
-		for i := 0; i < 8; i++ {
-			n = n * 256
-			n += uint64(src[i+1])
-		}
-		val := math.Float64frombits(n)
-		return val, 9, nil
-	}
-	return 0, 0, fmt.Errorf("Invalid Additional Type: %d in decodeFloat", minor)
-}
-
-func decodeStringComplex(dst []byte, s string, pos uint) []byte {
-	i := int(pos)
-	const hex = "0123456789abcdef"
-	start := 0
-
-	for i < len(s) {
-		b := s[i]
-		if b >= utf8.RuneSelf {
-			r, size := utf8.DecodeRuneInString(s[i:])
-			if r == utf8.RuneError && size == 1 {
-				// In case of error, first append previous simple characters to
-				// the byte slice if any and append a replacement character code
-				// in place of the invalid sequence.
-				if start < i {
-					dst = append(dst, s[start:i]...)
-				}
-				dst = append(dst, `\ufffd`...)
-				i += size
-				start = i
-				continue
-			}
-			i += size
-			continue
-		}
-		if b >= 0x20 && b <= 0x7e && b != '\\' && b != '"' {
-			i++
-			continue
-		}
-		// We encountered a character that needs to be encoded.
-		// Let's append the previous simple characters to the byte slice
-		// and switch our operation to read and encode the remainder
-		// characters byte-by-byte.
-		if start < i {
-			dst = append(dst, s[start:i]...)
-		}
-		switch b {
-		case '"', '\\':
-			dst = append(dst, '\\', b)
-		case '\b':
-			dst = append(dst, '\\', 'b')
-		case '\f':
-			dst = append(dst, '\\', 'f')
-		case '\n':
-			dst = append(dst, '\\', 'n')
-		case '\r':
-			dst = append(dst, '\\', 'r')
-		case '\t':
-			dst = append(dst, '\\', 't')
-		default:
-			dst = append(dst, '\\', 'u', '0', '0', hex[b>>4], hex[b&0xF])
-		}
-		i++
-		start = i
-	}
-	if start < len(s) {
-		dst = append(dst, s[start:]...)
-	}
-	return dst
-}
-
-func decodeString(src []byte, noQuotes bool) ([]byte, uint, error) {
-	major := src[0] & maskOutAdditionalType
-	minor := src[0] & maskOutMajorType
-	if major != majorTypeByteString {
-		return []byte{}, 0, fmt.Errorf("Major type is: %d in decodeString", major)
-	}
-	result := []byte{'"'}
-	if noQuotes {
-		result = []byte{}
-	}
-	length, bytesRead, err := decodeIntAdditonalType(src[1:], minor)
-	if err != nil {
-		return []byte{}, 0, err
-	}
-	bytesRead++
-	st := bytesRead
-	len := uint(length)
-	bytesRead += len
-
-	result = append(result, src[st:st+len]...)
-	if noQuotes {
-		return result, bytesRead, nil
-	}
-	return append(result, '"'), bytesRead, nil
-}
-
-func decodeUTF8String(src []byte) ([]byte, uint, error) {
-	major := src[0] & maskOutAdditionalType
-	minor := src[0] & maskOutMajorType
-	if major != majorTypeUtf8String {
-		return []byte{}, 0, fmt.Errorf("Major type is: %d in decodeUTF8String", major)
-	}
-	result := []byte{'"'}
-	length, bytesRead, err := decodeIntAdditonalType(src[1:], minor)
-	if err != nil {
-		return []byte{}, 0, err
-	}
-	bytesRead++
-	st := bytesRead
-	len := uint(length)
-	bytesRead += len
-
-	for i := st; i < bytesRead; i++ {
-		// Check if the character needs encoding. Control characters, slashes,
-		// and the double quote need json encoding. Bytes above the ascii
-		// boundary needs utf8 encoding.
-		if src[i] < 0x20 || src[i] > 0x7e || src[i] == '\\' || src[i] == '"' {
-			// We encountered a character that needs to be encoded. Switch
-			// to complex version of the algorithm.
-			dst := []byte{'"'}
-			dst = decodeStringComplex(dst, string(src[st:st+len]), i-st)
-			return append(dst, '"'), bytesRead, nil
-		}
-	}
-	// The string has no need for encoding an therefore is directly
-	// appended to the byte slice.
-	result = append(result, src[st:st+len]...)
-	return append(result, '"'), bytesRead, nil
-}
-
-func array2Json(src []byte, dst io.Writer) (uint, error) {
-	dst.Write([]byte{'['})
-	major := (src[0] & maskOutAdditionalType)
-	minor := src[0] & maskOutMajorType
-	if major != majorTypeArray {
-		return 0, fmt.Errorf("Major type is: %d in array2Json", major)
-	}
-	len := 0
-	bytesRead := uint(0)
-	unSpecifiedCount := false
-	if minor == additionalTypeInfiniteCount {
-		unSpecifiedCount = true
-		bytesRead = 1
-	} else {
-		var length int64
-		var err error
-		length, bytesRead, err = decodeIntAdditonalType(src[1:], minor)
-		if err != nil {
-			fmt.Println("Error!!!")
-			return 0, err
-		}
-		len = int(length)
-		bytesRead++
-	}
-	curPos := bytesRead
-	for i := 0; unSpecifiedCount || i < len; i++ {
-		bc, err := Cbor2JsonOneObject(src[curPos:], dst)
-		if err != nil {
-			if src[curPos] == byte(majorTypeSimpleAndFloat|additionalTypeBreak) {
-				bytesRead++
-				break
-			}
-			return 0, err
-		}
-		curPos += bc
-		bytesRead += bc
-		if unSpecifiedCount {
-			if src[curPos] == byte(majorTypeSimpleAndFloat|additionalTypeBreak) {
-				bytesRead++
-				break
-			}
-			dst.Write([]byte{','})
-		} else if i+1 < len {
-			dst.Write([]byte{','})
-		}
-	}
-	dst.Write([]byte{']'})
-	return bytesRead, nil
-}
-
-func map2Json(src []byte, dst io.Writer) (uint, error) {
-	major := (src[0] & maskOutAdditionalType)
-	minor := src[0] & maskOutMajorType
-	if major != majorTypeMap {
-		return 0, fmt.Errorf("Major type is: %d in map2Json", major)
-	}
-	len := 0
-	bytesRead := uint(0)
-	unSpecifiedCount := false
-	if minor == additionalTypeInfiniteCount {
-		unSpecifiedCount = true
-		bytesRead = 1
-	} else {
-		var length int64
-		var err error
-		length, bytesRead, err = decodeIntAdditonalType(src[1:], minor)
-		if err != nil {
-			fmt.Println("Error!!!")
-			return 0, err
-		}
-		len = int(length)
-		bytesRead++
-	}
-	if len%2 == 1 {
-		return 0, fmt.Errorf("Invalid Length of map %d - has to be even", len)
-	}
-	dst.Write([]byte{'{'})
-	curPos := bytesRead
-	for i := 0; unSpecifiedCount || i < len; i++ {
-		bc, err := Cbor2JsonOneObject(src[curPos:], dst)
-		if err != nil {
-			//We hit the BREAK
-			if src[curPos] == byte(majorTypeSimpleAndFloat|additionalTypeBreak) {
-				bytesRead++
-				break
-			}
-			return 0, err
-		}
-		curPos += bc
-		bytesRead += bc
-		if i%2 == 0 {
-			//Even position values are keys
-			dst.Write([]byte{':'})
-		} else {
-			if unSpecifiedCount {
-				if src[curPos] == byte(majorTypeSimpleAndFloat|additionalTypeBreak) {
-					bytesRead++
-					break
-				}
-				dst.Write([]byte{','})
-			} else if i+1 < len {
-				dst.Write([]byte{','})
-			}
-		}
-	}
-	dst.Write([]byte{'}'})
-	return bytesRead, nil
-}
-
-func decodeTagData(src []byte) ([]byte, uint, error) {
-	major := (src[0] & maskOutAdditionalType)
-	minor := src[0] & maskOutMajorType
-	if major != majorTypeTags {
-		return nil, 0, fmt.Errorf("Major type is: %d in decodeTagData", major)
-	}
-	if minor == additionalTypeTimestamp {
-		tsMajor := src[1] & maskOutAdditionalType
-		if tsMajor == majorTypeUnsignedInt || tsMajor == majorTypeNegativeInt {
-			n, bc, err := decodeInteger(src[1:])
-			if err != nil {
-				return []byte{}, 0, err
-			}
-			t := time.Unix(n, 0)
-			if decodeTimeZone != nil {
-				t = t.In(decodeTimeZone)
-			} else {
-				t = t.In(time.UTC)
-			}
-			tsb := []byte{}
-			tsb = append(tsb, '"')
-			tsb = t.AppendFormat(tsb, IntegerTimeFieldFormat)
-			tsb = append(tsb, '"')
-			return tsb, 1 + bc, nil
-		} else if tsMajor == majorTypeSimpleAndFloat {
-			n, bc, err := decodeFloat(src[1:])
-			if err != nil {
-				return []byte{}, 0, err
-			}
-			secs := int64(n)
-			n -= float64(secs)
-			n *= float64(1e9)
-			t := time.Unix(secs, int64(n))
-			if decodeTimeZone != nil {
-				t = t.In(decodeTimeZone)
-			} else {
-				t = t.In(time.UTC)
-			}
-			tsb := []byte{}
-			tsb = append(tsb, '"')
-			tsb = t.AppendFormat(tsb, NanoTimeFieldFormat)
-			tsb = append(tsb, '"')
-			return tsb, 1 + bc, nil
-		} else {
-			return nil, 0, fmt.Errorf("TS format is neigther int nor float: %d", tsMajor)
-		}
-	} else if minor == additionalTypeEmbeddedJSON {
-		dataMajor := src[1] & maskOutAdditionalType
-		if dataMajor == majorTypeByteString {
-			emb, bc, err := decodeString(src[1:], true)
-			if err != nil {
-				return nil, 0, err
-			}
-			return emb, 1 + bc, nil
-		}
-		return nil, 0, fmt.Errorf("Unsupported embedded Type: %d in decodeEmbeddedJSON", dataMajor)
-	} else if minor == additionalTypeIntUint16 {
-            val,_,_ := decodeIntAdditonalType(src[1:], minor)
-            if uint16(val) == additionalTypeTagHexString {
-                emb, bc, _ := decodeString(src[3:], true)
-                dst := []byte{'"'}
-                for _, v := range emb {
-                        dst = append(dst, hexTable[v>>4], hexTable[v&0x0f])
-                }
-                return append(dst, '"'), 3+bc, nil
-            }
-        }
-	return nil, 0, fmt.Errorf("Unsupported Additional Type: %d in decodeTagData", minor)
-}
-
-func decodeSimpleFloat(src []byte) ([]byte, uint, error) {
-	major := (src[0] & maskOutAdditionalType)
-	minor := src[0] & maskOutMajorType
-	if major != majorTypeSimpleAndFloat {
-		return nil, 0, fmt.Errorf("Major type is: %d in decodeSimpleFloat", major)
-	}
-	switch minor {
-	case additionalTypeBoolTrue:
-		return []byte("true"), 1, nil
-	case additionalTypeBoolFalse:
-		return []byte("false"), 1, nil
-	case additionalTypeNull:
-		return []byte("null"), 1, nil
-
-	case additionalTypeFloat16:
-		fallthrough
-	case additionalTypeFloat32:
-		fallthrough
-	case additionalTypeFloat64:
-		v, bc, err := decodeFloat(src)
-		if err != nil {
-			return nil, 0, err
-		}
-		ba := []byte{}
-		switch {
-		case math.IsNaN(v):
-			return []byte("\"NaN\""), bc, nil
-		case math.IsInf(v, 1):
-			return []byte("\"+Inf\""), bc, nil
-		case math.IsInf(v, -1):
-			return []byte("\"-Inf\""), bc, nil
-		}
-		if bc == 5 {
-			ba = strconv.AppendFloat(ba, v, 'f', -1, 32)
-		} else {
-			ba = strconv.AppendFloat(ba, v, 'f', -1, 64)
-		}
-		return ba, bc, nil
-	default:
-		return nil, 0, fmt.Errorf("Invalid Additional Type: %d in decodeSimpleFloat", minor)
-	}
-}
-
-// Cbor2JsonOneObject takes in byte array and decodes ONE CBOR Object
-// usually a MAP. Use this when only ONE CBOR object needs decoding.
-// Decoded string is written to the dst.
-// Returns the bytes decoded and if any error was encountered.
-func Cbor2JsonOneObject(src []byte, dst io.Writer) (uint, error) {
-	var err error
-	major := (src[0] & maskOutAdditionalType)
-	bc := uint(0)
-	var s []byte
-	switch major {
-	case majorTypeUnsignedInt:
-		fallthrough
-	case majorTypeNegativeInt:
-		var n int64
-		n, bc, err = decodeInteger(src)
-		dst.Write([]byte(strconv.Itoa(int(n))))
-
-	case majorTypeByteString:
-		s, bc, err = decodeString(src, false)
-		dst.Write(s)
-
-	case majorTypeUtf8String:
-		s, bc, err = decodeUTF8String(src)
-		dst.Write(s)
-
-	case majorTypeArray:
-		bc, err = array2Json(src, dst)
-
-	case majorTypeMap:
-		bc, err = map2Json(src, dst)
-
-	case majorTypeTags:
-		s, bc, err = decodeTagData(src)
-		dst.Write(s)
-
-	case majorTypeSimpleAndFloat:
-		s, bc, err = decodeSimpleFloat(src)
-		dst.Write(s)
-	}
-	return bc, err
-}
-
-// Cbor2JsonManyObjects decodes all the CBOR Objects present in the
-// source byte array. It keeps on decoding until it runs out of bytes.
-// Decoded string is written to the dst. At the end of every CBOR Object
-// newline is written to the output stream.
-// Returns the number of bytes decoded and if any error was encountered.
-func Cbor2JsonManyObjects(src []byte, dst io.Writer) (uint, error) {
-	curPos := uint(0)
-	totalBytes := uint(len(src))
-	for curPos < totalBytes {
-		bc, err := Cbor2JsonOneObject(src[curPos:], dst)
-		if err != nil {
-			return curPos, err
-		}
-		dst.Write([]byte("\n"))
-		curPos += bc
-	}
-	return curPos, nil
-}
-
-// Detect if the bytes to be printed is Binary or not.
-func binaryFmt(p []byte) bool {
-	if len(p) > 0 && p[0] > 0x7F {
-		return true
-	}
-	return false
-}
-
-// DecodeIfBinaryToString converts a binary formatted log msg to a
-// JSON formatted String Log message - suitable for printing to Console/Syslog.
-func DecodeIfBinaryToString(in []byte) string {
-	if binaryFmt(in) {
-		var b bytes.Buffer
-		Cbor2JsonManyObjects(in, &b)
-		return b.String()
-	}
-	return string(in)
-}
-
-// DecodeObjectToStr checks if the input is a binary format, if so,
-// it will decode a single Object and return the decoded string.
-func DecodeObjectToStr(in []byte) string {
-	if binaryFmt(in) {
-		var b bytes.Buffer
-		Cbor2JsonOneObject(in, &b)
-		return b.String()
-	}
-	return string(in)
-}
-
-// DecodeIfBinaryToBytes checks if the input is a binary format, if so,
-// it will decode all Objects and return the decoded string as byte array.
-func DecodeIfBinaryToBytes(in []byte) []byte {
-	if binaryFmt(in) {
-		var b bytes.Buffer
-		Cbor2JsonManyObjects(in, &b)
-		return b.Bytes()
-	}
-	return in
-}

internal/cbor/decoder_test.go

@@ -9,8 +9,8 @@ import (
 
 func TestDecodeInteger(t *testing.T) {
 	for _, tc := range integerTestCases {
-		gotv, gotc, err := decodeInteger([]byte(tc.binary))
-		if gotv != int64(tc.val) || int(gotc) != len(tc.binary) || err != nil {
+		gotv := decodeInteger(getReader(tc.binary))
+		if gotv != int64(tc.val) {
 			t.Errorf("decodeInteger(0x%s)=0x%d, want: 0x%d",
 				hex.EncodeToString([]byte(tc.binary)), gotv, tc.val)
 		}
@@ -19,10 +19,7 @@ func TestDecodeInteger(t *testing.T) {
 
 func TestDecodeString(t *testing.T) {
 	for _, tt := range encodeStringTests {
-		got, _, err := decodeUTF8String([]byte(tt.binary))
-		if err != nil {
-			t.Errorf("Got Error for the case: %s", hex.EncodeToString([]byte(tt.binary)))
-		}
+		got := decodeUTF8String(getReader(tt.binary))
 		if string(got) != "\""+tt.json+"\"" {
 			t.Errorf("DecodeString(0x%s)=%s, want:\"%s\"\n", hex.EncodeToString([]byte(tt.binary)), string(got),
 				hex.EncodeToString([]byte(tt.json)))
@@ -33,10 +30,7 @@ func TestDecodeString(t *testing.T) {
 func TestDecodeArray(t *testing.T) {
 	for _, tc := range integerArrayTestCases {
 		buf := bytes.NewBuffer([]byte{})
-		_, err := array2Json([]byte(tc.binary), buf)
-		if err != nil {
-			panic(err)
-		}
+		array2Json(getReader(tc.binary), buf)
 		if buf.String() != tc.json {
 			t.Errorf("array2Json(0x%s)=%s, want: %s", hex.EncodeToString([]byte(tc.binary)), buf.String(), tc.json)
 		}
@@ -54,20 +48,14 @@ func TestDecodeArray(t *testing.T) {
 	}
 	for _, tc := range infiniteArrayTestCases {
 		buf := bytes.NewBuffer([]byte{})
-		_, err := array2Json([]byte(tc.in), buf)
-		if err != nil {
-			panic(err)
-		}
+		array2Json(getReader(tc.in), buf)
 		if buf.String() != tc.out {
 			t.Errorf("array2Json(0x%s)=%s, want: %s", hex.EncodeToString([]byte(tc.out)), buf.String(), tc.out)
 		}
 	}
 	for _, tc := range booleanArrayTestCases {
 		buf := bytes.NewBuffer([]byte{})
-		_, err := array2Json([]byte(tc.binary), buf)
-		if err != nil {
-			t.Errorf("array2Json(0x%s) errored out: %s", hex.EncodeToString([]byte(tc.binary)), err.Error())
-		}
+		array2Json(getReader(tc.binary), buf)
 		if buf.String() != tc.json {
 			t.Errorf("array2Json(0x%s)=%s, want: %s", hex.EncodeToString([]byte(tc.binary)), buf.String(), tc.json)
 		}
@@ -94,20 +82,14 @@ var mapDecodeTestCases = []struct {
 func TestDecodeMap(t *testing.T) {
 	for _, tc := range mapDecodeTestCases {
 		buf := bytes.NewBuffer([]byte{})
-		_, err := map2Json(tc.bin, buf)
-		if err != nil {
-			t.Errorf("map2Json(0x%s) returned error", err)
-		}
+		map2Json(getReader(string(tc.bin)), buf)
 		if buf.String() != tc.json {
 			t.Errorf("map2Json(0x%s)=%s, want: %s", hex.EncodeToString(tc.bin), buf.String(), tc.json)
 		}
 	}
 	for _, tc := range infiniteMapDecodeTestCases {
 		buf := bytes.NewBuffer([]byte{})
-		_, err := map2Json(tc.bin, buf)
-		if err != nil {
-			t.Errorf("map2Json(0x%s) returned error", err)
-		}
+		map2Json(getReader(string(tc.bin)), buf)
 		if buf.String() != tc.json {
 			t.Errorf("map2Json(0x%s)=%s, want: %s", hex.EncodeToString(tc.bin), buf.String(), tc.json)
 		}
@@ -116,10 +98,7 @@ func TestDecodeMap(t *testing.T) {
 
 func TestDecodeBool(t *testing.T) {
 	for _, tc := range booleanTestCases {
-		got, _, err := decodeSimpleFloat([]byte(tc.binary))
-		if err != nil {
-			t.Errorf("decodeSimpleFloat(0x%s) errored %s", hex.EncodeToString([]byte(tc.binary)), err.Error())
-		}
+		got := decodeSimpleFloat(getReader(tc.binary))
 		if string(got) != tc.json {
 			t.Errorf("decodeSimpleFloat(0x%s)=%s, want:%s", hex.EncodeToString([]byte(tc.binary)), string(got), tc.json)
 		}
@@ -128,10 +107,7 @@ func TestDecodeBool(t *testing.T) {
 
 func TestDecodeFloat(t *testing.T) {
 	for _, tc := range float32TestCases {
-		got, _, err := decodeFloat([]byte(tc.binary))
-		if err != nil {
-			t.Errorf("decodeFloat(0x%s) returned error: %s", hex.EncodeToString([]byte(tc.binary)), err.Error())
-		}
+		got, _ := decodeFloat(getReader(tc.binary))
 		if got != float64(tc.val) {
 			t.Errorf("decodeFloat(0x%s)=%f, want:%f", hex.EncodeToString([]byte(tc.binary)), got, tc.val)
 		}
@@ -141,19 +117,13 @@ func TestDecodeFloat(t *testing.T) {
 func TestDecodeTimestamp(t *testing.T) {
 	decodeTimeZone, _ = time.LoadLocation("UTC")
 	for _, tc := range timeIntegerTestcases {
-		tm, _, err := decodeTagData([]byte(tc.binary))
-		if err != nil {
-			t.Errorf("decodeTagData(0x%s) returned error: %s", hex.EncodeToString([]byte(tc.binary)), err.Error())
-		}
+		tm := decodeTagData(getReader(tc.binary))
 		if string(tm) != "\""+tc.rfcStr+"\"" {
 			t.Errorf("decodeFloat(0x%s)=%s, want:%s", hex.EncodeToString([]byte(tc.binary)), tm, tc.rfcStr)
 		}
 	}
 	for _, tc := range timeFloatTestcases {
-		tm, _, err := decodeTagData([]byte(tc.out))
-		if err != nil {
-			t.Errorf("decodeTagData(0x%s) returned error: %s", hex.EncodeToString([]byte(tc.out)), err.Error())
-		}
+		tm := decodeTagData(getReader(tc.out))
 		//Since we convert to float and back - it may be slightly off - so
 		//we cannot check for exact equality instead, we'll check it is
 		//very close to each other Less than a Microsecond (lets not yet do nanosec)
@@ -166,6 +136,33 @@ func TestDecodeTimestamp(t *testing.T) {
 	}
 }
 
+func TestDecodeNetworkAddr(t *testing.T) {
+	for _, tc := range ipAddrTestCases {
+		d1 := decodeTagData(getReader(tc.binary))
+		if string(d1) != tc.text {
+			t.Errorf("decodeNetworkAddr(0x%s)=%s, want:%s", hex.EncodeToString([]byte(tc.binary)), d1, tc.text)
+		}
+	}
+}
+
+func TestDecodeMACAddr(t *testing.T) {
+	for _, tc := range macAddrTestCases {
+		d1 := decodeTagData(getReader(tc.binary))
+		if string(d1) != tc.text {
+			t.Errorf("decodeNetworkAddr(0x%s)=%s, want:%s", hex.EncodeToString([]byte(tc.binary)), d1, tc.text)
+		}
+	}
+}
+
+func TestDecodeIPPrefix(t *testing.T) {
+	for _, tc := range IPPrefixTestCases {
+		d1 := decodeTagData(getReader(tc.binary))
+		if string(d1) != tc.text {
+			t.Errorf("decodeIPPrefix(0x%s)=%s, want:%s", hex.EncodeToString([]byte(tc.binary)), d1, tc.text)
+		}
+	}
+}
+
 var compositeCborTestCases = []struct {
 	binary []byte
 	json   string
@@ -177,12 +174,32 @@ var compositeCborTestCases = []struct {
 func TestDecodeCbor2Json(t *testing.T) {
 	for _, tc := range compositeCborTestCases {
 		buf := bytes.NewBuffer([]byte{})
-		_, err := Cbor2JsonManyObjects(tc.binary, buf)
-		if err != nil {
-			t.Errorf("cbor2JsonManyObjects(0x%s) returned error", err)
-		}
-		if buf.String() != tc.json {
-			t.Errorf("cbor2JsonManyObjects(0x%s)=%s, want: %s", hex.EncodeToString(tc.binary), buf.String(), tc.json)
+		err := Cbor2JsonManyObjects(getReader(string(tc.binary)), buf)
+		if buf.String() != tc.json || err != nil {
+			t.Errorf("cbor2JsonManyObjects(0x%s)=%s, want: %s, err:%s", hex.EncodeToString(tc.binary), buf.String(), tc.json, err.Error())
+		}
+	}
+}
+
+var negativeCborTestCases = []struct {
+	binary []byte
+	errStr string
+}{
+	{[]byte("\xb9\x64IETF\x20\x65Array\x9f\x20\x00\x18\xc8\x14"), "Tried to Read 18 Bytes.. But hit end of file"},
+	{[]byte("\xbf\x64IETF\x20\x65Array\x9f\x20\x00\x18\xc8\x14"), "EOF"},
+	{[]byte("\xbf\x14IETF\x20\x65Array\x9f\x20\x00\x18\xc8\x14"), "Tried to Read 40736 Bytes.. But hit end of file"},
+	{[]byte("\xbf\x64IETF"), "EOF"},
+	{[]byte("\xbf\x64IETF\x20\x65Array\x9f\x20\x00\x18\xc8\xff\xff\xff"), "Invalid Additional Type: 31 in decodeSimpleFloat"},
+	{[]byte("\xbf\x64IETF\x20\x65Array"), "EOF"},
+	{[]byte("\xbf\x64"), "Tried to Read 4 Bytes.. But hit end of file"},
+}
+
+func TestDecodeNegativeCbor2Json(t *testing.T) {
+	for _, tc := range negativeCborTestCases {
+		buf := bytes.NewBuffer([]byte{})
+		err := Cbor2JsonManyObjects(getReader(string(tc.binary)), buf)
+		if err == nil || err.Error() != tc.errStr {
+			t.Errorf("Expected error got:%s, want:%s", err, tc.errStr)
 		}
 	}
 }

internal/cbor/examples/genLog.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"compress/zlib"
+	"flag"
+	"io"
+	"log"
+	"os"
+	"time"
+
+	"github.com/rs/zerolog"
+)
+
+func writeLog(fname string, count int, useCompress bool) {
+	opFile := os.Stdout
+	if fname != "<stdout>" {
+		fil, _ := os.Create(fname)
+		opFile = fil
+		defer func() {
+			if err := fil.Close(); err != nil {
+				log.Fatal(err)
+			}
+		}()
+	}
+
+	var f io.WriteCloser = opFile
+	if useCompress {
+		f = zlib.NewWriter(f)
+		defer func() {
+			if err := f.Close(); err != nil {
+				log.Fatal(err)
+			}
+		}()
+
+	}
+
+	zerolog.TimestampFunc = func() time.Time { return time.Now().Round(time.Second) }
+	log := zerolog.New(f).With().
+		Timestamp().
+		Logger()
+	for i := 0; i < count; i++ {
+		log.Error().
+			Int("Fault", 41650+i).Msg("Some Message")
+	}
+}
+
+func main() {
+	outFile := flag.String("out", "<stdout>", "Output File to which logs will be written to (WILL overwrite if already present).")
+	numLogs := flag.Int("num", 10, "Number of log messages to generate.")
+	doCompress := flag.Bool("compress", false, "Enable inline compressed writer")
+
+	flag.Parse()
+
+	writeLog(*outFile, *numLogs, *doCompress)
+}

internal/cbor/examples/makefile

@@ -0,0 +1,10 @@
+all: genLogJSON genLogCBOR
+
+genLogJSON: genLog.go
+	go build -o genLogJSON genLog.go 
+
+genLogCBOR: genLog.go
+	go build -tags binary_log -o genLogCBOR genLog.go 
+
+clean:
+	rm -f genLogJSON genLogCBOR

internal/cbor/string.go

@@ -1,7 +1,7 @@
 package cbor
 
 // AppendStrings encodes and adds an array of strings to the dst byte array.
-func AppendStrings(dst []byte, vals []string) []byte {
+func (e Encoder) AppendStrings(dst []byte, vals []string) []byte {
 	major := majorTypeArray
 	l := len(vals)
 	if l <= additionalMax {
@@ -11,13 +11,13 @@ func AppendStrings(dst []byte, vals []string) []byte {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
 	for _, v := range vals {
-		dst = AppendString(dst, v)
+		dst = e.AppendString(dst, v)
 	}
 	return dst
 }
 
 // AppendString encodes and adds a string to the dst byte array.
-func AppendString(dst []byte, s string) []byte {
+func (Encoder) AppendString(dst []byte, s string) []byte {
 	major := majorTypeUtf8String
 
 	l := len(s)
@@ -31,7 +31,7 @@ func AppendString(dst []byte, s string) []byte {
 }
 
 // AppendBytes encodes and adds an array of bytes to the dst byte array.
-func AppendBytes(dst, s []byte) []byte {
+func (Encoder) AppendBytes(dst, s []byte) []byte {
 	major := majorTypeByteString
 
 	l := len(s)
@@ -48,8 +48,13 @@ func AppendBytes(dst, s []byte) []byte {
 func AppendEmbeddedJSON(dst, s []byte) []byte {
 	major := majorTypeTags
 	minor := additionalTypeEmbeddedJSON
-	dst = append(dst, byte(major|minor))
 
+	// Append the TAG to indicate this is Embedded JSON.
+	dst = append(dst, byte(major|additionalTypeIntUint16))
+	dst = append(dst, byte(minor>>8))
+	dst = append(dst, byte(minor&0xff))
+
+	// Append the JSON Object as Byte String.
 	major = majorTypeByteString
 
 	l := len(s)

internal/cbor/string_test.go

@@ -59,7 +59,7 @@ var encodeByteTests = []struct {
 
 func TestAppendString(t *testing.T) {
 	for _, tt := range encodeStringTests {
-		b := AppendString([]byte{}, tt.plain)
+		b := enc.AppendString([]byte{}, tt.plain)
 		if got, want := string(b), tt.binary; got != want {
 			t.Errorf("appendString(%q) = %#q, want %#q", tt.plain, got, want)
 		}
@@ -72,7 +72,7 @@ func TestAppendString(t *testing.T) {
 	}
 	inp := buffer.String()
 	want := "\x7a\x00\x01\x11\x70" + inp
-	b := AppendString([]byte{}, inp)
+	b := enc.AppendString([]byte{}, inp)
 	if got := string(b); got != want {
 		t.Errorf("appendString(%q) = %#q, want %#q", inp, got, want)
 	}
@@ -80,7 +80,7 @@ func TestAppendString(t *testing.T) {
 
 func TestAppendBytes(t *testing.T) {
 	for _, tt := range encodeByteTests {
-		b := AppendBytes([]byte{}, tt.plain)
+		b := enc.AppendBytes([]byte{}, tt.plain)
 		if got, want := string(b), tt.binary; got != want {
 			t.Errorf("appendString(%q) = %#q, want %#q", tt.plain, got, want)
 		}
@@ -92,7 +92,7 @@ func TestAppendBytes(t *testing.T) {
 		inp = append(inp, byte('a'))
 	}
 	want := "\x5a\x00\x01\x11\x70" + string(inp)
-	b := AppendBytes([]byte{}, inp)
+	b := enc.AppendBytes([]byte{}, inp)
 	if got := string(b); got != want {
 		t.Errorf("appendString(%q) = %#q, want %#q", inp, got, want)
 	}
@@ -111,7 +111,7 @@ func BenchmarkAppendString(b *testing.B) {
 		b.Run(name, func(b *testing.B) {
 			buf := make([]byte, 0, 120)
 			for i := 0; i < b.N; i++ {
-				_ = AppendString(buf, str)
+				_ = enc.AppendString(buf, str)
 			}
 		})
 	}

internal/cbor/time.go

@@ -21,7 +21,7 @@ func appendIntegerTimestamp(dst []byte, t time.Time) []byte {
 	return dst
 }
 
-func appendFloatTimestamp(dst []byte, t time.Time) []byte {
+func (e Encoder) appendFloatTimestamp(dst []byte, t time.Time) []byte {
 	major := majorTypeTags
 	minor := additionalTypeTimestamp
 	dst = append(dst, byte(major|minor))
@@ -29,24 +29,24 @@ func appendFloatTimestamp(dst []byte, t time.Time) []byte {
 	nanos := t.Nanosecond()
 	var val float64
 	val = float64(secs)*1.0 + float64(nanos)*1E-9
-	return AppendFloat64(dst, val)
+	return e.AppendFloat64(dst, val)
 }
 
 // AppendTime encodes and adds a timestamp to the dst byte array.
-func AppendTime(dst []byte, t time.Time, unused string) []byte {
+func (e Encoder) AppendTime(dst []byte, t time.Time, unused string) []byte {
 	utc := t.UTC()
 	if utc.Nanosecond() == 0 {
 		return appendIntegerTimestamp(dst, utc)
 	}
-	return appendFloatTimestamp(dst, utc)
+	return e.appendFloatTimestamp(dst, utc)
 }
 
 // AppendTimes encodes and adds an array of timestamps to the dst byte array.
-func AppendTimes(dst []byte, vals []time.Time, unused string) []byte {
+func (e Encoder) AppendTimes(dst []byte, vals []time.Time, unused string) []byte {
 	major := majorTypeArray
 	l := len(vals)
 	if l == 0 {
-		return AppendArrayEnd(AppendArrayStart(dst))
+		return e.AppendArrayEnd(e.AppendArrayStart(dst))
 	}
 	if l <= additionalMax {
 		lb := byte(l)
@@ -56,7 +56,7 @@ func AppendTimes(dst []byte, vals []time.Time, unused string) []byte {
 	}
 
 	for _, t := range vals {
-		dst = AppendTime(dst, t, unused)
+		dst = e.AppendTime(dst, t, unused)
 	}
 	return dst
 }
@@ -64,21 +64,21 @@ func AppendTimes(dst []byte, vals []time.Time, unused string) []byte {
 // AppendDuration encodes and adds a duration to the dst byte array.
 // useInt field indicates whether to store the duration as seconds (integer) or
 // as seconds+nanoseconds (float).
-func AppendDuration(dst []byte, d time.Duration, unit time.Duration, useInt bool) []byte {
+func (e Encoder) AppendDuration(dst []byte, d time.Duration, unit time.Duration, useInt bool) []byte {
 	if useInt {
-		return AppendInt64(dst, int64(d/unit))
+		return e.AppendInt64(dst, int64(d/unit))
 	}
-	return AppendFloat64(dst, float64(d)/float64(unit))
+	return e.AppendFloat64(dst, float64(d)/float64(unit))
 }
 
 // AppendDurations encodes and adds an array of durations to the dst byte array.
 // useInt field indicates whether to store the duration as seconds (integer) or
 // as seconds+nanoseconds (float).
-func AppendDurations(dst []byte, vals []time.Duration, unit time.Duration, useInt bool) []byte {
+func (e Encoder) AppendDurations(dst []byte, vals []time.Duration, unit time.Duration, useInt bool) []byte {
 	major := majorTypeArray
 	l := len(vals)
 	if l == 0 {
-		return AppendArrayEnd(AppendArrayStart(dst))
+		return e.AppendArrayEnd(e.AppendArrayStart(dst))
 	}
 	if l <= additionalMax {
 		lb := byte(l)
@@ -87,7 +87,7 @@ func AppendDurations(dst []byte, vals []time.Duration, unit time.Duration, useIn
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
 	for _, d := range vals {
-		dst = AppendDuration(dst, d, unit, useInt)
+		dst = e.AppendDuration(dst, d, unit, useInt)
 	}
 	return dst
 }

internal/cbor/time_test.go

@@ -10,7 +10,7 @@ import (
 
 func TestAppendTimeNow(t *testing.T) {
 	tm := time.Now()
-	s := AppendTime([]byte{}, tm, "unused")
+	s := enc.AppendTime([]byte{}, tm, "unused")
 	got := string(s)
 
 	tm1 := float64(tm.Unix()) + float64(tm.Nanosecond())*1E-9
@@ -43,7 +43,7 @@ func TestAppendTimePastPresentInteger(t *testing.T) {
 			fmt.Println("Cannot parse input", tt.txt, ".. Skipping!", err)
 			continue
 		}
-		b := AppendTime([]byte{}, tin, "unused")
+		b := enc.AppendTime([]byte{}, tin, "unused")
 		if got, want := string(b), tt.binary; got != want {
 			t.Errorf("appendString(%s) = 0x%s, want 0x%s", tt.txt,
 				hex.EncodeToString(b),
@@ -68,7 +68,7 @@ func TestAppendTimePastPresentFloat(t *testing.T) {
 			fmt.Println("Cannot parse input", tt.rfcStr, ".. Skipping!")
 			continue
 		}
-		b := AppendTime([]byte{}, tin, "unused")
+		b := enc.AppendTime([]byte{}, tin, "unused")
 		if got, want := string(b), tt.out; got != want {
 			t.Errorf("appendString(%s) = 0x%s, want 0x%s", tt.rfcStr,
 				hex.EncodeToString(b),
@@ -92,7 +92,7 @@ func BenchmarkAppendTime(b *testing.B) {
 		b.Run(name, func(b *testing.B) {
 			buf := make([]byte, 0, 100)
 			for i := 0; i < b.N; i++ {
-				_ = AppendTime(buf, t, "unused")
+				_ = enc.AppendTime(buf, t, "unused")
 			}
 		})
 	}

internal/cbor/types.go

@@ -4,25 +4,55 @@ import (
 	"encoding/json"
 	"fmt"
 	"math"
+	"net"
 )
 
-// AppendNull inserts a 'Nil' object into the dst byte array.
-func AppendNull(dst []byte) []byte {
+// AppendNil inserts a 'Nil' object into the dst byte array.
+func (Encoder) AppendNil(dst []byte) []byte {
 	return append(dst, byte(majorTypeSimpleAndFloat|additionalTypeNull))
 }
 
 // AppendBeginMarker inserts a map start into the dst byte array.
-func AppendBeginMarker(dst []byte) []byte {
+func (Encoder) AppendBeginMarker(dst []byte) []byte {
 	return append(dst, byte(majorTypeMap|additionalTypeInfiniteCount))
 }
 
 // AppendEndMarker inserts a map end into the dst byte array.
-func AppendEndMarker(dst []byte) []byte {
+func (Encoder) AppendEndMarker(dst []byte) []byte {
 	return append(dst, byte(majorTypeSimpleAndFloat|additionalTypeBreak))
 }
 
+// AppendObjectData takes an object in form of a byte array and appends to dst.
+func (Encoder) AppendObjectData(dst []byte, o []byte) []byte {
+        // BeginMarker is present in the dst, which
+        // should not be copied when appending to existing data.
+        return append(dst, o[1:]...)
+}
+
+// AppendArrayStart adds markers to indicate the start of an array.
+func (Encoder) AppendArrayStart(dst []byte) []byte {
+	return append(dst, byte(majorTypeArray|additionalTypeInfiniteCount))
+}
+
+// AppendArrayEnd adds markers to indicate the end of an array.
+func (Encoder) AppendArrayEnd(dst []byte) []byte {
+	return append(dst, byte(majorTypeSimpleAndFloat|additionalTypeBreak))
+}
+
+// AppendArrayDelim adds markers to indicate end of a particular array element.
+func (Encoder) AppendArrayDelim(dst []byte) []byte {
+	//No delimiters needed in cbor
+	return dst
+}
+
+// AppendLineBreak is a noop that keep API compat with json encoder.
+func (Encoder) AppendLineBreak(dst []byte) []byte {
+	// No line breaks needed in binary format.
+	return dst
+}
+
 // AppendBool encodes and inserts a boolean value into the dst byte array.
-func AppendBool(dst []byte, val bool) []byte {
+func (Encoder) AppendBool(dst []byte, val bool) []byte {
 	b := additionalTypeBoolFalse
 	if val {
 		b = additionalTypeBoolTrue
@@ -31,11 +61,11 @@ func AppendBool(dst []byte, val bool) []byte {
 }
 
 // AppendBools encodes and inserts an array of boolean values into the dst byte array.
-func AppendBools(dst []byte, vals []bool) []byte {
+func (e Encoder) AppendBools(dst []byte, vals []bool) []byte {
 	major := majorTypeArray
 	l := len(vals)
 	if l == 0 {
-		return AppendArrayEnd(AppendArrayStart(dst))
+		return e.AppendArrayEnd(e.AppendArrayStart(dst))
 	}
 	if l <= additionalMax {
 		lb := byte(l)
@@ -44,13 +74,13 @@ func AppendBools(dst []byte, vals []bool) []byte {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
 	for _, v := range vals {
-		dst = AppendBool(dst, v)
+		dst = e.AppendBool(dst, v)
 	}
 	return dst
 }
 
 // AppendInt encodes and inserts an integer value into the dst byte array.
-func AppendInt(dst []byte, val int) []byte {
+func (Encoder) AppendInt(dst []byte, val int) []byte {
 	major := majorTypeUnsignedInt
 	contentVal := val
 	if val < 0 {
@@ -67,11 +97,11 @@ func AppendInt(dst []byte, val int) []byte {
 }
 
 // AppendInts encodes and inserts an array of integer values into the dst byte array.
-func AppendInts(dst []byte, vals []int) []byte {
+func (e Encoder) AppendInts(dst []byte, vals []int) []byte {
 	major := majorTypeArray
 	l := len(vals)
 	if l == 0 {
-		return AppendArrayEnd(AppendArrayStart(dst))
+		return e.AppendArrayEnd(e.AppendArrayStart(dst))
 	}
 	if l <= additionalMax {
 		lb := byte(l)
@@ -80,22 +110,22 @@ func AppendInts(dst []byte, vals []int) []byte {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
 	for _, v := range vals {
-		dst = AppendInt(dst, v)
+		dst = e.AppendInt(dst, v)
 	}
 	return dst
 }
 
 // AppendInt8 encodes and inserts an int8 value into the dst byte array.
-func AppendInt8(dst []byte, val int8) []byte {
-	return AppendInt(dst, int(val))
+func (e Encoder) AppendInt8(dst []byte, val int8) []byte {
+	return e.AppendInt(dst, int(val))
 }
 
 // AppendInts8 encodes and inserts an array of integer values into the dst byte array.
-func AppendInts8(dst []byte, vals []int8) []byte {
+func (e Encoder) AppendInts8(dst []byte, vals []int8) []byte {
 	major := majorTypeArray
 	l := len(vals)
 	if l == 0 {
-		return AppendArrayEnd(AppendArrayStart(dst))
+		return e.AppendArrayEnd(e.AppendArrayStart(dst))
 	}
 	if l <= additionalMax {
 		lb := byte(l)
@@ -104,22 +134,22 @@ func AppendInts8(dst []byte, vals []int8) []byte {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
 	for _, v := range vals {
-		dst = AppendInt(dst, int(v))
+		dst = e.AppendInt(dst, int(v))
 	}
 	return dst
 }
 
 // AppendInt16 encodes and inserts a int16 value into the dst byte array.
-func AppendInt16(dst []byte, val int16) []byte {
-	return AppendInt(dst, int(val))
+func (e Encoder) AppendInt16(dst []byte, val int16) []byte {
+	return e.AppendInt(dst, int(val))
 }
 
 // AppendInts16 encodes and inserts an array of int16 values into the dst byte array.
-func AppendInts16(dst []byte, vals []int16) []byte {
+func (e Encoder) AppendInts16(dst []byte, vals []int16) []byte {
 	major := majorTypeArray
 	l := len(vals)
 	if l == 0 {
-		return AppendArrayEnd(AppendArrayStart(dst))
+		return e.AppendArrayEnd(e.AppendArrayStart(dst))
 	}
 	if l <= additionalMax {
 		lb := byte(l)
@@ -128,22 +158,22 @@ func AppendInts16(dst []byte, vals []int16) []byte {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
 	for _, v := range vals {
-		dst = AppendInt(dst, int(v))
+		dst = e.AppendInt(dst, int(v))
 	}
 	return dst
 }
 
 // AppendInt32 encodes and inserts a int32 value into the dst byte array.
-func AppendInt32(dst []byte, val int32) []byte {
-	return AppendInt(dst, int(val))
+func (e Encoder) AppendInt32(dst []byte, val int32) []byte {
+	return e.AppendInt(dst, int(val))
 }
 
 // AppendInts32 encodes and inserts an array of int32 values into the dst byte array.
-func AppendInts32(dst []byte, vals []int32) []byte {
+func (e Encoder) AppendInts32(dst []byte, vals []int32) []byte {
 	major := majorTypeArray
 	l := len(vals)
 	if l == 0 {
-		return AppendArrayEnd(AppendArrayStart(dst))
+		return e.AppendArrayEnd(e.AppendArrayStart(dst))
 	}
 	if l <= additionalMax {
 		lb := byte(l)
@@ -152,13 +182,13 @@ func AppendInts32(dst []byte, vals []int32) []byte {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
 	for _, v := range vals {
-		dst = AppendInt(dst, int(v))
+		dst = e.AppendInt(dst, int(v))
 	}
 	return dst
 }
 
 // AppendInt64 encodes and inserts a int64 value into the dst byte array.
-func AppendInt64(dst []byte, val int64) []byte {
+func (Encoder) AppendInt64(dst []byte, val int64) []byte {
 	major := majorTypeUnsignedInt
 	contentVal := val
 	if val < 0 {
@@ -175,11 +205,11 @@ func AppendInt64(dst []byte, val int64) []byte {
 }
 
 // AppendInts64 encodes and inserts an array of int64 values into the dst byte array.
-func AppendInts64(dst []byte, vals []int64) []byte {
+func (e Encoder) AppendInts64(dst []byte, vals []int64) []byte {
 	major := majorTypeArray
 	l := len(vals)
 	if l == 0 {
-		return AppendArrayEnd(AppendArrayStart(dst))
+		return e.AppendArrayEnd(e.AppendArrayStart(dst))
 	}
 	if l <= additionalMax {
 		lb := byte(l)
@@ -188,22 +218,22 @@ func AppendInts64(dst []byte, vals []int64) []byte {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
 	for _, v := range vals {
-		dst = AppendInt64(dst, v)
+		dst = e.AppendInt64(dst, v)
 	}
 	return dst
 }
 
 // AppendUint encodes and inserts an unsigned integer value into the dst byte array.
-func AppendUint(dst []byte, val uint) []byte {
-	return AppendInt64(dst, int64(val))
+func (e Encoder) AppendUint(dst []byte, val uint) []byte {
+	return e.AppendInt64(dst, int64(val))
 }
 
 // AppendUints encodes and inserts an array of unsigned integer values into the dst byte array.
-func AppendUints(dst []byte, vals []uint) []byte {
+func (e Encoder) AppendUints(dst []byte, vals []uint) []byte {
 	major := majorTypeArray
 	l := len(vals)
 	if l == 0 {
-		return AppendArrayEnd(AppendArrayStart(dst))
+		return e.AppendArrayEnd(e.AppendArrayStart(dst))
 	}
 	if l <= additionalMax {
 		lb := byte(l)
@@ -212,22 +242,22 @@ func AppendUints(dst []byte, vals []uint) []byte {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
 	for _, v := range vals {
-		dst = AppendUint(dst, v)
+		dst = e.AppendUint(dst, v)
 	}
 	return dst
 }
 
 // AppendUint8 encodes and inserts a unsigned int8 value into the dst byte array.
-func AppendUint8(dst []byte, val uint8) []byte {
-	return AppendUint(dst, uint(val))
+func (e Encoder) AppendUint8(dst []byte, val uint8) []byte {
+	return e.AppendUint(dst, uint(val))
 }
 
 // AppendUints8 encodes and inserts an array of uint8 values into the dst byte array.
-func AppendUints8(dst []byte, vals []uint8) []byte {
+func (e Encoder) AppendUints8(dst []byte, vals []uint8) []byte {
 	major := majorTypeArray
 	l := len(vals)
 	if l == 0 {
-		return AppendArrayEnd(AppendArrayStart(dst))
+		return e.AppendArrayEnd(e.AppendArrayStart(dst))
 	}
 	if l <= additionalMax {
 		lb := byte(l)
@@ -236,22 +266,22 @@ func AppendUints8(dst []byte, vals []uint8) []byte {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
 	for _, v := range vals {
-		dst = AppendUint8(dst, v)
+		dst = e.AppendUint8(dst, v)
 	}
 	return dst
 }
 
 // AppendUint16 encodes and inserts a uint16 value into the dst byte array.
-func AppendUint16(dst []byte, val uint16) []byte {
-	return AppendUint(dst, uint(val))
+func (e Encoder) AppendUint16(dst []byte, val uint16) []byte {
+	return e.AppendUint(dst, uint(val))
 }
 
 // AppendUints16 encodes and inserts an array of uint16 values into the dst byte array.
-func AppendUints16(dst []byte, vals []uint16) []byte {
+func (e Encoder) AppendUints16(dst []byte, vals []uint16) []byte {
 	major := majorTypeArray
 	l := len(vals)
 	if l == 0 {
-		return AppendArrayEnd(AppendArrayStart(dst))
+		return e.AppendArrayEnd(e.AppendArrayStart(dst))
 	}
 	if l <= additionalMax {
 		lb := byte(l)
@@ -260,22 +290,22 @@ func AppendUints16(dst []byte, vals []uint16) []byte {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
 	for _, v := range vals {
-		dst = AppendUint16(dst, v)
+		dst = e.AppendUint16(dst, v)
 	}
 	return dst
 }
 
 // AppendUint32 encodes and inserts a uint32 value into the dst byte array.
-func AppendUint32(dst []byte, val uint32) []byte {
-	return AppendUint(dst, uint(val))
+func (e Encoder) AppendUint32(dst []byte, val uint32) []byte {
+	return e.AppendUint(dst, uint(val))
 }
 
 // AppendUints32 encodes and inserts an array of uint32 values into the dst byte array.
-func AppendUints32(dst []byte, vals []uint32) []byte {
+func (e Encoder) AppendUints32(dst []byte, vals []uint32) []byte {
 	major := majorTypeArray
 	l := len(vals)
 	if l == 0 {
-		return AppendArrayEnd(AppendArrayStart(dst))
+		return e.AppendArrayEnd(e.AppendArrayStart(dst))
 	}
 	if l <= additionalMax {
 		lb := byte(l)
@@ -284,13 +314,13 @@ func AppendUints32(dst []byte, vals []uint32) []byte {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
 	for _, v := range vals {
-		dst = AppendUint32(dst, v)
+		dst = e.AppendUint32(dst, v)
 	}
 	return dst
 }
 
 // AppendUint64 encodes and inserts a uint64 value into the dst byte array.
-func AppendUint64(dst []byte, val uint64) []byte {
+func (Encoder) AppendUint64(dst []byte, val uint64) []byte {
 	major := majorTypeUnsignedInt
 	contentVal := val
 	if contentVal <= additionalMax {
@@ -303,11 +333,11 @@ func AppendUint64(dst []byte, val uint64) []byte {
 }
 
 // AppendUints64 encodes and inserts an array of uint64 values into the dst byte array.
-func AppendUints64(dst []byte, vals []uint64) []byte {
+func (e Encoder) AppendUints64(dst []byte, vals []uint64) []byte {
 	major := majorTypeArray
 	l := len(vals)
 	if l == 0 {
-		return AppendArrayEnd(AppendArrayStart(dst))
+		return e.AppendArrayEnd(e.AppendArrayStart(dst))
 	}
 	if l <= additionalMax {
 		lb := byte(l)
@@ -316,13 +346,13 @@ func AppendUints64(dst []byte, vals []uint64) []byte {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
 	for _, v := range vals {
-		dst = AppendUint64(dst, v)
+		dst = e.AppendUint64(dst, v)
 	}
 	return dst
 }
 
 // AppendFloat32 encodes and inserts a single precision float value into the dst byte array.
-func AppendFloat32(dst []byte, val float32) []byte {
+func (Encoder) AppendFloat32(dst []byte, val float32) []byte {
 	switch {
 	case math.IsNaN(float64(val)):
 		return append(dst, "\xfa\x7f\xc0\x00\x00"...)
@@ -342,11 +372,11 @@ func AppendFloat32(dst []byte, val float32) []byte {
 }
 
 // AppendFloats32 encodes and inserts an array of single precision float value into the dst byte array.
-func AppendFloats32(dst []byte, vals []float32) []byte {
+func (e Encoder) AppendFloats32(dst []byte, vals []float32) []byte {
 	major := majorTypeArray
 	l := len(vals)
 	if l == 0 {
-		return AppendArrayEnd(AppendArrayStart(dst))
+		return e.AppendArrayEnd(e.AppendArrayStart(dst))
 	}
 	if l <= additionalMax {
 		lb := byte(l)
@@ -355,13 +385,13 @@ func AppendFloats32(dst []byte, vals []float32) []byte {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
 	for _, v := range vals {
-		dst = AppendFloat32(dst, v)
+		dst = e.AppendFloat32(dst, v)
 	}
 	return dst
 }
 
 // AppendFloat64 encodes and inserts a double precision float value into the dst byte array.
-func AppendFloat64(dst []byte, val float64) []byte {
+func (Encoder) AppendFloat64(dst []byte, val float64) []byte {
 	switch {
 	case math.IsNaN(val):
 		return append(dst, "\xfb\x7f\xf8\x00\x00\x00\x00\x00\x00"...)
@@ -382,11 +412,11 @@ func AppendFloat64(dst []byte, val float64) []byte {
 }
 
 // AppendFloats64 encodes and inserts an array of double precision float values into the dst byte array.
-func AppendFloats64(dst []byte, vals []float64) []byte {
+func (e Encoder) AppendFloats64(dst []byte, vals []float64) []byte {
 	major := majorTypeArray
 	l := len(vals)
 	if l == 0 {
-		return AppendArrayEnd(AppendArrayStart(dst))
+		return e.AppendArrayEnd(e.AppendArrayStart(dst))
 	}
 	if l <= additionalMax {
 		lb := byte(l)
@@ -395,44 +425,54 @@ func AppendFloats64(dst []byte, vals []float64) []byte {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
 	for _, v := range vals {
-		dst = AppendFloat64(dst, v)
+		dst = e.AppendFloat64(dst, v)
 	}
 	return dst
 }
 
 // AppendInterface takes an arbitrary object and converts it to JSON and embeds it dst.
-func AppendInterface(dst []byte, i interface{}) []byte {
+func (e Encoder) AppendInterface(dst []byte, i interface{}) []byte {
 	marshaled, err := json.Marshal(i)
 	if err != nil {
-		return AppendString(dst, fmt.Sprintf("marshaling error: %v", err))
+		return e.AppendString(dst, fmt.Sprintf("marshaling error: %v", err))
 	}
 	return AppendEmbeddedJSON(dst, marshaled)
 }
 
-// AppendObjectData takes an object in form of a byte array and appends to dst.
-func AppendObjectData(dst []byte, o []byte) []byte {
-	return append(dst, o...)
+// AppendIPAddr encodes and inserts an IP Address (IPv4 or IPv6).
+func (e Encoder) AppendIPAddr(dst []byte, ip net.IP) []byte {
+	dst = append(dst, byte(majorTypeTags|additionalTypeIntUint16))
+	dst = append(dst, byte(additionalTypeTagNetworkAddr>>8))
+	dst = append(dst, byte(additionalTypeTagNetworkAddr&0xff))
+	return e.AppendBytes(dst, ip)
 }
 
-// AppendArrayStart adds markers to indicate the start of an array.
-func AppendArrayStart(dst []byte) []byte {
-	return append(dst, byte(majorTypeArray|additionalTypeInfiniteCount))
+// AppendIPPrefix encodes and inserts an IP Address Prefix (Address + Mask Length).
+func (e Encoder) AppendIPPrefix(dst []byte, pfx net.IPNet) []byte {
+	dst = append(dst, byte(majorTypeTags|additionalTypeIntUint16))
+	dst = append(dst, byte(additionalTypeTagNetworkPrefix>>8))
+	dst = append(dst, byte(additionalTypeTagNetworkPrefix&0xff))
+
+	// Prefix is a tuple (aka MAP of 1 pair of elements) -
+	// first element is prefix, second is mask length.
+	dst = append(dst, byte(majorTypeMap|0x1))
+	dst = e.AppendBytes(dst, pfx.IP)
+	maskLen, _ := pfx.Mask.Size()
+	return e.AppendUint8(dst, uint8(maskLen))
 }
 
-// AppendArrayEnd adds markers to indicate the end of an array.
-func AppendArrayEnd(dst []byte) []byte {
-	return append(dst, byte(majorTypeSimpleAndFloat|additionalTypeBreak))
+// AppendMACAddr encodes and inserts an Hardware (MAC) address.
+func (e Encoder) AppendMACAddr(dst []byte, ha net.HardwareAddr) []byte {
+	dst = append(dst, byte(majorTypeTags|additionalTypeIntUint16))
+	dst = append(dst, byte(additionalTypeTagNetworkAddr>>8))
+	dst = append(dst, byte(additionalTypeTagNetworkAddr&0xff))
+	return e.AppendBytes(dst, ha)
 }
 
-// AppendArrayDelim adds markers to indicate end of a particular array element.
-func AppendArrayDelim(dst []byte) []byte {
-	//No delimiters needed in cbor
-	return dst
-}
-
-func AppendHex (dst []byte, val []byte) []byte {
-    dst = append(dst, byte(majorTypeTags|additionalTypeIntUint16))
-    dst = append(dst, byte(additionalTypeTagHexString>>8))
-    dst = append(dst, byte(additionalTypeTagHexString&0xff))
-    return AppendBytes(dst, val)
+// AppendHex adds a TAG and inserts a hex bytes as a string.
+func (e Encoder) AppendHex(dst []byte, val []byte) []byte {
+	dst = append(dst, byte(majorTypeTags|additionalTypeIntUint16))
+	dst = append(dst, byte(additionalTypeTagHexString>>8))
+	dst = append(dst, byte(additionalTypeTagHexString&0xff))
+	return e.AppendBytes(dst, val)
 }

internal/cbor/types_test.go

@@ -2,11 +2,14 @@ package cbor
 
 import (
 	"encoding/hex"
+	"net"
 	"testing"
 )
 
-func TestAppendNull(t *testing.T) {
-	s := AppendNull([]byte{})
+var enc = Encoder{}
+
+func TestAppendNil(t *testing.T) {
+	s := enc.AppendNil([]byte{})
 	got := string(s)
 	want := "\xf6"
 	if got != want {
@@ -26,7 +29,7 @@ var booleanTestCases = []struct {
 
 func TestAppendBool(t *testing.T) {
 	for _, tc := range booleanTestCases {
-		s := AppendBool([]byte{}, tc.val)
+		s := enc.AppendBool([]byte{}, tc.val)
 		got := string(s)
 		if got != tc.binary {
 			t.Errorf("AppendBool(%s)=0x%s, want: 0x%s",
@@ -47,7 +50,7 @@ var booleanArrayTestCases = []struct {
 
 func TestAppendBoolArray(t *testing.T) {
 	for _, tc := range booleanArrayTestCases {
-		s := AppendBools([]byte{}, tc.val)
+		s := enc.AppendBools([]byte{}, tc.val)
 		got := string(s)
 		if got != tc.binary {
 			t.Errorf("AppendBools(%s)=0x%s, want: 0x%s",
@@ -122,7 +125,7 @@ var integerTestCases = []struct {
 
 func TestAppendInt(t *testing.T) {
 	for _, tc := range integerTestCases {
-		s := AppendInt([]byte{}, tc.val)
+		s := enc.AppendInt([]byte{}, tc.val)
 		got := string(s)
 		if got != tc.binary {
 			t.Errorf("AppendInt(0x%x)=0x%s, want: 0x%s",
@@ -147,7 +150,7 @@ var integerArrayTestCases = []struct {
 
 func TestAppendIntArray(t *testing.T) {
 	for _, tc := range integerArrayTestCases {
-		s := AppendInts([]byte{}, tc.val)
+		s := enc.AppendInts([]byte{}, tc.val)
 		got := string(s)
 		if got != tc.binary {
 			t.Errorf("AppendInts(%s)=0x%s, want: 0x%s",
@@ -172,7 +175,7 @@ var float32TestCases = []struct {
 
 func TestAppendFloat32(t *testing.T) {
 	for _, tc := range float32TestCases {
-		s := AppendFloat32([]byte{}, tc.val)
+		s := enc.AppendFloat32([]byte{}, tc.val)
 		got := string(s)
 		if got != tc.binary {
 			t.Errorf("AppendFloat32(%f)=0x%s, want: 0x%s",
@@ -182,6 +185,72 @@ func TestAppendFloat32(t *testing.T) {
 	}
 }
 
+var ipAddrTestCases = []struct {
+	ipaddr net.IP
+	text   string // ASCII representation of ipaddr
+	binary string // CBOR representation of ipaddr
+}{
+	{net.IP{10, 0, 0, 1}, "\"10.0.0.1\"", "\xd9\x01\x04\x44\x0a\x00\x00\x01"},
+	{net.IP{0x20, 0x01, 0x0d, 0xb8, 0x85, 0xa3, 0x0, 0x0, 0x0, 0x0, 0x8a, 0x2e, 0x03, 0x70, 0x73, 0x34},
+		"\"2001:db8:85a3::8a2e:370:7334\"",
+		"\xd9\x01\x04\x50\x20\x01\x0d\xb8\x85\xa3\x00\x00\x00\x00\x8a\x2e\x03\x70\x73\x34"},
+}
+
+func TestAppendNetworkAddr(t *testing.T) {
+	for _, tc := range ipAddrTestCases {
+		s := enc.AppendIPAddr([]byte{}, tc.ipaddr)
+		got := string(s)
+		if got != tc.binary {
+			t.Errorf("AppendIPAddr(%s)=0x%s, want: 0x%s",
+				tc.ipaddr, hex.EncodeToString(s),
+				hex.EncodeToString([]byte(tc.binary)))
+		}
+	}
+}
+
+var macAddrTestCases = []struct {
+	macaddr net.HardwareAddr
+	text    string // ASCII representation of macaddr
+	binary  string // CBOR representation of macaddr
+}{
+	{net.HardwareAddr{0x12, 0x34, 0x56, 0x78, 0x90, 0xab}, "\"12:34:56:78:90:ab\"", "\xd9\x01\x04\x46\x12\x34\x56\x78\x90\xab"},
+	{net.HardwareAddr{0x20, 0x01, 0x0d, 0xb8, 0x85, 0xa3}, "\"20:01:0d:b8:85:a3\"", "\xd9\x01\x04\x46\x20\x01\x0d\xb8\x85\xa3"},
+}
+
+func TestAppendMacAddr(t *testing.T) {
+	for _, tc := range macAddrTestCases {
+		s := enc.AppendMACAddr([]byte{}, tc.macaddr)
+		got := string(s)
+		if got != tc.binary {
+			t.Errorf("AppendMACAddr(%s)=0x%s, want: 0x%s",
+				tc.macaddr.String(), hex.EncodeToString(s),
+				hex.EncodeToString([]byte(tc.binary)))
+		}
+	}
+}
+
+var IPPrefixTestCases = []struct {
+	pfx    net.IPNet
+	text   string // ASCII representation of pfx
+	binary string // CBOR representation of pfx
+}{
+	{net.IPNet{IP: net.IP{0, 0, 0, 0}, Mask: net.CIDRMask(0, 32)}, "\"0.0.0.0/0\"", "\xd9\x01\x05\xa1\x44\x00\x00\x00\x00\x00"},
+	{net.IPNet{IP: net.IP{192, 168, 0, 100}, Mask: net.CIDRMask(24, 32)}, "\"192.168.0.100/24\"",
+		"\xd9\x01\x05\xa1\x44\xc0\xa8\x00\x64\x18\x18"},
+}
+
+func TestAppendIPPrefix(t *testing.T) {
+	for _, tc := range IPPrefixTestCases {
+		s := enc.AppendIPPrefix([]byte{}, tc.pfx)
+		got := string(s)
+		if got != tc.binary {
+			t.Errorf("AppendIPPrefix(%s)=0x%s, want: 0x%s",
+				tc.pfx.String(), hex.EncodeToString(s),
+				hex.EncodeToString([]byte(tc.binary)))
+		}
+	}
+}
+
 func BenchmarkAppendInt(b *testing.B) {
 	type st struct {
 		sz  byte
@@ -205,23 +274,23 @@ func BenchmarkAppendInt(b *testing.B) {
 			for i := 0; i < b.N; i++ {
 				switch str.sz {
 				case 0:
-					_ = AppendInt(buf, int(str.val))
+					_ = enc.AppendInt(buf, int(str.val))
 				case 1:
-					_ = AppendUint8(buf, uint8(str.val))
+					_ = enc.AppendUint8(buf, uint8(str.val))
 				case 2:
-					_ = AppendUint16(buf, uint16(str.val))
+					_ = enc.AppendUint16(buf, uint16(str.val))
 				case 4:
-					_ = AppendUint32(buf, uint32(str.val))
+					_ = enc.AppendUint32(buf, uint32(str.val))
 				case 8:
-					_ = AppendUint64(buf, uint64(str.val))
+					_ = enc.AppendUint64(buf, uint64(str.val))
 				case 21:
-					_ = AppendInt8(buf, int8(str.val))
+					_ = enc.AppendInt8(buf, int8(str.val))
 				case 22:
-					_ = AppendInt16(buf, int16(str.val))
+					_ = enc.AppendInt16(buf, int16(str.val))
 				case 23:
-					_ = AppendInt32(buf, int32(str.val))
+					_ = enc.AppendInt32(buf, int32(str.val))
 				case 24:
-					_ = AppendInt64(buf, int64(str.val))
+					_ = enc.AppendInt64(buf, int64(str.val))
 				}
 			}
 		})
@@ -243,9 +312,9 @@ func BenchmarkAppendFloat(b *testing.B) {
 			for i := 0; i < b.N; i++ {
 				switch str.sz {
 				case 4:
-					_ = AppendFloat32(buf, float32(str.val))
+					_ = enc.AppendFloat32(buf, float32(str.val))
 				case 8:
-					_ = AppendFloat64(buf, str.val)
+					_ = enc.AppendFloat64(buf, str.val)
 				}
 			}
 		})

internal/json/base.go

@@ -1,32 +1,34 @@
 package json
 
+type Encoder struct{}
+
 // AppendKey appends a new key to the output JSON.
-func AppendKey(dst []byte, key string) []byte {
+func (e Encoder) AppendKey(dst []byte, key string) []byte {
 	if len(dst) > 1 && dst[len(dst)-1] != '{' {
 		dst = append(dst, ',')
 	}
-	dst = AppendString(dst, key)
+	dst = e.AppendString(dst, key)
 	return append(dst, ':')
 }
 
 // AppendError encodes the error string to json and appends
 // the encoded string to the input byte slice.
-func AppendError(dst []byte, err error) []byte {
+func (e Encoder) AppendError(dst []byte, err error) []byte {
 	if err == nil {
 		return append(dst, `null`...)
 	}
-	return AppendString(dst, err.Error())
+	return e.AppendString(dst, err.Error())
 }
 
 // AppendErrors encodes the error strings to json and
 // appends the encoded string list to the input byte slice.
-func AppendErrors(dst []byte, errs []error) []byte {
+func (e Encoder) AppendErrors(dst []byte, errs []error) []byte {
 	if len(errs) == 0 {
 		return append(dst, '[', ']')
 	}
 	dst = append(dst, '[')
 	if errs[0] != nil {
-		dst = AppendString(dst, errs[0].Error())
+		dst = e.AppendString(dst, errs[0].Error())
 	} else {
 		dst = append(dst, "null"...)
 	}
@@ -36,7 +38,7 @@ func AppendErrors(dst []byte, errs []error) []byte {
 				dst = append(dst, ",null"...)
 				continue
 			}
-			dst = AppendString(append(dst, ','), err.Error())
+			dst = e.AppendString(append(dst, ','), err.Error())
 		}
 	}
 	dst = append(dst, ']')

internal/json/bytes.go

@@ -3,7 +3,7 @@ package json
 import "unicode/utf8"
 
 // AppendBytes is a mirror of appendString with []byte arg
-func AppendBytes(dst, s []byte) []byte {
+func (Encoder) AppendBytes(dst, s []byte) []byte {
 	dst = append(dst, '"')
 	for i := 0; i < len(s); i++ {
 		if !noEscapeTable[s[i]] {
@@ -20,7 +20,7 @@ func AppendBytes(dst, s []byte) []byte {
 //
 // The operation loops though each byte and encodes it as hex using
 // the hex lookup table.
-func AppendHex(dst, s []byte) []byte {
+func (Encoder) AppendHex(dst, s []byte) []byte {
 	dst = append(dst, '"')
 	for _, v := range s {
 		dst = append(dst, hex[v>>4], hex[v&0x0f])

internal/json/bytes_test.go

@@ -5,9 +5,11 @@ import (
 	"unicode"
 )
 
+var enc = Encoder{}
+
 func TestAppendBytes(t *testing.T) {
 	for _, tt := range encodeStringTests {
-		b := AppendBytes([]byte{}, []byte(tt.in))
+		b := enc.AppendBytes([]byte{}, []byte(tt.in))
 		if got, want := string(b), tt.out; got != want {
 			t.Errorf("appendBytes(%q) = %#q, want %#q", tt.in, got, want)
 		}
@@ -16,7 +18,7 @@ func TestAppendBytes(t *testing.T) {
 
 func TestAppendHex(t *testing.T) {
 	for _, tt := range encodeHexTests {
-		b := AppendHex([]byte{}, []byte{tt.in})
+		b := enc.AppendHex([]byte{}, []byte{tt.in})
 		if got, want := string(b), tt.out; got != want {
 			t.Errorf("appendHex(%x) = %s, want %s", tt.in, got, want)
 		}
@@ -32,31 +34,31 @@ func TestStringBytes(t *testing.T) {
 	}
 	s := string(r) + "\xff\xff\xffhello" // some invalid UTF-8 too
 
-	enc := string(AppendString([]byte{}, s))
-	encBytes := string(AppendBytes([]byte{}, []byte(s)))
+	encStr := string(enc.AppendString([]byte{}, s))
+	encBytes := string(enc.AppendBytes([]byte{}, []byte(s)))
 
-	if enc != encBytes {
+	if encStr != encBytes {
 		i := 0
-		for i < len(enc) && i < len(encBytes) && enc[i] == encBytes[i] {
+		for i < len(encStr) && i < len(encBytes) && encStr[i] == encBytes[i] {
 			i++
 		}
-		enc = enc[i:]
+		encStr = encStr[i:]
 		encBytes = encBytes[i:]
 		i = 0
-		for i < len(enc) && i < len(encBytes) && enc[len(enc)-i-1] == encBytes[len(encBytes)-i-1] {
+		for i < len(encStr) && i < len(encBytes) && encStr[len(encStr)-i-1] == encBytes[len(encBytes)-i-1] {
 			i++
 		}
-		enc = enc[:len(enc)-i]
+		encStr = encStr[:len(encStr)-i]
 		encBytes = encBytes[:len(encBytes)-i]
 
-		if len(enc) > 20 {
-			enc = enc[:20] + "..."
+		if len(encStr) > 20 {
+			encStr = encStr[:20] + "..."
 		}
 		if len(encBytes) > 20 {
 			encBytes = encBytes[:20] + "..."
 		}
 
-		t.Errorf("encodings differ at %#q vs %#q", enc, encBytes)
+		t.Errorf("encodings differ at %#q vs %#q", encStr, encBytes)
 	}
 }
 
@@ -75,7 +77,7 @@ func BenchmarkAppendBytes(b *testing.B) {
 		b.Run(name, func(b *testing.B) {
 			buf := make([]byte, 0, 100)
 			for i := 0; i < b.N; i++ {
-				_ = AppendBytes(buf, byt)
+				_ = enc.AppendBytes(buf, byt)
 			}
 		})
 	}

internal/json/string.go

@@ -14,15 +14,15 @@ func init() {
 
 // AppendStrings encodes the input strings to json and
 // appends the encoded string list to the input byte slice.
-func AppendStrings(dst []byte, vals []string) []byte {
+func (e Encoder) AppendStrings(dst []byte, vals []string) []byte {
 	if len(vals) == 0 {
 		return append(dst, '[', ']')
 	}
 	dst = append(dst, '[')
-	dst = AppendString(dst, vals[0])
+	dst = e.AppendString(dst, vals[0])
 	if len(vals) > 1 {
 		for _, val := range vals[1:] {
-			dst = AppendString(append(dst, ','), val)
+			dst = e.AppendString(append(dst, ','), val)
 		}
 	}
 	dst = append(dst, ']')
@@ -38,7 +38,7 @@ func AppendStrings(dst []byte, vals []string) []byte {
 // entirety to the byte slice.
 // If we encounter a byte that does need encoding, switch up
 // the operation and perform a byte-by-byte read-encode-append.
-func AppendString(dst []byte, s string) []byte {
+func (Encoder) AppendString(dst []byte, s string) []byte {
 	// Start with a double quote.
 	dst = append(dst, '"')
 	// Loop through each character in the string.

internal/json/string_test.go

@@ -65,7 +65,7 @@ var encodeHexTests = []struct {
 
 func TestAppendString(t *testing.T) {
 	for _, tt := range encodeStringTests {
-		b := AppendString([]byte{}, tt.in)
+		b := enc.AppendString([]byte{}, tt.in)
 		if got, want := string(b), tt.out; got != want {
 			t.Errorf("appendString(%q) = %#q, want %#q", tt.in, got, want)
 		}
@@ -86,7 +86,7 @@ func BenchmarkAppendString(b *testing.B) {
 		b.Run(name, func(b *testing.B) {
 			buf := make([]byte, 0, 100)
 			for i := 0; i < b.N; i++ {
-				_ = AppendString(buf, str)
+				_ = enc.AppendString(buf, str)
 			}
 		})
 	}

internal/json/time.go

@@ -7,16 +7,16 @@ import (
 
 // AppendTime formats the input time with the given format
 // and appends the encoded string to the input byte slice.
-func AppendTime(dst []byte, t time.Time, format string) []byte {
+func (e Encoder) AppendTime(dst []byte, t time.Time, format string) []byte {
 	if format == "" {
-		return AppendInt64(dst, t.Unix())
+		return e.AppendInt64(dst, t.Unix())
 	}
 	return append(t.AppendFormat(append(dst, '"'), format), '"')
 }
 
 // AppendTimes converts the input times with the given format
 // and appends the encoded string list to the input byte slice.
-func AppendTimes(dst []byte, vals []time.Time, format string) []byte {
+func (Encoder) AppendTimes(dst []byte, vals []time.Time, format string) []byte {
 	if format == "" {
 		return appendUnixTimes(dst, vals)
 	}
@@ -42,7 +42,7 @@ func appendUnixTimes(dst []byte, vals []time.Time) []byte {
 	dst = strconv.AppendInt(dst, vals[0].Unix(), 10)
 	if len(vals) > 1 {
 		for _, t := range vals[1:] {
-			dst = strconv.AppendInt(dst, t.Unix(), 10)
+			dst = strconv.AppendInt(append(dst, ','), t.Unix(), 10)
 		}
 	}
 	dst = append(dst, ']')
@@ -51,24 +51,24 @@ func appendUnixTimes(dst []byte, vals []time.Time) []byte {
 
 // AppendDuration formats the input duration with the given unit & format
 // and appends the encoded string to the input byte slice.
-func AppendDuration(dst []byte, d time.Duration, unit time.Duration, useInt bool) []byte {
+func (e Encoder) AppendDuration(dst []byte, d time.Duration, unit time.Duration, useInt bool) []byte {
 	if useInt {
 		return strconv.AppendInt(dst, int64(d/unit), 10)
 	}
-	return AppendFloat64(dst, float64(d)/float64(unit))
+	return e.AppendFloat64(dst, float64(d)/float64(unit))
 }
 
 // AppendDurations formats the input durations with the given unit & format
 // and appends the encoded string list to the input byte slice.
-func AppendDurations(dst []byte, vals []time.Duration, unit time.Duration, useInt bool) []byte {
+func (e Encoder) AppendDurations(dst []byte, vals []time.Duration, unit time.Duration, useInt bool) []byte {
 	if len(vals) == 0 {
 		return append(dst, '[', ']')
 	}
 	dst = append(dst, '[')
-	dst = AppendDuration(dst, vals[0], unit, useInt)
+	dst = e.AppendDuration(dst, vals[0], unit, useInt)
 	if len(vals) > 1 {
 		for _, d := range vals[1:] {
-			dst = AppendDuration(append(dst, ','), d, unit, useInt)
+			dst = e.AppendDuration(append(dst, ','), d, unit, useInt)
 		}
 	}
 	dst = append(dst, ']')

internal/json/types.go

@@ -4,18 +4,57 @@ import (
 	"encoding/json"
 	"fmt"
 	"math"
+	"net"
 	"strconv"
 )
 
+// AppendNil inserts a 'Nil' object into the dst byte array.
+func (Encoder) AppendNil(dst []byte) []byte {
+	return append(dst, "null"...)
+}
+
+// AppendBeginMarker inserts a map start into the dst byte array.
+func (Encoder) AppendBeginMarker(dst []byte) []byte {
+	return append(dst, '{')
+}
+
+// AppendEndMarker inserts a map end into the dst byte array.
+func (Encoder) AppendEndMarker(dst []byte) []byte {
+	return append(dst, '}')
+}
+
+// AppendLineBreak appends a line break.
+func (Encoder) AppendLineBreak(dst []byte) []byte {
+	return append(dst, '\n')
+}
+
+// AppendArrayStart adds markers to indicate the start of an array.
+func (Encoder) AppendArrayStart(dst []byte) []byte {
+	return append(dst, '[')
+}
+
+// AppendArrayEnd adds markers to indicate the end of an array.
+func (Encoder) AppendArrayEnd(dst []byte) []byte {
+	return append(dst, ']')
+}
+
+// AppendArrayDelim adds markers to indicate end of a particular array element.
+func (Encoder) AppendArrayDelim(dst []byte) []byte {
+	if len(dst) > 0 {
+		return append(dst, ',')
+	}
+	return dst
+}
+
 // AppendBool converts the input bool to a string and
 // appends the encoded string to the input byte slice.
-func AppendBool(dst []byte, val bool) []byte {
+func (Encoder) AppendBool(dst []byte, val bool) []byte {
 	return strconv.AppendBool(dst, val)
 }
 
 // AppendBools encodes the input bools to json and
 // appends the encoded string list to the input byte slice.
-func AppendBools(dst []byte, vals []bool) []byte {
+func (Encoder) AppendBools(dst []byte, vals []bool) []byte {
 	if len(vals) == 0 {
 		return append(dst, '[', ']')
 	}
@@ -32,13 +71,13 @@ func AppendBools(dst []byte, vals []bool) []byte {
 
 // AppendInt converts the input int to a string and
 // appends the encoded string to the input byte slice.
-func AppendInt(dst []byte, val int) []byte {
+func (Encoder) AppendInt(dst []byte, val int) []byte {
 	return strconv.AppendInt(dst, int64(val), 10)
 }
 
 // AppendInts encodes the input ints to json and
 // appends the encoded string list to the input byte slice.
-func AppendInts(dst []byte, vals []int) []byte {
+func (Encoder) AppendInts(dst []byte, vals []int) []byte {
 	if len(vals) == 0 {
 		return append(dst, '[', ']')
 	}
@@ -55,13 +94,13 @@ func AppendInts(dst []byte, vals []int) []byte {
 
 // AppendInt8 converts the input []int8 to a string and
 // appends the encoded string to the input byte slice.
-func AppendInt8(dst []byte, val int8) []byte {
+func (Encoder) AppendInt8(dst []byte, val int8) []byte {
 	return strconv.AppendInt(dst, int64(val), 10)
 }
 
 // AppendInts8 encodes the input int8s to json and
 // appends the encoded string list to the input byte slice.
-func AppendInts8(dst []byte, vals []int8) []byte {
+func (Encoder) AppendInts8(dst []byte, vals []int8) []byte {
 	if len(vals) == 0 {
 		return append(dst, '[', ']')
 	}
@@ -78,13 +117,13 @@ func AppendInts8(dst []byte, vals []int8) []byte {
 
 // AppendInt16 converts the input int16 to a string and
 // appends the encoded string to the input byte slice.
-func AppendInt16(dst []byte, val int16) []byte {
+func (Encoder) AppendInt16(dst []byte, val int16) []byte {
 	return strconv.AppendInt(dst, int64(val), 10)
 }
 
 // AppendInts16 encodes the input int16s to json and
 // appends the encoded string list to the input byte slice.
-func AppendInts16(dst []byte, vals []int16) []byte {
+func (Encoder) AppendInts16(dst []byte, vals []int16) []byte {
 	if len(vals) == 0 {
 		return append(dst, '[', ']')
 	}
@@ -101,13 +140,13 @@ func AppendInts16(dst []byte, vals []int16) []byte {
 
 // AppendInt32 converts the input int32 to a string and
 // appends the encoded string to the input byte slice.
-func AppendInt32(dst []byte, val int32) []byte {
+func (Encoder) AppendInt32(dst []byte, val int32) []byte {
 	return strconv.AppendInt(dst, int64(val), 10)
 }
 
 // AppendInts32 encodes the input int32s to json and
 // appends the encoded string list to the input byte slice.
-func AppendInts32(dst []byte, vals []int32) []byte {
+func (Encoder) AppendInts32(dst []byte, vals []int32) []byte {
 	if len(vals) == 0 {
 		return append(dst, '[', ']')
 	}
@@ -124,13 +163,13 @@ func AppendInts32(dst []byte, vals []int32) []byte {
 
 // AppendInt64 converts the input int64 to a string and
 // appends the encoded string to the input byte slice.
-func AppendInt64(dst []byte, val int64) []byte {
+func (Encoder) AppendInt64(dst []byte, val int64) []byte {
 	return strconv.AppendInt(dst, val, 10)
 }
 
 // AppendInts64 encodes the input int64s to json and
 // appends the encoded string list to the input byte slice.
-func AppendInts64(dst []byte, vals []int64) []byte {
+func (Encoder) AppendInts64(dst []byte, vals []int64) []byte {
 	if len(vals) == 0 {
 		return append(dst, '[', ']')
 	}
@@ -147,13 +186,13 @@ func AppendInts64(dst []byte, vals []int64) []byte {
 
 // AppendUint converts the input uint to a string and
 // appends the encoded string to the input byte slice.
-func AppendUint(dst []byte, val uint) []byte {
+func (Encoder) AppendUint(dst []byte, val uint) []byte {
 	return strconv.AppendUint(dst, uint64(val), 10)
 }
 
 // AppendUints encodes the input uints to json and
 // appends the encoded string list to the input byte slice.
-func AppendUints(dst []byte, vals []uint) []byte {
+func (Encoder) AppendUints(dst []byte, vals []uint) []byte {
 	if len(vals) == 0 {
 		return append(dst, '[', ']')
 	}
@@ -170,13 +209,13 @@ func AppendUints(dst []byte, vals []uint) []byte {
 
 // AppendUint8 converts the input uint8 to a string and
 // appends the encoded string to the input byte slice.
-func AppendUint8(dst []byte, val uint8) []byte {
+func (Encoder) AppendUint8(dst []byte, val uint8) []byte {
 	return strconv.AppendUint(dst, uint64(val), 10)
 }
 
 // AppendUints8 encodes the input uint8s to json and
 // appends the encoded string list to the input byte slice.
-func AppendUints8(dst []byte, vals []uint8) []byte {
+func (Encoder) AppendUints8(dst []byte, vals []uint8) []byte {
 	if len(vals) == 0 {
 		return append(dst, '[', ']')
 	}
@@ -193,13 +232,13 @@ func AppendUints8(dst []byte, vals []uint8) []byte {
 
 // AppendUint16 converts the input uint16 to a string and
 // appends the encoded string to the input byte slice.
-func AppendUint16(dst []byte, val uint16) []byte {
+func (Encoder) AppendUint16(dst []byte, val uint16) []byte {
 	return strconv.AppendUint(dst, uint64(val), 10)
 }
 
 // AppendUints16 encodes the input uint16s to json and
 // appends the encoded string list to the input byte slice.
-func AppendUints16(dst []byte, vals []uint16) []byte {
+func (Encoder) AppendUints16(dst []byte, vals []uint16) []byte {
 	if len(vals) == 0 {
 		return append(dst, '[', ']')
 	}
@@ -216,13 +255,13 @@ func AppendUints16(dst []byte, vals []uint16) []byte {
 
 // AppendUint32 converts the input uint32 to a string and
 // appends the encoded string to the input byte slice.
-func AppendUint32(dst []byte, val uint32) []byte {
+func (Encoder) AppendUint32(dst []byte, val uint32) []byte {
 	return strconv.AppendUint(dst, uint64(val), 10)
 }
 
 // AppendUints32 encodes the input uint32s to json and
 // appends the encoded string list to the input byte slice.
-func AppendUints32(dst []byte, vals []uint32) []byte {
+func (Encoder) AppendUints32(dst []byte, vals []uint32) []byte {
 	if len(vals) == 0 {
 		return append(dst, '[', ']')
 	}
@@ -239,13 +278,13 @@ func AppendUints32(dst []byte, vals []uint32) []byte {
 
 // AppendUint64 converts the input uint64 to a string and
 // appends the encoded string to the input byte slice.
-func AppendUint64(dst []byte, val uint64) []byte {
+func (Encoder) AppendUint64(dst []byte, val uint64) []byte {
 	return strconv.AppendUint(dst, uint64(val), 10)
 }
 
 // AppendUints64 encodes the input uint64s to json and
 // appends the encoded string list to the input byte slice.
-func AppendUints64(dst []byte, vals []uint64) []byte {
+func (Encoder) AppendUints64(dst []byte, vals []uint64) []byte {
 	if len(vals) == 0 {
 		return append(dst, '[', ']')
 	}
@@ -260,9 +299,7 @@ func AppendUints64(dst []byte, vals []uint64) []byte {
 	return dst
 }
 
-// AppendFloat converts the input float to a string and
-// appends the encoded string to the input byte slice.
-func AppendFloat(dst []byte, val float64, bitSize int) []byte {
+func appendFloat(dst []byte, val float64, bitSize int) []byte {
 	// JSON does not permit NaN or Infinity. A typical JSON encoder would fail
 	// with an error, but a logging library wants the data to get thru so we
 	// make a tradeoff and store those types as string.
@@ -279,21 +316,21 @@ func AppendFloat(dst []byte, val float64, bitSize int) []byte {
 
 // AppendFloat32 converts the input float32 to a string and
 // appends the encoded string to the input byte slice.
-func AppendFloat32(dst []byte, val float32) []byte {
-	return AppendFloat(dst, float64(val), 32)
+func (Encoder) AppendFloat32(dst []byte, val float32) []byte {
+	return appendFloat(dst, float64(val), 32)
 }
 
 // AppendFloats32 encodes the input float32s to json and
 // appends the encoded string list to the input byte slice.
-func AppendFloats32(dst []byte, vals []float32) []byte {
+func (Encoder) AppendFloats32(dst []byte, vals []float32) []byte {
 	if len(vals) == 0 {
 		return append(dst, '[', ']')
 	}
 	dst = append(dst, '[')
-	dst = AppendFloat(dst, float64(vals[0]), 32)
+	dst = appendFloat(dst, float64(vals[0]), 32)
 	if len(vals) > 1 {
 		for _, val := range vals[1:] {
-			dst = AppendFloat(append(dst, ','), float64(val), 32)
+			dst = appendFloat(append(dst, ','), float64(val), 32)
 		}
 	}
 	dst = append(dst, ']')
@@ -302,21 +339,21 @@ func AppendFloats32(dst []byte, vals []float32) []byte {
 
 // AppendFloat64 converts the input float64 to a string and
 // appends the encoded string to the input byte slice.
-func AppendFloat64(dst []byte, val float64) []byte {
-	return AppendFloat(dst, val, 64)
+func (Encoder) AppendFloat64(dst []byte, val float64) []byte {
+	return appendFloat(dst, val, 64)
 }
 
 // AppendFloats64 encodes the input float64s to json and
 // appends the encoded string list to the input byte slice.
-func AppendFloats64(dst []byte, vals []float64) []byte {
+func (Encoder) AppendFloats64(dst []byte, vals []float64) []byte {
 	if len(vals) == 0 {
 		return append(dst, '[', ']')
 	}
 	dst = append(dst, '[')
-	dst = AppendFloat(dst, vals[0], 32)
+	dst = appendFloat(dst, vals[0], 32)
 	if len(vals) > 1 {
 		for _, val := range vals[1:] {
-			dst = AppendFloat(append(dst, ','), val, 64)
+			dst = appendFloat(append(dst, ','), val, 64)
 		}
 	}
 	dst = append(dst, ']')
@@ -325,15 +362,17 @@ func AppendFloats64(dst []byte, vals []float64) []byte {
 
 // AppendInterface marshals the input interface to a string and
 // appends the encoded string to the input byte slice.
-func AppendInterface(dst []byte, i interface{}) []byte {
+func (e Encoder) AppendInterface(dst []byte, i interface{}) []byte {
 	marshaled, err := json.Marshal(i)
 	if err != nil {
-		return AppendString(dst, fmt.Sprintf("marshaling error: %v", err))
+		return e.AppendString(dst, fmt.Sprintf("marshaling error: %v", err))
 	}
 	return append(dst, marshaled...)
 }
 
-func AppendObjectData(dst []byte, o []byte) []byte {
+// AppendObjectData takes in an object that is already in a byte array
+// and adds it to the dst.
+func (Encoder) AppendObjectData(dst []byte, o []byte) []byte {
 	// Two conditions we want to put a ',' between existing content and
 	// new content:
 	// 1. new content starts with '{' - which shd be dropped   OR
@@ -345,3 +384,19 @@ func AppendObjectData(dst []byte, o []byte) []byte {
 	}
 	return append(dst, o...)
 }
+
+// AppendIPAddr adds IPv4 or IPv6 address to dst.
+func (e Encoder) AppendIPAddr(dst []byte, ip net.IP) []byte {
+	return e.AppendString(dst, ip.String())
+}
+
+// AppendIPPrefix adds IPv4 or IPv6 Prefix (address & mask) to dst.
+func (e Encoder) AppendIPPrefix(dst []byte, pfx net.IPNet) []byte {
+	return e.AppendString(dst, pfx.String())
+
+}
+
+// AppendMACAddr adds MAC address to dst.
+func (e Encoder) AppendMACAddr(dst []byte, ha net.HardwareAddr) []byte {
+	return e.AppendString(dst, ha.String())
+}

internal/json/types_test.go

@@ -2,24 +2,25 @@ package json
 
 import (
 	"math"
+	"net"
 	"reflect"
 	"testing"
 )
 
 func TestAppendType(t *testing.T) {
 	w := map[string]func(interface{}) []byte{
-		"AppendInt":     func(v interface{}) []byte { return AppendInt([]byte{}, v.(int)) },
-		"AppendInt8":    func(v interface{}) []byte { return AppendInt8([]byte{}, v.(int8)) },
-		"AppendInt16":   func(v interface{}) []byte { return AppendInt16([]byte{}, v.(int16)) },
-		"AppendInt32":   func(v interface{}) []byte { return AppendInt32([]byte{}, v.(int32)) },
-		"AppendInt64":   func(v interface{}) []byte { return AppendInt64([]byte{}, v.(int64)) },
-		"AppendUint":    func(v interface{}) []byte { return AppendUint([]byte{}, v.(uint)) },
-		"AppendUint8":   func(v interface{}) []byte { return AppendUint8([]byte{}, v.(uint8)) },
-		"AppendUint16":  func(v interface{}) []byte { return AppendUint16([]byte{}, v.(uint16)) },
-		"AppendUint32":  func(v interface{}) []byte { return AppendUint32([]byte{}, v.(uint32)) },
-		"AppendUint64":  func(v interface{}) []byte { return AppendUint64([]byte{}, v.(uint64)) },
-		"AppendFloat32": func(v interface{}) []byte { return AppendFloat32([]byte{}, v.(float32)) },
-		"AppendFloat64": func(v interface{}) []byte { return AppendFloat64([]byte{}, v.(float64)) },
+		"AppendInt":     func(v interface{}) []byte { return enc.AppendInt([]byte{}, v.(int)) },
+		"AppendInt8":    func(v interface{}) []byte { return enc.AppendInt8([]byte{}, v.(int8)) },
+		"AppendInt16":   func(v interface{}) []byte { return enc.AppendInt16([]byte{}, v.(int16)) },
+		"AppendInt32":   func(v interface{}) []byte { return enc.AppendInt32([]byte{}, v.(int32)) },
+		"AppendInt64":   func(v interface{}) []byte { return enc.AppendInt64([]byte{}, v.(int64)) },
+		"AppendUint":    func(v interface{}) []byte { return enc.AppendUint([]byte{}, v.(uint)) },
+		"AppendUint8":   func(v interface{}) []byte { return enc.AppendUint8([]byte{}, v.(uint8)) },
+		"AppendUint16":  func(v interface{}) []byte { return enc.AppendUint16([]byte{}, v.(uint16)) },
+		"AppendUint32":  func(v interface{}) []byte { return enc.AppendUint32([]byte{}, v.(uint32)) },
+		"AppendUint64":  func(v interface{}) []byte { return enc.AppendUint64([]byte{}, v.(uint64)) },
+		"AppendFloat32": func(v interface{}) []byte { return enc.AppendFloat32([]byte{}, v.(float32)) },
+		"AppendFloat64": func(v interface{}) []byte { return enc.AppendFloat64([]byte{}, v.(float64)) },
 	}
 	tests := []struct {
 		name  string
@@ -61,3 +62,106 @@ func TestAppendType(t *testing.T) {
 		})
 	}
 }
+
+func Test_appendMAC(t *testing.T) {
+	MACtests := []struct {
+		input string
+		want  []byte
+	}{
+		{"01:23:45:67:89:ab", []byte(`"01:23:45:67:89:ab"`)},
+		{"cd:ef:11:22:33:44", []byte(`"cd:ef:11:22:33:44"`)},
+	}
+	for _, tt := range MACtests {
+		t.Run("MAC", func(t *testing.T) {
+			ha, _ := net.ParseMAC(tt.input)
+			if got := enc.AppendMACAddr([]byte{}, ha); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("appendMACAddr() = %s, want %s", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_appendIP(t *testing.T) {
+	IPv4tests := []struct {
+		input net.IP
+		want  []byte
+	}{
+		{net.IP{0, 0, 0, 0}, []byte(`"0.0.0.0"`)},
+		{net.IP{192, 0, 2, 200}, []byte(`"192.0.2.200"`)},
+	}
+
+	for _, tt := range IPv4tests {
+		t.Run("IPv4", func(t *testing.T) {
+			if got := enc.AppendIPAddr([]byte{}, tt.input); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("appendIPAddr() = %s, want %s", got, tt.want)
+			}
+		})
+	}
+	IPv6tests := []struct {
+		input net.IP
+		want  []byte
+	}{
+		{net.IPv6zero, []byte(`"::"`)},
+		{net.IPv6linklocalallnodes, []byte(`"ff02::1"`)},
+		{net.IP{0x20, 0x01, 0x0d, 0xb8, 0x85, 0xa3, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x2e, 0x03, 0x70, 0x73, 0x34}, []byte(`"2001:db8:85a3::8a2e:370:7334"`)},
+	}
+	for _, tt := range IPv6tests {
+		t.Run("IPv6", func(t *testing.T) {
+			if got := enc.AppendIPAddr([]byte{}, tt.input); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("appendIPAddr() = %s, want %s", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_appendIPPrefix(t *testing.T) {
+	IPv4Prefixtests := []struct {
+		input net.IPNet
+		want  []byte
+	}{
+		{net.IPNet{IP: net.IP{0, 0, 0, 0}, Mask: net.IPv4Mask(0, 0, 0, 0)}, []byte(`"0.0.0.0/0"`)},
+		{net.IPNet{IP: net.IP{192, 0, 2, 200}, Mask: net.IPv4Mask(255, 255, 255, 0)}, []byte(`"192.0.2.200/24"`)},
+	}
+	for _, tt := range IPv4Prefixtests {
+		t.Run("IPv4", func(t *testing.T) {
+			if got := enc.AppendIPPrefix([]byte{}, tt.input); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("appendIPPrefix() = %s, want %s", got, tt.want)
+			}
+		})
+	}
+	IPv6Prefixtests := []struct {
+		input net.IPNet
+		want  []byte
+	}{
+		{net.IPNet{IP: net.IPv6zero, Mask: net.CIDRMask(0, 128)}, []byte(`"::/0"`)},
+		{net.IPNet{IP: net.IPv6linklocalallnodes, Mask: net.CIDRMask(128, 128)}, []byte(`"ff02::1/128"`)},
+		{net.IPNet{IP: net.IP{0x20, 0x01, 0x0d, 0xb8, 0x85, 0xa3, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x2e, 0x03, 0x70, 0x73, 0x34},
+			Mask: net.CIDRMask(64, 128)},
+			[]byte(`"2001:db8:85a3::8a2e:370:7334/64"`)},
+	}
+	for _, tt := range IPv6Prefixtests {
+		t.Run("IPv6", func(t *testing.T) {
+			if got := enc.AppendIPPrefix([]byte{}, tt.input); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("appendIPPrefix() = %s, want %s", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_appendMac(t *testing.T) {
+	MACtests := []struct {
+		input net.HardwareAddr
+		want  []byte
+	}{
+		{net.HardwareAddr{0x12, 0x34, 0x56, 0x78, 0x90, 0xab}, []byte(`"12:34:56:78:90:ab"`)},
+		{net.HardwareAddr{0x12, 0x34, 0x00, 0x00, 0x90, 0xab}, []byte(`"12:34:00:00:90:ab"`)},
+	}
+
+	for _, tt := range MACtests {
+		t.Run("MAC", func(t *testing.T) {
+			if got := enc.AppendMACAddr([]byte{}, tt.input); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("appendMAC() = %s, want %s", got, tt.want)
+			}
+		})
+	}
+}

journald/journald.go

@@ -0,0 +1,115 @@
+// +build !windows
+
+// Package journald provides a io.Writer to send the logs
+// to journalD component of systemd.
+
+package journald
+
+// This file provides a zerolog writer so that logs printed
+// using zerolog library can be sent to a journalD.
+
+// Zerolog's Top level key/Value Pairs are translated to
+// journald's args - all Values are sent to journald as strings.
+// And all key strings are converted to uppercase before sending
+// to journald (as required by journald).
+
+// In addition, entire log message (all Key Value Pairs), is also
+// sent to journald under the key "JSON".
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"github.com/coreos/go-systemd/journal"
+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/internal/cbor"
+	"io"
+	"strings"
+)
+
+const defaultJournalDPrio = journal.PriNotice
+
+// NewJournalDWriter returns a zerolog log destination
+// to be used as parameter to New() calls. Writing logs
+// to this writer will send the log messages to journalD
+// running in this system.
+func NewJournalDWriter() io.Writer {
+	return journalWriter{}
+}
+
+type journalWriter struct {
+}
+
+// levelToJPrio converts zerolog Level string into
+// journalD's priority values. JournalD has more
+// priorities than zerolog.
+func levelToJPrio(zLevel string) journal.Priority {
+	lvl, _ := zerolog.ParseLevel(zLevel)
+
+	switch lvl {
+	case zerolog.DebugLevel:
+		return journal.PriDebug
+	case zerolog.InfoLevel:
+		return journal.PriInfo
+	case zerolog.WarnLevel:
+		return journal.PriWarning
+	case zerolog.ErrorLevel:
+		return journal.PriErr
+	case zerolog.FatalLevel:
+		return journal.PriCrit
+	case zerolog.PanicLevel:
+		return journal.PriEmerg
+	case zerolog.NoLevel:
+		return journal.PriNotice
+	}
+	return defaultJournalDPrio
+}
+
+func (w journalWriter) Write(p []byte) (n int, err error) {
+	if !journal.Enabled() {
+		err = fmt.Errorf("Cannot connect to journalD!!")
+		return
+	}
+	var event map[string]interface{}
+	p = cbor.DecodeIfBinaryToBytes(p)
+	d := json.NewDecoder(bytes.NewReader(p))
+	d.UseNumber()
+	err = d.Decode(&event)
+	jPrio := defaultJournalDPrio
+	args := make(map[string]string, 0)
+	if err != nil {
+		return
+	}
+	if l, ok := event[zerolog.LevelFieldName].(string); ok {
+		jPrio = levelToJPrio(l)
+	}
+
+	msg := ""
+	for key, value := range event {
+		jKey := strings.ToUpper(key)
+		switch key {
+		case zerolog.LevelFieldName, zerolog.TimestampFieldName:
+			continue
+		case zerolog.MessageFieldName:
+			msg, _ = value.(string)
+			continue
+		}
+
+		switch value.(type) {
+		case string:
+			args[jKey], _ = value.(string)
+		case json.Number:
+			args[jKey] = fmt.Sprint(value)
+		default:
+			b, err := json.Marshal(value)
+			if err != nil {
+				args[jKey] = fmt.Sprintf("[error: %v]", err)
+			} else {
+				args[jKey] = string(b)
+			}
+		}
+	}
+	args["JSON"] = string(p)
+	err = journal.Send(msg, jPrio, args)
+	return
+}

journald/journald_test.go

@@ -0,0 +1,44 @@
+// +build !windows
+
+package journald_test
+
+import "github.com/rs/zerolog"
+import "github.com/rs/zerolog/journald"
+
+func ExampleNewJournalDWriter() {
+	log := zerolog.New(journald.NewJournalDWriter())
+	log.Info().Str("foo", "bar").Uint64("small", 123).Float64("float", 3.14).Uint64("big", 1152921504606846976).Msg("Journal Test")
+	// Output:
+}
+
+/*
+
+There is no automated way to verify the output - since the output is sent
+to journald process and method to retrieve is journalctl. Will find a way
+to automate the process and fix this test.
+
+$ journalctl -o verbose -f
+
+Thu 2018-04-26 22:30:20.768136 PDT [s=3284d695bde946e4b5017c77a399237f;i=329f0;b=98c0dca0debc4b98a5b9534e910e7dd6;m=7a702e35dd4;t=56acdccd2ed0a;x=4690034cf0348614]
+    PRIORITY=6
+    _AUDIT_LOGINUID=1000
+    _BOOT_ID=98c0dca0debc4b98a5b9534e910e7dd6
+    _MACHINE_ID=926ed67eb4744580948de70fb474975e
+    _HOSTNAME=sprint
+    _UID=1000
+    _GID=1000
+    _CAP_EFFECTIVE=0
+    _SYSTEMD_SLICE=-.slice
+    _TRANSPORT=journal
+    _SYSTEMD_CGROUP=/
+    _AUDIT_SESSION=2945
+    MESSAGE=Journal Test
+    FOO=bar
+    BIG=1152921504606846976
+    _COMM=journald.test
+    SMALL=123
+    FLOAT=3.14
+    JSON={"level":"info","foo":"bar","small":123,"float":3.14,"big":1152921504606846976,"message":"Journal Test"}
+    _PID=27103
+    _SOURCE_REALTIME_TIMESTAMP=1524807020768136
+*/

log.go

@@ -148,6 +148,28 @@ func (l Level) String() string {
 	return ""
 }
 
+// ParseLevel converts a level string into a zerolog Level value.
+// returns an error if the input string does not match known values.
+func ParseLevel(levelStr string) (Level, error) {
+	switch levelStr {
+	case DebugLevel.String():
+		return DebugLevel, nil
+	case InfoLevel.String():
+		return InfoLevel, nil
+	case WarnLevel.String():
+		return WarnLevel, nil
+	case ErrorLevel.String():
+		return ErrorLevel, nil
+	case FatalLevel.String():
+		return FatalLevel, nil
+	case PanicLevel.String():
+		return PanicLevel, nil
+	case NoLevel.String():
+		return NoLevel, nil
+	}
+	return NoLevel, fmt.Errorf("Unknown Level String: '%s', defaulting to NoLevel", levelStr)
+}
+
 // 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
@@ -352,21 +374,21 @@ func (l *Logger) newEvent(level Level, done func(string)) *Event {
 	if !enabled {
 		return nil
 	}
-	e := newEvent(l.w, level, true)
+	e := newEvent(l.w, level)
 	e.done = done
 	e.ch = l.hooks
 	if level != NoLevel {
 		e.Str(LevelFieldName, level.String())
 	}
 	if l.context != nil && len(l.context) > 0 {
-		e.buf = appendObjectData(e.buf, l.context)
+		e.buf = enc.AppendObjectData(e.buf, l.context)
 	}
 	return e
 }
 
 // should returns true if the log event should be logged.
 func (l *Logger) should(lvl Level) bool {
-	if lvl < l.level || lvl < globalLevel() {
+	if lvl < l.level || lvl < GlobalLevel() {
 		return false
 	}
 	if l.sampler != nil && !samplingDisabled() {

log_example_test.go

@@ -4,7 +4,9 @@ package zerolog_test
 
 import (
 	"errors"
+	"fmt"
 	stdlog "log"
+	"net"
 	"os"
 	"time"
 
@@ -194,6 +196,22 @@ func (u User) MarshalZerologObject(e *zerolog.Event) {
 		Time("created", u.Created)
 }
 
+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))
+}
+
 type Users []User
 
 func (uu Users) MarshalZerologArray(a *zerolog.Array) {
@@ -247,6 +265,19 @@ func ExampleEvent_Object() {
 	// Output: {"foo":"bar","user":{"name":"John","age":35,"created":"0001-01-01T00:00:00Z"},"message":"hello world"}
 }
 
+func ExampleEvent_EmbedObject() {
+	log := zerolog.New(os.Stdout)
+
+	price := Price{val: 6449, prec: 2, unit: "$"}
+
+	log.Log().
+		Str("foo", "bar").
+		EmbedObject(price).
+		Msg("hello world")
+
+	// Output: {"foo":"bar","price":"$64.49","message":"hello world"}
+}
+
 func ExampleEvent_Interface() {
 	log := zerolog.New(os.Stdout)
 
@@ -350,6 +381,20 @@ func ExampleContext_Object() {
 	// Output: {"foo":"bar","user":{"name":"John","age":35,"created":"0001-01-01T00:00:00Z"},"message":"hello world"}
 }
 
+func ExampleContext_EmbedObject() {
+
+	price := Price{val: 6449, prec: 2, unit: "$"}
+
+	log := zerolog.New(os.Stdout).With().
+		Str("foo", "bar").
+		EmbedObject(price).
+		Logger()
+
+	log.Log().Msg("hello world")
+
+	// Output: {"foo":"bar","price":"$64.49","message":"hello world"}
+}
+
 func ExampleContext_Interface() {
 	obj := struct {
 		Name string `json:"name"`
@@ -395,3 +440,36 @@ func ExampleContext_Durs() {
 
 	// Output: {"foo":"bar","durs":[10000,20000],"message":"hello world"}
 }
+
+func ExampleContext_IPAddr() {
+	hostIP := net.IP{192, 168, 0, 100}
+	log := zerolog.New(os.Stdout).With().
+		IPAddr("HostIP", hostIP).
+		Logger()
+
+	log.Log().Msg("hello world")
+
+	// Output: {"HostIP":"192.168.0.100","message":"hello world"}
+}
+
+func ExampleContext_IPPrefix() {
+	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")
+
+	// Output: {"Route":"192.168.0.0/24","message":"hello world"}
+}
+
+func ExampleContext_MacAddr() {
+	mac := net.HardwareAddr{0x00, 0x14, 0x22, 0x01, 0x23, 0x45}
+	log := zerolog.New(os.Stdout).With().
+		MACAddr("hostMAC", mac).
+		Logger()
+
+	log.Log().Msg("hello world")
+
+	// Output: {"hostMAC":"00:14:22:01:23:45","message":"hello world"}
+}

log_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
+	"net"
 	"reflect"
 	"runtime"
 	"testing"
@@ -94,14 +95,14 @@ func TestWith(t *testing.T) {
 		Uint16("uint16", 8).
 		Uint32("uint32", 9).
 		Uint64("uint64", 10).
-		Float32("float32", 11).
-		Float64("float64", 12).
+		Float32("float32", 11.101).
+		Float64("float64", 12.30303).
 		Time("time", time.Time{})
 	_, file, line, _ := runtime.Caller(0)
 	caller := fmt.Sprintf("%s:%d", file, line+3)
 	log := ctx.Caller().Logger()
 	log.Log().Msg("")
-	if got, want := decodeIfBinaryToString(out.Bytes()), `{"string":"foo","bytes":"bar","hex":"12ef","json":{"some":"json"},"error":"some error","bool":true,"int":1,"int8":2,"int16":3,"int32":4,"int64":5,"uint":6,"uint8":7,"uint16":8,"uint32":9,"uint64":10,"float32":11,"float64":12,"time":"0001-01-01T00:00:00Z","caller":"`+caller+`"}`+"\n"; got != want {
+	if got, want := decodeIfBinaryToString(out.Bytes()), `{"string":"foo","bytes":"bar","hex":"12ef","json":{"some":"json"},"error":"some error","bool":true,"int":1,"int8":2,"int16":3,"int32":4,"int64":5,"uint":6,"uint8":7,"uint16":8,"uint32":9,"uint64":10,"float32":11.101,"float64":12.30303,"time":"0001-01-01T00:00:00Z","caller":"`+caller+`"}`+"\n"; got != want {
 		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
 	}
 }
@@ -127,10 +128,12 @@ func TestFieldsMap(t *testing.T) {
 		"uint64":  uint64(10),
 		"float32": float32(11),
 		"float64": float64(12),
+		"ipv6":    net.IP{0x20, 0x01, 0x0d, 0xb8, 0x85, 0xa3, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x2e, 0x03, 0x70, 0x73, 0x34},
 		"dur":     1 * time.Second,
 		"time":    time.Time{},
+		"obj":     obj{"a", "b", 1},
 	}).Msg("")
-	if got, want := decodeIfBinaryToString(out.Bytes()), `{"bool":true,"bytes":"bar","dur":1000,"error":"some error","float32":11,"float64":12,"int":1,"int16":3,"int32":4,"int64":5,"int8":2,"nil":null,"string":"foo","time":"0001-01-01T00:00:00Z","uint":6,"uint16":8,"uint32":9,"uint64":10,"uint8":7}`+"\n"; got != want {
+	if got, want := decodeIfBinaryToString(out.Bytes()), `{"bool":true,"bytes":"bar","dur":1000,"error":"some error","float32":11,"float64":12,"int":1,"int16":3,"int32":4,"int64":5,"int8":2,"ipv6":"2001:db8:85a3::8a2e:370:7334","nil":null,"obj":{"Pub":"a","Tag":"b","priv":1},"string":"foo","time":"0001-01-01T00:00:00Z","uint":6,"uint16":8,"uint32":9,"uint64":10,"uint8":7}`+"\n"; got != want {
 		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
 	}
 }
@@ -186,13 +189,17 @@ func TestFields(t *testing.T) {
 		Uint16("uint16", 8).
 		Uint32("uint32", 9).
 		Uint64("uint64", 10).
-		Float32("float32", 11).
-		Float64("float64", 12).
+		IPAddr("IPv4", net.IP{192, 168, 0, 100}).
+		IPAddr("IPv6", net.IP{0x20, 0x01, 0x0d, 0xb8, 0x85, 0xa3, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x2e, 0x03, 0x70, 0x73, 0x34}).
+		MACAddr("Mac", net.HardwareAddr{0x00, 0x14, 0x22, 0x01, 0x23, 0x45}).
+		IPPrefix("Prefix", net.IPNet{IP: net.IP{192, 168, 0, 100}, Mask: net.CIDRMask(24, 32)}).
+		Float32("float32", 11.1234).
+		Float64("float64", 12.321321321).
 		Dur("dur", 1*time.Second).
 		Time("time", time.Time{}).
 		TimeDiff("diff", now, now.Add(-10*time.Second)).
 		Msg("")
-	if got, want := decodeIfBinaryToString(out.Bytes()), `{"caller":"`+caller+`","string":"foo","bytes":"bar","hex":"12ef","json":{"some":"json"},"error":"some error","bool":true,"int":1,"int8":2,"int16":3,"int32":4,"int64":5,"uint":6,"uint8":7,"uint16":8,"uint32":9,"uint64":10,"float32":11,"float64":12,"dur":1000,"time":"0001-01-01T00:00:00Z","diff":10000}`+"\n"; got != want {
+	if got, want := decodeIfBinaryToString(out.Bytes()), `{"caller":"`+caller+`","string":"foo","bytes":"bar","hex":"12ef","json":{"some":"json"},"error":"some error","bool":true,"int":1,"int8":2,"int16":3,"int32":4,"int64":5,"uint":6,"uint8":7,"uint16":8,"uint32":9,"uint64":10,"IPv4":"192.168.0.100","IPv6":"2001:db8:85a3::8a2e:370:7334","Mac":"00:14:22:01:23:45","Prefix":"192.168.0.100/24","float32":11.1234,"float64":12.321321321,"dur":1000,"time":"0001-01-01T00:00:00Z","diff":10000}`+"\n"; got != want {
 		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
 	}
 }