pkgerrors: quick refactoring for better readibility

.github/dependabot.yml

@@ -1,10 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: github-actions
-    directory: /
-    schedule:
-      interval: weekly
-  - package-ecosystem: gomod
-    directory: /
-    schedule:
-      interval: weekly

.github/workflows/test.yml

@@ -1,36 +0,0 @@
-on: [push, pull_request]
-name: Test
-jobs:
-  test:
-    strategy:
-      matrix:
-        go-version: [1.21.x, 1.24.x]
-        os: [ubuntu-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Install Go
-      uses: actions/setup-go@v5
-      with:
-        go-version: ${{ matrix.go-version }}
-    - name: Checkout code
-      uses: actions/checkout@v4
-    - uses: actions/cache@v4
-      with:
-        path: ~/go/pkg/mod
-        key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-        restore-keys: |
-          ${{ runner.os }}-go-
-    - name: Test
-      run: go test -race -bench . -benchmem ./...
-    - name: Test CBOR
-      run: go test -tags binary_log ./...
-  coverage:
-    runs-on: ubuntu-latest
-    steps:
-    - name: Update coverage report
-      uses: ncruces/go-coverage-report@main
-      with:
-        report: 'true'
-        chart: 'true'
-        amend: 'true'
-      continue-on-error: true

.travis.yml

@@ -0,0 +1,13 @@
+language: go
+go:
+- "1.7"
+- "1.8"
+- "1.9"
+- "1.10"
+- "master"
+matrix:
+  allow_failures:
+      - go: "master"
+script:
+  - go test -v -race -cpu=1,2,4 -bench . -benchmem ./...
+  - go test -v -tags binary_log -race -cpu=1,2,4 -bench . -benchmem ./...

CNAME

@@ -0,0 +1 @@
+zerolog.io

CONTRIBUTING.md

@@ -1,43 +0,0 @@
-# Contributing to Zerolog
-
-Thank you for your interest in contributing to **Zerolog**!
-
-Zerolog is a **feature-complete**, high-performance logging library designed to be **lean** and **non-bloated**. The focus of ongoing development is on **bug fixes**, **performance improvements**, and **modernization efforts** (such as keeping up with Go best practices and compatibility with newer Go versions).
-
-## What We're Looking For
-
-We welcome contributions in the following areas:
-
-- **Bug Fixes**: If you find an issue or unexpected behavior, please open an issue and/or submit a fix.
-- **Performance Optimizations**: Improvements that reduce memory usage, allocation count, or CPU cycles without introducing complexity are appreciated.
-- **Modernization**: Compatibility updates for newer Go versions or idiomatic improvements that do not increase library size or complexity.
-- **Documentation Enhancements**: Corrections, clarifications, and improvements to documentation or code comments.
-
-## What We're *Not* Looking For
-
-Zerolog is intended to remain **minimalistic and efficient**. Therefore, we are **not accepting**:
-
-- New features that add optional behaviors or extend API surface area.
-- Built-in support for frameworks or external systems (e.g., bindings, integrations).
-- General-purpose abstractions or configuration helpers.
-
-If you're unsure whether a change aligns with the project's philosophy, feel free to open an issue for discussion before submitting a PR.
-
-## Contributing Guidelines
-
-1. **Fork the repository**
-2. **Create a branch** for your fix or improvement
-3. **Write tests** to cover your changes
-4. Ensure `go test ./...` passes
-5. Run `go fmt` and `go vet` to ensure code consistency
-6. **Submit a pull request** with a clear explanation of the motivation and impact
-
-## Code Style
-
-- Keep the code simple, efficient, and idiomatic.
-- Avoid introducing new dependencies.
-- Preserve backwards compatibility unless explicitly discussed.
-
----
-
-We appreciate your effort in helping us keep Zerolog fast, minimal, and reliable!

README.md

@@ -1,6 +1,6 @@
 # Zero Allocation JSON Logger
 
-[![godoc](http://img.shields.io/badge/godoc-reference-blue.svg?style=flat)](https://godoc.org/github.com/rs/zerolog) [![license](http://img.shields.io/badge/license-MIT-red.svg?style=flat)](https://raw.githubusercontent.com/rs/zerolog/master/LICENSE) [![Build Status](https://github.com/rs/zerolog/actions/workflows/test.yml/badge.svg)](https://github.com/rs/zerolog/actions/workflows/test.yml) [![Go Coverage](https://github.com/rs/zerolog/wiki/coverage.svg)](https://raw.githack.com/wiki/rs/zerolog/coverage.html)
+[![godoc](http://img.shields.io/badge/godoc-reference-blue.svg?style=flat)](https://godoc.org/github.com/rs/zerolog) [![license](http://img.shields.io/badge/license-MIT-red.svg?style=flat)](https://raw.githubusercontent.com/rs/zerolog/master/LICENSE) [![Build Status](https://travis-ci.org/rs/zerolog.svg?branch=master)](https://travis-ci.org/rs/zerolog) [![Coverage](http://gocover.io/_badge/github.com/rs/zerolog)](http://gocover.io/github.com/rs/zerolog)
 
 The zerolog package provides a fast and simple logger dedicated to JSON output.
 
@@ -18,21 +18,20 @@ Find out [who uses zerolog](https://github.com/rs/zerolog/wiki/Who-uses-zerolog)
 
 ## Features
 
-* [Blazing fast](#benchmarks)
-* [Low to zero allocation](#benchmarks)
-* [Leveled logging](#leveled-logging)
-* [Sampling](#log-sampling)
-* [Hooks](#hooks)
-* [Contextual fields](#contextual-logging)
-* [`context.Context` integration](#contextcontext-integration)
-* [Integration with `net/http`](#integration-with-nethttp)
-* [JSON and CBOR encoding formats](#binary-encoding)
-* [Pretty logging for development](#pretty-logging)
-* [Error Logging (with optional Stacktrace)](#error-logging)
+* Blazing fast
+* Low to zero allocation
+* Level logging
+* Sampling
+* Hooks
+* Contextual fields
+* `context.Context` integration
+* `net/http` helpers
+* JSON and CBOR encoding formats
+* Pretty logging for development
 
 ## Installation
 
-```bash
+```go
 go get -u github.com/rs/zerolog/log
 ```
 
@@ -52,7 +51,9 @@ import (
 
 func main() {
     // UNIX Time is faster and smaller than most timestamps
-    zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
+    // If you set zerolog.TimeFieldFormat to an empty string,
+    // logs will write with UNIX time
+    zerolog.TimeFieldFormat = ""
 
     log.Print("hello world")
 }
@@ -60,7 +61,7 @@ func main() {
 // Output: {"time":1516134303,"level":"debug","message":"hello world"}
 ```
 > Note: By default log writes to `os.Stderr`
-> Note: The default log level for `log.Print` is *trace*
+> Note: The default log level for `log.Print` is *debug*
 
 ### Contextual Logging
 
@@ -75,20 +76,15 @@ import (
 )
 
 func main() {
-    zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
+    zerolog.TimeFieldFormat = ""
 
     log.Debug().
         Str("Scale", "833 cents").
         Float64("Interval", 833.09).
         Msg("Fibonacci is everywhere")
-    
-    log.Debug().
-        Str("Name", "Tom").
-        Send()
 }
 
-// Output: {"level":"debug","Scale":"833 cents","Interval":833.09,"time":1562212768,"message":"Fibonacci is everywhere"}
-// Output: {"level":"debug","Name":"Tom","time":1562212768}
+// 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)
@@ -106,7 +102,7 @@ import (
 )
 
 func main() {
-    zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
+    zerolog.TimeFieldFormat = ""
 
     log.Info().Msg("hello world")
 }
@@ -124,7 +120,6 @@ func main() {
 * warn (`zerolog.WarnLevel`, 2)
 * info (`zerolog.InfoLevel`, 1)
 * debug (`zerolog.DebugLevel`, 0)
-* trace (`zerolog.TraceLevel`, -1)
 
 You can set the Global logging level to any of these options using the `SetGlobalLevel` function in the zerolog package, passing in one of the given constants above, e.g. `zerolog.InfoLevel` would be the "info" level.  Whichever level is chosen, all logs with a level greater than or equal to that level will be written. To turn off logging entirely, pass the `zerolog.Disabled` constant.
 
@@ -143,7 +138,7 @@ import (
 )
 
 func main() {
-    zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
+    zerolog.TimeFieldFormat = ""
     debug := flag.Bool("debug", false, "sets log level to debug")
 
     flag.Parse()
@@ -194,7 +189,7 @@ import (
 )
 
 func main() {
-    zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
+    zerolog.TimeFieldFormat = ""
 
     log.Log().
         Str("foo", "bar").
@@ -204,80 +199,6 @@ func main() {
 // Output: {"time":1494567715,"foo":"bar"}
 ```
 
-### Error Logging
-
-You can log errors using the `Err` method
-
-```go
-package main
-
-import (
-	"errors"
-
-	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
-)
-
-func main() {
-	zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
-
-	err := errors.New("seems we have an error here")
-	log.Error().Err(err).Msg("")
-}
-
-// Output: {"level":"error","error":"seems we have an error here","time":1609085256}
-```
-
-> The default field name for errors is `error`, you can change this by setting `zerolog.ErrorFieldName` to meet your needs.
-
-#### Error Logging with Stacktrace
-
-Using `github.com/pkg/errors`, you can add a formatted stacktrace to your errors. 
-
-```go
-package main
-
-import (
-	"github.com/pkg/errors"
-	"github.com/rs/zerolog/pkgerrors"
-
-	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
-)
-
-func main() {
-	zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
-	zerolog.ErrorStackMarshaler = pkgerrors.MarshalStack
-
-	err := outer()
-	log.Error().Stack().Err(err).Msg("")
-}
-
-func inner() error {
-	return errors.New("seems we have an error here")
-}
-
-func middle() error {
-	err := inner()
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func outer() error {
-	err := middle()
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// Output: {"level":"error","stack":[{"func":"inner","line":"20","source":"errors.go"},{"func":"middle","line":"24","source":"errors.go"},{"func":"outer","line":"32","source":"errors.go"},{"func":"main","line":"15","source":"errors.go"},{"func":"main","line":"204","source":"proc.go"},{"func":"goexit","line":"1374","source":"asm_amd64.s"}],"error":"seems we have an error here","time":1609086683}
-```
-
-> zerolog.ErrorStackMarshaler must be set in order for the stack to output anything.
-
 #### Logging Fatal Messages
 
 ```go
@@ -294,7 +215,7 @@ func main() {
     err := errors.New("A repo man spends his life getting into tense situations")
     service := "myservice"
 
-    zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
+    zerolog.TimeFieldFormat = ""
 
     log.Fatal().
         Err(err).
@@ -308,7 +229,6 @@ func main() {
 
 > NOTE: Using `Msgf` generates one allocation even when the logger is disabled.
 
-
 ### Create logger instance to manage different outputs
 
 ```go
@@ -366,37 +286,6 @@ log.Info().Str("foo", "bar").Msg("Hello World")
 // Output: 2006-01-02T15:04:05Z07:00 | INFO  | ***Hello World**** foo:BAR
 ```
 
-To use custom advanced formatting:
-
-```go
-output := zerolog.ConsoleWriter{Out: os.Stdout, NoColor: true,
-    PartsOrder:    []string{"level", "one", "two", "three", "message"},
-    FieldsExclude: []string{"one", "two", "three"}}
-output.FormatLevel = func(i interface{}) string { return strings.ToUpper(fmt.Sprintf("%-6s", i)) }
-output.FormatFieldName = func(i interface{}) string { return fmt.Sprintf("%s:", i) }
-output.FormatPartValueByName = func(i interface{}, s string) string {
-    var ret string
-    switch s {
-    case "one":
-        ret = strings.ToUpper(fmt.Sprintf("%s", i))
-    case "two":
-        ret = strings.ToLower(fmt.Sprintf("%s", i))
-    case "three":
-        ret = strings.ToLower(fmt.Sprintf("(%s)", i))
-    }
-    return ret
-}
-log := zerolog.New(output)
-
-log.Info().Str("foo", "bar").
-    Str("two", "TEST_TWO").
-    Str("one", "test_one").
-    Str("three", "test_three").
-    Msg("Hello World")
-    
-// Output: INFO   TEST_ONE test_two (test_three) Hello World foo:bar
-```
-
 ### Sub dictionary
 
 ```go
@@ -430,8 +319,6 @@ log.Logger = log.With().Str("foo", "bar").Logger()
 
 ### Add file and line number to log
 
-Equivalent of `Llongfile`:
-
 ```go
 log.Logger = log.With().Caller().Logger()
 log.Info().Msg("hello world")
@@ -439,27 +326,16 @@ log.Info().Msg("hello world")
 // Output: {"level": "info", "message": "hello world", "caller": "/go/src/your_project/some_file:21"}
 ```
 
-Equivalent of `Lshortfile`:
-
-```go
-zerolog.CallerMarshalFunc = func(pc uintptr, file string, line int) string {
-    return filepath.Base(file) + ":" + strconv.Itoa(line)
-}
-log.Logger = log.With().Caller().Logger()
-log.Info().Msg("hello world")
-
-// Output: {"level": "info", "message": "hello world", "caller": "some_file:21"}
-```
 
 ### Thread-safe, lock-free, non-blocking writer
 
-If your writer might be slow or not thread-safe and you need your log producers to never get slowed down by a slow writer, you can use a `diode.Writer` as follows:
+If your writer might be slow or not thread-safe and you need your log producers to never get slowed down by a slow writer, you can use a `diode.Writer` as follow:
 
 ```go
 wr := diode.NewWriter(os.Stdout, 1000, 10*time.Millisecond, func(missed int) {
 		fmt.Printf("Logger Dropped %d messages", missed)
 	})
-log := zerolog.New(wr)
+log := zerolog.New(w)
 log.Print("test")
 ```
 
@@ -534,58 +410,6 @@ stdlog.Print("hello world")
 // Output: {"foo":"bar","message":"hello world"}
 ```
 
-### context.Context integration
-
-Go contexts are commonly passed throughout Go code, and this can help you pass
-your Logger into places it might otherwise be hard to inject.  The `Logger`
-instance may be attached to Go context (`context.Context`) using
-`Logger.WithContext(ctx)` and extracted from it using `zerolog.Ctx(ctx)`.
-For example:
-
-```go
-func f() {
-    logger := zerolog.New(os.Stdout)
-    ctx := context.Background()
-
-    // Attach the Logger to the context.Context
-    ctx = logger.WithContext(ctx)
-    someFunc(ctx)
-}
-
-func someFunc(ctx context.Context) {
-    // Get Logger from the go Context. if it's nil, then
-    // `zerolog.DefaultContextLogger` is returned, if
-    // `DefaultContextLogger` is nil, then a disabled logger is returned.
-    logger := zerolog.Ctx(ctx)
-    logger.Info().Msg("Hello")
-}
-```
-
-A second form of `context.Context` integration allows you to pass the current
-context.Context into the logged event, and retrieve it from hooks.  This can be
-useful to log trace and span IDs or other information stored in the go context,
-and facilitates the unification of logging and tracing in some systems:
-
-```go
-type TracingHook struct{}
-
-func (h TracingHook) Run(e *zerolog.Event, level zerolog.Level, msg string) {
-    ctx := e.GetCtx()
-    spanId := getSpanIdFromContext(ctx) // as per your tracing framework
-    e.Str("span-id", spanId)
-}
-
-func f() {
-    // Setup the logger
-    logger := zerolog.New(os.Stdout)
-    logger = logger.Hook(TracingHook{})
-
-    ctx := context.Background()
-    // Use the Ctx function to make the context available to the hook
-    logger.Info().Ctx(ctx).Msg("Hello")
-}
-```
-
 ### Integration with `net/http`
 
 The `github.com/rs/zerolog/hlog` package provides some helpers to integrate zerolog with `http.Handler`.
@@ -605,11 +429,11 @@ c := alice.New()
 c = c.Append(hlog.NewHandler(log))
 
 // Install some provided extra handler to set some request's context fields.
-// Thanks to that handler, all our logs will come with some prepopulated fields.
+// Thanks to those handler, all our logs will come with some pre-populated fields.
 c = c.Append(hlog.AccessHandler(func(r *http.Request, status, size int, duration time.Duration) {
     hlog.FromRequest(r).Info().
         Str("method", r.Method).
-        Stringer("url", r.URL).
+        Str("url", r.URL.String()).
         Int("status", status).
         Int("size", size).
         Dur("duration", duration).
@@ -639,44 +463,23 @@ if err := http.ListenAndServe(":8080", nil); err != nil {
 }
 ```
 
-## Multiple Log Output
-`zerolog.MultiLevelWriter` may be used to send the log message to multiple outputs. 
-In this example, we send the log message to both `os.Stdout` and the in-built ConsoleWriter.
-```go
-func main() {
-	consoleWriter := zerolog.ConsoleWriter{Out: os.Stdout}
-
-	multi := zerolog.MultiLevelWriter(consoleWriter, os.Stdout)
-
-	logger := zerolog.New(multi).With().Timestamp().Logger()
-
-	logger.Info().Msg("Hello World!")
-}
-
-// Output (Line 1: Console; Line 2: Stdout)
-// 12:36PM INF Hello World!
-// {"level":"info","time":"2019-11-07T12:36:38+03:00","message":"Hello World!"}
-```
-
 ## Global Settings
 
-Some settings can be changed and will be applied to all loggers:
+Some settings can be changed and will by applied to all loggers:
 
 * `log.Logger`: You can set this value to customize the global logger (the one used by package level methods).
-* `zerolog.SetGlobalLevel`: Can raise the minimum level of all loggers. Call this with `zerolog.Disabled` to disable logging altogether (quiet mode).
+* `zerolog.SetGlobalLevel`: Can raise the minimum level of all loggers. Set this to `zerolog.Disabled` to disable logging altogether (quiet mode).
 * `zerolog.DisableSampling`: If argument is `true`, all sampled loggers will stop sampling and issue 100% of their log events.
 * `zerolog.TimestampFieldName`: Can be set to customize `Timestamp` field name.
 * `zerolog.LevelFieldName`: Can be set to customize level field name.
 * `zerolog.MessageFieldName`: Can be set to customize message field name.
 * `zerolog.ErrorFieldName`: Can be set to customize `Err` field name.
-* `zerolog.TimeFieldFormat`: Can be set to customize `Time` field value formatting. If set with `zerolog.TimeFormatUnix`, `zerolog.TimeFormatUnixMs` or `zerolog.TimeFormatUnixMicro`, times are formatted as UNIX timestamp.
-* `zerolog.DurationFieldUnit`: Can be set to customize the unit for time.Duration type fields added by `Dur` (default: `time.Millisecond`).
-* `zerolog.DurationFieldInteger`: If set to `true`, `Dur` fields are formatted as integers instead of floats (default: `false`). 
-* `zerolog.ErrorHandler`: Called whenever zerolog fails to write an event on its output. If not set, an error is printed on the stderr. This handler must be thread safe and non-blocking.
-* `zerolog.FloatingPointPrecision`: If set to a value other than -1, controls the number
-of digits when formatting float numbers in JSON. See
-[strconv.FormatFloat](https://pkg.go.dev/strconv#FormatFloat)
-for more details.
+* `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`: 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.
+* `ErrorHandler`: Called whenever zerolog fails to write an event on its output. If not set, an error is printed on the stderr. This handler must be thread safe and non-blocking.
 
 ## Field Types
 
@@ -690,21 +493,16 @@ for more details.
 
 ### Advanced Fields
 
-* `Err`: Takes an `error` and renders it as a string using the `zerolog.ErrorFieldName` field name.
-* `Func`: Run a `func` only if the level is enabled.
-* `Timestamp`: Inserts a timestamp field with `zerolog.TimestampFieldName` field name, formatted using `zerolog.TimeFieldFormat`.
-* `Time`: Adds a field with time formatted with `zerolog.TimeFieldFormat`.
-* `Dur`: Adds a field with `time.Duration`.
+* `Err`: Takes an `error` and render it as a string using the `zerolog.ErrorFieldName` field name.
+* `Timestamp`: Insert a timestamp field with `zerolog.TimestampFieldName` field name and formatted using `zerolog.TimeFieldFormat`.
+* `Time`: Adds a field with the time formated with the `zerolog.TimeFieldFormat`.
+* `Dur`: Adds a field with a `time.Duration`.
 * `Dict`: Adds a sub-key/value as a field of the event.
-* `RawJSON`: Adds a field with an already encoded JSON (`[]byte`)
-* `Hex`: Adds a field with value formatted as a hexadecimal string (`[]byte`)
 * `Interface`: Uses reflection to marshal the type.
 
-Most fields are also available in the slice format (`Strs` for `[]string`, `Errs` for `[]error` etc.)
-
 ## Binary Encoding
 
-In addition to the default JSON encoding, `zerolog` can produce binary logs using [CBOR](https://cbor.io) encoding. The choice of encoding can be decided at compile time using the build tag `binary_log` as follows:
+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 .
@@ -716,12 +514,10 @@ 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`
-* [overlog](https://github.com/Trendyol/overlog): Implementation of `Mapped Diagnostic Context` interface using `zerolog`
-* [zerologr](https://github.com/go-logr/zerologr): Implementation of `logr.LogSink` interface using `zerolog`
 
 ## Benchmarks
 
-See [logbench](http://bench.zerolog.io/) for more comprehensive and up-to-date benchmarks.
+See [logbench](http://hackemist.com/logbench/) for more comprehensive and up-to-date benchmarks.
 
 All operations are allocation free (those numbers *include* JSON encoding):
 
@@ -782,9 +578,7 @@ Log a static string, without any context or `printf`-style templating:
 
 ## Caveats
 
-### Field duplication
-
-Note that zerolog does no de-duplication of fields. Using the same key multiple times creates multiple keys in final JSON:
+Note that zerolog does de-duplication fields. Using the same key multiple times creates multiple keys in final JSON:
 
 ```go
 logger := zerolog.New(os.Stderr).With().Timestamp().Logger()
@@ -794,20 +588,4 @@ logger.Info().
 // Output: {"level":"info","time":1494567715,"time":1494567715,"message":"dup"}
 ```
 
-In this case, many consumers will take the last value, but this is not guaranteed; check yours if in doubt.
-
-### Concurrency safety
-
-Be careful when calling UpdateContext. It is not concurrency safe. Use the With method to create a child logger:
-
-```go
-func handler(w http.ResponseWriter, r *http.Request) {
-    // Create a child logger for concurrency safety
-    logger := log.Logger.With().Logger()
-
-    // Add context fields, for example User-Agent from HTTP headers
-    logger.UpdateContext(func(c zerolog.Context) zerolog.Context {
-        ...
-    })
-}
-```
+However, it’s not a big deal as JSON accepts dup keys; the last one prevails.

_config.yml

@@ -0,0 +1 @@
+remote_theme: rs/gh-readme

array.go

@@ -49,7 +49,7 @@ func (*Array) MarshalZerologArray(*Array) {
 func (a *Array) write(dst []byte) []byte {
 	dst = enc.AppendArrayStart(dst)
 	if len(a.buf) > 0 {
-		dst = append(dst, a.buf...)
+		dst = append(append(dst, a.buf...))
 	}
 	dst = enc.AppendArrayEnd(dst)
 	putArray(a)
@@ -57,7 +57,7 @@ func (a *Array) write(dst []byte) []byte {
 }
 
 // Object marshals an object that implement the LogObjectMarshaler
-// interface and appends it to the array.
+// interface and append append it to the array.
 func (a *Array) Object(obj LogObjectMarshaler) *Array {
 	e := Dict()
 	obj.MarshalZerologObject(e)
@@ -67,33 +67,28 @@ func (a *Array) Object(obj LogObjectMarshaler) *Array {
 	return a
 }
 
-// Str appends 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 = enc.AppendString(enc.AppendArrayDelim(a.buf), val)
 	return a
 }
 
-// Bytes appends 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 = enc.AppendBytes(enc.AppendArrayDelim(a.buf), val)
 	return a
 }
 
-// Hex appends 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 = enc.AppendHex(enc.AppendArrayDelim(a.buf), val)
 	return a
 }
 
-// RawJSON adds already encoded JSON to the array.
-func (a *Array) RawJSON(val []byte) *Array {
-	a.buf = appendJSON(enc.AppendArrayDelim(a.buf), val)
-	return a
-}
-
 // Err serializes and appends the err to the array.
 func (a *Array) Err(err error) *Array {
-	switch m := ErrorMarshalFunc(err).(type) {
+	marshaled := ErrorMarshalFunc(err)
+	switch m := marshaled.(type) {
 	case LogObjectMarshaler:
 		e := newEvent(nil, 0)
 		e.buf = e.buf[:0]
@@ -101,11 +96,7 @@ func (a *Array) Err(err error) *Array {
 		a.buf = append(enc.AppendArrayDelim(a.buf), e.buf...)
 		putEvent(e)
 	case error:
-		if m == nil || isNilValue(m) {
-			a.buf = enc.AppendNil(enc.AppendArrayDelim(a.buf))
-		} else {
-			a.buf = enc.AppendString(enc.AppendArrayDelim(a.buf), m.Error())
-		}
+		a.buf = enc.AppendString(enc.AppendArrayDelim(a.buf), m.Error())
 	case string:
 		a.buf = enc.AppendString(enc.AppendArrayDelim(a.buf), m)
 	default:
@@ -115,97 +106,97 @@ func (a *Array) Err(err error) *Array {
 	return a
 }
 
-// Bool appends 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 = enc.AppendBool(enc.AppendArrayDelim(a.buf), b)
 	return a
 }
 
-// Int appends 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 = enc.AppendInt(enc.AppendArrayDelim(a.buf), i)
 	return a
 }
 
-// Int8 appends 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 = enc.AppendInt8(enc.AppendArrayDelim(a.buf), i)
 	return a
 }
 
-// Int16 appends 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 = enc.AppendInt16(enc.AppendArrayDelim(a.buf), i)
 	return a
 }
 
-// Int32 appends 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 = enc.AppendInt32(enc.AppendArrayDelim(a.buf), i)
 	return a
 }
 
-// Int64 appends 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 = enc.AppendInt64(enc.AppendArrayDelim(a.buf), i)
 	return a
 }
 
-// Uint appends 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 = enc.AppendUint(enc.AppendArrayDelim(a.buf), i)
 	return a
 }
 
-// Uint8 appends 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 = enc.AppendUint8(enc.AppendArrayDelim(a.buf), i)
 	return a
 }
 
-// Uint16 appends 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 = enc.AppendUint16(enc.AppendArrayDelim(a.buf), i)
 	return a
 }
 
-// Uint32 appends 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 = enc.AppendUint32(enc.AppendArrayDelim(a.buf), i)
 	return a
 }
 
-// Uint64 appends 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 = enc.AppendUint64(enc.AppendArrayDelim(a.buf), i)
 	return a
 }
 
-// Float32 appends 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 = enc.AppendFloat32(enc.AppendArrayDelim(a.buf), f, FloatingPointPrecision)
+	a.buf = enc.AppendFloat32(enc.AppendArrayDelim(a.buf), f)
 	return a
 }
 
-// Float64 appends 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 = enc.AppendFloat64(enc.AppendArrayDelim(a.buf), f, FloatingPointPrecision)
+	a.buf = enc.AppendFloat64(enc.AppendArrayDelim(a.buf), f)
 	return a
 }
 
-// Time appends t formatted 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 = enc.AppendTime(enc.AppendArrayDelim(a.buf), t, TimeFieldFormat)
 	return a
 }
 
-// Dur appends d to the array.
+// Dur append append d to the array.
 func (a *Array) Dur(d time.Duration) *Array {
-	a.buf = enc.AppendDuration(enc.AppendArrayDelim(a.buf), d, DurationFieldUnit, DurationFieldInteger, FloatingPointPrecision)
+	a.buf = enc.AppendDuration(enc.AppendArrayDelim(a.buf), d, DurationFieldUnit, DurationFieldInteger)
 	return a
 }
 
-// Interface appends 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)
@@ -231,10 +222,3 @@ func (a *Array) MACAddr(ha net.HardwareAddr) *Array {
 	a.buf = enc.AppendMACAddr(enc.AppendArrayDelim(a.buf), ha)
 	return a
 }
-
-// Dict adds the dict Event to the array
-func (a *Array) Dict(dict *Event) *Array {
-	dict.buf = enc.AppendEndMarker(dict.buf)
-	a.buf = append(enc.AppendArrayDelim(a.buf), dict.buf...)
-	return a
-}

array_test.go

@@ -24,15 +24,10 @@ func TestArray(t *testing.T) {
 		Str("a").
 		Bytes([]byte("b")).
 		Hex([]byte{0x1f}).
-		RawJSON([]byte(`{"some":"json"}`)).
 		Time(time.Time{}).
 		IPAddr(net.IP{192, 168, 0, 10}).
-		Dur(0).
-		Dict(Dict().
-			Str("bar", "baz").
-			Int("n", 1),
-		)
-	want := `[true,1,2,3,4,5,6,7,8,9,10,11.98122,12.987654321,"a","b","1f",{"some":"json"},"0001-01-01T00:00:00Z","192.168.0.10",0,{"bar":"baz","n":1}]`
+		Dur(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)
 	}

benchmark_test.go

@@ -1,10 +1,8 @@
 package zerolog
 
 import (
-	"context"
 	"errors"
-	"io"
-	"net"
+	"io/ioutil"
 	"testing"
 	"time"
 )
@@ -15,7 +13,7 @@ var (
 )
 
 func BenchmarkLogEmpty(b *testing.B) {
-	logger := New(io.Discard)
+	logger := New(ioutil.Discard)
 	b.ResetTimer()
 	b.RunParallel(func(pb *testing.PB) {
 		for pb.Next() {
@@ -25,7 +23,7 @@ func BenchmarkLogEmpty(b *testing.B) {
 }
 
 func BenchmarkDisabled(b *testing.B) {
-	logger := New(io.Discard).Level(Disabled)
+	logger := New(ioutil.Discard).Level(Disabled)
 	b.ResetTimer()
 	b.RunParallel(func(pb *testing.PB) {
 		for pb.Next() {
@@ -35,7 +33,7 @@ func BenchmarkDisabled(b *testing.B) {
 }
 
 func BenchmarkInfo(b *testing.B) {
-	logger := New(io.Discard)
+	logger := New(ioutil.Discard)
 	b.ResetTimer()
 	b.RunParallel(func(pb *testing.PB) {
 		for pb.Next() {
@@ -45,7 +43,7 @@ func BenchmarkInfo(b *testing.B) {
 }
 
 func BenchmarkContextFields(b *testing.B) {
-	logger := New(io.Discard).With().
+	logger := New(ioutil.Discard).With().
 		Str("string", "four!").
 		Time("time", time.Time{}).
 		Int("int", 123).
@@ -60,7 +58,7 @@ func BenchmarkContextFields(b *testing.B) {
 }
 
 func BenchmarkContextAppend(b *testing.B) {
-	logger := New(io.Discard).With().
+	logger := New(ioutil.Discard).With().
 		Str("foo", "bar").
 		Logger()
 	b.ResetTimer()
@@ -72,7 +70,7 @@ func BenchmarkContextAppend(b *testing.B) {
 }
 
 func BenchmarkLogFields(b *testing.B) {
-	logger := New(io.Discard)
+	logger := New(ioutil.Discard)
 	b.ResetTimer()
 	b.RunParallel(func(pb *testing.PB) {
 		for pb.Next() {
@@ -102,7 +100,7 @@ func BenchmarkLogArrayObject(b *testing.B) {
 	obj1 := obj{"a", "b", 2}
 	obj2 := obj{"c", "d", 3}
 	obj3 := obj{"e", "f", 4}
-	logger := New(io.Discard)
+	logger := New(ioutil.Discard)
 	b.ResetTimer()
 	b.ReportAllocs()
 	for i := 0; i < b.N; i++ {
@@ -149,19 +147,18 @@ func BenchmarkLogFieldType(b *testing.B) {
 		{"a", "a", 0},
 	}
 	objects := []obj{
-		{"a", "a", 0},
-		{"a", "a", 0},
-		{"a", "a", 0},
-		{"a", "a", 0},
-		{"a", "a", 0},
-		{"a", "a", 0},
-		{"a", "a", 0},
-		{"a", "a", 0},
-		{"a", "a", 0},
-		{"a", "a", 0},
+		obj{"a", "a", 0},
+		obj{"a", "a", 0},
+		obj{"a", "a", 0},
+		obj{"a", "a", 0},
+		obj{"a", "a", 0},
+		obj{"a", "a", 0},
+		obj{"a", "a", 0},
+		obj{"a", "a", 0},
+		obj{"a", "a", 0},
+		obj{"a", "a", 0},
 	}
 	errs := []error{errors.New("a"), errors.New("b"), errors.New("c"), errors.New("d"), errors.New("e")}
-	ctx := context.Background()
 	types := map[string]func(e *Event) *Event{
 		"Bool": func(e *Event) *Event {
 			return e.Bool("k", bools[0])
@@ -193,9 +190,6 @@ func BenchmarkLogFieldType(b *testing.B) {
 		"Errs": func(e *Event) *Event {
 			return e.Errs("k", errs)
 		},
-		"Ctx": func(e *Event) *Event {
-			return e.Ctx(ctx)
-		},
 		"Time": func(e *Event) *Event {
 			return e.Time("k", times[0])
 		},
@@ -224,7 +218,7 @@ func BenchmarkLogFieldType(b *testing.B) {
 			return e.Object("k", objects[0])
 		},
 	}
-	logger := New(io.Discard)
+	logger := New(ioutil.Discard)
 	b.ResetTimer()
 	for name := range types {
 		f := types[name]
@@ -240,13 +234,12 @@ func BenchmarkLogFieldType(b *testing.B) {
 
 func BenchmarkContextFieldType(b *testing.B) {
 	oldFormat := TimeFieldFormat
-	TimeFieldFormat = TimeFormatUnix
+	TimeFieldFormat = ""
 	defer func() { TimeFieldFormat = oldFormat }()
 	bools := []bool{true, false, true, false, true, false, true, false, true, false}
 	ints := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
 	floats := []float64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
 	strings := []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"}
-	stringer := net.IP{127, 0, 0, 1}
 	durations := []time.Duration{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
 	times := []time.Time{
 		time.Unix(0, 0),
@@ -277,19 +270,18 @@ func BenchmarkContextFieldType(b *testing.B) {
 		{"a", "a", 0},
 	}
 	objects := []obj{
-		{"a", "a", 0},
-		{"a", "a", 0},
-		{"a", "a", 0},
-		{"a", "a", 0},
-		{"a", "a", 0},
-		{"a", "a", 0},
-		{"a", "a", 0},
-		{"a", "a", 0},
-		{"a", "a", 0},
-		{"a", "a", 0},
+		obj{"a", "a", 0},
+		obj{"a", "a", 0},
+		obj{"a", "a", 0},
+		obj{"a", "a", 0},
+		obj{"a", "a", 0},
+		obj{"a", "a", 0},
+		obj{"a", "a", 0},
+		obj{"a", "a", 0},
+		obj{"a", "a", 0},
+		obj{"a", "a", 0},
 	}
 	errs := []error{errors.New("a"), errors.New("b"), errors.New("c"), errors.New("d"), errors.New("e")}
-	ctx := context.Background()
 	types := map[string]func(c Context) Context{
 		"Bool": func(c Context) Context {
 			return c.Bool("k", bools[0])
@@ -315,18 +307,12 @@ func BenchmarkContextFieldType(b *testing.B) {
 		"Strs": func(c Context) Context {
 			return c.Strs("k", strings)
 		},
-		"Stringer": func(c Context) Context {
-			return c.Stringer("k", stringer)
-		},
 		"Err": func(c Context) Context {
 			return c.Err(errs[0])
 		},
 		"Errs": func(c Context) Context {
 			return c.Errs("k", errs)
 		},
-		"Ctx": func(c Context) Context {
-			return c.Ctx(ctx)
-		},
 		"Time": func(c Context) Context {
 			return c.Time("k", times[0])
 		},
@@ -358,7 +344,7 @@ func BenchmarkContextFieldType(b *testing.B) {
 			return c.Timestamp()
 		},
 	}
-	logger := New(io.Discard)
+	logger := New(ioutil.Discard)
 	b.ResetTimer()
 	for name := range types {
 		f := types[name]

binary_test.go

@@ -7,6 +7,7 @@ import (
 	"errors"
 	"fmt"
 
+	//	"io/ioutil"
 	stdlog "log"
 	"time"
 )
@@ -107,19 +108,6 @@ func ExampleLogger_Printf() {
 	// Output: {"level":"debug","message":"hello world"}
 }
 
-func ExampleLogger_Trace() {
-	dst := bytes.Buffer{}
-	log := New(&dst)
-
-	log.Trace().
-		Str("foo", "bar").
-		Int("n", 123).
-		Msg("hello world")
-
-	fmt.Println(decodeIfBinaryToString(dst.Bytes()))
-	// Output: {"level":"trace","foo":"bar","n":123,"message":"hello world"}
-}
-
 func ExampleLogger_Debug() {
 	dst := bytes.Buffer{}
 	log := New(&dst)
@@ -363,42 +351,6 @@ func ExampleEvent_Durs() {
 	// Output: {"foo":"bar","durs":[10000,20000],"message":"hello world"}
 }
 
-func ExampleEvent_Fields_map() {
-	fields := map[string]interface{}{
-		"bar": "baz",
-		"n":   1,
-	}
-
-	dst := bytes.Buffer{}
-	log := New(&dst)
-
-	log.Log().
-		Str("foo", "bar").
-		Fields(fields).
-		Msg("hello world")
-
-	fmt.Println(decodeIfBinaryToString(dst.Bytes()))
-	// Output: {"foo":"bar","bar":"baz","n":1,"message":"hello world"}
-}
-
-func ExampleEvent_Fields_slice() {
-	fields := []interface{}{
-		"bar", "baz",
-		"n", 1,
-	}
-
-	dst := bytes.Buffer{}
-	log := New(&dst)
-
-	log.Log().
-		Str("foo", "bar").
-		Fields(fields).
-		Msg("hello world")
-
-	fmt.Println(decodeIfBinaryToString(dst.Bytes()))
-	// Output: {"foo":"bar","bar":"baz","n":1,"message":"hello world"}
-}
-
 func ExampleContext_Dict() {
 	dst := bytes.Buffer{}
 	log := New(&dst).With().
@@ -545,39 +497,3 @@ func ExampleContext_Durs() {
 	fmt.Println(decodeIfBinaryToString(dst.Bytes()))
 	// Output: {"foo":"bar","durs":[10000,20000],"message":"hello world"}
 }
-
-func ExampleContext_Fields_map() {
-	fields := map[string]interface{}{
-		"bar": "baz",
-		"n":   1,
-	}
-
-	dst := bytes.Buffer{}
-	log := New(&dst).With().
-		Str("foo", "bar").
-		Fields(fields).
-		Logger()
-
-	log.Log().Msg("hello world")
-
-	fmt.Println(decodeIfBinaryToString(dst.Bytes()))
-	// Output: {"foo":"bar","bar":"baz","n":1,"message":"hello world"}
-}
-
-func ExampleContext_Fields_slice() {
-	fields := []interface{}{
-		"bar", "baz",
-		"n", 1,
-	}
-
-	dst := bytes.Buffer{}
-	log := New(&dst).With().
-		Str("foo", "bar").
-		Fields(fields).
-		Logger()
-
-	log.Log().Msg("hello world")
-
-	fmt.Println(decodeIfBinaryToString(dst.Bytes()))
-	// Output: {"foo":"bar","bar":"baz","n":1,"message":"hello world"}
-}

cmd/lint/go.mod

@@ -1,5 +0,0 @@
-module github.com/rs/zerolog/cmd/lint
-
-go 1.15
-
-require golang.org/x/tools v0.1.8

cmd/lint/go.sum

@@ -1,28 +0,0 @@
-github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/mod v0.5.1 h1:OJxoQ/rynoF0dcCdI7cLPktw/hR2cueqYfjm43oqK38=
-golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20211019181941-9d821ace8654 h1:id054HUawV2/6IGm2IV8KZQjqtwAOo2CYlOToYqa0d0=
-golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.1.8 h1:P1HhGGuLW4aAclzjtmJdf0mJOjVUZUzOTqkAkWL+l6w=
-golang.org/x/tools v0.1.8/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

cmd/lint/readme.md

@@ -1,7 +1,5 @@
 # Zerolog Lint
 
-**DEPRECATED: In favor of https://github.com/ykadowak/zerologlint which is integrated with `go vet` and [golangci-lint](https://golangci-lint.run/).**
-
 This is a basic linter that checks for missing log event finishers. Finds errors like: `log.Error().Int64("userID": 5)` - missing the `Msg`/`Msgf` finishers.
 
 ## Problem
@@ -29,7 +27,7 @@ The command accepts only one argument - the package to be inspected - and 4 opti
 - ignoreFile
     - which files to ignore, either by full path or by go path (package/file.go)
 - ignorePkg
-    - do not inspect the specified package if found in the dependency tree
+    - do not inspect the specified package if found in the dependecy tree
 - ignorePkgRecursively
     - do not inspect the specified package or its subpackages if found in the dependency tree
 

cmd/prettylog/README.md

@@ -1,40 +0,0 @@
-# Zerolog PrettyLog
-
-This is a basic CLI utility that will colorize and pretty print your structured JSON logs.
-
-## Usage
-
-You can compile it or run it directly. The only issue is that by default Zerolog does not output to `stdout`
-but rather to `stderr` so we must pipe `stderr` stream to this CLI tool.
-
-### Linux
-
-These commands will redirect `stderr` to our `prettylog` tool and `stdout` will remain unaffected.
-
-1. Compiled version
-
-```shell
-some_program_with_zerolog 2> >(prettylog)
-```
-
-2. Run it directly with `go run`
-
-```shell
-some_program_with_zerolog 2> >(go run cmd/prettylog/prettylog.go)
-```
-
-### Windows
-
-These commands will redirect `stderr` to `stdout` and then pipe it to our `prettylog` tool.
-
-1. Compiled version
-
-```shell
-some_program_with_zerolog 2>&1 | prettylog
-```
-
-2. Run it directly with `go run`
-
-```shell
-some_program_with_zerolog 2>&1 | go run cmd/prettylog/prettylog.go
-```

cmd/prettylog/prettylog.go

@@ -1,82 +0,0 @@
-package main
-
-import (
-	"bufio"
-	"errors"
-	"flag"
-	"fmt"
-	"io"
-	"os"
-	"time"
-
-	"github.com/rs/zerolog"
-)
-
-func isInputFromPipe() bool {
-	fileInfo, _ := os.Stdin.Stat()
-	return fileInfo.Mode()&os.ModeCharDevice == 0
-}
-
-func processInput(reader io.Reader, writer io.Writer) error {
-	scanner := bufio.NewScanner(reader)
-	for scanner.Scan() {
-		bytesToWrite := scanner.Bytes()
-		_, err := writer.Write(bytesToWrite)
-		if err != nil {
-			if errors.Is(err, io.EOF) {
-				break
-			}
-
-			fmt.Printf("%s\n", bytesToWrite)
-		}
-	}
-
-	return scanner.Err()
-}
-
-func main() {
-	timeFormats := map[string]string{
-		"default": time.Kitchen,
-		"full":    time.RFC1123,
-	}
-
-	timeFormatFlag := flag.String(
-		"time-format",
-		"default",
-		"Time format, either 'default' or 'full'",
-	)
-
-	flag.Parse()
-
-	timeFormat, ok := timeFormats[*timeFormatFlag]
-	if !ok {
-		panic("Invalid time-format provided")
-	}
-
-	writer := zerolog.NewConsoleWriter()
-	writer.TimeFormat = timeFormat
-
-	if isInputFromPipe() {
-		_ = processInput(os.Stdin, writer)
-	} else if flag.NArg() >= 1 {
-		for _, filename := range flag.Args() {
-			// Scan each line from filename and write it into writer
-			reader, err := os.Open(filename)
-			if err != nil {
-				fmt.Printf("%s open: %v", filename, err)
-				os.Exit(1)
-			}
-
-			if err := processInput(reader, writer); err != nil {
-				fmt.Printf("%s scan: %v", filename, err)
-				os.Exit(1)
-			}
-		}
-	} else {
-		fmt.Println("Usage:")
-		fmt.Println("  app_with_zerolog | 2> >(prettylog)")
-		fmt.Println("  prettylog zerolog_output.jsonl")
-		os.Exit(1)
-		return
-	}
-}

console.go

@@ -6,14 +6,16 @@ import (
 	"fmt"
 	"io"
 	"os"
-	"path/filepath"
 	"sort"
 	"strconv"
 	"strings"
 	"sync"
 	"time"
+)
 
-	"github.com/mattn/go-colorable"
+const (
+	colorBold = iota + 1
+	colorFaint
 )
 
 const (
@@ -25,11 +27,6 @@ const (
 	colorMagenta
 	colorCyan
 	colorWhite
-
-	colorBold     = 1
-	colorDarkGray = 90
-
-	unknownLevel = "???"
 )
 
 var (
@@ -47,10 +44,6 @@ const (
 // Formatter transforms the input into a formatted string.
 type Formatter func(interface{}) string
 
-// FormatterByFieldName transforms the input into a formatted string,
-// being able to differentiate formatting based on field name.
-type FormatterByFieldName func(interface{}, string) string
-
 // ConsoleWriter parses the JSON input and writes it in an
 // (optionally) colorized, human-friendly format to Out.
 type ConsoleWriter struct {
@@ -63,24 +56,9 @@ type ConsoleWriter struct {
 	// TimeFormat specifies the format for timestamp in output.
 	TimeFormat string
 
-	// TimeLocation tells ConsoleWriter’s default FormatTimestamp
-	// how to localize the time.
-	TimeLocation *time.Location
-
 	// PartsOrder defines the order of parts in output.
 	PartsOrder []string
 
-	// PartsExclude defines parts to not display in output.
-	PartsExclude []string
-
-	// FieldsOrder defines the order of contextual fields in output.
-	FieldsOrder []string
-
-	fieldIsOrdered map[string]int
-
-	// FieldsExclude defines contextual fields to not display in output.
-	FieldsExclude []string
-
 	FormatTimestamp     Formatter
 	FormatLevel         Formatter
 	FormatCaller        Formatter
@@ -89,42 +67,25 @@ type ConsoleWriter struct {
 	FormatFieldValue    Formatter
 	FormatErrFieldName  Formatter
 	FormatErrFieldValue Formatter
-	// If this is configured it is used for "part" values and
-	// has precedence on FormatFieldValue
-	FormatPartValueByName FormatterByFieldName
-
-	FormatExtra func(map[string]interface{}, *bytes.Buffer) error
-
-	FormatPrepare func(map[string]interface{}) error
 }
 
 // NewConsoleWriter creates and initializes a new ConsoleWriter.
 func NewConsoleWriter(options ...func(w *ConsoleWriter)) ConsoleWriter {
 	w := ConsoleWriter{
-		Out:          os.Stdout,
-		TimeFormat:   consoleDefaultTimeFormat,
-		PartsOrder:   consoleDefaultPartsOrder(),
+		Out:        os.Stdout,
+		TimeFormat: consoleDefaultTimeFormat,
+		PartsOrder: consoleDefaultPartsOrder(),
 	}
 
 	for _, opt := range options {
 		opt(&w)
 	}
 
-	// Fix color on Windows
-	if w.Out == os.Stdout || w.Out == os.Stderr {
-		w.Out = colorable.NewColorable(w.Out.(*os.File))
-	}
-
 	return w
 }
 
 // Write transforms the JSON input with formatters and appends to w.Out.
 func (w ConsoleWriter) Write(p []byte) (n int, err error) {
-	// Fix color on Windows
-	if w.Out == os.Stdout || w.Out == os.Stderr {
-		w.Out = colorable.NewColorable(w.Out.(*os.File))
-	}
-
 	if w.PartsOrder == nil {
 		w.PartsOrder = consoleDefaultPartsOrder()
 	}
@@ -144,74 +105,33 @@ func (w ConsoleWriter) Write(p []byte) (n int, err error) {
 		return n, fmt.Errorf("cannot decode event: %s", err)
 	}
 
-	if w.FormatPrepare != nil {
-		err = w.FormatPrepare(evt)
-		if err != nil {
-			return n, err
-		}
-	}
-
 	for _, p := range w.PartsOrder {
 		w.writePart(buf, evt, p)
 	}
 
 	w.writeFields(evt, buf)
 
-	if w.FormatExtra != nil {
-		err = w.FormatExtra(evt, buf)
-		if err != nil {
-			return n, err
-		}
-	}
-
 	err = buf.WriteByte('\n')
 	if err != nil {
 		return n, err
 	}
-
 	_, err = buf.WriteTo(w.Out)
 	return len(p), err
 }
 
-// Call the underlying writer's Close method if it is an io.Closer. Otherwise
-// does nothing.
-func (w ConsoleWriter) Close() error {
-	if closer, ok := w.Out.(io.Closer); ok {
-		return closer.Close()
-	}
-	return nil
-}
-
 // writeFields appends formatted key-value pairs to buf.
 func (w ConsoleWriter) writeFields(evt map[string]interface{}, buf *bytes.Buffer) {
 	var fields = make([]string, 0, len(evt))
 	for field := range evt {
-		var isExcluded bool
-		for _, excluded := range w.FieldsExclude {
-			if field == excluded {
-				isExcluded = true
-				break
-			}
-		}
-		if isExcluded {
-			continue
-		}
-
 		switch field {
 		case LevelFieldName, TimestampFieldName, MessageFieldName, CallerFieldName:
 			continue
 		}
 		fields = append(fields, field)
 	}
+	sort.Strings(fields)
 
-	if len(w.FieldsOrder) > 0 {
-		w.orderFields(fields)
-	} else {
-		sort.Strings(fields)
-	}
-
-	// Write space only if something has already been written to the buffer, and if there are fields.
-	if buf.Len() > 0 && len(fields) > 0 {
+	if len(fields) > 0 {
 		buf.WriteByte(' ')
 	}
 
@@ -272,7 +192,7 @@ func (w ConsoleWriter) writeFields(evt map[string]interface{}, buf *bytes.Buffer
 		case json.Number:
 			buf.WriteString(fv(fValue))
 		default:
-			b, err := InterfaceMarshalFunc(fValue)
+			b, err := json.Marshal(fValue)
 			if err != nil {
 				fmt.Fprintf(buf, colorize("[error: %v]", colorRed, w.NoColor), err)
 			} else {
@@ -289,15 +209,6 @@ func (w ConsoleWriter) writeFields(evt map[string]interface{}, buf *bytes.Buffer
 // writePart appends a formatted part to buf.
 func (w ConsoleWriter) writePart(buf *bytes.Buffer, evt map[string]interface{}, p string) {
 	var f Formatter
-	var fvn FormatterByFieldName
-
-	if len(w.PartsExclude) > 0 {
-		for _, exclude := range w.PartsExclude {
-			if exclude == p {
-				return
-			}
-		}
-	}
 
 	switch p {
 	case LevelFieldName:
@@ -308,13 +219,13 @@ func (w ConsoleWriter) writePart(buf *bytes.Buffer, evt map[string]interface{},
 		}
 	case TimestampFieldName:
 		if w.FormatTimestamp == nil {
-			f = consoleDefaultFormatTimestamp(w.TimeFormat, w.TimeLocation, w.NoColor)
+			f = consoleDefaultFormatTimestamp(w.TimeFormat, w.NoColor)
 		} else {
 			f = w.FormatTimestamp
 		}
 	case MessageFieldName:
 		if w.FormatMessage == nil {
-			f = consoleDefaultFormatMessage(w.NoColor, evt[LevelFieldName])
+			f = consoleDefaultFormatMessage
 		} else {
 			f = w.FormatMessage
 		}
@@ -325,54 +236,21 @@ func (w ConsoleWriter) writePart(buf *bytes.Buffer, evt map[string]interface{},
 			f = w.FormatCaller
 		}
 	default:
-		if w.FormatPartValueByName != nil {
-			fvn = w.FormatPartValueByName
-		} else if w.FormatFieldValue != nil {
-			f = w.FormatFieldValue
-		} else {
+		if w.FormatFieldValue == nil {
 			f = consoleDefaultFormatFieldValue
+		} else {
+			f = w.FormatFieldValue
 		}
 	}
 
-	var s string
-	if f == nil {
-		s = fvn(evt[p], p)
-	} else {
-		s = f(evt[p])
-	}
+	var s = f(evt[p])
 
 	if len(s) > 0 {
-		if buf.Len() > 0 {
-			buf.WriteByte(' ') // Write space only if not the first part
-		}
 		buf.WriteString(s)
-	}
-}
-
-// orderFields takes an array of field names and an array representing field order
-// and returns an array with any ordered fields at the beginning, in order,
-// and the remaining fields after in their original order.
-func (w ConsoleWriter) orderFields(fields []string) {
-	if w.fieldIsOrdered == nil {
-		w.fieldIsOrdered = make(map[string]int)
-		for i, fieldName := range w.FieldsOrder {
-			w.fieldIsOrdered[fieldName] = i
+		if p != w.PartsOrder[len(w.PartsOrder)-1] { // Skip space for last part
+			buf.WriteByte(' ')
 		}
 	}
-	sort.Slice(fields, func(i, j int) bool {
-		ii, iOrdered := w.fieldIsOrdered[fields[i]]
-		jj, jOrdered := w.fieldIsOrdered[fields[j]]
-		if iOrdered && jOrdered {
-			return ii < jj
-		}
-		if iOrdered {
-			return true
-		}
-		if jOrdered {
-			return false
-		}
-		return fields[i] < fields[j]
-	})
 }
 
 // needsQuote returns true when the string s should be quoted in output.
@@ -385,13 +263,8 @@ func needsQuote(s string) bool {
 	return false
 }
 
-// colorize returns the string s wrapped in ANSI code c, unless disabled is true or c is 0.
+// colorize returns the string s wrapped in ANSI code c, unless disabled is true.
 func colorize(s interface{}, c int, disabled bool) string {
-	e := os.Getenv("NO_COLOR")
-	if e != "" || c == 0 {
-		disabled = true
-	}
-
 	if disabled {
 		return fmt.Sprintf("%s", s)
 	}
@@ -409,74 +282,51 @@ func consoleDefaultPartsOrder() []string {
 	}
 }
 
-func consoleDefaultFormatTimestamp(timeFormat string, location *time.Location, noColor bool) Formatter {
+func consoleDefaultFormatTimestamp(timeFormat string, noColor bool) Formatter {
 	if timeFormat == "" {
 		timeFormat = consoleDefaultTimeFormat
 	}
-	if location == nil {
-		location = time.Local
-	}
-
 	return func(i interface{}) string {
 		t := "<nil>"
 		switch tt := i.(type) {
 		case string:
-			ts, err := time.ParseInLocation(TimeFieldFormat, tt, location)
+			ts, err := time.Parse(TimeFieldFormat, tt)
 			if err != nil {
 				t = tt
 			} else {
-				t = ts.In(location).Format(timeFormat)
+				t = ts.Format(timeFormat)
 			}
 		case json.Number:
-			i, err := tt.Int64()
-			if err != nil {
-				t = tt.String()
-			} else {
-				var sec, nsec int64
-
-				switch TimeFieldFormat {
-				case TimeFormatUnixNano:
-					sec, nsec = 0, i
-				case TimeFormatUnixMicro:
-					sec, nsec = 0, int64(time.Duration(i)*time.Microsecond)
-				case TimeFormatUnixMs:
-					sec, nsec = 0, int64(time.Duration(i)*time.Millisecond)
-				default:
-					sec, nsec = i, 0
-				}
-
-				ts := time.Unix(sec, nsec)
-				t = ts.In(location).Format(timeFormat)
-			}
+			t = tt.String()
 		}
-		return colorize(t, colorDarkGray, noColor)
+		return colorize(t, colorFaint, noColor)
 	}
 }
 
-func stripLevel(ll string) string {
-	if len(ll) == 0 {
-		return unknownLevel
-	}
-	if len(ll) > 3 {
-		ll = ll[:3]
-	}
-	return strings.ToUpper(ll)
-}
-
 func consoleDefaultFormatLevel(noColor bool) Formatter {
 	return func(i interface{}) string {
+		var l string
 		if ll, ok := i.(string); ok {
-			level, _ := ParseLevel(ll)
-			fl, ok := FormattedLevels[level]
-			if ok {
-				return colorize(fl, LevelColors[level], noColor)
+			switch ll {
+			case "debug":
+				l = colorize("DBG", colorYellow, noColor)
+			case "info":
+				l = colorize("INF", colorGreen, noColor)
+			case "warn":
+				l = colorize("WRN", colorRed, noColor)
+			case "error":
+				l = colorize(colorize("ERR", colorRed, noColor), colorBold, noColor)
+			case "fatal":
+				l = colorize(colorize("FTL", colorRed, noColor), colorBold, noColor)
+			case "panic":
+				l = colorize(colorize("PNC", colorRed, noColor), colorBold, noColor)
+			default:
+				l = colorize("???", colorBold, noColor)
 			}
-			return stripLevel(ll)
+		} else {
+			l = strings.ToUpper(fmt.Sprintf("%s", i))[0:3]
 		}
-		if i == nil {
-			return unknownLevel
-		}
-		return stripLevel(fmt.Sprintf("%s", i))
+		return l
 	}
 }
 
@@ -487,34 +337,24 @@ func consoleDefaultFormatCaller(noColor bool) Formatter {
 			c = cc
 		}
 		if len(c) > 0 {
-			if cwd, err := os.Getwd(); err == nil {
-				if rel, err := filepath.Rel(cwd, c); err == nil {
-					c = rel
-				}
+			cwd, err := os.Getwd()
+			if err == nil {
+				c = strings.TrimPrefix(c, cwd)
+				c = strings.TrimPrefix(c, "/")
 			}
-			c = colorize(c, colorBold, noColor) + colorize(" >", colorCyan, noColor)
+			c = colorize(c, colorBold, noColor) + colorize(" >", colorFaint, noColor)
 		}
 		return c
 	}
 }
 
-func consoleDefaultFormatMessage(noColor bool, level interface{}) Formatter {
-	return func(i interface{}) string {
-		if i == nil || i == "" {
-			return ""
-		}
-		switch level {
-		case LevelInfoValue, LevelWarnValue, LevelErrorValue, LevelFatalValue, LevelPanicValue:
-			return colorize(fmt.Sprintf("%s", i), colorBold, noColor)
-		default:
-			return fmt.Sprintf("%s", i)
-		}
-	}
+func consoleDefaultFormatMessage(i interface{}) string {
+	return fmt.Sprintf("%s", i)
 }
 
 func consoleDefaultFormatFieldName(noColor bool) Formatter {
 	return func(i interface{}) string {
-		return colorize(fmt.Sprintf("%s=", i), colorCyan, noColor)
+		return colorize(fmt.Sprintf("%s=", i), colorFaint, noColor)
 	}
 }
 
@@ -524,12 +364,12 @@ func consoleDefaultFormatFieldValue(i interface{}) string {
 
 func consoleDefaultFormatErrFieldName(noColor bool) Formatter {
 	return func(i interface{}) string {
-		return colorize(fmt.Sprintf("%s=", i), colorCyan, noColor)
+		return colorize(fmt.Sprintf("%s=", i), colorRed, noColor)
 	}
 }
 
 func consoleDefaultFormatErrFieldValue(noColor bool) Formatter {
 	return func(i interface{}) string {
-		return colorize(colorize(fmt.Sprintf("%s", i), colorBold, noColor), colorRed, noColor)
+		return colorize(fmt.Sprintf("%s", i), colorRed, noColor)
 	}
 }

console_test.go

@@ -2,11 +2,9 @@ package zerolog_test
 
 import (
 	"bytes"
-	"encoding/json"
 	"fmt"
-	"io"
+	"io/ioutil"
 	"os"
-	"path/filepath"
 	"strings"
 	"testing"
 	"time"
@@ -32,34 +30,6 @@ func ExampleConsoleWriter_customFormatters() {
 	// Output: <nil> INFO  | Hello World foo:BAR
 }
 
-func ExampleConsoleWriter_partValueFormatter() {
-	out := zerolog.ConsoleWriter{Out: os.Stdout, NoColor: true,
-		PartsOrder:    []string{"level", "one", "two", "three", "message"},
-		FieldsExclude: []string{"one", "two", "three"}}
-	out.FormatLevel = func(i interface{}) string { return strings.ToUpper(fmt.Sprintf("%-6s", i)) }
-	out.FormatFieldName = func(i interface{}) string { return fmt.Sprintf("%s:", i) }
-	out.FormatPartValueByName = func(i interface{}, s string) string {
-		var ret string
-		switch s {
-		case "one":
-			ret = strings.ToUpper(fmt.Sprintf("%s", i))
-		case "two":
-			ret = strings.ToLower(fmt.Sprintf("%s", i))
-		case "three":
-			ret = strings.ToLower(fmt.Sprintf("(%s)", i))
-		}
-		return ret
-	}
-	log := zerolog.New(out)
-
-	log.Info().Str("foo", "bar").
-		Str("two", "TEST_TWO").
-		Str("one", "test_one").
-		Str("three", "test_three").
-		Msg("Hello World")
-	// Output: INFO   TEST_ONE test_two (test_three) Hello World foo:bar
-}
-
 func ExampleNewConsoleWriter() {
 	out := zerolog.NewConsoleWriter()
 	out.NoColor = true // For testing purposes only
@@ -106,7 +76,7 @@ func TestConsoleWriter(t *testing.T) {
 		buf := &bytes.Buffer{}
 		w := zerolog.ConsoleWriter{Out: buf, NoColor: true, PartsOrder: []string{"foo"}}
 
-		_, err := w.Write([]byte(`{"foo": "DEFAULT"}`))
+		_, err := w.Write([]byte(`{"foo" : "DEFAULT"}`))
 		if err != nil {
 			t.Errorf("Unexpected error when writing output: %s", err)
 		}
@@ -122,163 +92,29 @@ func TestConsoleWriter(t *testing.T) {
 		buf := &bytes.Buffer{}
 		w := zerolog.ConsoleWriter{Out: buf, NoColor: false}
 
-		_, err := w.Write([]byte(`{"level": "warn", "message": "Foobar"}`))
+		_, err := w.Write([]byte(`{"level" : "warn", "message" : "Foobar"}`))
 		if err != nil {
 			t.Errorf("Unexpected error when writing output: %s", err)
 		}
 
-		expectedOutput := "\x1b[90m<nil>\x1b[0m \x1b[33mWRN\x1b[0m \x1b[1mFoobar\x1b[0m\n"
+		expectedOutput := "\x1b[2m<nil>\x1b[0m \x1b[31mWRN\x1b[0m Foobar\n"
 		actualOutput := buf.String()
 		if actualOutput != expectedOutput {
 			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
 		}
 	})
 
-	t.Run("NO_COLOR = true", func(t *testing.T) {
-		os.Setenv("NO_COLOR", "anything")
-
-		buf := &bytes.Buffer{}
-		w := zerolog.ConsoleWriter{Out: buf}
-
-		_, err := w.Write([]byte(`{"level": "warn", "message": "Foobar"}`))
-		if err != nil {
-			t.Errorf("Unexpected error when writing output: %s", err)
-		}
-
-		expectedOutput := "<nil> WRN Foobar\n"
-		actualOutput := buf.String()
-		if actualOutput != expectedOutput {
-			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
-		}
-		os.Unsetenv("NO_COLOR")
-	})
-
 	t.Run("Write fields", func(t *testing.T) {
 		buf := &bytes.Buffer{}
 		w := zerolog.ConsoleWriter{Out: buf, NoColor: true}
 
-		ts := time.Unix(0, 0)
-		d := ts.UTC().Format(time.RFC3339)
-		_, err := w.Write([]byte(`{"time": "` + d + `", "level": "debug", "message": "Foobar", "foo": "bar"}`))
+		d := time.Unix(0, 0).UTC().Format(time.RFC3339)
+		_, err := w.Write([]byte(`{"time" : "` + d + `", "level" : "debug", "message" : "Foobar", "foo" : "bar"}`))
 		if err != nil {
 			t.Errorf("Unexpected error when writing output: %s", err)
 		}
 
-		expectedOutput := ts.Format(time.Kitchen) + " DBG Foobar foo=bar\n"
-		actualOutput := buf.String()
-		if actualOutput != expectedOutput {
-			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
-		}
-	})
-
-	t.Run("Unix timestamp input format", func(t *testing.T) {
-		of := zerolog.TimeFieldFormat
-		defer func() {
-			zerolog.TimeFieldFormat = of
-		}()
-		zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
-
-		buf := &bytes.Buffer{}
-		w := zerolog.ConsoleWriter{Out: buf, TimeFormat: time.StampMilli, NoColor: true}
-
-		_, err := w.Write([]byte(`{"time": 1234, "level": "debug", "message": "Foobar", "foo": "bar"}`))
-		if err != nil {
-			t.Errorf("Unexpected error when writing output: %s", err)
-		}
-
-		expectedOutput := time.Unix(1234, 0).Format(time.StampMilli) + " DBG Foobar foo=bar\n"
-		actualOutput := buf.String()
-		if actualOutput != expectedOutput {
-			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
-		}
-	})
-
-	t.Run("Unix timestamp ms input format", func(t *testing.T) {
-		of := zerolog.TimeFieldFormat
-		defer func() {
-			zerolog.TimeFieldFormat = of
-		}()
-		zerolog.TimeFieldFormat = zerolog.TimeFormatUnixMs
-
-		buf := &bytes.Buffer{}
-		w := zerolog.ConsoleWriter{Out: buf, TimeFormat: time.StampMilli, NoColor: true}
-
-		_, err := w.Write([]byte(`{"time": 1234567, "level": "debug", "message": "Foobar", "foo": "bar"}`))
-		if err != nil {
-			t.Errorf("Unexpected error when writing output: %s", err)
-		}
-
-		expectedOutput := time.Unix(1234, 567000000).Format(time.StampMilli) + " DBG Foobar foo=bar\n"
-		actualOutput := buf.String()
-		if actualOutput != expectedOutput {
-			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
-		}
-	})
-
-	t.Run("Unix timestamp us input format", func(t *testing.T) {
-		of := zerolog.TimeFieldFormat
-		defer func() {
-			zerolog.TimeFieldFormat = of
-		}()
-		zerolog.TimeFieldFormat = zerolog.TimeFormatUnixMicro
-
-		buf := &bytes.Buffer{}
-		w := zerolog.ConsoleWriter{Out: buf, TimeFormat: time.StampMicro, NoColor: true}
-
-		_, err := w.Write([]byte(`{"time": 1234567891, "level": "debug", "message": "Foobar", "foo": "bar"}`))
-		if err != nil {
-			t.Errorf("Unexpected error when writing output: %s", err)
-		}
-
-		expectedOutput := time.Unix(1234, 567891000).Format(time.StampMicro) + " DBG Foobar foo=bar\n"
-		actualOutput := buf.String()
-		if actualOutput != expectedOutput {
-			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
-		}
-	})
-
-	t.Run("No message field", func(t *testing.T) {
-		buf := &bytes.Buffer{}
-		w := zerolog.ConsoleWriter{Out: buf, NoColor: true}
-
-		_, err := w.Write([]byte(`{"level": "debug", "foo": "bar"}`))
-		if err != nil {
-			t.Errorf("Unexpected error when writing output: %s", err)
-		}
-
-		expectedOutput := "<nil> DBG foo=bar\n"
-		actualOutput := buf.String()
-		if actualOutput != expectedOutput {
-			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
-		}
-	})
-
-	t.Run("No level field", func(t *testing.T) {
-		buf := &bytes.Buffer{}
-		w := zerolog.ConsoleWriter{Out: buf, NoColor: true}
-
-		_, err := w.Write([]byte(`{"message": "Foobar", "foo": "bar"}`))
-		if err != nil {
-			t.Errorf("Unexpected error when writing output: %s", err)
-		}
-
-		expectedOutput := "<nil> ??? Foobar foo=bar\n"
-		actualOutput := buf.String()
-		if actualOutput != expectedOutput {
-			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
-		}
-	})
-
-	t.Run("Write colorized fields", func(t *testing.T) {
-		buf := &bytes.Buffer{}
-		w := zerolog.ConsoleWriter{Out: buf, NoColor: false}
-
-		_, err := w.Write([]byte(`{"level": "warn", "message": "Foobar", "foo": "bar"}`))
-		if err != nil {
-			t.Errorf("Unexpected error when writing output: %s", err)
-		}
-
-		expectedOutput := "\x1b[90m<nil>\x1b[0m \x1b[33mWRN\x1b[0m \x1b[1mFoobar\x1b[0m \x1b[36mfoo=\x1b[0mbar\n"
+		expectedOutput := "12:00AM DBG Foobar foo=bar\n"
 		actualOutput := buf.String()
 		if actualOutput != expectedOutput {
 			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
@@ -289,9 +125,8 @@ func TestConsoleWriter(t *testing.T) {
 		buf := &bytes.Buffer{}
 		w := zerolog.ConsoleWriter{Out: buf, NoColor: true}
 
-		ts := time.Unix(0, 0)
-		d := ts.UTC().Format(time.RFC3339)
-		evt := `{"time": "` + d + `", "level": "error", "message": "Foobar", "aaa": "bbb", "error": "Error"}`
+		d := time.Unix(0, 0).UTC().Format(time.RFC3339)
+		evt := `{"time" : "` + d + `", "level" : "error", "message" : "Foobar", "aaa" : "bbb", "error" : "Error"}`
 		// t.Log(evt)
 
 		_, err := w.Write([]byte(evt))
@@ -299,7 +134,7 @@ func TestConsoleWriter(t *testing.T) {
 			t.Errorf("Unexpected error when writing output: %s", err)
 		}
 
-		expectedOutput := ts.Format(time.Kitchen) + " ERR Foobar error=Error aaa=bbb\n"
+		expectedOutput := "12:00AM ERR Foobar error=Error aaa=bbb\n"
 		actualOutput := buf.String()
 		if actualOutput != expectedOutput {
 			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
@@ -315,35 +150,17 @@ func TestConsoleWriter(t *testing.T) {
 			t.Fatalf("Cannot get working directory: %s", err)
 		}
 
-		ts := time.Unix(0, 0)
-		d := ts.UTC().Format(time.RFC3339)
+		d := time.Unix(0, 0).UTC().Format(time.RFC3339)
+		evt := `{"time" : "` + d + `", "level" : "debug", "message" : "Foobar", "foo" : "bar", "caller" : "` + cwd + `/foo/bar.go"}`
+		// t.Log(evt)
 
-		fields := map[string]interface{}{
-			"time":    d,
-			"level":   "debug",
-			"message": "Foobar",
-			"foo":     "bar",
-			"caller":  filepath.Join(cwd, "foo", "bar.go"),
-		}
-
-		evt, err := json.Marshal(fields)
-		if err != nil {
-			t.Fatalf("Cannot marshal fields: %s", err)
-		}
-
-		_, err = w.Write(evt)
+		_, err = w.Write([]byte(evt))
 		if err != nil {
 			t.Errorf("Unexpected error when writing output: %s", err)
 		}
 
-		// Define the expected output with forward slashes
-		expectedOutput := ts.Format(time.Kitchen) + " DBG foo/bar.go > Foobar foo=bar\n"
-
-		// Get the actual output and normalize path separators to forward slashes
+		expectedOutput := "12:00AM DBG foo/bar.go > Foobar foo=bar\n"
 		actualOutput := buf.String()
-		actualOutput = strings.ReplaceAll(actualOutput, string(os.PathSeparator), "/")
-
-		// Compare the normalized actual output to the expected output
 		if actualOutput != expectedOutput {
 			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
 		}
@@ -353,7 +170,7 @@ func TestConsoleWriter(t *testing.T) {
 		buf := &bytes.Buffer{}
 		w := zerolog.ConsoleWriter{Out: buf, NoColor: true}
 
-		evt := `{"level": "debug", "message": "Foobar", "foo": [1, 2, 3], "bar": true}`
+		evt := `{"level" : "debug", "message" : "Foobar", "foo" : [1, 2, 3], "bar" : true}`
 		// t.Log(evt)
 
 		_, err := w.Write([]byte(evt))
@@ -367,85 +184,6 @@ func TestConsoleWriter(t *testing.T) {
 			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
 		}
 	})
-
-	t.Run("With an extra 'level' field", func(t *testing.T) {
-		t.Run("malformed string", func(t *testing.T) {
-			cases := []struct {
-				field  string
-				output string
-			}{
-				{"", "<nil> ??? Hello World foo=bar\n"},
-				{"-", "<nil> - Hello World foo=bar\n"},
-				{"1", "<nil> " + zerolog.FormattedLevels[1] + " Hello World foo=bar\n"},
-				{"a", "<nil> A Hello World foo=bar\n"},
-				{"12", "<nil> 12 Hello World foo=bar\n"},
-				{"a2", "<nil> A2 Hello World foo=bar\n"},
-				{"2a", "<nil> 2A Hello World foo=bar\n"},
-				{"ab", "<nil> AB Hello World foo=bar\n"},
-				{"12a", "<nil> 12A Hello World foo=bar\n"},
-				{"a12", "<nil> A12 Hello World foo=bar\n"},
-				{"abc", "<nil> ABC Hello World foo=bar\n"},
-				{"123", "<nil> 123 Hello World foo=bar\n"},
-				{"abcd", "<nil> ABC Hello World foo=bar\n"},
-				{"1234", "<nil> 123 Hello World foo=bar\n"},
-				{"123d", "<nil> 123 Hello World foo=bar\n"},
-				{"01", "<nil> " + zerolog.FormattedLevels[1] + " Hello World foo=bar\n"},
-				{"001", "<nil> " + zerolog.FormattedLevels[1] + " Hello World foo=bar\n"},
-				{"0001", "<nil> " + zerolog.FormattedLevels[1] + " Hello World foo=bar\n"},
-			}
-			for i, c := range cases {
-				c := c
-				t.Run(fmt.Sprintf("case %d", i), func(t *testing.T) {
-					buf := &bytes.Buffer{}
-					out := zerolog.NewConsoleWriter()
-					out.NoColor = true
-					out.Out = buf
-					log := zerolog.New(out)
-
-					log.Debug().Str("level", c.field).Str("foo", "bar").Msg("Hello World")
-
-					actualOutput := buf.String()
-					if actualOutput != c.output {
-						t.Errorf("Unexpected output %q, want: %q", actualOutput, c.output)
-					}
-				})
-			}
-		})
-
-		t.Run("weird value", func(t *testing.T) {
-			cases := []struct {
-				field  interface{}
-				output string
-			}{
-				{0, "<nil> 0 Hello World foo=bar\n"},
-				{1, "<nil> 1 Hello World foo=bar\n"},
-				{-1, "<nil> -1 Hello World foo=bar\n"},
-				{-3, "<nil> -3 Hello World foo=bar\n"},
-				{-32, "<nil> -32 Hello World foo=bar\n"},
-				{-321, "<nil> -32 Hello World foo=bar\n"},
-				{12, "<nil> 12 Hello World foo=bar\n"},
-				{123, "<nil> 123 Hello World foo=bar\n"},
-				{1234, "<nil> 123 Hello World foo=bar\n"},
-			}
-			for i, c := range cases {
-				c := c
-				t.Run(fmt.Sprintf("case %d", i), func(t *testing.T) {
-					buf := &bytes.Buffer{}
-					out := zerolog.NewConsoleWriter()
-					out.NoColor = true
-					out.Out = buf
-					log := zerolog.New(out)
-
-					log.Debug().Interface("level", c.field).Str("foo", "bar").Msg("Hello World")
-
-					actualOutput := buf.String()
-					if actualOutput != c.output {
-						t.Errorf("Unexpected output %q, want: %q", actualOutput, c.output)
-					}
-				})
-			}
-		})
-	})
 }
 
 func TestConsoleWriterConfiguration(t *testing.T) {
@@ -453,56 +191,26 @@ func TestConsoleWriterConfiguration(t *testing.T) {
 		buf := &bytes.Buffer{}
 		w := zerolog.ConsoleWriter{Out: buf, NoColor: true, TimeFormat: time.RFC3339}
 
-		ts := time.Unix(0, 0)
-		d := ts.UTC().Format(time.RFC3339)
-		evt := `{"time": "` + d + `", "level": "info", "message": "Foobar"}`
+		d := time.Unix(0, 0).UTC().Format(time.RFC3339)
+		evt := `{"time" : "` + d + `", "level" : "info", "message" : "Foobar"}`
 
 		_, err := w.Write([]byte(evt))
 		if err != nil {
 			t.Errorf("Unexpected error when writing output: %s", err)
 		}
 
-		expectedOutput := ts.Format(time.RFC3339) + " INF Foobar\n"
+		expectedOutput := "1970-01-01T00:00:00Z INF Foobar\n"
 		actualOutput := buf.String()
 		if actualOutput != expectedOutput {
 			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
 		}
 	})
 
-	t.Run("Sets TimeFormat and TimeLocation", func(t *testing.T) {
-		locs := []*time.Location{time.Local, time.UTC}
-
-		for _, location := range locs {
-			buf := &bytes.Buffer{}
-			w := zerolog.ConsoleWriter{
-				Out:          buf,
-				NoColor:      true,
-				TimeFormat:   time.RFC3339,
-				TimeLocation: location,
-			}
-
-			ts := time.Unix(0, 0)
-			d := ts.UTC().Format(time.RFC3339)
-			evt := `{"time": "` + d + `", "level": "info", "message": "Foobar"}`
-
-			_, err := w.Write([]byte(evt))
-			if err != nil {
-				t.Errorf("Unexpected error when writing output: %s", err)
-			}
-
-			expectedOutput := ts.In(location).Format(time.RFC3339) + " INF Foobar\n"
-			actualOutput := buf.String()
-			if actualOutput != expectedOutput {
-				t.Errorf("Unexpected output %q, want: %q (location=%s)", actualOutput, expectedOutput, location)
-			}
-		}
-	})
-
 	t.Run("Sets PartsOrder", func(t *testing.T) {
 		buf := &bytes.Buffer{}
 		w := zerolog.ConsoleWriter{Out: buf, NoColor: true, PartsOrder: []string{"message", "level"}}
 
-		evt := `{"level": "info", "message": "Foobar"}`
+		evt := `{"level" : "info", "message" : "Foobar"}`
 		_, err := w.Write([]byte(evt))
 		if err != nil {
 			t.Errorf("Unexpected error when writing output: %s", err)
@@ -514,139 +222,15 @@ func TestConsoleWriterConfiguration(t *testing.T) {
 			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
 		}
 	})
-
-	t.Run("Sets PartsExclude", func(t *testing.T) {
-		buf := &bytes.Buffer{}
-		w := zerolog.ConsoleWriter{Out: buf, NoColor: true, PartsExclude: []string{"time"}}
-
-		d := time.Unix(0, 0).UTC().Format(time.RFC3339)
-		evt := `{"time": "` + d + `", "level": "info", "message": "Foobar"}`
-		_, err := w.Write([]byte(evt))
-		if err != nil {
-			t.Errorf("Unexpected error when writing output: %s", err)
-		}
-
-		expectedOutput := "INF Foobar\n"
-		actualOutput := buf.String()
-		if actualOutput != expectedOutput {
-			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
-		}
-	})
-
-	t.Run("Sets FieldsOrder", func(t *testing.T) {
-		buf := &bytes.Buffer{}
-		w := zerolog.ConsoleWriter{Out: buf, NoColor: true, FieldsOrder: []string{"zebra", "aardvark"}}
-
-		evt := `{"level": "info", "message": "Zoo", "aardvark": "Able", "mussel": "Mountain", "zebra": "Zulu"}`
-		_, err := w.Write([]byte(evt))
-		if err != nil {
-			t.Errorf("Unexpected error when writing output: %s", err)
-		}
-
-		expectedOutput := "<nil> INF Zoo zebra=Zulu aardvark=Able mussel=Mountain\n"
-		actualOutput := buf.String()
-		if actualOutput != expectedOutput {
-			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
-		}
-	})
-
-	t.Run("Sets FieldsExclude", func(t *testing.T) {
-		buf := &bytes.Buffer{}
-		w := zerolog.ConsoleWriter{Out: buf, NoColor: true, FieldsExclude: []string{"foo"}}
-
-		evt := `{"level": "info", "message": "Foobar", "foo":"bar", "baz":"quux"}`
-		_, err := w.Write([]byte(evt))
-		if err != nil {
-			t.Errorf("Unexpected error when writing output: %s", err)
-		}
-
-		expectedOutput := "<nil> INF Foobar baz=quux\n"
-		actualOutput := buf.String()
-		if actualOutput != expectedOutput {
-			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
-		}
-	})
-
-	t.Run("Sets FormatExtra", func(t *testing.T) {
-		buf := &bytes.Buffer{}
-		w := zerolog.ConsoleWriter{
-			Out: buf, NoColor: true, PartsOrder: []string{"level", "message"},
-			FormatExtra: func(evt map[string]interface{}, buf *bytes.Buffer) error {
-				buf.WriteString("\nAdditional stacktrace")
-				return nil
-			},
-		}
-
-		evt := `{"level": "info", "message": "Foobar"}`
-		_, err := w.Write([]byte(evt))
-		if err != nil {
-			t.Errorf("Unexpected error when writing output: %s", err)
-		}
-
-		expectedOutput := "INF Foobar\nAdditional stacktrace\n"
-		actualOutput := buf.String()
-		if actualOutput != expectedOutput {
-			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
-		}
-	})
-
-	t.Run("Sets FormatPrepare", func(t *testing.T) {
-		buf := &bytes.Buffer{}
-		w := zerolog.ConsoleWriter{
-			Out: buf, NoColor: true, PartsOrder: []string{"level", "message"},
-			FormatPrepare: func(evt map[string]interface{}) error {
-				evt["message"] = fmt.Sprintf("msg=%s", evt["message"])
-				return nil
-			},
-		}
-
-		evt := `{"level": "info", "message": "Foobar"}`
-		_, err := w.Write([]byte(evt))
-		if err != nil {
-			t.Errorf("Unexpected error when writing output: %s", err)
-		}
-
-		expectedOutput := "INF msg=Foobar\n"
-		actualOutput := buf.String()
-		if actualOutput != expectedOutput {
-			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
-		}
-	})
-
-	t.Run("Uses local time for console writer without time zone", func(t *testing.T) {
-		// Regression test for issue #483 (check there for more details)
-
-		timeFormat := "2006-01-02 15:04:05"
-		expectedOutput := "2022-10-20 20:24:50 INF Foobar\n"
-		evt := `{"time": "2022-10-20 20:24:50", "level": "info", "message": "Foobar"}`
-
-		of := zerolog.TimeFieldFormat
-		defer func() {
-			zerolog.TimeFieldFormat = of
-		}()
-		zerolog.TimeFieldFormat = timeFormat
-
-		buf := &bytes.Buffer{}
-		w := zerolog.ConsoleWriter{Out: buf, NoColor: true, TimeFormat: timeFormat}
-		_, err := w.Write([]byte(evt))
-		if err != nil {
-			t.Errorf("Unexpected error when writing output: %s", err)
-		}
-
-		actualOutput := buf.String()
-		if actualOutput != expectedOutput {
-			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
-		}
-	})
 }
 
 func BenchmarkConsoleWriter(b *testing.B) {
 	b.ResetTimer()
 	b.ReportAllocs()
 
-	var msg = []byte(`{"level": "info", "foo": "bar", "message": "HELLO", "time": "1990-01-01"}`)
+	var msg = []byte(`{"level" : "info", "foo" : "bar", "message" : "HELLO", "time" : "1990-01-01"}`)
 
-	w := zerolog.ConsoleWriter{Out: io.Discard, NoColor: false}
+	w := zerolog.ConsoleWriter{Out: ioutil.Discard, NoColor: false}
 
 	for i := 0; i < b.N; i++ {
 		w.Write(msg)

context.go

@@ -1,10 +1,7 @@
 package zerolog
 
 import (
-	"context"
-	"fmt"
-	"io"
-	"math"
+	"io/ioutil"
 	"net"
 	"time"
 )
@@ -19,11 +16,9 @@ func (c Context) Logger() Logger {
 	return c.l
 }
 
-// Fields is a helper function to use a map or slice to set fields using type assertion.
-// Only map[string]interface{} and []interface{} are accepted. []interface{} must
-// alternate string keys and arbitrary values, and extraneous ones are ignored.
-func (c Context) Fields(fields interface{}) Context {
-	c.l.context = appendFields(c.l.context, fields, c.l.stack)
+// Fields is a helper function to use a map to set fields using type assertion.
+func (c Context) Fields(fields map[string]interface{}) Context {
+	c.l.context = appendFields(c.l.context, fields)
 	return c
 }
 
@@ -57,7 +52,7 @@ 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{io.Discard}, 0)
+	e := newEvent(levelWriterAdapter{ioutil.Discard}, 0)
 	e.Object(key, obj)
 	c.l.context = enc.AppendObjectData(c.l.context, e.buf)
 	putEvent(e)
@@ -66,7 +61,7 @@ func (c Context) Object(key string, obj LogObjectMarshaler) Context {
 
 // EmbedObject marshals and Embeds an object that implement the LogObjectMarshaler interface.
 func (c Context) EmbedObject(obj LogObjectMarshaler) Context {
-	e := newEvent(LevelWriterAdapter{io.Discard}, 0)
+	e := newEvent(levelWriterAdapter{ioutil.Discard}, 0)
 	e.EmbedObject(obj)
 	c.l.context = enc.AppendObjectData(c.l.context, e.buf)
 	putEvent(e)
@@ -85,17 +80,6 @@ func (c Context) Strs(key string, vals []string) Context {
 	return c
 }
 
-// Stringer adds the field key with val.String() (or null if val is nil) to the logger context.
-func (c Context) Stringer(key string, val fmt.Stringer) Context {
-	if val != nil {
-		c.l.context = enc.AppendString(enc.AppendKey(c.l.context, key), val.String())
-		return c
-	}
-
-	c.l.context = enc.AppendInterface(enc.AppendKey(c.l.context, key), nil)
-	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 = enc.AppendBytes(enc.AppendKey(c.l.context, key), val)
@@ -119,17 +103,14 @@ func (c Context) RawJSON(key string, b []byte) Context {
 
 // AnErr adds the field key with serialized err to the logger context.
 func (c Context) AnErr(key string, err error) Context {
-	switch m := ErrorMarshalFunc(err).(type) {
+	marshaled := ErrorMarshalFunc(err)
+	switch m := marshaled.(type) {
 	case nil:
 		return c
 	case LogObjectMarshaler:
 		return c.Object(key, m)
 	case error:
-		if m == nil || isNilValue(m) {
-			return c
-		} else {
-			return c.Str(key, m.Error())
-		}
+		return c.Str(key, m.Error())
 	case string:
 		return c.Str(key, m)
 	default:
@@ -142,15 +123,12 @@ func (c Context) AnErr(key string, err error) Context {
 func (c Context) Errs(key string, errs []error) Context {
 	arr := Arr()
 	for _, err := range errs {
-		switch m := ErrorMarshalFunc(err).(type) {
+		marshaled := ErrorMarshalFunc(err)
+		switch m := marshaled.(type) {
 		case LogObjectMarshaler:
 			arr = arr.Object(m)
 		case error:
-			if m == nil || isNilValue(m) {
-				arr = arr.Interface(nil)
-			} else {
-				arr = arr.Str(m.Error())
-			}
+			arr = arr.Str(m.Error())
 		case string:
 			arr = arr.Str(m)
 		default:
@@ -163,34 +141,9 @@ func (c Context) Errs(key string, errs []error) Context {
 
 // Err adds the field "error" with serialized err to the logger context.
 func (c Context) Err(err error) Context {
-	if c.l.stack && ErrorStackMarshaler != nil {
-		switch m := ErrorStackMarshaler(err).(type) {
-		case nil:
-		case LogObjectMarshaler:
-			c = c.Object(ErrorStackFieldName, m)
-		case error:
-			if m != nil && !isNilValue(m) {
-				c = c.Str(ErrorStackFieldName, m.Error())
-			}
-		case string:
-			c = c.Str(ErrorStackFieldName, m)
-		default:
-			c = c.Interface(ErrorStackFieldName, m)
-		}
-	}
-
 	return c.AnErr(ErrorFieldName, err)
 }
 
-// Ctx adds the context.Context to the logger context. The context.Context is
-// not rendered in the error message, but is made available for hooks to use.
-// A typical use case is to extract tracing information from the
-// context.Context.
-func (c Context) Ctx(ctx context.Context) Context {
-	c.l.ctx = ctx
-	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 = enc.AppendBool(enc.AppendKey(c.l.context, key), b)
@@ -325,25 +278,25 @@ func (c Context) Uints64(key string, i []uint64) Context {
 
 // 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 = enc.AppendFloat32(enc.AppendKey(c.l.context, key), f, FloatingPointPrecision)
+	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 = enc.AppendFloats32(enc.AppendKey(c.l.context, key), f, FloatingPointPrecision)
+	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 = enc.AppendFloat64(enc.AppendKey(c.l.context, key), f, FloatingPointPrecision)
+	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 = enc.AppendFloats64(enc.AppendKey(c.l.context, key), f, FloatingPointPrecision)
+	c.l.context = enc.AppendFloats64(enc.AppendKey(c.l.context, key), f)
 	return c
 }
 
@@ -355,9 +308,8 @@ func (ts timestampHook) Run(e *Event, level Level, msg string) {
 
 var th = timestampHook{}
 
-// Timestamp adds the current local time to the logger context with the "time" key, formatted using zerolog.TimeFieldFormat.
+// Timestamp adds the current local time as UNIX timestamp to the logger context with the "time" key.
 // To customize the key name, change zerolog.TimestampFieldName.
-// To customize the time format, change zerolog.TimeFieldFormat.
 //
 // NOTE: It won't dedupe the "time" key if the *Context has one already.
 func (c Context) Timestamp() Context {
@@ -365,13 +317,13 @@ func (c Context) Timestamp() Context {
 	return c
 }
 
-// Time adds the field key with t formatted as string using zerolog.TimeFieldFormat.
+// 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 = enc.AppendTime(enc.AppendKey(c.l.context, key), t, TimeFieldFormat)
 	return c
 }
 
-// Times adds the field key with t formatted as string using zerolog.TimeFieldFormat.
+// 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 = enc.AppendTimes(enc.AppendKey(c.l.context, key), t, TimeFieldFormat)
 	return c
@@ -379,67 +331,30 @@ func (c Context) Times(key string, t []time.Time) Context {
 
 // 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 = enc.AppendDuration(enc.AppendKey(c.l.context, key), d, DurationFieldUnit, DurationFieldInteger, FloatingPointPrecision)
+	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 = enc.AppendDurations(enc.AppendKey(c.l.context, key), d, DurationFieldUnit, DurationFieldInteger, FloatingPointPrecision)
+	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 {
-	if obj, ok := i.(LogObjectMarshaler); ok {
-		return c.Object(key, obj)
-	}
 	c.l.context = enc.AppendInterface(enc.AppendKey(c.l.context, key), i)
 	return c
 }
 
-// Type adds the field key with val's type using reflection.
-func (c Context) Type(key string, val interface{}) Context {
-	c.l.context = enc.AppendType(enc.AppendKey(c.l.context, key), val)
-	return c
-}
-
-// Any is a wrapper around Context.Interface.
-func (c Context) Any(key string, i interface{}) Context {
-	return c.Interface(key, i)
-}
-
-// Reset removes all the context fields.
-func (c Context) Reset() Context {
-	c.l.context = enc.AppendBeginMarker(make([]byte, 0, 500))
-	return c
-}
-
-type callerHook struct {
-	callerSkipFrameCount int
-}
-
-func newCallerHook(skipFrameCount int) callerHook {
-	return callerHook{callerSkipFrameCount: skipFrameCount}
-}
+type callerHook struct{}
 
 func (ch callerHook) Run(e *Event, level Level, msg string) {
-	switch ch.callerSkipFrameCount {
-	case useGlobalSkipFrameCount:
-		// Extra frames to skip (added by hook infra).
-		e.caller(CallerSkipFrameCount + contextCallerSkipFrameCount)
-	default:
-		// Extra frames to skip (added by hook infra).
-		e.caller(ch.callerSkipFrameCount + contextCallerSkipFrameCount)
-	}
+	// Three extra frames to skip (added by hook infra).
+	e.caller(CallerSkipFrameCount + 3)
 }
 
-// useGlobalSkipFrameCount acts as a flag to informat callerHook.Run
-// to use the global CallerSkipFrameCount.
-const useGlobalSkipFrameCount = math.MinInt32
-
-// ch is the default caller hook using the global CallerSkipFrameCount.
-var ch = newCallerHook(useGlobalSkipFrameCount)
+var ch = callerHook{}
 
 // Caller adds the file:line of the caller with the zerolog.CallerFieldName key.
 func (c Context) Caller() Context {
@@ -447,17 +362,17 @@ func (c Context) Caller() Context {
 	return c
 }
 
-// CallerWithSkipFrameCount adds the file:line of the caller with the zerolog.CallerFieldName key.
-// The specified skipFrameCount int will override the global CallerSkipFrameCount for this context's respective logger.
-// If set to -1 the global CallerSkipFrameCount will be used.
-func (c Context) CallerWithSkipFrameCount(skipFrameCount int) Context {
-	c.l = c.l.Hook(newCallerHook(skipFrameCount))
-	return c
+type stackTraceHook struct{}
+
+func (sh stackTraceHook) Run(e *Event, level Level, msg string) {
+	e.Stack()
 }
 
+var sh = stackTraceHook{}
+
 // Stack enables stack trace printing for the error passed to Err().
 func (c Context) Stack() Context {
-	c.l.stack = true
+	c.l = c.l.Hook(sh)
 	return c
 }
 

ctx.go

@@ -7,22 +7,16 @@ import (
 var disabledLogger *Logger
 
 func init() {
-	SetGlobalLevel(TraceLevel)
 	l := Nop()
 	disabledLogger = &l
 }
 
 type ctxKey struct{}
 
-// WithContext returns a copy of ctx with the receiver attached. The Logger
-// attached to the provided Context (if any) will not be effected.  If the
-// receiver's log level is Disabled it will only be attached to the returned
-// Context if the provided Context has a previously attached Logger. If the
-// provided Context has no attached Logger, a Disabled Logger will not be
-// attached.
+// WithContext returns a copy of ctx with l associated. If an instance of Logger
+// is already in the context, the context is not updated.
 //
-// Note: to modify the existing Logger attached to a Context (instead of
-// replacing it in a new Context), use UpdateContext with the following
+// For instance, to add a field to an existing logger in the context, use this
 // notation:
 //
 //     ctx := r.Context()
@@ -30,23 +24,24 @@ type ctxKey struct{}
 //     l.UpdateContext(func(c Context) Context {
 //         return c.Str("bar", "baz")
 //     })
-//
-func (l Logger) WithContext(ctx context.Context) context.Context {
-	if _, ok := ctx.Value(ctxKey{}).(*Logger); !ok && l.level == Disabled {
+func (l *Logger) WithContext(ctx context.Context) context.Context {
+	if lp, ok := ctx.Value(ctxKey{}).(*Logger); ok {
+		if lp == l {
+			// Do not store same logger.
+			return ctx
+		}
+	} else if l.level == Disabled {
 		// Do not store disabled logger.
 		return ctx
 	}
-	return context.WithValue(ctx, ctxKey{}, &l)
+	return context.WithValue(ctx, ctxKey{}, l)
 }
 
 // Ctx returns the Logger associated with the ctx. If no logger
-// is associated, DefaultContextLogger is returned, unless DefaultContextLogger
-// is nil, in which case a disabled logger is returned.
+// is associated, a disabled logger is returned.
 func Ctx(ctx context.Context) *Logger {
 	if l, ok := ctx.Value(ctxKey{}).(*Logger); ok {
 		return l
-	} else if l = DefaultContextLogger; l != nil {
-		return l
 	}
 	return disabledLogger
 }

ctx_test.go

@@ -1,17 +1,14 @@
 package zerolog
 
 import (
-	"bytes"
 	"context"
-	"io"
+	"io/ioutil"
 	"reflect"
 	"testing"
-
-	"github.com/rs/zerolog/internal/cbor"
 )
 
 func TestCtx(t *testing.T) {
-	log := New(io.Discard)
+	log := New(ioutil.Discard)
 	ctx := log.WithContext(context.Background())
 	log2 := Ctx(ctx)
 	if !reflect.DeepEqual(log, *log2) {
@@ -30,25 +27,18 @@ func TestCtx(t *testing.T) {
 	if log2 != disabledLogger {
 		t.Error("Ctx did not return the expected logger")
 	}
-
-	DefaultContextLogger = &log
-	t.Cleanup(func() { DefaultContextLogger = nil })
-	log2 = Ctx(context.Background())
-	if log2 != &log {
-		t.Error("Ctx did not return the expected logger")
-	}
 }
 
 func TestCtxDisabled(t *testing.T) {
-	dl := New(io.Discard).Level(Disabled)
+	dl := New(ioutil.Discard).Level(Disabled)
 	ctx := dl.WithContext(context.Background())
 	if ctx != context.Background() {
 		t.Error("WithContext stored a disabled logger")
 	}
 
-	l := New(io.Discard).With().Str("foo", "bar").Logger()
+	l := New(ioutil.Discard).With().Str("foo", "bar").Logger()
 	ctx = l.WithContext(ctx)
-	if !reflect.DeepEqual(Ctx(ctx), &l) {
+	if Ctx(ctx) != &l {
 		t.Error("WithContext did not store logger")
 	}
 
@@ -56,46 +46,18 @@ func TestCtxDisabled(t *testing.T) {
 		return c.Str("bar", "baz")
 	})
 	ctx = l.WithContext(ctx)
-	if !reflect.DeepEqual(Ctx(ctx), &l) {
+	if Ctx(ctx) != &l {
 		t.Error("WithContext did not store updated logger")
 	}
 
 	l = l.Level(DebugLevel)
 	ctx = l.WithContext(ctx)
-	if !reflect.DeepEqual(Ctx(ctx), &l) {
+	if Ctx(ctx) != &l {
 		t.Error("WithContext did not store copied logger")
 	}
 
 	ctx = dl.WithContext(ctx)
-	if !reflect.DeepEqual(Ctx(ctx), &dl) {
-		t.Error("WithContext did not override logger with a disabled logger")
-	}
-}
-
-type logObjectMarshalerImpl struct {
-	name string
-	age  int
-}
-
-func (t logObjectMarshalerImpl) MarshalZerologObject(e *Event) {
-	e.Str("name", "custom_value").Int("age", t.age)
-}
-
-func Test_InterfaceLogObjectMarshaler(t *testing.T) {
-	var buf bytes.Buffer
-	log := New(&buf)
-	ctx := log.WithContext(context.Background())
-
-	log2 := Ctx(ctx)
-
-	withLog := log2.With().Interface("obj", &logObjectMarshalerImpl{
-		name: "foo",
-		age:  29,
-	}).Logger()
-
-	withLog.Info().Msg("test")
-
-	if got, want := cbor.DecodeIfBinaryToString(buf.Bytes()), `{"level":"info","obj":{"name":"custom_value","age":29},"message":"test"}`+"\n"; got != want {
-		t.Errorf("got %q, want %q", got, want)
+	if Ctx(ctx) != &dl {
+		t.Error("WithContext did not overide logger with a disabled logger")
 	}
 }

diode/diode.go

@@ -48,7 +48,7 @@ type Writer struct {
 // used.
 //
 // See code.cloudfoundry.org/go-diodes for more info on diode.
-func NewWriter(w io.Writer, size int, pollInterval time.Duration, f Alerter) Writer {
+func NewWriter(w io.Writer, size int, poolInterval time.Duration, f Alerter) Writer {
 	ctx, cancel := context.WithCancel(context.Background())
 	dw := Writer{
 		w:    w,
@@ -59,9 +59,9 @@ func NewWriter(w io.Writer, size int, pollInterval time.Duration, f Alerter) Wri
 		f = func(int) {}
 	}
 	d := diodes.NewManyToOne(size, diodes.AlertFunc(f))
-	if pollInterval > 0 {
+	if poolInterval > 0 {
 		dw.d = diodes.NewPoller(d,
-			diodes.WithPollingInterval(pollInterval),
+			diodes.WithPollingInterval(poolInterval),
 			diodes.WithPollingContext(ctx))
 	} else {
 		dw.d = diodes.NewWaiter(d,

diode/diode_test.go

@@ -3,10 +3,9 @@ package diode_test
 import (
 	"bytes"
 	"fmt"
-	"io"
+	"io/ioutil"
 	"log"
 	"os"
-	"os/exec"
 	"testing"
 	"time"
 
@@ -31,105 +30,8 @@ func TestNewWriter(t *testing.T) {
 	}
 }
 
-func TestClose(t *testing.T) {
-	buf := bytes.Buffer{}
-	w := diode.NewWriter(&buf, 1000, 0, func(missed int) {})
-	log := zerolog.New(w)
-	log.Print("test")
-	w.Close()
-}
-
-func TestFatal(t *testing.T) {
-	if os.Getenv("TEST_FATAL") == "1" {
-		w := diode.NewWriter(os.Stderr, 1000, 0, func(missed int) {
-			fmt.Printf("Dropped %d messages\n", missed)
-		})
-		defer w.Close()
-		log := zerolog.New(w)
-		log.Fatal().Msg("test")
-		return
-	}
-
-	cmd := exec.Command(os.Args[0], "-test.run=TestFatal")
-	cmd.Env = append(os.Environ(), "TEST_FATAL=1")
-	stderr, err := cmd.StderrPipe()
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = cmd.Start()
-	if err != nil {
-		t.Fatal(err)
-	}
-	slurp, err := io.ReadAll(stderr)
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = cmd.Wait()
-	if err == nil {
-		t.Error("Expected log.Fatal to exit with non-zero status")
-	}
-
-	want := "{\"level\":\"fatal\",\"message\":\"test\"}\n"
-	got := cbor.DecodeIfBinaryToString(slurp)
-	if got != want {
-		t.Errorf("Diode Fatal Test failed. got:%s, want:%s!", got, want)
-	}
-}
-
-type SlowWriter struct{}
-
-func (rw *SlowWriter) Write(p []byte) (n int, err error) {
-	time.Sleep(200 * time.Millisecond)
-	fmt.Print(string(p))
-	return len(p), nil
-}
-
-func TestFatalWithFilteredLevelWriter(t *testing.T) {
-	if os.Getenv("TEST_FATAL_SLOW") == "1" {
-		slowWriter := SlowWriter{}
-		diodeWriter := diode.NewWriter(&slowWriter, 500, 0, func(missed int) {
-			fmt.Printf("Missed %d logs\n", missed)
-		})
-		leveledDiodeWriter := zerolog.LevelWriterAdapter{
-			Writer: &diodeWriter,
-		}
-		filteredDiodeWriter := zerolog.FilteredLevelWriter{
-			Writer: &leveledDiodeWriter,
-			Level:  zerolog.InfoLevel,
-		}
-		logger := zerolog.New(&filteredDiodeWriter)
-		logger.Fatal().Msg("test")
-		return
-	}
-
-	cmd := exec.Command(os.Args[0], "-test.run=TestFatalWithFilteredLevelWriter")
-	cmd.Env = append(os.Environ(), "TEST_FATAL_SLOW=1")
-	stdout, err := cmd.StdoutPipe()
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = cmd.Start()
-	if err != nil {
-		t.Fatal(err)
-	}
-	slurp, err := io.ReadAll(stdout)
-	if err != nil {
-		t.Fatal(err)
-	}
-	err = cmd.Wait()
-	if err == nil {
-		t.Error("Expected log.Fatal to exit with non-zero status")
-	}
-
-	got := cbor.DecodeIfBinaryToString(slurp)
-	want := "{\"level\":\"fatal\",\"message\":\"test\"}\n"
-	if got != want {
-		t.Errorf("Expected output %q, got: %q", want, got)
-	}
-}
-
 func Benchmark(b *testing.B) {
-	log.SetOutput(io.Discard)
+	log.SetOutput(ioutil.Discard)
 	defer log.SetOutput(os.Stderr)
 	benchs := map[string]time.Duration{
 		"Waiter": 0,
@@ -137,7 +39,7 @@ func Benchmark(b *testing.B) {
 	}
 	for name, interval := range benchs {
 		b.Run(name, func(b *testing.B) {
-			w := diode.NewWriter(io.Discard, 100000, interval, nil)
+			w := diode.NewWriter(ioutil.Discard, 100000, interval, nil)
 			log := zerolog.New(w)
 			defer w.Close()
 

diode/internal/diodes/many_to_one.go

@@ -9,14 +9,14 @@ import (
 // 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
-	buffer     []unsafe.Pointer
 	alerter    Alerter
 }
 
 // NewManyToOne creates a new diode (ring buffer). The ManyToOne diode
-// is optimized for many writers (on go-routines B-n) and a single reader
+// 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.
@@ -66,7 +66,7 @@ func (d *ManyToOne) Set(data GenericDataType) {
 }
 
 // TryNext will attempt to read from the next slot of the ring buffer.
-// If there is no data available, it will return (nil, false).
+// 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))
@@ -80,7 +80,7 @@ func (d *ManyToOne) TryNext() (data GenericDataType, ok bool) {
 	}
 
 	// When the seq value is less than the current read index that means a
-	// value was read from idx that was previously written but since has
+	// 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.
 	//

diode/internal/diodes/one_to_one.go

@@ -31,9 +31,9 @@ type bucket struct {
 // 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
-	buffer     []unsafe.Pointer
 	alerter    Alerter
 }
 
@@ -80,7 +80,7 @@ func (d *OneToOne) TryNext() (data GenericDataType, ok bool) {
 	}
 
 	// When the seq value is less than the current read index that means a
-	// value was read from idx that was previously written but since has
+	// 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.
 	//

diode/internal/diodes/poller.go

@@ -24,18 +24,18 @@ 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 func(c *Poller) {
+	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 func(c *Poller) {
+	return PollerConfigOption(func(c *Poller) {
 		c.ctx = ctx
-	}
+	})
 }
 
 // NewPoller returns a new Poller that wraps the given diode.

diode/internal/diodes/waiter.go

@@ -21,9 +21,9 @@ type WaiterConfigOption func(*Waiter)
 // will not change any results for adding data (Set()). Default is
 // context.Background().
 func WithWaiterContext(ctx context.Context) WaiterConfigOption {
-	return func(c *Waiter) {
+	return WaiterConfigOption(func(c *Waiter) {
 		c.ctx = ctx
-	}
+	})
 }
 
 // NewWaiter returns a new Waiter that wraps the given diode.
@@ -39,12 +39,7 @@ func NewWaiter(d Diode, opts ...WaiterConfigOption) *Waiter {
 
 	go func() {
 		<-w.ctx.Done()
-
-		// Mutex is strictly necessary here to avoid a race in Next() (between
-		// w.isDone() and w.c.Wait()) and w.c.Broadcast() here.
-		w.mu.Lock()
 		w.c.Broadcast()
-		w.mu.Unlock()
 	}()
 
 	return w

encoder.go

@@ -13,13 +13,13 @@ type encoder interface {
 	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, precision int) []byte
-	AppendDurations(dst []byte, vals []time.Duration, unit time.Duration, useInt bool, precision int) []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
-	AppendFloat32(dst []byte, val float32, precision int) []byte
-	AppendFloat64(dst []byte, val float64, precision int) []byte
-	AppendFloats32(dst []byte, vals []float32, precision int) []byte
-	AppendFloats64(dst []byte, vals []float64, precision int) []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

encoder_cbor.go

@@ -14,19 +14,9 @@ var (
 	enc = cbor.Encoder{}
 )
 
-func init() {
-	// using closure to reflect the changes at runtime.
-	cbor.JSONMarshalFunc = func(v interface{}) ([]byte, error) {
-		return InterfaceMarshalFunc(v)
-	}
-}
-
 func appendJSON(dst []byte, j []byte) []byte {
 	return cbor.AppendEmbeddedJSON(dst, j)
 }
-func appendCBOR(dst []byte, c []byte) []byte {
-	return cbor.AppendEmbeddedCBOR(dst, c)
-}
 
 // decodeIfBinaryToString - converts a binary formatted log msg to a
 // JSON formatted String Log message.

encoder_json.go

@@ -6,7 +6,6 @@ package zerolog
 // JSON encoded byte stream.
 
 import (
-	"encoding/base64"
 	"github.com/rs/zerolog/internal/json"
 )
 
@@ -16,27 +15,9 @@ var (
 	enc = json.Encoder{}
 )
 
-func init() {
-	// using closure to reflect the changes at runtime.
-	json.JSONMarshalFunc = func(v interface{}) ([]byte, error) {
-		return InterfaceMarshalFunc(v)
-	}
-}
-
 func appendJSON(dst []byte, j []byte) []byte {
 	return append(dst, j...)
 }
-func appendCBOR(dst []byte, cbor []byte) []byte {
-	dst = append(dst, []byte("\"data:application/cbor;base64,")...)
-	l := len(dst)
-	enc := base64.StdEncoding
-	n := enc.EncodedLen(len(cbor))
-	for i := 0; i < n; i++ {
-		dst = append(dst, '.')
-	}
-	enc.Encode(dst[l:], cbor)
-	return append(dst, '"')
-}
 
 func decodeIfBinaryToString(in []byte) string {
 	return string(in)

event.go

@@ -1,11 +1,11 @@
 package zerolog
 
 import (
-	"context"
 	"fmt"
 	"net"
 	"os"
 	"runtime"
+	"strconv"
 	"sync"
 	"time"
 )
@@ -21,14 +21,12 @@ var eventPool = &sync.Pool{
 // Event represents a log event. It is instanced by one of the level method of
 // Logger and finalized by the Msg or Msgf method.
 type Event struct {
-	buf       []byte
-	w         LevelWriter
-	level     Level
-	done      func(msg string)
-	stack     bool            // enable error stack trace
-	ch        []Hook          // hooks from context
-	skipFrame int             // The number of additional frames to skip when printing the caller.
-	ctx       context.Context // Optional Go context for event
+	buf   []byte
+	w     LevelWriter
+	level Level
+	done  func(msg string)
+	stack bool   // enable error stack trace
+	ch    []Hook // hooks from context
 }
 
 func putEvent(e *Event) {
@@ -64,8 +62,6 @@ func newEvent(w LevelWriter, level Level) *Event {
 	e.buf = enc.AppendBeginMarker(e.buf)
 	e.w = w
 	e.level = level
-	e.stack = false
-	e.skipFrame = 0
 	return e
 }
 
@@ -110,20 +106,10 @@ func (e *Event) Msg(msg string) {
 	e.msg(msg)
 }
 
-// Send is equivalent to calling Msg("").
+// Msgf sends the event with formated msg added as the message field if not empty.
 //
-// NOTICE: once this method is called, the *Event should be disposed.
-func (e *Event) Send() {
-	if e == nil {
-		return
-	}
-	e.msg("")
-}
-
-// Msgf sends the event with formatted msg added as the message field if not empty.
-//
-// NOTICE: once this method is called, the *Event should be disposed.
-// Calling Msgf twice can have unexpected result.
+// NOTICE: once this methid is called, the *Event should be disposed.
+// Calling Msg twice can have unexpected result.
 func (e *Event) Msgf(format string, v ...interface{}) {
 	if e == nil {
 		return
@@ -131,16 +117,14 @@ func (e *Event) Msgf(format string, v ...interface{}) {
 	e.msg(fmt.Sprintf(format, v...))
 }
 
-func (e *Event) MsgFunc(createMsg func() string) {
-	if e == nil {
-		return
-	}
-	e.msg(createMsg())
-}
-
 func (e *Event) msg(msg string) {
-	for _, hook := range e.ch {
-		hook.Run(e, e.level, msg)
+	if len(e.ch) > 0 {
+		e.ch[0].Run(e, e.level, msg)
+		if len(e.ch) > 1 {
+			for _, hook := range e.ch[1:] {
+				hook.Run(e, e.level, msg)
+			}
+		}
 	}
 	if msg != "" {
 		e.buf = enc.AppendString(enc.AppendKey(e.buf, MessageFieldName), msg)
@@ -157,14 +141,12 @@ func (e *Event) msg(msg string) {
 	}
 }
 
-// Fields is a helper function to use a map or slice to set fields using type assertion.
-// Only map[string]interface{} and []interface{} are accepted. []interface{} must
-// alternate string keys and arbitrary values, and extraneous ones are ignored.
-func (e *Event) Fields(fields interface{}) *Event {
+// Fields is a helper function to use a map to set fields using type assertion.
+func (e *Event) Fields(fields map[string]interface{}) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = appendFields(e.buf, fields, e.stack)
+	e.buf = appendFields(e.buf, fields)
 	return e
 }
 
@@ -218,32 +200,15 @@ func (e *Event) Object(key string, obj LogObjectMarshaler) *Event {
 		return e
 	}
 	e.buf = enc.AppendKey(e.buf, key)
-	if obj == nil {
-		e.buf = enc.AppendNil(e.buf)
-
-		return e
-	}
-
 	e.appendObject(obj)
 	return e
 }
 
-// Func allows an anonymous func to run only if the event is enabled.
-func (e *Event) Func(f func(e *Event)) *Event {
-	if e != nil && e.Enabled() {
-		f(e)
-	}
-	return e
-}
-
-// EmbedObject marshals an object that implement the LogObjectMarshaler interface.
+// Object marshals an object that implement the LogObjectMarshaler interface.
 func (e *Event) EmbedObject(obj LogObjectMarshaler) *Event {
 	if e == nil {
 		return e
 	}
-	if obj == nil {
-		return e
-	}
 	obj.MarshalZerologObject(e)
 	return e
 }
@@ -266,27 +231,6 @@ func (e *Event) Strs(key string, vals []string) *Event {
 	return e
 }
 
-// Stringer adds the field key with val.String() (or null if val is nil)
-// to the *Event context.
-func (e *Event) Stringer(key string, val fmt.Stringer) *Event {
-	if e == nil {
-		return e
-	}
-	e.buf = enc.AppendStringer(enc.AppendKey(e.buf, key), val)
-	return e
-}
-
-// Stringers adds the field key with vals where each individual val
-// is used as val.String() (or null if val is empty) to the *Event
-// context.
-func (e *Event) Stringers(key string, vals []fmt.Stringer) *Event {
-	if e == nil {
-		return e
-	}
-	e.buf = enc.AppendStringers(enc.AppendKey(e.buf, key), vals)
-	return e
-}
-
 // Bytes adds the field key with val as a string to the *Event context.
 //
 // Runes outside of normal ASCII ranges will be hex-encoded in the resulting
@@ -320,18 +264,6 @@ func (e *Event) RawJSON(key string, b []byte) *Event {
 	return e
 }
 
-// RawCBOR adds already encoded CBOR to the log line under key.
-//
-// No sanity check is performed on b
-// Note: The full featureset of CBOR is supported as data will not be mapped to json but stored as data-url
-func (e *Event) RawCBOR(key string, b []byte) *Event {
-	if e == nil {
-		return e
-	}
-	e.buf = appendCBOR(enc.AppendKey(e.buf, key), b)
-	return e
-}
-
 // AnErr adds the field key with serialized err to the *Event context.
 // If err is nil, no field is added.
 func (e *Event) AnErr(key string, err error) *Event {
@@ -344,11 +276,7 @@ func (e *Event) AnErr(key string, err error) *Event {
 	case LogObjectMarshaler:
 		return e.Object(key, m)
 	case error:
-		if m == nil || isNilValue(m) {
-			return e
-		} else {
-			return e.Str(key, m.Error())
-		}
+		return e.Str(key, m.Error())
 	case string:
 		return e.Str(key, m)
 	default:
@@ -381,6 +309,7 @@ func (e *Event) Errs(key string, errs []error) *Event {
 
 // Err adds the field "error" with serialized err to the *Event context.
 // If err is nil, no field is added.
+// To customize the key name, change zerolog.ErrorFieldName.
 //
 // To customize the key name, change zerolog.ErrorFieldName.
 //
@@ -397,9 +326,7 @@ func (e *Event) Err(err error) *Event {
 		case LogObjectMarshaler:
 			e.Object(ErrorStackFieldName, m)
 		case error:
-			if m != nil && !isNilValue(m) {
-				e.Str(ErrorStackFieldName, m.Error())
-			}
+			e.Str(ErrorStackFieldName, m.Error())
 		case string:
 			e.Str(ErrorStackFieldName, m)
 		default:
@@ -419,28 +346,6 @@ func (e *Event) Stack() *Event {
 	return e
 }
 
-// Ctx adds the Go Context to the *Event context.  The context is not rendered
-// in the output message, but is available to hooks and to Func() calls via the
-// GetCtx() accessor. A typical use case is to extract tracing information from
-// the Go Ctx.
-func (e *Event) Ctx(ctx context.Context) *Event {
-	if e != nil {
-		e.ctx = ctx
-	}
-	return e
-}
-
-// GetCtx retrieves the Go context.Context which is optionally stored in the
-// Event.  This allows Hooks and functions passed to Func() to retrieve values
-// which are stored in the context.Context.  This can be useful in tracing,
-// where span information is commonly propagated in the context.Context.
-func (e *Event) GetCtx() context.Context {
-	if e == nil || e.ctx == nil {
-		return context.Background()
-	}
-	return e.ctx
-}
-
 // Bool adds the field key with val as a bool to the *Event context.
 func (e *Event) Bool(key string, b bool) *Event {
 	if e == nil {
@@ -644,7 +549,7 @@ func (e *Event) Float32(key string, f float32) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = enc.AppendFloat32(enc.AppendKey(e.buf, key), f, FloatingPointPrecision)
+	e.buf = enc.AppendFloat32(enc.AppendKey(e.buf, key), f)
 	return e
 }
 
@@ -653,7 +558,7 @@ func (e *Event) Floats32(key string, f []float32) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = enc.AppendFloats32(enc.AppendKey(e.buf, key), f, FloatingPointPrecision)
+	e.buf = enc.AppendFloats32(enc.AppendKey(e.buf, key), f)
 	return e
 }
 
@@ -662,7 +567,7 @@ func (e *Event) Float64(key string, f float64) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = enc.AppendFloat64(enc.AppendKey(e.buf, key), f, FloatingPointPrecision)
+	e.buf = enc.AppendFloat64(enc.AppendKey(e.buf, key), f)
 	return e
 }
 
@@ -671,7 +576,7 @@ func (e *Event) Floats64(key string, f []float64) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = enc.AppendFloats64(enc.AppendKey(e.buf, key), f, FloatingPointPrecision)
+	e.buf = enc.AppendFloats64(enc.AppendKey(e.buf, key), f)
 	return e
 }
 
@@ -688,7 +593,7 @@ func (e *Event) Timestamp() *Event {
 	return e
 }
 
-// Time adds the field key with t formatted as string using zerolog.TimeFieldFormat.
+// Time adds the field key with t formated as string using zerolog.TimeFieldFormat.
 func (e *Event) Time(key string, t time.Time) *Event {
 	if e == nil {
 		return e
@@ -697,7 +602,7 @@ func (e *Event) Time(key string, t time.Time) *Event {
 	return e
 }
 
-// Times adds the field key with t formatted as string using zerolog.TimeFieldFormat.
+// Times adds the field key with t formated as string using zerolog.TimeFieldFormat.
 func (e *Event) Times(key string, t []time.Time) *Event {
 	if e == nil {
 		return e
@@ -713,7 +618,7 @@ func (e *Event) Dur(key string, d time.Duration) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = enc.AppendDuration(enc.AppendKey(e.buf, key), d, DurationFieldUnit, DurationFieldInteger, FloatingPointPrecision)
+	e.buf = enc.AppendDuration(enc.AppendKey(e.buf, key), d, DurationFieldUnit, DurationFieldInteger)
 	return e
 }
 
@@ -724,7 +629,7 @@ func (e *Event) Durs(key string, d []time.Duration) *Event {
 	if e == nil {
 		return e
 	}
-	e.buf = enc.AppendDurations(enc.AppendKey(e.buf, key), d, DurationFieldUnit, DurationFieldInteger, FloatingPointPrecision)
+	e.buf = enc.AppendDurations(enc.AppendKey(e.buf, key), d, DurationFieldUnit, DurationFieldInteger)
 	return e
 }
 
@@ -739,15 +644,10 @@ func (e *Event) TimeDiff(key string, t time.Time, start time.Time) *Event {
 	if t.After(start) {
 		d = t.Sub(start)
 	}
-	e.buf = enc.AppendDuration(enc.AppendKey(e.buf, key), d, DurationFieldUnit, DurationFieldInteger, FloatingPointPrecision)
+	e.buf = enc.AppendDuration(enc.AppendKey(e.buf, key), d, DurationFieldUnit, DurationFieldInteger)
 	return e
 }
 
-// Any is a wrapper around Event.Interface.
-func (e *Event) Any(key string, i interface{}) *Event {
-	return e.Interface(key, i)
-}
-
 // Interface adds the field key with i marshaled using reflection.
 func (e *Event) Interface(key string, i interface{}) *Event {
 	if e == nil {
@@ -760,45 +660,20 @@ func (e *Event) Interface(key string, i interface{}) *Event {
 	return e
 }
 
-// Type adds the field key with val's type using reflection.
-func (e *Event) Type(key string, val interface{}) *Event {
-	if e == nil {
-		return e
-	}
-	e.buf = enc.AppendType(enc.AppendKey(e.buf, key), val)
-	return e
-}
-
-// CallerSkipFrame instructs any future Caller calls to skip the specified number of frames.
-// This includes those added via hooks from the context.
-func (e *Event) CallerSkipFrame(skip int) *Event {
-	if e == nil {
-		return e
-	}
-	e.skipFrame += skip
-	return e
-}
-
 // Caller adds the file:line of the caller with the zerolog.CallerFieldName key.
-// The argument skip is the number of stack frames to ascend
-// Skip If not passed, use the global variable CallerSkipFrameCount
-func (e *Event) Caller(skip ...int) *Event {
-	sk := CallerSkipFrameCount
-	if len(skip) > 0 {
-		sk = skip[0] + CallerSkipFrameCount
-	}
-	return e.caller(sk)
+func (e *Event) Caller() *Event {
+	return e.caller(CallerSkipFrameCount)
 }
 
 func (e *Event) caller(skip int) *Event {
 	if e == nil {
 		return e
 	}
-	pc, file, line, ok := runtime.Caller(skip + e.skipFrame)
+	_, file, line, ok := runtime.Caller(skip)
 	if !ok {
 		return e
 	}
-	e.buf = enc.AppendString(enc.AppendKey(e.buf, CallerFieldName), CallerMarshalFunc(pc, file, line))
+	e.buf = enc.AppendString(enc.AppendKey(e.buf, CallerFieldName), file+":"+strconv.Itoa(line))
 	return e
 }
 

event_test.go

@@ -1,65 +0,0 @@
-// +build !binary_log
-
-package zerolog
-
-import (
-	"bytes"
-	"errors"
-	"strings"
-	"testing"
-)
-
-type nilError struct{}
-
-func (nilError) Error() string {
-	return ""
-}
-
-func TestEvent_AnErr(t *testing.T) {
-	tests := []struct {
-		name string
-		err  error
-		want string
-	}{
-		{"nil", nil, `{}`},
-		{"error", errors.New("test"), `{"err":"test"}`},
-		{"nil interface", func() *nilError { return nil }(), `{}`},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			var buf bytes.Buffer
-			e := newEvent(LevelWriterAdapter{&buf}, DebugLevel)
-			e.AnErr("err", tt.err)
-			_ = e.write()
-			if got, want := strings.TrimSpace(buf.String()), tt.want; got != want {
-				t.Errorf("Event.AnErr() = %v, want %v", got, want)
-			}
-		})
-	}
-}
-
-func TestEvent_ObjectWithNil(t *testing.T) {
-	var buf bytes.Buffer
-	e := newEvent(LevelWriterAdapter{&buf}, DebugLevel)
-	_ = e.Object("obj", nil)
-	_ = e.write()
-
-	want := `{"obj":null}`
-	got := strings.TrimSpace(buf.String())
-	if got != want {
-		t.Errorf("Event.Object() = %q, want %q", got, want)
-	}
-}
-
-func TestEvent_EmbedObjectWithNil(t *testing.T) {
-	var buf bytes.Buffer
-	e := newEvent(LevelWriterAdapter{&buf}, DebugLevel)
-	_ = e.EmbedObject(nil)
-	_ = e.write()
-
-	want := "{}"
-	got := strings.TrimSpace(buf.String())
-	if got != want {
-		t.Errorf("Event.EmbedObject() = %q, want %q", got, want)
-	}
-}

example.jsonl

@@ -1,7 +0,0 @@
-{"time":"5:41PM","level":"info","message":"Starting listener","listen":":8080","pid":37556}
-{"time":"5:41PM","level":"debug","message":"Access","database":"myapp","host":"localhost:4962","pid":37556}
-{"time":"5:41PM","level":"info","message":"Access","method":"GET","path":"/users","pid":37556,"resp_time":23}
-{"time":"5:41PM","level":"info","message":"Access","method":"POST","path":"/posts","pid":37556,"resp_time":532}
-{"time":"5:41PM","level":"warn","message":"Slow request","method":"POST","path":"/posts","pid":37556,"resp_time":532}
-{"time":"5:41PM","level":"info","message":"Access","method":"GET","path":"/users","pid":37556,"resp_time":10}
-{"time":"5:41PM","level":"error","message":"Database connection lost","database":"myapp","pid":37556,"error":"connection reset by peer"}

fields.go

@@ -1,47 +1,20 @@
 package zerolog
 
 import (
-	"encoding/json"
 	"net"
 	"sort"
 	"time"
-	"unsafe"
 )
 
-func isNilValue(i interface{}) bool {
-	return (*[2]uintptr)(unsafe.Pointer(&i))[1] == 0
-}
-
-func appendFields(dst []byte, fields interface{}, stack bool) []byte {
-	switch fields := fields.(type) {
-	case []interface{}:
-		if n := len(fields); n&0x1 == 1 { // odd number
-			fields = fields[:n-1]
-		}
-		dst = appendFieldList(dst, fields, stack)
-	case map[string]interface{}:
-		keys := make([]string, 0, len(fields))
-		for key := range fields {
-			keys = append(keys, key)
-		}
-		sort.Strings(keys)
-		kv := make([]interface{}, 2)
-		for _, key := range keys {
-			kv[0], kv[1] = key, fields[key]
-			dst = appendFieldList(dst, kv, stack)
-		}
+func appendFields(dst []byte, fields map[string]interface{}) []byte {
+	keys := make([]string, 0, len(fields))
+	for key := range fields {
+		keys = append(keys, key)
 	}
-	return dst
-}
-
-func appendFieldList(dst []byte, kvList []interface{}, stack bool) []byte {
-	for i, n := 0, len(kvList); i < n; i += 2 {
-		key, val := kvList[i], kvList[i+1]
-		if key, ok := key.(string); ok {
-			dst = enc.AppendKey(dst, key)
-		} else {
-			continue
-		}
+	sort.Strings(keys)
+	for _, key := range keys {
+		dst = enc.AppendKey(dst, key)
+		val := fields[key]
 		if val, ok := val.(LogObjectMarshaler); ok {
 			e := newEvent(nil, 0)
 			e.buf = e.buf[:0]
@@ -56,7 +29,8 @@ func appendFieldList(dst []byte, kvList []interface{}, stack bool) []byte {
 		case []byte:
 			dst = enc.AppendBytes(dst, val)
 		case error:
-			switch m := ErrorMarshalFunc(val).(type) {
+			marshaled := ErrorMarshalFunc(val)
+			switch m := marshaled.(type) {
 			case LogObjectMarshaler:
 				e := newEvent(nil, 0)
 				e.buf = e.buf[:0]
@@ -64,35 +38,17 @@ func appendFieldList(dst []byte, kvList []interface{}, stack bool) []byte {
 				dst = append(dst, e.buf...)
 				putEvent(e)
 			case error:
-				if m == nil || isNilValue(m) {
-					dst = enc.AppendNil(dst)
-				} else {
-					dst = enc.AppendString(dst, m.Error())
-				}
+				dst = enc.AppendString(dst, m.Error())
 			case string:
 				dst = enc.AppendString(dst, m)
 			default:
 				dst = enc.AppendInterface(dst, m)
 			}
-
-			if stack && ErrorStackMarshaler != nil {
-				dst = enc.AppendKey(dst, ErrorStackFieldName)
-				switch m := ErrorStackMarshaler(val).(type) {
-				case nil:
-				case error:
-					if m != nil && !isNilValue(m) {
-						dst = enc.AppendString(dst, m.Error())
-					}
-				case string:
-					dst = enc.AppendString(dst, m)
-				default:
-					dst = enc.AppendInterface(dst, m)
-				}
-			}
 		case []error:
 			dst = enc.AppendArrayStart(dst)
 			for i, err := range val {
-				switch m := ErrorMarshalFunc(err).(type) {
+				marshaled := ErrorMarshalFunc(err)
+				switch m := marshaled.(type) {
 				case LogObjectMarshaler:
 					e := newEvent(nil, 0)
 					e.buf = e.buf[:0]
@@ -100,11 +56,7 @@ func appendFieldList(dst []byte, kvList []interface{}, stack bool) []byte {
 					dst = append(dst, e.buf...)
 					putEvent(e)
 				case error:
-					if m == nil || isNilValue(m) {
-						dst = enc.AppendNil(dst)
-					} else {
-						dst = enc.AppendString(dst, m.Error())
-					}
+					dst = enc.AppendString(dst, m.Error())
 				case string:
 					dst = enc.AppendString(dst, m)
 				default:
@@ -139,13 +91,13 @@ func appendFieldList(dst []byte, kvList []interface{}, stack bool) []byte {
 		case uint64:
 			dst = enc.AppendUint64(dst, val)
 		case float32:
-			dst = enc.AppendFloat32(dst, val, FloatingPointPrecision)
+			dst = enc.AppendFloat32(dst, val)
 		case float64:
-			dst = enc.AppendFloat64(dst, val, FloatingPointPrecision)
+			dst = enc.AppendFloat64(dst, val)
 		case time.Time:
 			dst = enc.AppendTime(dst, val, TimeFieldFormat)
 		case time.Duration:
-			dst = enc.AppendDuration(dst, val, DurationFieldUnit, DurationFieldInteger, FloatingPointPrecision)
+			dst = enc.AppendDuration(dst, val, DurationFieldUnit, DurationFieldInteger)
 		case *string:
 			if val != nil {
 				dst = enc.AppendString(dst, *val)
@@ -220,13 +172,13 @@ func appendFieldList(dst []byte, kvList []interface{}, stack bool) []byte {
 			}
 		case *float32:
 			if val != nil {
-				dst = enc.AppendFloat32(dst, *val, FloatingPointPrecision)
+				dst = enc.AppendFloat32(dst, *val)
 			} else {
 				dst = enc.AppendNil(dst)
 			}
 		case *float64:
 			if val != nil {
-				dst = enc.AppendFloat64(dst, *val, FloatingPointPrecision)
+				dst = enc.AppendFloat64(dst, *val)
 			} else {
 				dst = enc.AppendNil(dst)
 			}
@@ -238,7 +190,7 @@ func appendFieldList(dst []byte, kvList []interface{}, stack bool) []byte {
 			}
 		case *time.Duration:
 			if val != nil {
-				dst = enc.AppendDuration(dst, *val, DurationFieldUnit, DurationFieldInteger, FloatingPointPrecision)
+				dst = enc.AppendDuration(dst, *val, DurationFieldUnit, DurationFieldInteger)
 			} else {
 				dst = enc.AppendNil(dst)
 			}
@@ -267,13 +219,13 @@ func appendFieldList(dst []byte, kvList []interface{}, stack bool) []byte {
 		case []uint64:
 			dst = enc.AppendUints64(dst, val)
 		case []float32:
-			dst = enc.AppendFloats32(dst, val, FloatingPointPrecision)
+			dst = enc.AppendFloats32(dst, val)
 		case []float64:
-			dst = enc.AppendFloats64(dst, val, FloatingPointPrecision)
+			dst = enc.AppendFloats64(dst, val)
 		case []time.Time:
 			dst = enc.AppendTimes(dst, val, TimeFieldFormat)
 		case []time.Duration:
-			dst = enc.AppendDurations(dst, val, DurationFieldUnit, DurationFieldInteger, FloatingPointPrecision)
+			dst = enc.AppendDurations(dst, val, DurationFieldUnit, DurationFieldInteger)
 		case nil:
 			dst = enc.AppendNil(dst)
 		case net.IP:
@@ -282,8 +234,6 @@ func appendFieldList(dst []byte, kvList []interface{}, stack bool) []byte {
 			dst = enc.AppendIPPrefix(dst, val)
 		case net.HardwareAddr:
 			dst = enc.AppendMACAddr(dst, val)
-		case json.RawMessage:
-			dst = appendJSON(dst, val)
 		default:
 			dst = enc.AppendInterface(dst, val)
 		}

globals.go

@@ -1,30 +1,7 @@
 package zerolog
 
-import (
-	"bytes"
-	"encoding/json"
-	"strconv"
-	"sync/atomic"
-	"time"
-)
-
-const (
-	// TimeFormatUnix defines a time format that makes time fields to be
-	// serialized as Unix timestamp integers.
-	TimeFormatUnix = ""
-
-	// TimeFormatUnixMs defines a time format that makes time fields to be
-	// serialized as Unix timestamp integers in milliseconds.
-	TimeFormatUnixMs = "UNIXMS"
-
-	// TimeFormatUnixMicro defines a time format that makes time fields to be
-	// serialized as Unix timestamp integers in microseconds.
-	TimeFormatUnixMicro = "UNIXMICRO"
-
-	// TimeFormatUnixNano defines a time format that makes time fields to be
-	// serialized as Unix timestamp integers in nanoseconds.
-	TimeFormatUnixNano = "UNIXNANO"
-)
+import "time"
+import "sync/atomic"
 
 var (
 	// TimestampFieldName is the field name used for the timestamp field.
@@ -33,26 +10,6 @@ var (
 	// LevelFieldName is the field name used for the level field.
 	LevelFieldName = "level"
 
-	// LevelTraceValue is the value used for the trace level field.
-	LevelTraceValue = "trace"
-	// LevelDebugValue is the value used for the debug level field.
-	LevelDebugValue = "debug"
-	// LevelInfoValue is the value used for the info level field.
-	LevelInfoValue = "info"
-	// LevelWarnValue is the value used for the warn level field.
-	LevelWarnValue = "warn"
-	// LevelErrorValue is the value used for the error level field.
-	LevelErrorValue = "error"
-	// LevelFatalValue is the value used for the fatal level field.
-	LevelFatalValue = "fatal"
-	// LevelPanicValue is the value used for the panic level field.
-	LevelPanicValue = "panic"
-
-	// LevelFieldMarshalFunc allows customization of global level field marshaling.
-	LevelFieldMarshalFunc = func(l Level) string {
-		return l.String()
-	}
-
 	// MessageFieldName is the field name used for the message field.
 	MessageFieldName = "message"
 
@@ -65,11 +22,6 @@ var (
 	// CallerSkipFrameCount is the number of stack frames to skip to find the caller.
 	CallerSkipFrameCount = 2
 
-	// CallerMarshalFunc allows customization of global caller marshaling
-	CallerMarshalFunc = func(pc uintptr, file string, line int) string {
-		return file + ":" + strconv.Itoa(line)
-	}
-
 	// ErrorStackFieldName is the field name used for error stacks.
 	ErrorStackFieldName = "stack"
 
@@ -81,27 +33,9 @@ var (
 		return err
 	}
 
-	// InterfaceMarshalFunc allows customization of interface marshaling.
-	// Default: "encoding/json.Marshal" with disabled HTML escaping
-	InterfaceMarshalFunc = func(v interface{}) ([]byte, error) {
-		var buf bytes.Buffer
-		encoder := json.NewEncoder(&buf)
-		encoder.SetEscapeHTML(false)
-		err := encoder.Encode(v)
-		if err != nil {
-			return nil, err
-		}
-		b := buf.Bytes()
-		if len(b) > 0 {
-			// Remove trailing \n which is added by Encode.
-			return b[:len(b)-1], nil
-		}
-		return b, nil
-	}
-
-	// TimeFieldFormat defines the time format of the Time field type. If set to
-	// TimeFormatUnix, TimeFormatUnixMs, TimeFormatUnixMicro or TimeFormatUnixNano, the time is formatted as a UNIX
-	// timestamp as integer.
+	// TimeFieldFormat defines the time format of the Time field type.
+	// If set to an empty string, the time is formatted as an UNIX timestamp
+	// as integer.
 	TimeFieldFormat = time.RFC3339
 
 	// TimestampFunc defines the function called to generate a timestamp.
@@ -119,48 +53,11 @@ var (
 	// output. If not set, an error is printed on the stderr. This handler must
 	// be thread safe and non-blocking.
 	ErrorHandler func(err error)
-
-	// DefaultContextLogger is returned from Ctx() if there is no logger associated
-	// with the context.
-	DefaultContextLogger *Logger
-
-	// LevelColors are used by ConsoleWriter's consoleDefaultFormatLevel to color
-	// log levels.
-	LevelColors = map[Level]int{
-		TraceLevel: colorBlue,
-		DebugLevel: 0,
-		InfoLevel:  colorGreen,
-		WarnLevel:  colorYellow,
-		ErrorLevel: colorRed,
-		FatalLevel: colorRed,
-		PanicLevel: colorRed,
-	}
-
-	// FormattedLevels are used by ConsoleWriter's consoleDefaultFormatLevel
-	// for a short level name.
-	FormattedLevels = map[Level]string{
-		TraceLevel: "TRC",
-		DebugLevel: "DBG",
-		InfoLevel:  "INF",
-		WarnLevel:  "WRN",
-		ErrorLevel: "ERR",
-		FatalLevel: "FTL",
-		PanicLevel: "PNC",
-	}
-
-	// TriggerLevelWriterBufferReuseLimit is a limit in bytes that a buffer is dropped
-	// from the TriggerLevelWriter buffer pool if the buffer grows above the limit.
-	TriggerLevelWriterBufferReuseLimit = 64 * 1024
-
-	// FloatingPointPrecision, if set to a value other than -1, controls the number
-	// of digits when formatting float numbers in JSON. See strconv.FormatFloat for
-	// more details.
-	FloatingPointPrecision = -1
 )
 
 var (
-	gLevel          = new(int32)
-	disableSampling = new(int32)
+	gLevel          = new(uint32)
+	disableSampling = new(uint32)
 )
 
 // SetGlobalLevel sets the global override for log level. If this
@@ -168,23 +65,23 @@ var (
 //
 // To globally disable logs, set GlobalLevel to Disabled.
 func SetGlobalLevel(l Level) {
-	atomic.StoreInt32(gLevel, int32(l))
+	atomic.StoreUint32(gLevel, uint32(l))
 }
 
 // GlobalLevel returns the current global log level
 func GlobalLevel() Level {
-	return Level(atomic.LoadInt32(gLevel))
+	return Level(atomic.LoadUint32(gLevel))
 }
 
 // DisableSampling will disable sampling in all Loggers if true.
 func DisableSampling(v bool) {
-	var i int32
+	var i uint32
 	if v {
 		i = 1
 	}
-	atomic.StoreInt32(disableSampling, i)
+	atomic.StoreUint32(disableSampling, i)
 }
 
 func samplingDisabled() bool {
-	return atomic.LoadInt32(disableSampling) == 1
+	return atomic.LoadUint32(disableSampling) == 1
 }

go.mod

@@ -1,12 +1 @@
 module github.com/rs/zerolog
-
-go 1.15
-
-require (
-	github.com/coreos/go-systemd/v22 v22.5.0
-	github.com/mattn/go-colorable v0.1.13
-	github.com/mattn/go-isatty v0.0.19 // indirect
-	github.com/pkg/errors v0.9.1
-	github.com/rs/xid v1.6.0
-	golang.org/x/sys v0.12.0 // indirect
-)

go.sum

@@ -1,16 +0,0 @@
-github.com/coreos/go-systemd/v22 v22.5.0 h1:RrqgGjYQKalulkV8NGVIfkXQf6YYmOyiJKk8iXXhfZs=
-github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
-github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
-github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
-github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
-github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
-github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU=
-github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
-golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.12.0 h1:CM0HF96J0hcLAwsHPJZjfdNzs0gftsLfgKt57wWHJ0o=
-golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

go112.go

@@ -1,7 +0,0 @@
-// +build go1.12
-
-package zerolog
-
-// Since go 1.12, some auto generated init functions are hidden from
-// runtime.Caller.
-const contextCallerSkipFrameCount = 2

hlog/hlog.go

@@ -5,13 +5,12 @@ import (
 	"context"
 	"net"
 	"net/http"
-	"strings"
 	"time"
 
 	"github.com/rs/xid"
 	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/hlog/internal/mutil"
 	"github.com/rs/zerolog/log"
+	"github.com/zenazn/goji/web/mutil"
 )
 
 // FromRequest gets the logger in the request's context.
@@ -80,39 +79,10 @@ func RequestHandler(fieldKey string) func(next http.Handler) http.Handler {
 func RemoteAddrHandler(fieldKey string) func(next http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			if r.RemoteAddr != "" {
+			if host, _, err := net.SplitHostPort(r.RemoteAddr); err == nil {
 				log := zerolog.Ctx(r.Context())
 				log.UpdateContext(func(c zerolog.Context) zerolog.Context {
-					return c.Str(fieldKey, r.RemoteAddr)
-				})
-			}
-			next.ServeHTTP(w, r)
-		})
-	}
-}
-
-func getHost(hostPort string) string {
-	if hostPort == "" {
-		return ""
-	}
-
-	host, _, err := net.SplitHostPort(hostPort)
-	if err != nil {
-		return hostPort
-	}
-	return host
-}
-
-// RemoteIPHandler is similar to RemoteAddrHandler, but logs only
-// an IP, not a port.
-func RemoteIPHandler(fieldKey string) func(next http.Handler) http.Handler {
-	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			ip := getHost(r.RemoteAddr)
-			if ip != "" {
-				log := zerolog.Ctx(r.Context())
-				log.UpdateContext(func(c zerolog.Context) zerolog.Context {
-					return c.Str(fieldKey, ip)
+					return c.Str(fieldKey, host)
 				})
 			}
 			next.ServeHTTP(w, r)
@@ -152,35 +122,6 @@ func RefererHandler(fieldKey string) func(next http.Handler) http.Handler {
 	}
 }
 
-// ProtoHandler adds the requests protocol version as a field to the context logger
-// using fieldKey as field Key.
-func ProtoHandler(fieldKey string) func(next http.Handler) http.Handler {
-	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			log := zerolog.Ctx(r.Context())
-			log.UpdateContext(func(c zerolog.Context) zerolog.Context {
-				return c.Str(fieldKey, r.Proto)
-			})
-			next.ServeHTTP(w, r)
-		})
-	}
-}
-
-// HTTPVersionHandler is similar to ProtoHandler, but it does not store the "HTTP/"
-// prefix in the protocol name.
-func HTTPVersionHandler(fieldKey string) func(next http.Handler) http.Handler {
-	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			proto := strings.TrimPrefix(r.Proto, "HTTP/")
-			log := zerolog.Ctx(r.Context())
-			log.UpdateContext(func(c zerolog.Context) zerolog.Context {
-				return c.Str(fieldKey, proto)
-			})
-			next.ServeHTTP(w, r)
-		})
-	}
-}
-
 type idKey struct{}
 
 // IDFromRequest returns the unique id associated to the request if any.
@@ -197,11 +138,6 @@ func IDFromCtx(ctx context.Context) (id xid.ID, ok bool) {
 	return
 }
 
-// CtxWithID adds the given xid.ID to the context
-func CtxWithID(ctx context.Context, id xid.ID) context.Context {
-	return context.WithValue(ctx, idKey{}, id)
-}
-
 // RequestIDHandler returns a handler setting a unique id to the request which can
 // be gathered using IDFromRequest(req). This generated id is added as a field to the
 // logger using the passed fieldKey as field name. The id is also added as a response
@@ -218,7 +154,7 @@ func RequestIDHandler(fieldKey, headerName string) func(next http.Handler) http.
 			id, ok := IDFromRequest(r)
 			if !ok {
 				id = xid.New()
-				ctx = CtxWithID(ctx, id)
+				ctx = context.WithValue(ctx, idKey{}, id)
 				r = r.WithContext(ctx)
 			}
 			if fieldKey != "" {
@@ -235,92 +171,14 @@ func RequestIDHandler(fieldKey, headerName string) func(next http.Handler) http.
 	}
 }
 
-// CustomHeaderHandler adds given header from request's header as a field to
-// the context's logger using fieldKey as field key.
-func CustomHeaderHandler(fieldKey, header string) func(next http.Handler) http.Handler {
-	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			if val := r.Header.Get(header); val != "" {
-				log := zerolog.Ctx(r.Context())
-				log.UpdateContext(func(c zerolog.Context) zerolog.Context {
-					return c.Str(fieldKey, val)
-				})
-			}
-			next.ServeHTTP(w, r)
-		})
-	}
-}
-
-// EtagHandler adds Etag header from response's header as a field to
-// the context's logger using fieldKey as field key.
-func EtagHandler(fieldKey string) func(next http.Handler) http.Handler {
-	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			defer func() {
-				etag := w.Header().Get("Etag")
-				if etag != "" {
-					etag = strings.ReplaceAll(etag, `"`, "")
-					log := zerolog.Ctx(r.Context())
-					log.UpdateContext(func(c zerolog.Context) zerolog.Context {
-						return c.Str(fieldKey, etag)
-					})
-				}
-			}()
-			next.ServeHTTP(w, r)
-		})
-	}
-}
-
-func ResponseHeaderHandler(fieldKey, headerName string) func(next http.Handler) http.Handler {
-	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			defer func() {
-				value := w.Header().Get(headerName)
-				if value != "" {
-					log := zerolog.Ctx(r.Context())
-					log.UpdateContext(func(c zerolog.Context) zerolog.Context {
-						return c.Str(fieldKey, value)
-					})
-				}
-			}()
-			next.ServeHTTP(w, r)
-		})
-	}
-}
-
 // AccessHandler returns a handler that call f after each request.
 func AccessHandler(f func(r *http.Request, status, size int, duration time.Duration)) func(next http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			start := time.Now()
 			lw := mutil.WrapWriter(w)
-			defer func() {
-				f(r, lw.Status(), lw.BytesWritten(), time.Since(start))
-			}()
 			next.ServeHTTP(lw, r)
-		})
-	}
-}
-
-// HostHandler adds the request's host as a field to the context's logger
-// using fieldKey as field key. If trimPort is set to true, then port is
-// removed from the host.
-func HostHandler(fieldKey string, trimPort ...bool) func(next http.Handler) http.Handler {
-	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			var host string
-			if len(trimPort) > 0 && trimPort[0] {
-				host = getHost(r.Host)
-			} else {
-				host = r.Host
-			}
-			if host != "" {
-				log := zerolog.Ctx(r.Context())
-				log.UpdateContext(func(c zerolog.Context) zerolog.Context {
-					return c.Str(fieldKey, host)
-				})
-			}
-			next.ServeHTTP(w, r)
+			f(r, lw.Status(), lw.BytesWritten(), time.Since(start))
 		})
 	}
 }

hlog/hlog_example_test.go

@@ -48,8 +48,8 @@ func Example_handler() {
 	// Install the logger handler with default output on the console
 	c = c.Append(hlog.NewHandler(log))
 
-	// Install some provided extra handlers to set some request's context fields.
-	// Thanks to those handlers, all our logs will come with some pre-populated fields.
+	// Install some provided extra handler to set some request's context fields.
+	// Thanks to those handler, all our logs will come with some pre-populated fields.
 	c = c.Append(hlog.RemoteAddrHandler("ip"))
 	c = c.Append(hlog.UserAgentHandler("user_agent"))
 	c = c.Append(hlog.RefererHandler("referer"))
@@ -63,11 +63,11 @@ func Example_handler() {
 		hlog.FromRequest(r).Info().
 			Str("user", "current user").
 			Str("status", "ok").
-			Msg("Something happened")
+			Msg("Something happend")
 	}))
 	http.Handle("/", h)
 
 	h.ServeHTTP(httptest.NewRecorder(), &http.Request{})
 
-	// Output: {"level":"info","role":"my-service","host":"local-hostname","user":"current user","status":"ok","time":"2001-02-03T04:05:06Z","message":"Something happened"}
+	// Output: {"level":"info","role":"my-service","host":"local-hostname","user":"current user","status":"ok","time":"2001-02-03T04:05:06Z","message":"Something happend"}
 }

hlog/hlog_test.go

@@ -1,20 +1,19 @@
-//go:build go1.7
 // +build go1.7
 
 package hlog
 
 import (
 	"bytes"
-	"context"
 	"fmt"
-	"io"
+	"io/ioutil"
 	"net/http"
-	"net/http/httptest"
 	"net/url"
-	"reflect"
 	"testing"
 
-	"github.com/rs/xid"
+	"reflect"
+
+	"net/http/httptest"
+
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/internal/cbor"
 )
@@ -101,7 +100,7 @@ func TestRemoteAddrHandler(t *testing.T) {
 	}))
 	h = NewHandler(zerolog.New(out))(h)
 	h.ServeHTTP(nil, r)
-	if want, got := `{"ip":"1.2.3.4:1234"}`+"\n", decodeIfBinary(out); want != got {
+	if want, got := `{"ip":"1.2.3.4"}`+"\n", decodeIfBinary(out); want != got {
 		t.Errorf("Invalid log output, got: %s, want: %s", got, want)
 	}
 }
@@ -117,38 +116,6 @@ func TestRemoteAddrHandlerIPv6(t *testing.T) {
 	}))
 	h = NewHandler(zerolog.New(out))(h)
 	h.ServeHTTP(nil, r)
-	if want, got := `{"ip":"[2001:db8:a0b:12f0::1]:1234"}`+"\n", decodeIfBinary(out); want != got {
-		t.Errorf("Invalid log output, got: %s, want: %s", got, want)
-	}
-}
-
-func TestRemoteIPHandler(t *testing.T) {
-	out := &bytes.Buffer{}
-	r := &http.Request{
-		RemoteAddr: "1.2.3.4:1234",
-	}
-	h := RemoteIPHandler("ip")(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		l := FromRequest(r)
-		l.Log().Msg("")
-	}))
-	h = NewHandler(zerolog.New(out))(h)
-	h.ServeHTTP(nil, r)
-	if want, got := `{"ip":"1.2.3.4"}`+"\n", decodeIfBinary(out); want != got {
-		t.Errorf("Invalid log output, got: %s, want: %s", got, want)
-	}
-}
-
-func TestRemoteIPHandlerIPv6(t *testing.T) {
-	out := &bytes.Buffer{}
-	r := &http.Request{
-		RemoteAddr: "[2001:db8:a0b:12f0::1]:1234",
-	}
-	h := RemoteIPHandler("ip")(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		l := FromRequest(r)
-		l.Log().Msg("")
-	}))
-	h = NewHandler(zerolog.New(out))(h)
-	h.ServeHTTP(nil, r)
 	if want, got := `{"ip":"2001:db8:a0b:12f0::1"}`+"\n", decodeIfBinary(out); want != got {
 		t.Errorf("Invalid log output, got: %s, want: %s", got, want)
 	}
@@ -215,96 +182,6 @@ func TestRequestIDHandler(t *testing.T) {
 	h.ServeHTTP(httptest.NewRecorder(), r)
 }
 
-func TestCustomHeaderHandler(t *testing.T) {
-	out := &bytes.Buffer{}
-	r := &http.Request{
-		Header: http.Header{
-			"X-Request-Id": []string{"514bbe5bb5251c92bd07a9846f4a1ab6"},
-		},
-	}
-	h := CustomHeaderHandler("reqID", "X-Request-Id")(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		l := FromRequest(r)
-		l.Log().Msg("")
-	}))
-	h = NewHandler(zerolog.New(out))(h)
-	h.ServeHTTP(nil, r)
-	if want, got := `{"reqID":"514bbe5bb5251c92bd07a9846f4a1ab6"}`+"\n", decodeIfBinary(out); want != got {
-		t.Errorf("Invalid log output, got: %s, want: %s", got, want)
-	}
-}
-
-func TestEtagHandler(t *testing.T) {
-	out := &bytes.Buffer{}
-	w := httptest.NewRecorder()
-	r := &http.Request{}
-	h := EtagHandler("etag")(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Etag", `"abcdef"`)
-		w.WriteHeader(http.StatusOK)
-	}))
-	h2 := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		h.ServeHTTP(w, r)
-		l := FromRequest(r)
-		l.Log().Msg("")
-	})
-	h3 := NewHandler(zerolog.New(out))(h2)
-	h3.ServeHTTP(w, r)
-	if want, got := `{"etag":"abcdef"}`+"\n", decodeIfBinary(out); want != got {
-		t.Errorf("Invalid log output, got: %s, want: %s", got, want)
-	}
-}
-
-func TestResponseHeaderHandler(t *testing.T) {
-	out := &bytes.Buffer{}
-	w := httptest.NewRecorder()
-	r := &http.Request{}
-	h := ResponseHeaderHandler("encoding", "Content-Encoding")(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Encoding", `gzip`)
-		w.WriteHeader(http.StatusOK)
-	}))
-	h2 := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		h.ServeHTTP(w, r)
-		l := FromRequest(r)
-		l.Log().Msg("")
-	})
-	h3 := NewHandler(zerolog.New(out))(h2)
-	h3.ServeHTTP(w, r)
-	if want, got := `{"encoding":"gzip"}`+"\n", decodeIfBinary(out); want != got {
-		t.Errorf("Invalid log output, got: %s, want: %s", got, want)
-	}
-}
-
-func TestProtoHandler(t *testing.T) {
-	out := &bytes.Buffer{}
-	r := &http.Request{
-		Proto: "test",
-	}
-	h := ProtoHandler("proto")(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		l := FromRequest(r)
-		l.Log().Msg("")
-	}))
-	h = NewHandler(zerolog.New(out))(h)
-	h.ServeHTTP(nil, r)
-	if want, got := `{"proto":"test"}`+"\n", decodeIfBinary(out); want != got {
-		t.Errorf("Invalid log output, got: %s, want: %s", got, want)
-	}
-}
-
-func TestHTTPVersionHandler(t *testing.T) {
-	out := &bytes.Buffer{}
-	r := &http.Request{
-		Proto: "HTTP/1.1",
-	}
-	h := HTTPVersionHandler("proto")(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		l := FromRequest(r)
-		l.Log().Msg("")
-	}))
-	h = NewHandler(zerolog.New(out))(h)
-	h.ServeHTTP(nil, r)
-	if want, got := `{"proto":"1.1"}`+"\n", decodeIfBinary(out); want != got {
-		t.Errorf("Invalid log output, got: %s, want: %s", got, want)
-	}
-}
-
 func TestCombinedHandlers(t *testing.T) {
 	out := &bytes.Buffer{}
 	r := &http.Request{
@@ -333,10 +210,10 @@ func BenchmarkHandlers(b *testing.B) {
 	}))
 	h2 := MethodHandler("method")(RequestHandler("request")(h1))
 	handlers := map[string]http.Handler{
-		"Single":           NewHandler(zerolog.New(io.Discard))(h1),
-		"Combined":         NewHandler(zerolog.New(io.Discard))(h2),
-		"SingleDisabled":   NewHandler(zerolog.New(io.Discard).Level(zerolog.Disabled))(h1),
-		"CombinedDisabled": NewHandler(zerolog.New(io.Discard).Level(zerolog.Disabled))(h2),
+		"Single":           NewHandler(zerolog.New(ioutil.Discard))(h1),
+		"Combined":         NewHandler(zerolog.New(ioutil.Discard))(h2),
+		"SingleDisabled":   NewHandler(zerolog.New(ioutil.Discard).Level(zerolog.Disabled))(h1),
+		"CombinedDisabled": NewHandler(zerolog.New(ioutil.Discard).Level(zerolog.Disabled))(h2),
 	}
 	for name := range handlers {
 		h := handlers[name]
@@ -367,69 +244,3 @@ func BenchmarkDataRace(b *testing.B) {
 		}
 	})
 }
-
-func TestCtxWithID(t *testing.T) {
-	ctx := context.Background()
-
-	id, _ := xid.FromString(`c0umremcie6smuu506pg`)
-
-	want := context.Background()
-	want = context.WithValue(want, idKey{}, id)
-
-	if got := CtxWithID(ctx, id); !reflect.DeepEqual(got, want) {
-		t.Errorf("CtxWithID() = %v, want %v", got, want)
-	}
-}
-
-func TestHostHandler(t *testing.T) {
-	out := &bytes.Buffer{}
-	r := &http.Request{Host: "example.com:8080"}
-	h := HostHandler("host")(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		l := FromRequest(r)
-		l.Log().Msg("")
-	}))
-	h = NewHandler(zerolog.New(out))(h)
-	h.ServeHTTP(nil, r)
-	if want, got := `{"host":"example.com:8080"}`+"\n", decodeIfBinary(out); want != got {
-		t.Errorf("Invalid log output, got: %s, want: %s", got, want)
-	}
-}
-
-func TestHostHandlerWithoutPort(t *testing.T) {
-	out := &bytes.Buffer{}
-	r := &http.Request{Host: "example.com:8080"}
-	h := HostHandler("host", true)(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		l := FromRequest(r)
-		l.Log().Msg("")
-	}))
-	h = NewHandler(zerolog.New(out))(h)
-	h.ServeHTTP(nil, r)
-	if want, got := `{"host":"example.com"}`+"\n", decodeIfBinary(out); want != got {
-		t.Errorf("Invalid log output, got: %s, want: %s", got, want)
-	}
-}
-
-func TestGetHost(t *testing.T) {
-	tests := []struct {
-		input    string
-		expected string
-	}{
-		{"", ""},
-		{"example.com:8080", "example.com"},
-		{"example.com", "example.com"},
-		{"invalid", "invalid"},
-		{"192.168.0.1:8080", "192.168.0.1"},
-		{"[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:8080", "2001:0db8:85a3:0000:0000:8a2e:0370:7334"},
-		{"こんにちは.com:8080", "こんにちは.com"},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.input, func(t *testing.T) {
-			result := getHost(tt.input)
-			if tt.expected != result {
-				t.Errorf("Invalid log output, got: %s, want: %s", result, tt.expected)
-			}
-		})
-	}
-}

hlog/internal/mutil/LICENSE

@@ -1,20 +0,0 @@
-Copyright (c) 2014, 2015, 2016 Carl Jackson (carl@avtok.com)
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

hlog/internal/mutil/mutil.go

@@ -1,6 +0,0 @@
-// Package mutil contains various functions that are helpful when writing http
-// middleware.
-//
-// It has been vendored from Goji v1.0, with the exception of the code for Go 1.8:
-// https://github.com/zenazn/goji/
-package mutil

hlog/internal/mutil/writer_proxy.go

@@ -1,154 +0,0 @@
-package mutil
-
-import (
-	"bufio"
-	"io"
-	"net"
-	"net/http"
-)
-
-// WriterProxy is a proxy around an http.ResponseWriter that allows you to hook
-// into various parts of the response process.
-type WriterProxy interface {
-	http.ResponseWriter
-	// Status returns the HTTP status of the request, or 0 if one has not
-	// yet been sent.
-	Status() int
-	// BytesWritten returns the total number of bytes sent to the client.
-	BytesWritten() int
-	// Tee causes the response body to be written to the given io.Writer in
-	// addition to proxying the writes through. Only one io.Writer can be
-	// tee'd to at once: setting a second one will overwrite the first.
-	// Writes will be sent to the proxy before being written to this
-	// io.Writer. It is illegal for the tee'd writer to be modified
-	// concurrently with writes.
-	Tee(io.Writer)
-	// Unwrap returns the original proxied target.
-	Unwrap() http.ResponseWriter
-}
-
-// WrapWriter wraps an http.ResponseWriter, returning a proxy that allows you to
-// hook into various parts of the response process.
-func WrapWriter(w http.ResponseWriter) WriterProxy {
-	_, cn := w.(http.CloseNotifier)
-	_, fl := w.(http.Flusher)
-	_, hj := w.(http.Hijacker)
-	_, rf := w.(io.ReaderFrom)
-
-	bw := basicWriter{ResponseWriter: w}
-	if cn && fl && hj && rf {
-		return &fancyWriter{bw}
-	}
-	if fl {
-		return &flushWriter{bw}
-	}
-	return &bw
-}
-
-// basicWriter wraps a http.ResponseWriter that implements the minimal
-// http.ResponseWriter interface.
-type basicWriter struct {
-	http.ResponseWriter
-	wroteHeader bool
-	code        int
-	bytes       int
-	tee         io.Writer
-}
-
-func (b *basicWriter) WriteHeader(code int) {
-	if !b.wroteHeader {
-		b.code = code
-		b.wroteHeader = true
-		b.ResponseWriter.WriteHeader(code)
-	}
-}
-
-func (b *basicWriter) Write(buf []byte) (int, error) {
-	b.WriteHeader(http.StatusOK)
-	n, err := b.ResponseWriter.Write(buf)
-	if b.tee != nil {
-		_, err2 := b.tee.Write(buf[:n])
-		// Prefer errors generated by the proxied writer.
-		if err == nil {
-			err = err2
-		}
-	}
-	b.bytes += n
-	return n, err
-}
-
-func (b *basicWriter) maybeWriteHeader() {
-	if !b.wroteHeader {
-		b.WriteHeader(http.StatusOK)
-	}
-}
-
-func (b *basicWriter) Status() int {
-	return b.code
-}
-
-func (b *basicWriter) BytesWritten() int {
-	return b.bytes
-}
-
-func (b *basicWriter) Tee(w io.Writer) {
-	b.tee = w
-}
-
-func (b *basicWriter) Unwrap() http.ResponseWriter {
-	return b.ResponseWriter
-}
-
-// fancyWriter is a writer that additionally satisfies http.CloseNotifier,
-// http.Flusher, http.Hijacker, and io.ReaderFrom. It exists for the common case
-// of wrapping the http.ResponseWriter that package http gives you, in order to
-// make the proxied object support the full method set of the proxied object.
-type fancyWriter struct {
-	basicWriter
-}
-
-func (f *fancyWriter) CloseNotify() <-chan bool {
-	cn := f.basicWriter.ResponseWriter.(http.CloseNotifier)
-	return cn.CloseNotify()
-}
-
-func (f *fancyWriter) Flush() {
-	fl := f.basicWriter.ResponseWriter.(http.Flusher)
-	fl.Flush()
-}
-
-func (f *fancyWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
-	hj := f.basicWriter.ResponseWriter.(http.Hijacker)
-	return hj.Hijack()
-}
-
-func (f *fancyWriter) ReadFrom(r io.Reader) (int64, error) {
-	if f.basicWriter.tee != nil {
-		n, err := io.Copy(&f.basicWriter, r)
-		f.bytes += int(n)
-		return n, err
-	}
-	rf := f.basicWriter.ResponseWriter.(io.ReaderFrom)
-	f.basicWriter.maybeWriteHeader()
-
-	n, err := rf.ReadFrom(r)
-	f.bytes += int(n)
-	return n, err
-}
-
-type flushWriter struct {
-	basicWriter
-}
-
-func (f *flushWriter) Flush() {
-	fl := f.basicWriter.ResponseWriter.(http.Flusher)
-	fl.Flush()
-}
-
-var (
-	_ http.CloseNotifier = &fancyWriter{}
-	_ http.Flusher       = &fancyWriter{}
-	_ http.Hijacker      = &fancyWriter{}
-	_ io.ReaderFrom      = &fancyWriter{}
-	_ http.Flusher       = &flushWriter{}
-)

hook.go

@@ -17,16 +17,12 @@ func (h HookFunc) Run(e *Event, level Level, message string) {
 
 // LevelHook applies a different hook for each level.
 type LevelHook struct {
-	NoLevelHook, TraceHook, DebugHook, InfoHook, WarnHook, ErrorHook, FatalHook, PanicHook Hook
+	NoLevelHook, DebugHook, InfoHook, WarnHook, ErrorHook, FatalHook, PanicHook Hook
 }
 
 // Run implements the Hook interface.
 func (h LevelHook) Run(e *Event, level Level, message string) {
 	switch level {
-	case TraceLevel:
-		if h.TraceHook != nil {
-			h.TraceHook.Run(e, level, message)
-		}
 	case DebugLevel:
 		if h.DebugHook != nil {
 			h.DebugHook.Run(e, level, message)

hook_test.go

@@ -2,15 +2,10 @@ package zerolog
 
 import (
 	"bytes"
-	"context"
-	"io"
+	"io/ioutil"
 	"testing"
 )
 
-type contextKeyType int
-
-var contextKey contextKeyType
-
 var (
 	levelNameHook = HookFunc(func(e *Event, level Level, msg string) {
 		levelName := level.String()
@@ -36,12 +31,6 @@ var (
 	discardHook = HookFunc(func(e *Event, level Level, message string) {
 		e.Discard()
 	})
-	contextHook = HookFunc(func(e *Event, level Level, message string) {
-		contextData, ok := e.GetCtx().Value(contextKey).(string)
-		if ok {
-			e.Str("context-data", contextData)
-		}
-	})
 )
 
 func TestHook(t *testing.T) {
@@ -131,29 +120,6 @@ func TestHook(t *testing.T) {
 			log = log.Hook(discardHook)
 			log.Log().Msg("test message")
 		}},
-		{"Context/Background", `{"level":"info","message":"test message"}` + "\n", func(log Logger) {
-			log = log.Hook(contextHook)
-			log.Info().Ctx(context.Background()).Msg("test message")
-		}},
-		{"Context/nil", `{"level":"info","message":"test message"}` + "\n", func(log Logger) {
-			// passing `nil` where a context is wanted is against
-			// the rules, but people still do it.
-			log = log.Hook(contextHook)
-			log.Info().Ctx(nil).Msg("test message") // nolint
-		}},
-		{"Context/valid", `{"level":"info","context-data":"12345abcdef","message":"test message"}` + "\n", func(log Logger) {
-			ctx := context.Background()
-			ctx = context.WithValue(ctx, contextKey, "12345abcdef")
-			log = log.Hook(contextHook)
-			log.Info().Ctx(ctx).Msg("test message")
-		}},
-		{"Context/With/valid", `{"level":"info","context-data":"12345abcdef","message":"test message"}` + "\n", func(log Logger) {
-			ctx := context.Background()
-			ctx = context.WithValue(ctx, contextKey, "12345abcdef")
-			log = log.Hook(contextHook)
-			log = log.With().Ctx(ctx).Logger()
-			log.Info().Msg("test message")
-		}},
 		{"None", `{"level":"error"}` + "\n", func(log Logger) {
 			log.Error().Msg("")
 		}},
@@ -172,7 +138,7 @@ func TestHook(t *testing.T) {
 }
 
 func BenchmarkHooks(b *testing.B) {
-	logger := New(io.Discard)
+	logger := New(ioutil.Discard)
 	b.ResetTimer()
 	b.Run("Nop/Single", func(b *testing.B) {
 		log := logger.Hook(nopHook)

internal/cbor/base.go

@@ -1,13 +1,5 @@
 package cbor
 
-// JSONMarshalFunc is used to marshal interface to JSON encoded byte slice.
-// Making it package level instead of embedded in Encoder brings
-// some extra efforts at importing, but avoids value copy when the functions
-// of Encoder being invoked.
-// DO REMEMBER to set this variable at importing, or
-// you might get a nil pointer dereference panic at runtime.
-var JSONMarshalFunc func(v interface{}) ([]byte, error)
-
 type Encoder struct{}
 
 // AppendKey adds a key (string) to the binary encoded log message
@@ -16,4 +8,4 @@ func (e Encoder) AppendKey(dst []byte, key string) []byte {
 		dst = e.AppendBeginMarker(dst)
 	}
 	return e.AppendString(dst, key)
-}
+}

internal/cbor/cbor.go

@@ -26,8 +26,7 @@ const (
 	additionalTypeBreak   byte = 31
 
 	// Tag Sub-types.
-	additionalTypeTimestamp    byte = 01
-	additionalTypeEmbeddedCBOR byte = 63
+	additionalTypeTimestamp byte = 01
 
 	// Extended Tags - from https://www.iana.org/assignments/cbor-tags/cbor-tags.xhtml
 	additionalTypeTagNetworkAddr   uint16 = 260
@@ -68,7 +67,7 @@ const (
 var IntegerTimeFieldFormat = time.RFC3339
 
 // NanoTimeFieldFormat indicates the format of timestamp decoded
-// from a float value (time in seconds and nanoseconds).
+// from a float value (time in seconds and nano seconds).
 var NanoTimeFieldFormat = time.RFC3339Nano
 
 func appendCborTypePrefix(dst []byte, major byte, number uint64) []byte {
@@ -92,8 +91,7 @@ func appendCborTypePrefix(dst []byte, major byte, number uint64) []byte {
 		minor = additionalTypeIntUint64
 
 	}
-
-	dst = append(dst, major|minor)
+	dst = append(dst, byte(major|minor))
 	byteCount--
 	for ; byteCount >= 0; byteCount-- {
 		dst = append(dst, byte(number>>(uint(byteCount)*8)))

internal/cbor/decode_stream.go

@@ -5,7 +5,6 @@ package cbor
 import (
 	"bufio"
 	"bytes"
-	"encoding/base64"
 	"fmt"
 	"io"
 	"math"
@@ -44,7 +43,7 @@ func readByte(src *bufio.Reader) byte {
 	return b
 }
 
-func decodeIntAdditionalType(src *bufio.Reader, minor byte) int64 {
+func decodeIntAdditonalType(src *bufio.Reader, minor byte) int64 {
 	val := int64(0)
 	if minor <= 23 {
 		val = int64(minor)
@@ -78,7 +77,7 @@ func decodeInteger(src *bufio.Reader) int64 {
 	if major != majorTypeUnsignedInt && major != majorTypeNegativeInt {
 		panic(fmt.Errorf("Major type is: %d in decodeInteger!! (expected 0 or 1)", major))
 	}
-	val := decodeIntAdditionalType(src, minor)
+	val := decodeIntAdditonalType(src, minor)
 	if major == 0 {
 		return val
 	}
@@ -95,7 +94,7 @@ func decodeFloat(src *bufio.Reader) (float64, int) {
 
 	switch minor {
 	case additionalTypeFloat16:
-		panic(fmt.Errorf("float16 is not supported in decodeFloat"))
+		panic(fmt.Errorf("float16 is not suppported in decodeFloat"))
 
 	case additionalTypeFloat32:
 		pb := readNBytes(src, 4)
@@ -205,7 +204,7 @@ func decodeString(src *bufio.Reader, noQuotes bool) []byte {
 	if !noQuotes {
 		result = append(result, '"')
 	}
-	length := decodeIntAdditionalType(src, minor)
+	length := decodeIntAdditonalType(src, minor)
 	len := int(length)
 	pbs := readNBytes(src, len)
 	result = append(result, pbs...)
@@ -214,31 +213,6 @@ func decodeString(src *bufio.Reader, noQuotes bool) []byte {
 	}
 	return append(result, '"')
 }
-func decodeStringToDataUrl(src *bufio.Reader, mimeType string) []byte {
-	pb := readByte(src)
-	major := pb & maskOutAdditionalType
-	minor := pb & maskOutMajorType
-	if major != majorTypeByteString {
-		panic(fmt.Errorf("Major type is: %d in decodeString", major))
-	}
-	length := decodeIntAdditionalType(src, minor)
-	l := int(length)
-	enc := base64.StdEncoding
-	lEnc := enc.EncodedLen(l)
-	result := make([]byte, len("\"data:;base64,\"")+len(mimeType)+lEnc)
-	dest := result
-	u := copy(dest, "\"data:")
-	dest = dest[u:]
-	u = copy(dest, mimeType)
-	dest = dest[u:]
-	u = copy(dest, ";base64,")
-	dest = dest[u:]
-	pbs := readNBytes(src, l)
-	enc.Encode(dest, pbs)
-	dest = dest[lEnc:]
-	dest[0] = '"'
-	return result
-}
 
 func decodeUTF8String(src *bufio.Reader) []byte {
 	pb := readByte(src)
@@ -248,7 +222,7 @@ func decodeUTF8String(src *bufio.Reader) []byte {
 		panic(fmt.Errorf("Major type is: %d in decodeUTF8String", major))
 	}
 	result := []byte{'"'}
-	length := decodeIntAdditionalType(src, minor)
+	length := decodeIntAdditonalType(src, minor)
 	len := int(length)
 	pbs := readNBytes(src, len)
 
@@ -264,7 +238,7 @@ func decodeUTF8String(src *bufio.Reader) []byte {
 			return append(dst, '"')
 		}
 	}
-	// The string has no need for encoding and therefore is directly
+	// The string has no need for encoding an therefore is directly
 	// appended to the byte slice.
 	result = append(result, pbs...)
 	return append(result, '"')
@@ -283,7 +257,7 @@ func array2Json(src *bufio.Reader, dst io.Writer) {
 	if minor == additionalTypeInfiniteCount {
 		unSpecifiedCount = true
 	} else {
-		length := decodeIntAdditionalType(src, minor)
+		length := decodeIntAdditonalType(src, minor)
 		len = int(length)
 	}
 	for i := 0; unSpecifiedCount || i < len; i++ {
@@ -292,7 +266,7 @@ func array2Json(src *bufio.Reader, dst io.Writer) {
 			if e != nil {
 				panic(e)
 			}
-			if pb[0] == majorTypeSimpleAndFloat|additionalTypeBreak {
+			if pb[0] == byte(majorTypeSimpleAndFloat|additionalTypeBreak) {
 				readByte(src)
 				break
 			}
@@ -303,7 +277,7 @@ func array2Json(src *bufio.Reader, dst io.Writer) {
 			if e != nil {
 				panic(e)
 			}
-			if pb[0] == majorTypeSimpleAndFloat|additionalTypeBreak {
+			if pb[0] == byte(majorTypeSimpleAndFloat|additionalTypeBreak) {
 				readByte(src)
 				break
 			}
@@ -327,7 +301,7 @@ func map2Json(src *bufio.Reader, dst io.Writer) {
 	if minor == additionalTypeInfiniteCount {
 		unSpecifiedCount = true
 	} else {
-		length := decodeIntAdditionalType(src, minor)
+		length := decodeIntAdditonalType(src, minor)
 		len = int(length)
 	}
 	dst.Write([]byte{'{'})
@@ -337,7 +311,7 @@ func map2Json(src *bufio.Reader, dst io.Writer) {
 			if e != nil {
 				panic(e)
 			}
-			if pb[0] == majorTypeSimpleAndFloat|additionalTypeBreak {
+			if pb[0] == byte(majorTypeSimpleAndFloat|additionalTypeBreak) {
 				readByte(src)
 				break
 			}
@@ -352,7 +326,7 @@ func map2Json(src *bufio.Reader, dst io.Writer) {
 				if e != nil {
 					panic(e)
 				}
-				if pb[0] == majorTypeSimpleAndFloat|additionalTypeBreak {
+				if pb[0] == byte(majorTypeSimpleAndFloat|additionalTypeBreak) {
 					readByte(src)
 					break
 				}
@@ -375,24 +349,10 @@ func decodeTagData(src *bufio.Reader) []byte {
 	switch minor {
 	case additionalTypeTimestamp:
 		return decodeTimeStamp(src)
-	case additionalTypeIntUint8:
-		val := decodeIntAdditionalType(src, minor)
-		switch byte(val) {
-		case additionalTypeEmbeddedCBOR:
-			pb := readByte(src)
-			dataMajor := pb & maskOutAdditionalType
-			if dataMajor != majorTypeByteString {
-				panic(fmt.Errorf("Unsupported embedded Type: %d in decodeEmbeddedCBOR", dataMajor))
-			}
-			src.UnreadByte()
-			return decodeStringToDataUrl(src, "application/cbor")
-		default:
-			panic(fmt.Errorf("Unsupported Additional Tag Type: %d in decodeTagData", val))
-		}
 
 	// Tag value is larger than 256 (so uint16).
 	case additionalTypeIntUint16:
-		val := decodeIntAdditionalType(src, minor)
+		val := decodeIntAdditonalType(src, minor)
 
 		switch uint16(val) {
 		case additionalTypeEmbeddedJSON:
@@ -423,7 +383,7 @@ func decodeTagData(src *bufio.Reader) []byte {
 
 		case additionalTypeTagNetworkPrefix:
 			pb := readByte(src)
-			if pb != majorTypeMap|0x1 {
+			if pb != byte(majorTypeMap|0x1) {
 				panic(fmt.Errorf("IP Prefix is NOT of MAP of 1 elements as expected"))
 			}
 			octets := decodeString(src, true)

internal/cbor/string.go

@@ -1,14 +1,12 @@
 package cbor
 
-import "fmt"
-
 // AppendStrings encodes and adds an array of strings to the dst byte array.
 func (e Encoder) AppendStrings(dst []byte, vals []string) []byte {
 	major := majorTypeArray
 	l := len(vals)
 	if l <= additionalMax {
 		lb := byte(l)
-		dst = append(dst, major|lb)
+		dst = append(dst, byte(major|lb))
 	} else {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
@@ -25,38 +23,13 @@ func (Encoder) AppendString(dst []byte, s string) []byte {
 	l := len(s)
 	if l <= additionalMax {
 		lb := byte(l)
-		dst = append(dst, major|lb)
+		dst = append(dst, byte(major|lb))
 	} else {
 		dst = appendCborTypePrefix(dst, majorTypeUtf8String, uint64(l))
 	}
 	return append(dst, s...)
 }
 
-// AppendStringers encodes and adds an array of Stringer values
-// to the dst byte array.
-func (e Encoder) AppendStringers(dst []byte, vals []fmt.Stringer) []byte {
-	if len(vals) == 0 {
-		return e.AppendArrayEnd(e.AppendArrayStart(dst))
-	}
-	dst = e.AppendArrayStart(dst)
-	dst = e.AppendStringer(dst, vals[0])
-	if len(vals) > 1 {
-		for _, val := range vals[1:] {
-			dst = e.AppendStringer(dst, val)
-		}
-	}
-	return e.AppendArrayEnd(dst)
-}
-
-// AppendStringer encodes and adds the Stringer value to the dst
-// byte array.
-func (e Encoder) AppendStringer(dst []byte, val fmt.Stringer) []byte {
-	if val == nil {
-		return e.AppendNil(dst)
-	}
-	return e.AppendString(dst, val.String())
-}
-
 // AppendBytes encodes and adds an array of bytes to the dst byte array.
 func (Encoder) AppendBytes(dst, s []byte) []byte {
 	major := majorTypeByteString
@@ -64,7 +37,7 @@ func (Encoder) AppendBytes(dst, s []byte) []byte {
 	l := len(s)
 	if l <= additionalMax {
 		lb := byte(l)
-		dst = append(dst, major|lb)
+		dst = append(dst, byte(major|lb))
 	} else {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
@@ -77,7 +50,7 @@ func AppendEmbeddedJSON(dst, s []byte) []byte {
 	minor := additionalTypeEmbeddedJSON
 
 	// Append the TAG to indicate this is Embedded JSON.
-	dst = append(dst, major|additionalTypeIntUint16)
+	dst = append(dst, byte(major|additionalTypeIntUint16))
 	dst = append(dst, byte(minor>>8))
 	dst = append(dst, byte(minor&0xff))
 
@@ -87,29 +60,7 @@ func AppendEmbeddedJSON(dst, s []byte) []byte {
 	l := len(s)
 	if l <= additionalMax {
 		lb := byte(l)
-		dst = append(dst, major|lb)
-	} else {
-		dst = appendCborTypePrefix(dst, major, uint64(l))
-	}
-	return append(dst, s...)
-}
-
-// AppendEmbeddedCBOR adds a tag and embeds input CBOR as such.
-func AppendEmbeddedCBOR(dst, s []byte) []byte {
-	major := majorTypeTags
-	minor := additionalTypeEmbeddedCBOR
-
-	// Append the TAG to indicate this is Embedded JSON.
-	dst = append(dst, major|additionalTypeIntUint8)
-	dst = append(dst, minor)
-
-	// Append the CBOR Object as Byte String.
-	major = majorTypeByteString
-
-	l := len(s)
-	if l <= additionalMax {
-		lb := byte(l)
-		dst = append(dst, major|lb)
+		dst = append(dst, byte(major|lb))
 	} else {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}

internal/cbor/time.go

@@ -7,7 +7,7 @@ import (
 func appendIntegerTimestamp(dst []byte, t time.Time) []byte {
 	major := majorTypeTags
 	minor := additionalTypeTimestamp
-	dst = append(dst, major|minor)
+	dst = append(dst, byte(major|minor))
 	secs := t.Unix()
 	var val uint64
 	if secs < 0 {
@@ -17,19 +17,19 @@ func appendIntegerTimestamp(dst []byte, t time.Time) []byte {
 		major = majorTypeUnsignedInt
 		val = uint64(secs)
 	}
-	dst = appendCborTypePrefix(dst, major, val)
+	dst = appendCborTypePrefix(dst, major, uint64(val))
 	return dst
 }
 
 func (e Encoder) appendFloatTimestamp(dst []byte, t time.Time) []byte {
 	major := majorTypeTags
 	minor := additionalTypeTimestamp
-	dst = append(dst, major|minor)
+	dst = append(dst, byte(major|minor))
 	secs := t.Unix()
 	nanos := t.Nanosecond()
 	var val float64
-	val = float64(secs)*1.0 + float64(nanos)*1e-9
-	return e.AppendFloat64(dst, val, -1)
+	val = float64(secs)*1.0 + float64(nanos)*1E-9
+	return e.AppendFloat64(dst, val)
 }
 
 // AppendTime encodes and adds a timestamp to the dst byte array.
@@ -50,7 +50,7 @@ func (e Encoder) AppendTimes(dst []byte, vals []time.Time, unused string) []byte
 	}
 	if l <= additionalMax {
 		lb := byte(l)
-		dst = append(dst, major|lb)
+		dst = append(dst, byte(major|lb))
 	} else {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
@@ -64,17 +64,17 @@ func (e Encoder) 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 (e Encoder) AppendDuration(dst []byte, d time.Duration, unit time.Duration, useInt bool, unused int) []byte {
+func (e Encoder) AppendDuration(dst []byte, d time.Duration, unit time.Duration, useInt bool) []byte {
 	if useInt {
 		return e.AppendInt64(dst, int64(d/unit))
 	}
-	return e.AppendFloat64(dst, float64(d)/float64(unit), unused)
+	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 (e Encoder) AppendDurations(dst []byte, vals []time.Duration, unit time.Duration, useInt bool, unused int) []byte {
+func (e Encoder) AppendDurations(dst []byte, vals []time.Duration, unit time.Duration, useInt bool) []byte {
 	major := majorTypeArray
 	l := len(vals)
 	if l == 0 {
@@ -82,12 +82,12 @@ func (e Encoder) AppendDurations(dst []byte, vals []time.Duration, unit time.Dur
 	}
 	if l <= additionalMax {
 		lb := byte(l)
-		dst = append(dst, major|lb)
+		dst = append(dst, byte(major|lb))
 	} else {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
 	for _, d := range vals {
-		dst = e.AppendDuration(dst, d, unit, useInt, unused)
+		dst = e.AppendDuration(dst, d, unit, useInt)
 	}
 	return dst
 }

internal/cbor/types.go

@@ -1,42 +1,42 @@
 package cbor
 
 import (
+	"encoding/json"
 	"fmt"
 	"math"
 	"net"
-	"reflect"
 )
 
 // AppendNil inserts a 'Nil' object into the dst byte array.
 func (Encoder) AppendNil(dst []byte) []byte {
-	return append(dst, majorTypeSimpleAndFloat|additionalTypeNull)
+	return append(dst, byte(majorTypeSimpleAndFloat|additionalTypeNull))
 }
 
 // AppendBeginMarker inserts a map start into the dst byte array.
 func (Encoder) AppendBeginMarker(dst []byte) []byte {
-	return append(dst, majorTypeMap|additionalTypeInfiniteCount)
+	return append(dst, byte(majorTypeMap|additionalTypeInfiniteCount))
 }
 
 // AppendEndMarker inserts a map end into the dst byte array.
 func (Encoder) AppendEndMarker(dst []byte) []byte {
-	return append(dst, majorTypeSimpleAndFloat|additionalTypeBreak)
+	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:]...)
+        // 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, majorTypeArray|additionalTypeInfiniteCount)
+	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, majorTypeSimpleAndFloat|additionalTypeBreak)
+	return append(dst, byte(majorTypeSimpleAndFloat|additionalTypeBreak))
 }
 
 // AppendArrayDelim adds markers to indicate end of a particular array element.
@@ -57,7 +57,7 @@ func (Encoder) AppendBool(dst []byte, val bool) []byte {
 	if val {
 		b = additionalTypeBoolTrue
 	}
-	return append(dst, majorTypeSimpleAndFloat|b)
+	return append(dst, byte(majorTypeSimpleAndFloat|b))
 }
 
 // AppendBools encodes and inserts an array of boolean values into the dst byte array.
@@ -69,7 +69,7 @@ func (e Encoder) AppendBools(dst []byte, vals []bool) []byte {
 	}
 	if l <= additionalMax {
 		lb := byte(l)
-		dst = append(dst, major|lb)
+		dst = append(dst, byte(major|lb))
 	} else {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
@@ -89,7 +89,7 @@ func (Encoder) AppendInt(dst []byte, val int) []byte {
 	}
 	if contentVal <= additionalMax {
 		lb := byte(contentVal)
-		dst = append(dst, major|lb)
+		dst = append(dst, byte(major|lb))
 	} else {
 		dst = appendCborTypePrefix(dst, major, uint64(contentVal))
 	}
@@ -105,7 +105,7 @@ func (e Encoder) AppendInts(dst []byte, vals []int) []byte {
 	}
 	if l <= additionalMax {
 		lb := byte(l)
-		dst = append(dst, major|lb)
+		dst = append(dst, byte(major|lb))
 	} else {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
@@ -129,7 +129,7 @@ func (e Encoder) AppendInts8(dst []byte, vals []int8) []byte {
 	}
 	if l <= additionalMax {
 		lb := byte(l)
-		dst = append(dst, major|lb)
+		dst = append(dst, byte(major|lb))
 	} else {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
@@ -153,7 +153,7 @@ func (e Encoder) AppendInts16(dst []byte, vals []int16) []byte {
 	}
 	if l <= additionalMax {
 		lb := byte(l)
-		dst = append(dst, major|lb)
+		dst = append(dst, byte(major|lb))
 	} else {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
@@ -177,7 +177,7 @@ func (e Encoder) AppendInts32(dst []byte, vals []int32) []byte {
 	}
 	if l <= additionalMax {
 		lb := byte(l)
-		dst = append(dst, major|lb)
+		dst = append(dst, byte(major|lb))
 	} else {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
@@ -197,7 +197,7 @@ func (Encoder) AppendInt64(dst []byte, val int64) []byte {
 	}
 	if contentVal <= additionalMax {
 		lb := byte(contentVal)
-		dst = append(dst, major|lb)
+		dst = append(dst, byte(major|lb))
 	} else {
 		dst = appendCborTypePrefix(dst, major, uint64(contentVal))
 	}
@@ -213,7 +213,7 @@ func (e Encoder) AppendInts64(dst []byte, vals []int64) []byte {
 	}
 	if l <= additionalMax {
 		lb := byte(l)
-		dst = append(dst, major|lb)
+		dst = append(dst, byte(major|lb))
 	} else {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
@@ -237,7 +237,7 @@ func (e Encoder) AppendUints(dst []byte, vals []uint) []byte {
 	}
 	if l <= additionalMax {
 		lb := byte(l)
-		dst = append(dst, major|lb)
+		dst = append(dst, byte(major|lb))
 	} else {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
@@ -261,7 +261,7 @@ func (e Encoder) AppendUints8(dst []byte, vals []uint8) []byte {
 	}
 	if l <= additionalMax {
 		lb := byte(l)
-		dst = append(dst, major|lb)
+		dst = append(dst, byte(major|lb))
 	} else {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
@@ -285,7 +285,7 @@ func (e Encoder) AppendUints16(dst []byte, vals []uint16) []byte {
 	}
 	if l <= additionalMax {
 		lb := byte(l)
-		dst = append(dst, major|lb)
+		dst = append(dst, byte(major|lb))
 	} else {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
@@ -309,7 +309,7 @@ func (e Encoder) AppendUints32(dst []byte, vals []uint32) []byte {
 	}
 	if l <= additionalMax {
 		lb := byte(l)
-		dst = append(dst, major|lb)
+		dst = append(dst, byte(major|lb))
 	} else {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
@@ -325,9 +325,9 @@ func (Encoder) AppendUint64(dst []byte, val uint64) []byte {
 	contentVal := val
 	if contentVal <= additionalMax {
 		lb := byte(contentVal)
-		dst = append(dst, major|lb)
+		dst = append(dst, byte(major|lb))
 	} else {
-		dst = appendCborTypePrefix(dst, major, contentVal)
+		dst = appendCborTypePrefix(dst, major, uint64(contentVal))
 	}
 	return dst
 }
@@ -341,7 +341,7 @@ func (e Encoder) AppendUints64(dst []byte, vals []uint64) []byte {
 	}
 	if l <= additionalMax {
 		lb := byte(l)
-		dst = append(dst, major|lb)
+		dst = append(dst, byte(major|lb))
 	} else {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
@@ -352,7 +352,7 @@ func (e Encoder) AppendUints64(dst []byte, vals []uint64) []byte {
 }
 
 // AppendFloat32 encodes and inserts a single precision float value into the dst byte array.
-func (Encoder) AppendFloat32(dst []byte, val float32, unused int) []byte {
+func (Encoder) AppendFloat32(dst []byte, val float32) []byte {
 	switch {
 	case math.IsNaN(float64(val)):
 		return append(dst, "\xfa\x7f\xc0\x00\x00"...)
@@ -368,11 +368,11 @@ func (Encoder) AppendFloat32(dst []byte, val float32, unused int) []byte {
 	for i := uint(0); i < 4; i++ {
 		buf[i] = byte(n >> ((3 - i) * 8))
 	}
-	return append(append(dst, major|subType), buf[0], buf[1], buf[2], buf[3])
+	return append(append(dst, byte(major|subType)), buf[0], buf[1], buf[2], buf[3])
 }
 
 // AppendFloats32 encodes and inserts an array of single precision float value into the dst byte array.
-func (e Encoder) AppendFloats32(dst []byte, vals []float32, unused int) []byte {
+func (e Encoder) AppendFloats32(dst []byte, vals []float32) []byte {
 	major := majorTypeArray
 	l := len(vals)
 	if l == 0 {
@@ -380,18 +380,18 @@ func (e Encoder) AppendFloats32(dst []byte, vals []float32, unused int) []byte {
 	}
 	if l <= additionalMax {
 		lb := byte(l)
-		dst = append(dst, major|lb)
+		dst = append(dst, byte(major|lb))
 	} else {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
 	for _, v := range vals {
-		dst = e.AppendFloat32(dst, v, unused)
+		dst = e.AppendFloat32(dst, v)
 	}
 	return dst
 }
 
 // AppendFloat64 encodes and inserts a double precision float value into the dst byte array.
-func (Encoder) AppendFloat64(dst []byte, val float64, unused int) []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"...)
@@ -403,7 +403,7 @@ func (Encoder) AppendFloat64(dst []byte, val float64, unused int) []byte {
 	major := majorTypeSimpleAndFloat
 	subType := additionalTypeFloat64
 	n := math.Float64bits(val)
-	dst = append(dst, major|subType)
+	dst = append(dst, byte(major|subType))
 	for i := uint(1); i <= 8; i++ {
 		b := byte(n >> ((8 - i) * 8))
 		dst = append(dst, b)
@@ -412,7 +412,7 @@ func (Encoder) AppendFloat64(dst []byte, val float64, unused int) []byte {
 }
 
 // AppendFloats64 encodes and inserts an array of double precision float values into the dst byte array.
-func (e Encoder) AppendFloats64(dst []byte, vals []float64, unused int) []byte {
+func (e Encoder) AppendFloats64(dst []byte, vals []float64) []byte {
 	major := majorTypeArray
 	l := len(vals)
 	if l == 0 {
@@ -420,36 +420,28 @@ func (e Encoder) AppendFloats64(dst []byte, vals []float64, unused int) []byte {
 	}
 	if l <= additionalMax {
 		lb := byte(l)
-		dst = append(dst, major|lb)
+		dst = append(dst, byte(major|lb))
 	} else {
 		dst = appendCborTypePrefix(dst, major, uint64(l))
 	}
 	for _, v := range vals {
-		dst = e.AppendFloat64(dst, v, unused)
+		dst = e.AppendFloat64(dst, v)
 	}
 	return dst
 }
 
 // AppendInterface takes an arbitrary object and converts it to JSON and embeds it dst.
 func (e Encoder) AppendInterface(dst []byte, i interface{}) []byte {
-	marshaled, err := JSONMarshalFunc(i)
+	marshaled, err := json.Marshal(i)
 	if err != nil {
 		return e.AppendString(dst, fmt.Sprintf("marshaling error: %v", err))
 	}
 	return AppendEmbeddedJSON(dst, marshaled)
 }
 
-// AppendType appends the parameter type (as a string) to the input byte slice.
-func (e Encoder) AppendType(dst []byte, i interface{}) []byte {
-	if i == nil {
-		return e.AppendString(dst, "<nil>")
-	}
-	return e.AppendString(dst, reflect.TypeOf(i).String())
-}
-
 // AppendIPAddr encodes and inserts an IP Address (IPv4 or IPv6).
 func (e Encoder) AppendIPAddr(dst []byte, ip net.IP) []byte {
-	dst = append(dst, majorTypeTags|additionalTypeIntUint16)
+	dst = append(dst, byte(majorTypeTags|additionalTypeIntUint16))
 	dst = append(dst, byte(additionalTypeTagNetworkAddr>>8))
 	dst = append(dst, byte(additionalTypeTagNetworkAddr&0xff))
 	return e.AppendBytes(dst, ip)
@@ -457,21 +449,21 @@ func (e Encoder) AppendIPAddr(dst []byte, ip net.IP) []byte {
 
 // AppendIPPrefix encodes and inserts an IP Address Prefix (Address + Mask Length).
 func (e Encoder) AppendIPPrefix(dst []byte, pfx net.IPNet) []byte {
-	dst = append(dst, majorTypeTags|additionalTypeIntUint16)
+	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, majorTypeMap|0x1)
+	dst = append(dst, byte(majorTypeMap|0x1))
 	dst = e.AppendBytes(dst, pfx.IP)
 	maskLen, _ := pfx.Mask.Size()
 	return e.AppendUint8(dst, uint8(maskLen))
 }
 
-// AppendMACAddr encodes and inserts a Hardware (MAC) address.
+// AppendMACAddr encodes and inserts an Hardware (MAC) address.
 func (e Encoder) AppendMACAddr(dst []byte, ha net.HardwareAddr) []byte {
-	dst = append(dst, majorTypeTags|additionalTypeIntUint16)
+	dst = append(dst, byte(majorTypeTags|additionalTypeIntUint16))
 	dst = append(dst, byte(additionalTypeTagNetworkAddr>>8))
 	dst = append(dst, byte(additionalTypeTagNetworkAddr&0xff))
 	return e.AppendBytes(dst, ha)
@@ -479,7 +471,7 @@ func (e Encoder) AppendMACAddr(dst []byte, ha net.HardwareAddr) []byte {
 
 // AppendHex adds a TAG and inserts a hex bytes as a string.
 func (e Encoder) AppendHex(dst []byte, val []byte) []byte {
-	dst = append(dst, majorTypeTags|additionalTypeIntUint16)
+	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_64_test.go

@@ -1,34 +0,0 @@
-// +build !386
-
-package cbor
-
-import (
-	"encoding/hex"
-	"testing"
-)
-
-var enc2 = Encoder{}
-
-var integerTestCases_64bit = []struct {
-	val    int
-	binary string
-}{
-	// Value in 8 bytes.
-	{0xabcd100000000, "\x1b\x00\x0a\xbc\xd1\x00\x00\x00\x00"},
-	{1000000000000, "\x1b\x00\x00\x00\xe8\xd4\xa5\x10\x00"},
-	// Value in 8 bytes.
-	{-0xabcd100000001, "\x3b\x00\x0a\xbc\xd1\x00\x00\x00\x00"},
-	{-1000000000001, "\x3b\x00\x00\x00\xe8\xd4\xa5\x10\x00"},
-}
-
-func TestAppendInt_64bit(t *testing.T) {
-	for _, tc := range integerTestCases_64bit {
-		s := enc2.AppendInt([]byte{}, tc.val)
-		got := string(s)
-		if got != tc.binary {
-			t.Errorf("AppendInt(0x%x)=0x%s, want: 0x%s",
-				tc.val, hex.EncodeToString(s),
-				hex.EncodeToString([]byte(tc.binary)))
-		}
-	}
-}

internal/cbor/types_test.go

@@ -88,8 +88,11 @@ var integerTestCases = []struct {
 	{0xFFFF, "\x19\xff\xff"},
 	// Value in 4 bytes.
 	{0x10000, "\x1a\x00\x01\x00\x00"},
-	{0x7FFFFFFE, "\x1a\x7f\xff\xff\xfe"},
+	{0xFFFFFFFE, "\x1a\xff\xff\xff\xfe"},
 	{1000000, "\x1a\x00\x0f\x42\x40"},
+	// Value in 8 bytes.
+	{0xabcd100000000, "\x1b\x00\x0a\xbc\xd1\x00\x00\x00\x00"},
+	{1000000000000, "\x1b\x00\x00\x00\xe8\xd4\xa5\x10\x00"},
 	// Negative number test cases.
 	// Value included in the type.
 	{-1, "\x20"},
@@ -113,8 +116,11 @@ var integerTestCases = []struct {
 	{-1000, "\x39\x03\xe7"},
 	// Value in 4 bytes.
 	{-0x10001, "\x3a\x00\x01\x00\x00"},
-	{-0x7FFFFFFE, "\x3a\x7f\xff\xff\xfd"},
+	{-0xFFFFFFFE, "\x3a\xff\xff\xff\xfd"},
 	{-1000000, "\x3a\x00\x0f\x42\x3f"},
+	// Value in 8 bytes.
+	{-0xabcd100000001, "\x3b\x00\x0a\xbc\xd1\x00\x00\x00\x00"},
+	{-1000000000001, "\x3b\x00\x00\x00\xe8\xd4\xa5\x10\x00"},
 }
 
 func TestAppendInt(t *testing.T) {
@@ -169,7 +175,7 @@ var float32TestCases = []struct {
 
 func TestAppendFloat32(t *testing.T) {
 	for _, tc := range float32TestCases {
-		s := enc.AppendFloat32([]byte{}, tc.val, -1)
+		s := enc.AppendFloat32([]byte{}, tc.val)
 		got := string(s)
 		if got != tc.binary {
 			t.Errorf("AppendFloat32(%f)=0x%s, want: 0x%s",
@@ -211,7 +217,7 @@ var macAddrTestCases = []struct {
 	{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) {
+func TestAppendMacAddr(t *testing.T) {
 	for _, tc := range macAddrTestCases {
 		s := enc.AppendMACAddr([]byte{}, tc.macaddr)
 		got := string(s)
@@ -306,9 +312,9 @@ func BenchmarkAppendFloat(b *testing.B) {
 			for i := 0; i < b.N; i++ {
 				switch str.sz {
 				case 4:
-					_ = enc.AppendFloat32(buf, float32(str.val), -1)
+					_ = enc.AppendFloat32(buf, float32(str.val))
 				case 8:
-					_ = enc.AppendFloat64(buf, str.val, -1)
+					_ = enc.AppendFloat64(buf, str.val)
 				}
 			}
 		})

internal/json/base.go

@@ -1,19 +1,12 @@
 package json
 
-// JSONMarshalFunc is used to marshal interface to JSON encoded byte slice.
-// Making it package level instead of embedded in Encoder brings
-// some extra efforts at importing, but avoids value copy when the functions
-// of Encoder being invoked.
-// DO REMEMBER to set this variable at importing, or
-// you might get a nil pointer dereference panic at runtime.
-var JSONMarshalFunc func(v interface{}) ([]byte, error)
-
 type Encoder struct{}
 
 // AppendKey appends a new key to the output JSON.
 func (e Encoder) AppendKey(dst []byte, key string) []byte {
-	if dst[len(dst)-1] != '{' {
+	if len(dst) > 1 && dst[len(dst)-1] != '{' {
 		dst = append(dst, ',')
 	}
-	return append(e.AppendString(dst, key), ':')
-}
+	dst = e.AppendString(dst, key)
+	return append(dst, ':')
+}

internal/json/string.go

@@ -1,9 +1,6 @@
 package json
 
-import (
-	"fmt"
-	"unicode/utf8"
-)
+import "unicode/utf8"
 
 const hex = "0123456789abcdef"
 
@@ -37,7 +34,7 @@ func (e Encoder) AppendStrings(dst []byte, vals []string) []byte {
 //
 // The operation loops though each byte in the string looking
 // for characters that need json or utf8 encoding. If the string
-// does not need encoding, then the string is appended in its
+// does not need encoding, then the string is appended in it's
 // 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.
@@ -56,39 +53,14 @@ func (Encoder) AppendString(dst []byte, s string) []byte {
 			return append(dst, '"')
 		}
 	}
-	// The string has no need for encoding and therefore is directly
+	// The string has no need for encoding an therefore is directly
 	// appended to the byte slice.
 	dst = append(dst, s...)
 	// End with a double quote
 	return append(dst, '"')
 }
 
-// AppendStringers encodes the provided Stringer list to json and
-// appends the encoded Stringer list to the input byte slice.
-func (e Encoder) AppendStringers(dst []byte, vals []fmt.Stringer) []byte {
-	if len(vals) == 0 {
-		return append(dst, '[', ']')
-	}
-	dst = append(dst, '[')
-	dst = e.AppendStringer(dst, vals[0])
-	if len(vals) > 1 {
-		for _, val := range vals[1:] {
-			dst = e.AppendStringer(append(dst, ','), val)
-		}
-	}
-	return append(dst, ']')
-}
-
-// AppendStringer encodes the input Stringer to json and appends the
-// encoded Stringer value to the input byte slice.
-func (e Encoder) AppendStringer(dst []byte, val fmt.Stringer) []byte {
-	if val == nil {
-		return e.AppendInterface(dst, nil)
-	}
-	return e.AppendString(dst, val.String())
-}
-
-//// appendStringComplex is used by appendString to take over an in
+// appendStringComplex is used by appendString to take over an in
 // progress JSON string encoding that encountered a character that needs
 // to be encoded.
 func appendStringComplex(dst []byte, s string, i int) []byte {
@@ -99,7 +71,7 @@ func appendStringComplex(dst []byte, s string, i int) []byte {
 			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
+				// the byte slice if any and append a remplacement character code
 				// in place of the invalid sequence.
 				if start < i {
 					dst = append(dst, s[start:i]...)

internal/json/time.go

@@ -5,26 +5,11 @@ import (
 	"time"
 )
 
-const (
-	// Import from zerolog/global.go
-	timeFormatUnix      = ""
-	timeFormatUnixMs    = "UNIXMS"
-	timeFormatUnixMicro = "UNIXMICRO"
-	timeFormatUnixNano  = "UNIXNANO"
-)
-
 // AppendTime formats the input time with the given format
 // and appends the encoded string to the input byte slice.
 func (e Encoder) AppendTime(dst []byte, t time.Time, format string) []byte {
-	switch format {
-	case timeFormatUnix:
+	if format == "" {
 		return e.AppendInt64(dst, t.Unix())
-	case timeFormatUnixMs:
-		return e.AppendInt64(dst, t.UnixNano()/1000000)
-	case timeFormatUnixMicro:
-		return e.AppendInt64(dst, t.UnixNano()/1000)
-	case timeFormatUnixNano:
-		return e.AppendInt64(dst, t.UnixNano())
 	}
 	return append(t.AppendFormat(append(dst, '"'), format), '"')
 }
@@ -32,15 +17,8 @@ func (e Encoder) AppendTime(dst []byte, t time.Time, format string) []byte {
 // AppendTimes converts the input times with the given format
 // and appends the encoded string list to the input byte slice.
 func (Encoder) AppendTimes(dst []byte, vals []time.Time, format string) []byte {
-	switch format {
-	case timeFormatUnix:
+	if format == "" {
 		return appendUnixTimes(dst, vals)
-	case timeFormatUnixMs:
-		return appendUnixNanoTimes(dst, vals, 1000000)
-	case timeFormatUnixMicro:
-		return appendUnixNanoTimes(dst, vals, 1000)
-	case timeFormatUnixNano:
-		return appendUnixNanoTimes(dst, vals, 1)
 	}
 	if len(vals) == 0 {
 		return append(dst, '[', ']')
@@ -71,41 +49,26 @@ func appendUnixTimes(dst []byte, vals []time.Time) []byte {
 	return dst
 }
 
-func appendUnixNanoTimes(dst []byte, vals []time.Time, div int64) []byte {
-	if len(vals) == 0 {
-		return append(dst, '[', ']')
-	}
-	dst = append(dst, '[')
-	dst = strconv.AppendInt(dst, vals[0].UnixNano()/div, 10)
-	if len(vals) > 1 {
-		for _, t := range vals[1:] {
-			dst = strconv.AppendInt(append(dst, ','), t.UnixNano()/div, 10)
-		}
-	}
-	dst = append(dst, ']')
-	return dst
-}
-
 // AppendDuration formats the input duration with the given unit & format
 // and appends the encoded string to the input byte slice.
-func (e Encoder) AppendDuration(dst []byte, d time.Duration, unit time.Duration, useInt bool, precision int) []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 e.AppendFloat64(dst, float64(d)/float64(unit), precision)
+	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 (e Encoder) AppendDurations(dst []byte, vals []time.Duration, unit time.Duration, useInt bool, precision int) []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 = e.AppendDuration(dst, vals[0], unit, useInt, precision)
+	dst = e.AppendDuration(dst, vals[0], unit, useInt)
 	if len(vals) > 1 {
 		for _, d := range vals[1:] {
-			dst = e.AppendDuration(append(dst, ','), d, unit, useInt, precision)
+			dst = e.AppendDuration(append(dst, ','), d, unit, useInt)
 		}
 	}
 	dst = append(dst, ']')

internal/json/types.go

@@ -1,10 +1,10 @@
 package json
 
 import (
+	"encoding/json"
 	"fmt"
 	"math"
 	"net"
-	"reflect"
 	"strconv"
 )
 
@@ -279,7 +279,7 @@ func (Encoder) 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 (Encoder) AppendUint64(dst []byte, val uint64) []byte {
-	return strconv.AppendUint(dst, val, 10)
+	return strconv.AppendUint(dst, uint64(val), 10)
 }
 
 // AppendUints64 encodes the input uint64s to json and
@@ -299,9 +299,9 @@ func (Encoder) AppendUints64(dst []byte, vals []uint64) []byte {
 	return dst
 }
 
-func appendFloat(dst []byte, val float64, bitSize, precision 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 through so we
+	// with an error, but a logging library wants the data to get thru so we
 	// make a tradeoff and store those types as string.
 	switch {
 	case math.IsNaN(val):
@@ -311,47 +311,26 @@ func appendFloat(dst []byte, val float64, bitSize, precision int) []byte {
 	case math.IsInf(val, -1):
 		return append(dst, `"-Inf"`...)
 	}
-	// convert as if by es6 number to string conversion
-	// see also https://cs.opensource.google/go/go/+/refs/tags/go1.20.3:src/encoding/json/encode.go;l=573
-	strFmt := byte('f')
-	// If precision is set to a value other than -1, we always just format the float using that precision.
-	if precision == -1 {
-		// Use float32 comparisons for underlying float32 value to get precise cutoffs right.
-		if abs := math.Abs(val); abs != 0 {
-			if bitSize == 64 && (abs < 1e-6 || abs >= 1e21) || bitSize == 32 && (float32(abs) < 1e-6 || float32(abs) >= 1e21) {
-				strFmt = 'e'
-			}
-		}
-	}
-	dst = strconv.AppendFloat(dst, val, strFmt, precision, bitSize)
-	if strFmt == 'e' {
-		// Clean up e-09 to e-9
-		n := len(dst)
-		if n >= 4 && dst[n-4] == 'e' && dst[n-3] == '-' && dst[n-2] == '0' {
-			dst[n-2] = dst[n-1]
-			dst = dst[:n-1]
-		}
-	}
-	return dst
+	return strconv.AppendFloat(dst, val, 'f', -1, bitSize)
 }
 
 // AppendFloat32 converts the input float32 to a string and
 // appends the encoded string to the input byte slice.
-func (Encoder) AppendFloat32(dst []byte, val float32, precision int) []byte {
-	return appendFloat(dst, float64(val), 32, precision)
+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 (Encoder) AppendFloats32(dst []byte, vals []float32, precision int) []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, precision)
+	dst = appendFloat(dst, float64(vals[0]), 32)
 	if len(vals) > 1 {
 		for _, val := range vals[1:] {
-			dst = appendFloat(append(dst, ','), float64(val), 32, precision)
+			dst = appendFloat(append(dst, ','), float64(val), 32)
 		}
 	}
 	dst = append(dst, ']')
@@ -360,21 +339,21 @@ func (Encoder) AppendFloats32(dst []byte, vals []float32, precision int) []byte
 
 // AppendFloat64 converts the input float64 to a string and
 // appends the encoded string to the input byte slice.
-func (Encoder) AppendFloat64(dst []byte, val float64, precision int) []byte {
-	return appendFloat(dst, val, 64, precision)
+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 (Encoder) AppendFloats64(dst []byte, vals []float64, precision int) []byte {
+func (Encoder) AppendFloats64(dst []byte, vals []float64) []byte {
 	if len(vals) == 0 {
 		return append(dst, '[', ']')
 	}
 	dst = append(dst, '[')
-	dst = appendFloat(dst, vals[0], 64, precision)
+	dst = appendFloat(dst, vals[0], 32)
 	if len(vals) > 1 {
 		for _, val := range vals[1:] {
-			dst = appendFloat(append(dst, ','), val, 64, precision)
+			dst = appendFloat(append(dst, ','), val, 64)
 		}
 	}
 	dst = append(dst, ']')
@@ -384,34 +363,22 @@ func (Encoder) AppendFloats64(dst []byte, vals []float64, precision int) []byte
 // AppendInterface marshals the input interface to a string and
 // appends the encoded string to the input byte slice.
 func (e Encoder) AppendInterface(dst []byte, i interface{}) []byte {
-	marshaled, err := JSONMarshalFunc(i)
+	marshaled, err := json.Marshal(i)
 	if err != nil {
 		return e.AppendString(dst, fmt.Sprintf("marshaling error: %v", err))
 	}
 	return append(dst, marshaled...)
 }
 
-// AppendType appends the parameter type (as a string) to the input byte slice.
-func (e Encoder) AppendType(dst []byte, i interface{}) []byte {
-	if i == nil {
-		return e.AppendString(dst, "<nil>")
-	}
-	return e.AppendString(dst, reflect.TypeOf(i).String())
-}
-
 // 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 {
-	// Three conditions apply here:
-	// 1. new content starts with '{' - which should be dropped   OR
-	// 2. new content starts with '{' - which should be replaced with ','
-	//    to separate with existing content OR
-	// 3. existing content has already other fields
+	// Two conditions we want to put a ',' between existing content and
+	// new content:
+	// 1. new content starts with '{' - which shd be dropped   OR
+	// 2. existing content has already other fields
 	if o[0] == '{' {
-		if len(dst) > 1 {
-			dst = append(dst, ',')
-		}
-		o = o[1:]
+		o[0] = ','
 	} else if len(dst) > 1 {
 		dst = append(dst, ',')
 	}

internal/json/types_test.go

@@ -1,9 +1,7 @@
 package json
 
 import (
-	"encoding/json"
 	"math"
-	"math/rand"
 	"net"
 	"reflect"
 	"testing"
@@ -11,20 +9,18 @@ import (
 
 func TestAppendType(t *testing.T) {
 	w := map[string]func(interface{}) []byte{
-		"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), -1) },
-		"AppendFloat64":               func(v interface{}) []byte { return enc.AppendFloat64([]byte{}, v.(float64), -1) },
-		"AppendFloat32SmallPrecision": func(v interface{}) []byte { return enc.AppendFloat32([]byte{}, v.(float32), 1) },
-		"AppendFloat64SmallPrecision": func(v interface{}) []byte { return enc.AppendFloat64([]byte{}, v.(float64), 1) },
+		"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
@@ -48,7 +44,7 @@ func TestAppendType(t *testing.T) {
 		{"AppendFloat32(0)", "AppendFloat32", float32(0), []byte(`0`)},
 		{"AppendFloat32(-1.1)", "AppendFloat32", float32(-1.1), []byte(`-1.1`)},
 		{"AppendFloat32(1e20)", "AppendFloat32", float32(1e20), []byte(`100000000000000000000`)},
-		{"AppendFloat32(1e21)", "AppendFloat32", float32(1e21), []byte(`1e+21`)},
+		{"AppendFloat32(1e21)", "AppendFloat32", float32(1e21), []byte(`1000000000000000000000`)},
 
 		{"AppendFloat64(-Inf)", "AppendFloat64", float64(math.Inf(-1)), []byte(`"-Inf"`)},
 		{"AppendFloat64(+Inf)", "AppendFloat64", float64(math.Inf(1)), []byte(`"+Inf"`)},
@@ -56,10 +52,7 @@ func TestAppendType(t *testing.T) {
 		{"AppendFloat64(0)", "AppendFloat64", float64(0), []byte(`0`)},
 		{"AppendFloat64(-1.1)", "AppendFloat64", float64(-1.1), []byte(`-1.1`)},
 		{"AppendFloat64(1e20)", "AppendFloat64", float64(1e20), []byte(`100000000000000000000`)},
-		{"AppendFloat64(1e21)", "AppendFloat64", float64(1e21), []byte(`1e+21`)},
-
-		{"AppendFloat32SmallPrecision(-1.123)", "AppendFloat32SmallPrecision", float32(-1.123), []byte(`-1.1`)},
-		{"AppendFloat64SmallPrecision(-1.123)", "AppendFloat64SmallPrecision", float64(-1.123), []byte(`-1.1`)},
+		{"AppendFloat64(1e21)", "AppendFloat64", float64(1e21), []byte(`1000000000000000000000`)},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -172,382 +165,3 @@ func Test_appendMac(t *testing.T) {
 		})
 	}
 }
-
-func Test_appendType(t *testing.T) {
-	typeTests := []struct {
-		label string
-		input interface{}
-		want  []byte
-	}{
-		{"int", 42, []byte(`"int"`)},
-		{"MAC", net.HardwareAddr{0x12, 0x34, 0x00, 0x00, 0x90, 0xab}, []byte(`"net.HardwareAddr"`)},
-		{"float64", float64(2.50), []byte(`"float64"`)},
-		{"nil", nil, []byte(`"<nil>"`)},
-		{"bool", true, []byte(`"bool"`)},
-	}
-
-	for _, tt := range typeTests {
-		t.Run(tt.label, func(t *testing.T) {
-			if got := enc.AppendType([]byte{}, tt.input); !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("appendType() = %s, want %s", got, tt.want)
-			}
-		})
-	}
-}
-
-func Test_appendObjectData(t *testing.T) {
-	tests := []struct {
-		dst  []byte
-		obj  []byte
-		want []byte
-	}{
-		{[]byte{}, []byte(`{"foo":"bar"}`), []byte(`"foo":"bar"}`)},
-		{[]byte(`{"qux":"quz"`), []byte(`{"foo":"bar"}`), []byte(`{"qux":"quz","foo":"bar"}`)},
-		{[]byte{}, []byte(`"foo":"bar"`), []byte(`"foo":"bar"`)},
-		{[]byte(`{"qux":"quz"`), []byte(`"foo":"bar"`), []byte(`{"qux":"quz","foo":"bar"`)},
-	}
-	for _, tt := range tests {
-		t.Run("ObjectData", func(t *testing.T) {
-			if got := enc.AppendObjectData(tt.dst, tt.obj); !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("appendObjectData() = %s, want %s", got, tt.want)
-			}
-		})
-	}
-}
-
-var float64Tests = []struct {
-	Name string
-	Val  float64
-	Want string
-}{
-	{
-		Name: "Positive integer",
-		Val:  1234.0,
-		Want: "1234",
-	},
-	{
-		Name: "Negative integer",
-		Val:  -5678.0,
-		Want: "-5678",
-	},
-	{
-		Name: "Positive decimal",
-		Val:  12.3456,
-		Want: "12.3456",
-	},
-	{
-		Name: "Negative decimal",
-		Val:  -78.9012,
-		Want: "-78.9012",
-	},
-	{
-		Name: "Large positive number",
-		Val:  123456789.0,
-		Want: "123456789",
-	},
-	{
-		Name: "Large negative number",
-		Val:  -987654321.0,
-		Want: "-987654321",
-	},
-	{
-		Name: "Zero",
-		Val:  0.0,
-		Want: "0",
-	},
-	{
-		Name: "Smallest positive value",
-		Val:  math.SmallestNonzeroFloat64,
-		Want: "5e-324",
-	},
-	{
-		Name: "Largest positive value",
-		Val:  math.MaxFloat64,
-		Want: "1.7976931348623157e+308",
-	},
-	{
-		Name: "Smallest negative value",
-		Val:  -math.SmallestNonzeroFloat64,
-		Want: "-5e-324",
-	},
-	{
-		Name: "Largest negative value",
-		Val:  -math.MaxFloat64,
-		Want: "-1.7976931348623157e+308",
-	},
-	{
-		Name: "NaN",
-		Val:  math.NaN(),
-		Want: `"NaN"`,
-	},
-	{
-		Name: "+Inf",
-		Val:  math.Inf(1),
-		Want: `"+Inf"`,
-	},
-	{
-		Name: "-Inf",
-		Val:  math.Inf(-1),
-		Want: `"-Inf"`,
-	},
-	{
-		Name: "Clean up e-09 to e-9 case 1",
-		Val:  1e-9,
-		Want: "1e-9",
-	},
-	{
-		Name: "Clean up e-09 to e-9 case 2",
-		Val:  -2.236734e-9,
-		Want: "-2.236734e-9",
-	},
-}
-
-func TestEncoder_AppendFloat64(t *testing.T) {
-	for _, tc := range float64Tests {
-		t.Run(tc.Name, func(t *testing.T) {
-			var b []byte
-			b = (Encoder{}).AppendFloat64(b, tc.Val, -1)
-			if s := string(b); tc.Want != s {
-				t.Errorf("%q", s)
-			}
-		})
-	}
-}
-
-func FuzzEncoder_AppendFloat64(f *testing.F) {
-	for _, tc := range float64Tests {
-		f.Add(tc.Val)
-	}
-	f.Fuzz(func(t *testing.T, val float64) {
-		actual := (Encoder{}).AppendFloat64(nil, val, -1)
-		if len(actual) == 0 {
-			t.Fatal("empty buffer")
-		}
-
-		if actual[0] == '"' {
-			switch string(actual) {
-			case `"NaN"`:
-				if !math.IsNaN(val) {
-					t.Fatalf("expected %v got NaN", val)
-				}
-			case `"+Inf"`:
-				if !math.IsInf(val, 1) {
-					t.Fatalf("expected %v got +Inf", val)
-				}
-			case `"-Inf"`:
-				if !math.IsInf(val, -1) {
-					t.Fatalf("expected %v got -Inf", val)
-				}
-			default:
-				t.Fatalf("unexpected string: %s", actual)
-			}
-			return
-		}
-
-		if expected, err := json.Marshal(val); err != nil {
-			t.Error(err)
-		} else if string(actual) != string(expected) {
-			t.Errorf("expected %s, got %s", expected, actual)
-		}
-
-		var parsed float64
-		if err := json.Unmarshal(actual, &parsed); err != nil {
-			t.Fatal(err)
-		}
-
-		if parsed != val {
-			t.Fatalf("expected %v, got %v", val, parsed)
-		}
-	})
-}
-
-var float32Tests = []struct {
-	Name string
-	Val  float32
-	Want string
-}{
-	{
-		Name: "Positive integer",
-		Val:  1234.0,
-		Want: "1234",
-	},
-	{
-		Name: "Negative integer",
-		Val:  -5678.0,
-		Want: "-5678",
-	},
-	{
-		Name: "Positive decimal",
-		Val:  12.3456,
-		Want: "12.3456",
-	},
-	{
-		Name: "Negative decimal",
-		Val:  -78.9012,
-		Want: "-78.9012",
-	},
-	{
-		Name: "Large positive number",
-		Val:  123456789.0,
-		Want: "123456790",
-	},
-	{
-		Name: "Large negative number",
-		Val:  -987654321.0,
-		Want: "-987654340",
-	},
-	{
-		Name: "Zero",
-		Val:  0.0,
-		Want: "0",
-	},
-	{
-		Name: "Smallest positive value",
-		Val:  math.SmallestNonzeroFloat32,
-		Want: "1e-45",
-	},
-	{
-		Name: "Largest positive value",
-		Val:  math.MaxFloat32,
-		Want: "3.4028235e+38",
-	},
-	{
-		Name: "Smallest negative value",
-		Val:  -math.SmallestNonzeroFloat32,
-		Want: "-1e-45",
-	},
-	{
-		Name: "Largest negative value",
-		Val:  -math.MaxFloat32,
-		Want: "-3.4028235e+38",
-	},
-	{
-		Name: "NaN",
-		Val:  float32(math.NaN()),
-		Want: `"NaN"`,
-	},
-	{
-		Name: "+Inf",
-		Val:  float32(math.Inf(1)),
-		Want: `"+Inf"`,
-	},
-	{
-		Name: "-Inf",
-		Val:  float32(math.Inf(-1)),
-		Want: `"-Inf"`,
-	},
-	{
-		Name: "Clean up e-09 to e-9 case 1",
-		Val:  1e-9,
-		Want: "1e-9",
-	},
-	{
-		Name: "Clean up e-09 to e-9 case 2",
-		Val:  -2.236734e-9,
-		Want: "-2.236734e-9",
-	},
-}
-
-func TestEncoder_AppendFloat32(t *testing.T) {
-	for _, tc := range float32Tests {
-		t.Run(tc.Name, func(t *testing.T) {
-			var b []byte
-			b = (Encoder{}).AppendFloat32(b, tc.Val, -1)
-			if s := string(b); tc.Want != s {
-				t.Errorf("%q", s)
-			}
-		})
-	}
-}
-
-func FuzzEncoder_AppendFloat32(f *testing.F) {
-	for _, tc := range float32Tests {
-		f.Add(tc.Val)
-	}
-	f.Fuzz(func(t *testing.T, val float32) {
-		actual := (Encoder{}).AppendFloat32(nil, val, -1)
-		if len(actual) == 0 {
-			t.Fatal("empty buffer")
-		}
-
-		if actual[0] == '"' {
-			val := float64(val)
-			switch string(actual) {
-			case `"NaN"`:
-				if !math.IsNaN(val) {
-					t.Fatalf("expected %v got NaN", val)
-				}
-			case `"+Inf"`:
-				if !math.IsInf(val, 1) {
-					t.Fatalf("expected %v got +Inf", val)
-				}
-			case `"-Inf"`:
-				if !math.IsInf(val, -1) {
-					t.Fatalf("expected %v got -Inf", val)
-				}
-			default:
-				t.Fatalf("unexpected string: %s", actual)
-			}
-			return
-		}
-
-		if expected, err := json.Marshal(val); err != nil {
-			t.Error(err)
-		} else if string(actual) != string(expected) {
-			t.Errorf("expected %s, got %s", expected, actual)
-		}
-
-		var parsed float32
-		if err := json.Unmarshal(actual, &parsed); err != nil {
-			t.Fatal(err)
-		}
-
-		if parsed != val {
-			t.Fatalf("expected %v, got %v", val, parsed)
-		}
-	})
-}
-
-func generateFloat32s(n int) []float32 {
-	floats := make([]float32, n)
-	for i := 0; i < n; i++ {
-		floats[i] = rand.Float32()
-	}
-	return floats
-}
-
-func generateFloat64s(n int) []float64 {
-	floats := make([]float64, n)
-	for i := 0; i < n; i++ {
-		floats[i] = rand.Float64()
-	}
-	return floats
-}
-
-// this is really just for the memory allocation characteristics
-func BenchmarkEncoder_AppendFloat32(b *testing.B) {
-	floats := append(generateFloat32s(5000), float32(math.NaN()), float32(math.Inf(1)), float32(math.Inf(-1)))
-	dst := make([]byte, 0, 128)
-
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		for _, f := range floats {
-			dst = (Encoder{}).AppendFloat32(dst[:0], f, -1)
-		}
-	}
-}
-
-// this is really just for the memory allocation characteristics
-func BenchmarkEncoder_AppendFloat64(b *testing.B) {
-	floats := append(generateFloat64s(5000), math.NaN(), math.Inf(1), math.Inf(-1))
-	dst := make([]byte, 0, 128)
-
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		for _, f := range floats {
-			dst = (Encoder{}).AppendFloat64(dst[:0], f, -1)
-		}
-	}
-}

journald/journald.go

@@ -1,4 +1,3 @@
-//go:build !windows
 // +build !windows
 
 // Package journald provides a io.Writer to send the logs
@@ -21,12 +20,11 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
-	"io"
-	"strings"
-
-	"github.com/coreos/go-systemd/v22/journal"
+	"github.com/coreos/go-systemd/journal"
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/internal/cbor"
+	"io"
+	"strings"
 )
 
 const defaultJournalDPrio = journal.PriNotice
@@ -49,8 +47,6 @@ func levelToJPrio(zLevel string) journal.Priority {
 	lvl, _ := zerolog.ParseLevel(zLevel)
 
 	switch lvl {
-	case zerolog.TraceLevel:
-		return journal.PriDebug
 	case zerolog.DebugLevel:
 		return journal.PriDebug
 	case zerolog.InfoLevel:
@@ -70,14 +66,17 @@ func levelToJPrio(zLevel string) journal.Priority {
 }
 
 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{}
-	origPLen := len(p)
 	p = cbor.DecodeIfBinaryToBytes(p)
 	d := json.NewDecoder(bytes.NewReader(p))
 	d.UseNumber()
 	err = d.Decode(&event)
 	jPrio := defaultJournalDPrio
-	args := make(map[string]string)
+	args := make(map[string]string, 0)
 	if err != nil {
 		return
 	}
@@ -96,13 +95,13 @@ func (w journalWriter) Write(p []byte) (n int, err error) {
 			continue
 		}
 
-		switch v := value.(type) {
+		switch value.(type) {
 		case string:
-			args[jKey] = v
+			args[jKey], _ = value.(string)
 		case json.Number:
 			args[jKey] = fmt.Sprint(value)
 		default:
-			b, err := zerolog.InterfaceMarshalFunc(value)
+			b, err := json.Marshal(value)
 			if err != nil {
 				args[jKey] = fmt.Sprintf("[error: %v]", err)
 			} else {
@@ -112,10 +111,5 @@ func (w journalWriter) Write(p []byte) (n int, err error) {
 	}
 	args["JSON"] = string(p)
 	err = journal.Send(msg, jPrio, args)
-
-	if err == nil {
-		n = origPLen
-	}
-
 	return
 }

journald/journald_test.go

@@ -1,15 +1,9 @@
-// +build linux
+// +build !windows
 
 package journald_test
 
-import (
-	"bytes"
-	"io"
-	"testing"
-
-	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/journald"
-)
+import "github.com/rs/zerolog"
+import "github.com/rs/zerolog/journald"
 
 func ExampleNewJournalDWriter() {
 	log := zerolog.New(journald.NewJournalDWriter())
@@ -48,39 +42,3 @@ Thu 2018-04-26 22:30:20.768136 PDT [s=3284d695bde946e4b5017c77a399237f;i=329f0;b
     _PID=27103
     _SOURCE_REALTIME_TIMESTAMP=1524807020768136
 */
-
-func TestWriteReturnsNoOfWrittenBytes(t *testing.T) {
-	input := []byte(`{"level":"info","time":1570912626,"message":"Starting..."}`)
-	wr := journald.NewJournalDWriter()
-	want := len(input)
-	got, err := wr.Write(input)
-
-	if err != nil {
-		t.Errorf("Unexpected error %v", err)
-	}
-
-	if want != got {
-		t.Errorf("Expected %d bytes to be written got %d", want, got)
-	}
-}
-
-func TestMultiWrite(t *testing.T) {
-	var (
-		w1 = new(bytes.Buffer)
-		w2 = new(bytes.Buffer)
-		w3 = journald.NewJournalDWriter()
-	)
-
-	zerolog.ErrorHandler = func(err error) {
-		if err == io.ErrShortWrite {
-			t.Errorf("Unexpected ShortWriteError")
-			t.FailNow()
-		}
-	}
-
-	log := zerolog.New(io.MultiWriter(w1, w2, w3)).With().Logger()
-
-	for i := 0; i < 10; i++ {
-		log.Info().Msg("Tick!")
-	}
-}

log.go

@@ -24,7 +24,7 @@
 //
 // Sub-loggers let you chain loggers with additional context:
 //
-//     sublogger := log.With().Str("component", "foo").Logger()
+//     sublogger := log.With().Str("component": "foo").Logger()
 //     sublogger.Info().Msg("hello world")
 //     // Output: {"time":1494567715,"level":"info","message":"hello world","component":"foo"}
 //
@@ -82,9 +82,8 @@
 //     log.Warn().Msg("")
 //     // Output: {"level":"warn","severity":"warn"}
 //
-// # Caveats
 //
-// Field duplication:
+// Caveats
 //
 // There is no fields deduplication out-of-the-box.
 // Using the same key multiple times creates new key in final JSON each time.
@@ -95,36 +94,20 @@
 //            Msg("dup")
 //     // Output: {"level":"info","time":1494567715,"time":1494567715,"message":"dup"}
 //
-// In this case, many consumers will take the last value,
-// but this is not guaranteed; check yours if in doubt.
-//
-// Concurrency safety:
-//
-// Be careful when calling UpdateContext. It is not concurrency safe. Use the With method to create a child logger:
-//
-//     func handler(w http.ResponseWriter, r *http.Request) {
-//         // Create a child logger for concurrency safety
-//         logger := log.Logger.With().Logger()
-//
-//         // Add context fields, for example User-Agent from HTTP headers
-//         logger.UpdateContext(func(c zerolog.Context) zerolog.Context {
-//             ...
-//         })
-//     }
+// However, it’s not a big deal though as JSON accepts dup keys,
+// the last one prevails.
 package zerolog
 
 import (
-	"context"
-	"errors"
 	"fmt"
 	"io"
+	"io/ioutil"
 	"os"
 	"strconv"
-	"strings"
 )
 
 // Level defines log levels.
-type Level int8
+type Level uint8
 
 const (
 	// DebugLevel defines debug log level.
@@ -143,87 +126,53 @@ const (
 	NoLevel
 	// Disabled disables the logger.
 	Disabled
-
-	// TraceLevel defines trace log level.
-	TraceLevel Level = -1
-	// Values less than TraceLevel are handled as numbers.
 )
 
 func (l Level) String() string {
 	switch l {
-	case TraceLevel:
-		return LevelTraceValue
 	case DebugLevel:
-		return LevelDebugValue
+		return "debug"
 	case InfoLevel:
-		return LevelInfoValue
+		return "info"
 	case WarnLevel:
-		return LevelWarnValue
+		return "warn"
 	case ErrorLevel:
-		return LevelErrorValue
+		return "error"
 	case FatalLevel:
-		return LevelFatalValue
+		return "fatal"
 	case PanicLevel:
-		return LevelPanicValue
-	case Disabled:
-		return "disabled"
+		return "panic"
 	case NoLevel:
 		return ""
 	}
-	return strconv.Itoa(int(l))
+	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 {
-	case strings.EqualFold(levelStr, LevelFieldMarshalFunc(TraceLevel)):
-		return TraceLevel, nil
-	case strings.EqualFold(levelStr, LevelFieldMarshalFunc(DebugLevel)):
+	switch levelStr {
+	case DebugLevel.String():
 		return DebugLevel, nil
-	case strings.EqualFold(levelStr, LevelFieldMarshalFunc(InfoLevel)):
+	case InfoLevel.String():
 		return InfoLevel, nil
-	case strings.EqualFold(levelStr, LevelFieldMarshalFunc(WarnLevel)):
+	case WarnLevel.String():
 		return WarnLevel, nil
-	case strings.EqualFold(levelStr, LevelFieldMarshalFunc(ErrorLevel)):
+	case ErrorLevel.String():
 		return ErrorLevel, nil
-	case strings.EqualFold(levelStr, LevelFieldMarshalFunc(FatalLevel)):
+	case FatalLevel.String():
 		return FatalLevel, nil
-	case strings.EqualFold(levelStr, LevelFieldMarshalFunc(PanicLevel)):
+	case PanicLevel.String():
 		return PanicLevel, nil
-	case strings.EqualFold(levelStr, LevelFieldMarshalFunc(Disabled)):
-		return Disabled, nil
-	case strings.EqualFold(levelStr, LevelFieldMarshalFunc(NoLevel)):
+	case NoLevel.String():
 		return NoLevel, nil
 	}
-	i, err := strconv.Atoi(levelStr)
-	if err != nil {
-		return NoLevel, fmt.Errorf("Unknown Level String: '%s', defaulting to NoLevel", levelStr)
-	}
-	if i > 127 || i < -128 {
-		return NoLevel, fmt.Errorf("Out-Of-Bounds Level: '%d', defaulting to NoLevel", i)
-	}
-	return Level(i), nil
-}
-
-// UnmarshalText implements encoding.TextUnmarshaler to allow for easy reading from toml/yaml/json formats
-func (l *Level) UnmarshalText(text []byte) error {
-	if l == nil {
-		return errors.New("can't unmarshal a nil *Level")
-	}
-	var err error
-	*l, err = ParseLevel(string(text))
-	return err
-}
-
-// MarshalText implements encoding.TextMarshaler to allow for easy writing into toml/yaml/json formats
-func (l Level) MarshalText() ([]byte, error) {
-	return []byte(LevelFieldMarshalFunc(l)), 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 guarantee on access
+// call to the Writer's Write method. There is no guaranty on access
 // serialization to the Writer. If your Writer is not thread safe,
 // you may consider a sync wrapper.
 type Logger struct {
@@ -232,8 +181,6 @@ type Logger struct {
 	sampler Sampler
 	context []byte
 	hooks   []Hook
-	stack   bool
-	ctx     context.Context
 }
 
 // New creates a root logger with given output writer. If the output writer implements
@@ -241,17 +188,17 @@ type Logger struct {
 // one.
 //
 // Each logging operation makes a single call to the Writer's Write method. There is no
-// guarantee on access serialization to the Writer. If your Writer is not thread safe,
+// guaranty on access serialization to the Writer. If your Writer is not thread safe,
 // you may consider using sync wrapper.
 func New(w io.Writer) Logger {
 	if w == nil {
-		w = io.Discard
+		w = ioutil.Discard
 	}
 	lw, ok := w.(LevelWriter)
 	if !ok {
-		lw = LevelWriterAdapter{w}
+		lw = levelWriterAdapter{w}
 	}
-	return Logger{w: lw, level: TraceLevel}
+	return Logger{w: lw}
 }
 
 // Nop returns a disabled logger for which all operation are no-op.
@@ -264,7 +211,6 @@ func (l Logger) Output(w io.Writer) Logger {
 	l2 := New(w)
 	l2.level = l.level
 	l2.sampler = l.sampler
-	l2.stack = l.stack
 	if len(l.hooks) > 0 {
 		l2.hooks = append(l2.hooks, l.hooks...)
 	}
@@ -281,18 +227,13 @@ func (l Logger) With() Context {
 	l.context = make([]byte, 0, 500)
 	if context != nil {
 		l.context = append(l.context, context...)
-	} else {
-		// This is needed for AppendKey to not check len of input
-		// thus making it inlinable
-		l.context = enc.AppendBeginMarker(l.context)
 	}
 	return Context{l}
 }
 
 // UpdateContext updates the internal logger's context.
 //
-// Caution: This method is not concurrency safe.
-// Use the With method to create a child logger before modifying the context from concurrent goroutines.
+// Use this method with caution. If unsure, prefer the With method.
 func (l *Logger) UpdateContext(update func(c Context) Context) {
 	if l == disabledLogger {
 		return
@@ -300,9 +241,6 @@ func (l *Logger) UpdateContext(update func(c Context) Context) {
 	if cap(l.context) == 0 {
 		l.context = make([]byte, 0, 500)
 	}
-	if len(l.context) == 0 {
-		l.context = enc.AppendBeginMarker(l.context)
-	}
 	c := update(Context{*l})
 	l.context = c.l.context
 }
@@ -313,11 +251,6 @@ func (l Logger) Level(lvl Level) Logger {
 	return l
 }
 
-// GetLevel returns the current Level of l.
-func (l Logger) GetLevel() Level {
-	return l.level
-}
-
 // Sample returns a logger with the s sampler.
 func (l Logger) Sample(s Sampler) Logger {
 	l.sampler = s
@@ -325,23 +258,11 @@ func (l Logger) Sample(s Sampler) Logger {
 }
 
 // Hook returns a logger with the h Hook.
-func (l Logger) Hook(hooks ...Hook) Logger {
-	if len(hooks) == 0 {
-		return l
-	}
-	newHooks := make([]Hook, len(l.hooks), len(l.hooks)+len(hooks))
-	copy(newHooks, l.hooks)
-	l.hooks = append(newHooks, hooks...)
+func (l Logger) Hook(h Hook) Logger {
+	l.hooks = append(l.hooks, h)
 	return l
 }
 
-// Trace starts a new message with trace level.
-//
-// You must call Msg on the returned event in order to send the event.
-func (l *Logger) Trace() *Event {
-	return l.newEvent(TraceLevel, nil)
-}
-
 // Debug starts a new message with debug level.
 //
 // You must call Msg on the returned event in order to send the event.
@@ -370,31 +291,12 @@ func (l *Logger) Error() *Event {
 	return l.newEvent(ErrorLevel, nil)
 }
 
-// Err starts a new message with error level with err as a field if not nil or
-// with info level if err is nil.
-//
-// You must call Msg on the returned event in order to send the event.
-func (l *Logger) Err(err error) *Event {
-	if err != nil {
-		return l.Error().Err(err)
-	}
-
-	return l.Info()
-}
-
 // Fatal starts a new message with fatal level. The os.Exit(1) function
 // is called by the Msg method, which terminates the program immediately.
 //
 // You must call Msg on the returned event in order to send the event.
 func (l *Logger) Fatal() *Event {
-	return l.newEvent(FatalLevel, func(msg string) {
-		if closer, ok := l.w.(io.Closer); ok {
-			// Close the writer to flush any buffered message. Otherwise the message
-			// will be lost as os.Exit() terminates the program immediately.
-			closer.Close()
-		}
-		os.Exit(1)
-	})
+	return l.newEvent(FatalLevel, func(msg string) { os.Exit(1) })
 }
 
 // Panic starts a new message with panic level. The panic() function
@@ -407,13 +309,11 @@ func (l *Logger) Panic() *Event {
 
 // WithLevel starts a new message with level. Unlike Fatal and Panic
 // methods, WithLevel does not terminate the program or stop the ordinary
-// flow of a goroutine when used with their respective levels.
+// flow of a gourotine when used with their respective levels.
 //
 // You must call Msg on the returned event in order to send the event.
 func (l *Logger) WithLevel(level Level) *Event {
 	switch level {
-	case TraceLevel:
-		return l.Trace()
 	case DebugLevel:
 		return l.Debug()
 	case InfoLevel:
@@ -431,7 +331,7 @@ func (l *Logger) WithLevel(level Level) *Event {
 	case Disabled:
 		return nil
 	default:
-		return l.newEvent(level, nil)
+		panic("zerolog: WithLevel(): invalid level: " + strconv.Itoa(int(level)))
 	}
 }
 
@@ -447,7 +347,7 @@ func (l *Logger) Log() *Event {
 // Arguments are handled in the manner of fmt.Print.
 func (l *Logger) Print(v ...interface{}) {
 	if e := l.Debug(); e.Enabled() {
-		e.CallerSkipFrame(1).Msg(fmt.Sprint(v...))
+		e.Msg(fmt.Sprint(v...))
 	}
 }
 
@@ -455,15 +355,7 @@ func (l *Logger) Print(v ...interface{}) {
 // Arguments are handled in the manner of fmt.Printf.
 func (l *Logger) Printf(format string, v ...interface{}) {
 	if e := l.Debug(); e.Enabled() {
-		e.CallerSkipFrame(1).Msg(fmt.Sprintf(format, v...))
-	}
-}
-
-// Println sends a log event using debug level and no extra field.
-// Arguments are handled in the manner of fmt.Println.
-func (l *Logger) Println(v ...interface{}) {
-	if e := l.Debug(); e.Enabled() {
-		e.CallerSkipFrame(1).Msg(fmt.Sprintln(v...))
+		e.Msg(fmt.Sprintf(format, v...))
 	}
 }
 
@@ -475,39 +367,29 @@ func (l Logger) Write(p []byte) (n int, err error) {
 		// Trim CR added by stdlog.
 		p = p[0 : n-1]
 	}
-	l.Log().CallerSkipFrame(1).Msg(string(p))
+	l.Log().Msg(string(p))
 	return
 }
 
 func (l *Logger) newEvent(level Level, done func(string)) *Event {
 	enabled := l.should(level)
 	if !enabled {
-		if done != nil {
-			done("")
-		}
 		return nil
 	}
 	e := newEvent(l.w, level)
 	e.done = done
 	e.ch = l.hooks
-	e.ctx = l.ctx
-	if level != NoLevel && LevelFieldName != "" {
-		e.Str(LevelFieldName, LevelFieldMarshalFunc(level))
+	if level != NoLevel {
+		e.Str(LevelFieldName, level.String())
 	}
-	if len(l.context) > 1 {
+	if l.context != nil && len(l.context) > 0 {
 		e.buf = enc.AppendObjectData(e.buf, l.context)
 	}
-	if l.stack {
-		e.Stack()
-	}
 	return e
 }
 
 // should returns true if the log event should be logged.
 func (l *Logger) should(lvl Level) bool {
-	if l.w == nil {
-		return false
-	}
 	if lvl < l.level || lvl < GlobalLevel() {
 		return false
 	}

log/log.go

@@ -3,7 +3,6 @@ package log
 
 import (
 	"context"
-	"fmt"
 	"io"
 	"os"
 
@@ -38,21 +37,6 @@ func Hook(h zerolog.Hook) zerolog.Logger {
 	return Logger.Hook(h)
 }
 
-// Err starts a new message with error level with err as a field if not nil or
-// with info level if err is nil.
-//
-// You must call Msg on the returned event in order to send the event.
-func Err(err error) *zerolog.Event {
-	return Logger.Err(err)
-}
-
-// Trace starts a new message with trace level.
-//
-// You must call Msg on the returned event in order to send the event.
-func Trace() *zerolog.Event {
-	return Logger.Trace()
-}
-
 // Debug starts a new message with debug level.
 //
 // You must call Msg on the returned event in order to send the event.
@@ -115,13 +99,13 @@ func Log() *zerolog.Event {
 // Print sends a log event using debug level and no extra field.
 // Arguments are handled in the manner of fmt.Print.
 func Print(v ...interface{}) {
-	Logger.Debug().CallerSkipFrame(1).Msg(fmt.Sprint(v...))
+	Logger.Print(v...)
 }
 
 // Printf sends a log event using debug level and no extra field.
 // Arguments are handled in the manner of fmt.Printf.
 func Printf(format string, v ...interface{}) {
-	Logger.Debug().CallerSkipFrame(1).Msgf(format, v...)
+	Logger.Printf(format, v...)
 }
 
 // Ctx returns the Logger associated with the ctx. If no logger

log/log_example_test.go

@@ -54,25 +54,6 @@ func ExampleLog() {
 	// Output: {"time":1199811905,"message":"hello world"}
 }
 
-// Example of a conditional level based on the presence of an error.
-func ExampleErr() {
-	setup()
-	err := errors.New("some error")
-	log.Err(err).Msg("hello world")
-	log.Err(nil).Msg("hello world")
-
-	// Output: {"level":"error","error":"some error","time":1199811905,"message":"hello world"}
-	// {"level":"info","time":1199811905,"message":"hello world"}
-}
-
-// Example of a log at a particular "level" (in this case, "trace")
-func ExampleTrace() {
-	setup()
-	log.Trace().Msg("hello world")
-
-	// Output: {"level":"trace","time":1199811905,"message":"hello world"}
-}
-
 // Example of a log at a particular "level" (in this case, "debug")
 func ExampleDebug() {
 	setup()

log_example_test.go

@@ -72,7 +72,7 @@ func ExampleLogger_Hook() {
 	var levelNameHook LevelNameHook
 	var messageHook MessageHook = "The message"
 
-	log := zerolog.New(os.Stdout).Hook(levelNameHook, messageHook)
+	log := zerolog.New(os.Stdout).Hook(levelNameHook).Hook(messageHook)
 
 	log.Info().Msg("hello world")
 
@@ -95,25 +95,6 @@ func ExampleLogger_Printf() {
 	// Output: {"level":"debug","message":"hello world"}
 }
 
-func ExampleLogger_Println() {
-	log := zerolog.New(os.Stdout)
-
-	log.Println("hello world")
-
-	// Output: {"level":"debug","message":"hello world\n"}
-}
-
-func ExampleLogger_Trace() {
-	log := zerolog.New(os.Stdout)
-
-	log.Trace().
-		Str("foo", "bar").
-		Int("n", 123).
-		Msg("hello world")
-
-	// Output: {"level":"trace","foo":"bar","n":123,"message":"hello world"}
-}
-
 func ExampleLogger_Debug() {
 	log := zerolog.New(os.Stdout)
 
@@ -246,15 +227,11 @@ func ExampleEvent_Array() {
 		Str("foo", "bar").
 		Array("array", zerolog.Arr().
 			Str("baz").
-			Int(1).
-			Dict(zerolog.Dict().
-				Str("bar", "baz").
-				Int("n", 1),
-			),
+			Int(1),
 		).
 		Msg("hello world")
 
-	// Output: {"foo":"bar","array":["baz",1,{"bar":"baz","n":1}],"message":"hello world"}
+	// Output: {"foo":"bar","array":["baz",1],"message":"hello world"}
 }
 
 func ExampleEvent_Array_object() {
@@ -319,7 +296,7 @@ func ExampleEvent_Interface() {
 }
 
 func ExampleEvent_Dur() {
-	d := 10 * time.Second
+	d := time.Duration(10 * time.Second)
 
 	log := zerolog.New(os.Stdout)
 
@@ -333,8 +310,8 @@ func ExampleEvent_Dur() {
 
 func ExampleEvent_Durs() {
 	d := []time.Duration{
-		10 * time.Second,
-		20 * time.Second,
+		time.Duration(10 * time.Second),
+		time.Duration(20 * time.Second),
 	}
 
 	log := zerolog.New(os.Stdout)
@@ -347,38 +324,6 @@ func ExampleEvent_Durs() {
 	// Output: {"foo":"bar","durs":[10000,20000],"message":"hello world"}
 }
 
-func ExampleEvent_Fields_map() {
-	fields := map[string]interface{}{
-		"bar": "baz",
-		"n":   1,
-	}
-
-	log := zerolog.New(os.Stdout)
-
-	log.Log().
-		Str("foo", "bar").
-		Fields(fields).
-		Msg("hello world")
-
-	// Output: {"foo":"bar","bar":"baz","n":1,"message":"hello world"}
-}
-
-func ExampleEvent_Fields_slice() {
-	fields := []interface{}{
-		"bar", "baz",
-		"n", 1,
-	}
-
-	log := zerolog.New(os.Stdout)
-
-	log.Log().
-		Str("foo", "bar").
-		Fields(fields).
-		Msg("hello world")
-
-	// Output: {"foo":"bar","bar":"baz","n":1,"message":"hello world"}
-}
-
 func ExampleContext_Dict() {
 	log := zerolog.New(os.Stdout).With().
 		Str("foo", "bar").
@@ -468,7 +413,7 @@ func ExampleContext_Interface() {
 }
 
 func ExampleContext_Dur() {
-	d := 10 * time.Second
+	d := time.Duration(10 * time.Second)
 
 	log := zerolog.New(os.Stdout).With().
 		Str("foo", "bar").
@@ -482,8 +427,8 @@ func ExampleContext_Dur() {
 
 func ExampleContext_Durs() {
 	d := []time.Duration{
-		10 * time.Second,
-		20 * time.Second,
+		time.Duration(10 * time.Second),
+		time.Duration(20 * time.Second),
 	}
 
 	log := zerolog.New(os.Stdout).With().
@@ -518,7 +463,7 @@ func ExampleContext_IPPrefix() {
 	// Output: {"Route":"192.168.0.0/24","message":"hello world"}
 }
 
-func ExampleContext_MACAddr() {
+func ExampleContext_MacAddr() {
 	mac := net.HardwareAddr{0x00, 0x14, 0x22, 0x01, 0x23, 0x45}
 	log := zerolog.New(os.Stdout).With().
 		MACAddr("hostMAC", mac).
@@ -528,35 +473,3 @@ func ExampleContext_MACAddr() {
 
 	// Output: {"hostMAC":"00:14:22:01:23:45","message":"hello world"}
 }
-
-func ExampleContext_Fields_map() {
-	fields := map[string]interface{}{
-		"bar": "baz",
-		"n":   1,
-	}
-
-	log := zerolog.New(os.Stdout).With().
-		Str("foo", "bar").
-		Fields(fields).
-		Logger()
-
-	log.Log().Msg("hello world")
-
-	// Output: {"foo":"bar","bar":"baz","n":1,"message":"hello world"}
-}
-
-func ExampleContext_Fields_slice() {
-	fields := []interface{}{
-		"bar", "baz",
-		"n", 1,
-	}
-
-	log := zerolog.New(os.Stdout).With().
-		Str("foo", "bar").
-		Fields(fields).
-		Logger()
-
-	log.Log().Msg("hello world")
-
-	// Output: {"foo":"bar","bar":"baz","n":1,"message":"hello world"}
-}

log_test.go

@@ -2,14 +2,11 @@ package zerolog
 
 import (
 	"bytes"
-	"context"
 	"errors"
 	"fmt"
 	"net"
 	"reflect"
 	"runtime"
-	"strconv"
-	"strings"
 	"testing"
 	"time"
 )
@@ -78,30 +75,10 @@ func TestInfo(t *testing.T) {
 	})
 }
 
-func TestEmptyLevelFieldName(t *testing.T) {
-	fieldName := LevelFieldName
-	LevelFieldName = ""
-
-	t.Run("empty setting", func(t *testing.T) {
-		out := &bytes.Buffer{}
-		log := New(out)
-		log.Info().
-			Str("foo", "bar").
-			Int("n", 123).
-			Msg("")
-		if got, want := decodeIfBinaryToString(out.Bytes()), `{"foo":"bar","n":123}`+"\n"; got != want {
-			t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
-		}
-	})
-	LevelFieldName = fieldName
-}
-
 func TestWith(t *testing.T) {
 	out := &bytes.Buffer{}
 	ctx := New(out).With().
 		Str("string", "foo").
-		Stringer("stringer", net.IP{127, 0, 0, 1}).
-		Stringer("stringer_nil", nil).
 		Bytes("bytes", []byte("bar")).
 		Hex("hex", []byte{0x12, 0xef}).
 		RawJSON("json", []byte(`{"some":"json"}`)).
@@ -120,46 +97,12 @@ func TestWith(t *testing.T) {
 		Uint64("uint64", 10).
 		Float32("float32", 11.101).
 		Float64("float64", 12.30303).
-		Time("time", time.Time{}).
-		Ctx(context.Background())
+		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","stringer":"127.0.0.1","stringer_nil":null,"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)
-	}
-
-	// Validate CallerWithSkipFrameCount.
-	out.Reset()
-	_, file, line, _ = runtime.Caller(0)
-	caller = fmt.Sprintf("%s:%d", file, line+5)
-	log = ctx.CallerWithSkipFrameCount(3).Logger()
-	func() {
-		log.Log().Msg("")
-	}()
-	// The above line is a little contrived, but the line above should be the line due
-	// to the extra frame skip.
-	if got, want := decodeIfBinaryToString(out.Bytes()), `{"string":"foo","stringer":"127.0.0.1","stringer_nil":null,"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)
-	}
-}
-
-func TestWithReset(t *testing.T) {
-	out := &bytes.Buffer{}
-	ctx := New(out).With().
-		Str("string", "foo").
-		Stringer("stringer", net.IP{127, 0, 0, 1}).
-		Stringer("stringer_nil", nil).
-		Reset().
-		Bytes("bytes", []byte("bar")).
-		Hex("hex", []byte{0x12, 0xef}).
-		Uint64("uint64", 10).
-		Float64("float64", 12.30303).
-		Ctx(context.Background())
-	log := ctx.Logger()
-	log.Log().Msg("")
-	if got, want := decodeIfBinaryToString(out.Bytes()), `{"bytes":"bar","hex":"12ef","uint64":10,"float64":12.30303}`+"\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)
 	}
 }
@@ -267,66 +210,6 @@ func TestFieldsMapNilPnt(t *testing.T) {
 	}
 }
 
-func TestFieldsSlice(t *testing.T) {
-	out := &bytes.Buffer{}
-	log := New(out)
-	log.Log().Fields([]interface{}{
-		"nil", nil,
-		"string", "foo",
-		"bytes", []byte("bar"),
-		"error", errors.New("some error"),
-		"bool", true,
-		"int", int(1),
-		"int8", int8(2),
-		"int16", int16(3),
-		"int32", int32(4),
-		"int64", int64(5),
-		"uint", uint(6),
-		"uint8", uint8(7),
-		"uint16", uint16(8),
-		"uint32", uint32(9),
-		"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()), `{"nil":null,"string":"foo","bytes":"bar","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,"ipv6":"2001:db8:85a3::8a2e:370:7334","dur":1000,"time":"0001-01-01T00:00:00Z","obj":{"Pub":"a","Tag":"b","priv":1}}`+"\n"; got != want {
-		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
-	}
-}
-
-func TestFieldsSliceExtraneous(t *testing.T) {
-	out := &bytes.Buffer{}
-	log := New(out)
-	log.Log().Fields([]interface{}{
-		"string", "foo",
-		"error", errors.New("some error"),
-		32, "valueForNonStringKey",
-		"bool", true,
-		"int", int(1),
-		"keyWithoutValue",
-	}).Msg("")
-	if got, want := decodeIfBinaryToString(out.Bytes()), `{"string":"foo","error":"some error","bool":true,"int":1}`+"\n"; got != want {
-		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
-	}
-}
-
-func TestFieldsNotMapSlice(t *testing.T) {
-	out := &bytes.Buffer{}
-	log := New(out)
-	log.Log().
-		Fields(obj{"a", "b", 1}).
-		Fields("string").
-		Fields(1).
-		Msg("")
-	if got, want := decodeIfBinaryToString(out.Bytes()), `{}`+"\n"; got != want {
-		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
-	}
-}
-
 func TestFields(t *testing.T) {
 	out := &bytes.Buffer{}
 	log := New(out)
@@ -336,13 +219,9 @@ func TestFields(t *testing.T) {
 	log.Log().
 		Caller().
 		Str("string", "foo").
-		Stringer("stringer", net.IP{127, 0, 0, 1}).
-		Stringer("stringer_nil", nil).
 		Bytes("bytes", []byte("bar")).
 		Hex("hex", []byte{0x12, 0xef}).
 		RawJSON("json", []byte(`{"some":"json"}`)).
-		RawCBOR("cbor", []byte{0x83, 0x01, 0x82, 0x02, 0x03, 0x82, 0x04, 0x05}).
-		Func(func(e *Event) { e.Str("func", "func_output") }).
 		AnErr("some_err", nil).
 		Err(errors.New("some error")).
 		Bool("bool", true).
@@ -365,9 +244,8 @@ func TestFields(t *testing.T) {
 		Dur("dur", 1*time.Second).
 		Time("time", time.Time{}).
 		TimeDiff("diff", now, now.Add(-10*time.Second)).
-		Ctx(context.Background()).
 		Msg("")
-	if got, want := decodeIfBinaryToString(out.Bytes()), `{"caller":"`+caller+`","string":"foo","stringer":"127.0.0.1","stringer_nil":null,"bytes":"bar","hex":"12ef","json":{"some":"json"},"cbor":"data:application/cbor;base64,gwGCAgOCBAU=","func":"func_output","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 {
+	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)
 	}
 }
@@ -377,7 +255,6 @@ func TestFieldsArrayEmpty(t *testing.T) {
 	log := New(out)
 	log.Log().
 		Strs("string", []string{}).
-		Stringers("stringer", []fmt.Stringer{}).
 		Errs("err", []error{}).
 		Bools("bool", []bool{}).
 		Ints("int", []int{}).
@@ -395,7 +272,7 @@ func TestFieldsArrayEmpty(t *testing.T) {
 		Durs("dur", []time.Duration{}).
 		Times("time", []time.Time{}).
 		Msg("")
-	if got, want := decodeIfBinaryToString(out.Bytes()), `{"string":[],"stringer":[],"err":[],"bool":[],"int":[],"int8":[],"int16":[],"int32":[],"int64":[],"uint":[],"uint8":[],"uint16":[],"uint32":[],"uint64":[],"float32":[],"float64":[],"dur":[],"time":[]}`+"\n"; got != want {
+	if got, want := decodeIfBinaryToString(out.Bytes()), `{"string":[],"err":[],"bool":[],"int":[],"int8":[],"int16":[],"int32":[],"int64":[],"uint":[],"uint8":[],"uint16":[],"uint32":[],"uint64":[],"float32":[],"float64":[],"dur":[],"time":[]}`+"\n"; got != want {
 		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
 	}
 }
@@ -405,7 +282,6 @@ func TestFieldsArraySingleElement(t *testing.T) {
 	log := New(out)
 	log.Log().
 		Strs("string", []string{"foo"}).
-		Stringers("stringer", []fmt.Stringer{net.IP{127, 0, 0, 1}}).
 		Errs("err", []error{errors.New("some error")}).
 		Bools("bool", []bool{true}).
 		Ints("int", []int{1}).
@@ -421,9 +297,9 @@ func TestFieldsArraySingleElement(t *testing.T) {
 		Floats32("float32", []float32{11}).
 		Floats64("float64", []float64{12}).
 		Durs("dur", []time.Duration{1 * time.Second}).
-		Times("time", []time.Time{{}}).
+		Times("time", []time.Time{time.Time{}}).
 		Msg("")
-	if got, want := decodeIfBinaryToString(out.Bytes()), `{"string":["foo"],"stringer":["127.0.0.1"],"err":["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"]}`+"\n"; got != want {
+	if got, want := decodeIfBinaryToString(out.Bytes()), `{"string":["foo"],"err":["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"]}`+"\n"; got != want {
 		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
 	}
 }
@@ -433,7 +309,6 @@ func TestFieldsArrayMultipleElement(t *testing.T) {
 	log := New(out)
 	log.Log().
 		Strs("string", []string{"foo", "bar"}).
-		Stringers("stringer", []fmt.Stringer{nil, net.IP{127, 0, 0, 1}}).
 		Errs("err", []error{errors.New("some error"), nil}).
 		Bools("bool", []bool{true, false}).
 		Ints("int", []int{1, 0}).
@@ -449,9 +324,9 @@ func TestFieldsArrayMultipleElement(t *testing.T) {
 		Floats32("float32", []float32{11, 0}).
 		Floats64("float64", []float64{12, 0}).
 		Durs("dur", []time.Duration{1 * time.Second, 0}).
-		Times("time", []time.Time{{}, {}}).
+		Times("time", []time.Time{time.Time{}, time.Time{}}).
 		Msg("")
-	if got, want := decodeIfBinaryToString(out.Bytes()), `{"string":["foo","bar"],"stringer":[null,"127.0.0.1"],"err":["some error",null],"bool":[true,false],"int":[1,0],"int8":[2,0],"int16":[3,0],"int32":[4,0],"int64":[5,0],"uint":[6,0],"uint8":[7,0],"uint16":[8,0],"uint32":[9,0],"uint64":[10,0],"float32":[11,0],"float64":[12,0],"dur":[1000,0],"time":["0001-01-01T00:00:00Z","0001-01-01T00:00:00Z"]}`+"\n"; got != want {
+	if got, want := decodeIfBinaryToString(out.Bytes()), `{"string":["foo","bar"],"err":["some error",null],"bool":[true,false],"int":[1,0],"int8":[2,0],"int16":[3,0],"int32":[4,0],"int64":[5,0],"uint":[6,0],"uint8":[7,0],"uint16":[8,0],"uint32":[9,0],"uint64":[10,0],"float32":[11,0],"float64":[12,0],"dur":[1000,0],"time":["0001-01-01T00:00:00Z","0001-01-01T00:00:00Z"]}`+"\n"; got != want {
 		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
 	}
 }
@@ -462,12 +337,10 @@ func TestFieldsDisabled(t *testing.T) {
 	now := time.Now()
 	log.Debug().
 		Str("string", "foo").
-		Stringer("stringer", net.IP{127, 0, 0, 1}).
 		Bytes("bytes", []byte("bar")).
 		Hex("hex", []byte{0x12, 0xef}).
 		AnErr("some_err", nil).
 		Err(errors.New("some error")).
-		Func(func(e *Event) { e.Str("func", "func_output") }).
 		Bool("bool", true).
 		Int("int", 1).
 		Int8("int8", 2).
@@ -484,7 +357,6 @@ func TestFieldsDisabled(t *testing.T) {
 		Dur("dur", 1*time.Second).
 		Time("time", time.Time{}).
 		TimeDiff("diff", now, now.Add(-10*time.Second)).
-		Ctx(context.Background()).
 		Msg("")
 	if got, want := decodeIfBinaryToString(out.Bytes()), ""; got != want {
 		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
@@ -565,24 +437,6 @@ func TestLevel(t *testing.T) {
 	})
 }
 
-func TestGetLevel(t *testing.T) {
-	levels := []Level{
-		DebugLevel,
-		InfoLevel,
-		WarnLevel,
-		ErrorLevel,
-		FatalLevel,
-		PanicLevel,
-		NoLevel,
-		Disabled,
-	}
-	for _, level := range levels {
-		if got, want := New(nil).Level(level).GetLevel(), level; got != want {
-			t.Errorf("GetLevel() = %v, want: %v", got, want)
-		}
-	}
-}
-
 func TestSampling(t *testing.T) {
 	out := &bytes.Buffer{}
 	log := New(out).Sample(&BasicSampler{N: 2})
@@ -637,45 +491,32 @@ func TestLevelWriter(t *testing.T) {
 			p string
 		}{},
 	}
-
-	// Allow extra-verbose logs.
-	SetGlobalLevel(TraceLevel - 1)
-	log := New(lw).Level(TraceLevel - 1)
-
-	log.Trace().Msg("0")
+	log := New(lw)
 	log.Debug().Msg("1")
 	log.Info().Msg("2")
 	log.Warn().Msg("3")
 	log.Error().Msg("4")
 	log.Log().Msg("nolevel-1")
-	log.WithLevel(TraceLevel).Msg("5")
-	log.WithLevel(DebugLevel).Msg("6")
-	log.WithLevel(InfoLevel).Msg("7")
-	log.WithLevel(WarnLevel).Msg("8")
-	log.WithLevel(ErrorLevel).Msg("9")
+	log.WithLevel(DebugLevel).Msg("5")
+	log.WithLevel(InfoLevel).Msg("6")
+	log.WithLevel(WarnLevel).Msg("7")
+	log.WithLevel(ErrorLevel).Msg("8")
 	log.WithLevel(NoLevel).Msg("nolevel-2")
-	log.WithLevel(-1).Msg("-1") // Same as TraceLevel
-	log.WithLevel(-2).Msg("-2") // Will log
-	log.WithLevel(-3).Msg("-3") // Will not log
 
 	want := []struct {
 		l Level
 		p string
 	}{
-		{TraceLevel, `{"level":"trace","message":"0"}` + "\n"},
 		{DebugLevel, `{"level":"debug","message":"1"}` + "\n"},
 		{InfoLevel, `{"level":"info","message":"2"}` + "\n"},
 		{WarnLevel, `{"level":"warn","message":"3"}` + "\n"},
 		{ErrorLevel, `{"level":"error","message":"4"}` + "\n"},
 		{NoLevel, `{"message":"nolevel-1"}` + "\n"},
-		{TraceLevel, `{"level":"trace","message":"5"}` + "\n"},
-		{DebugLevel, `{"level":"debug","message":"6"}` + "\n"},
-		{InfoLevel, `{"level":"info","message":"7"}` + "\n"},
-		{WarnLevel, `{"level":"warn","message":"8"}` + "\n"},
-		{ErrorLevel, `{"level":"error","message":"9"}` + "\n"},
+		{DebugLevel, `{"level":"debug","message":"5"}` + "\n"},
+		{InfoLevel, `{"level":"info","message":"6"}` + "\n"},
+		{WarnLevel, `{"level":"warn","message":"7"}` + "\n"},
+		{ErrorLevel, `{"level":"error","message":"8"}` + "\n"},
 		{NoLevel, `{"message":"nolevel-2"}` + "\n"},
-		{Level(-1), `{"level":"trace","message":"-1"}` + "\n"},
-		{Level(-2), `{"level":"-2","message":"-2"}` + "\n"},
 	}
 	if got := lw.ops; !reflect.DeepEqual(got, want) {
 		t.Errorf("invalid ops:\ngot:\n%v\nwant:\n%v", got, want)
@@ -800,75 +641,6 @@ func TestErrorMarshalFunc(t *testing.T) {
 	}
 }
 
-func TestCallerMarshalFunc(t *testing.T) {
-	out := &bytes.Buffer{}
-	log := New(out)
-
-	// test default behaviour this is really brittle due to the line numbers
-	// actually mattering for validation
-	pc, file, line, _ := runtime.Caller(0)
-	caller := fmt.Sprintf("%s:%d", file, line+2)
-	log.Log().Caller().Msg("msg")
-	if got, want := decodeIfBinaryToString(out.Bytes()), `{"caller":"`+caller+`","message":"msg"}`+"\n"; got != want {
-		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
-	}
-	out.Reset()
-
-	// test custom behavior. In this case we'll take just the last directory
-	origCallerMarshalFunc := CallerMarshalFunc
-	defer func() { CallerMarshalFunc = origCallerMarshalFunc }()
-	CallerMarshalFunc = func(pc uintptr, file string, line int) string {
-		parts := strings.Split(file, "/")
-		if len(parts) > 1 {
-			return strings.Join(parts[len(parts)-2:], "/") + ":" + strconv.Itoa(line)
-		}
-
-		return runtime.FuncForPC(pc).Name() + ":" + file + ":" + strconv.Itoa(line)
-	}
-	pc, file, line, _ = runtime.Caller(0)
-	caller = CallerMarshalFunc(pc, file, line+2)
-	log.Log().Caller().Msg("msg")
-	if got, want := decodeIfBinaryToString(out.Bytes()), `{"caller":"`+caller+`","message":"msg"}`+"\n"; got != want {
-		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
-	}
-}
-
-func TestLevelFieldMarshalFunc(t *testing.T) {
-	origLevelFieldMarshalFunc := LevelFieldMarshalFunc
-	LevelFieldMarshalFunc = func(l Level) string {
-		return strings.ToUpper(l.String())
-	}
-	defer func() {
-		LevelFieldMarshalFunc = origLevelFieldMarshalFunc
-	}()
-	out := &bytes.Buffer{}
-	log := New(out)
-
-	log.Debug().Msg("test")
-	if got, want := decodeIfBinaryToString(out.Bytes()), `{"level":"DEBUG","message":"test"}`+"\n"; got != want {
-		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
-	}
-	out.Reset()
-
-	log.Info().Msg("test")
-	if got, want := decodeIfBinaryToString(out.Bytes()), `{"level":"INFO","message":"test"}`+"\n"; got != want {
-		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
-	}
-	out.Reset()
-
-	log.Warn().Msg("test")
-	if got, want := decodeIfBinaryToString(out.Bytes()), `{"level":"WARN","message":"test"}`+"\n"; got != want {
-		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
-	}
-	out.Reset()
-
-	log.Error().Msg("test")
-	if got, want := decodeIfBinaryToString(out.Bytes()), `{"level":"ERROR","message":"test"}`+"\n"; got != want {
-		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
-	}
-	out.Reset()
-}
-
 type errWriter struct {
 	error
 }
@@ -889,155 +661,3 @@ func TestErrorHandler(t *testing.T) {
 		t.Errorf("ErrorHandler err = %#v, want %#v", got, want)
 	}
 }
-
-func TestUpdateEmptyContext(t *testing.T) {
-	var buf bytes.Buffer
-	log := New(&buf)
-
-	log.UpdateContext(func(c Context) Context {
-		return c.Str("foo", "bar")
-	})
-	log.Info().Msg("no panic")
-
-	want := `{"level":"info","foo":"bar","message":"no panic"}` + "\n"
-
-	if got := decodeIfBinaryToString(buf.Bytes()); got != want {
-		t.Errorf("invalid log output:\ngot:  %q\nwant: %q", got, want)
-	}
-}
-
-func TestLevel_String(t *testing.T) {
-	tests := []struct {
-		name string
-		l    Level
-		want string
-	}{
-		{"trace", TraceLevel, "trace"},
-		{"debug", DebugLevel, "debug"},
-		{"info", InfoLevel, "info"},
-		{"warn", WarnLevel, "warn"},
-		{"error", ErrorLevel, "error"},
-		{"fatal", FatalLevel, "fatal"},
-		{"panic", PanicLevel, "panic"},
-		{"disabled", Disabled, "disabled"},
-		{"nolevel", NoLevel, ""},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := tt.l.String(); got != tt.want {
-				t.Errorf("String() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestLevel_MarshalText(t *testing.T) {
-	tests := []struct {
-		name string
-		l    Level
-		want string
-	}{
-		{"trace", TraceLevel, "trace"},
-		{"debug", DebugLevel, "debug"},
-		{"info", InfoLevel, "info"},
-		{"warn", WarnLevel, "warn"},
-		{"error", ErrorLevel, "error"},
-		{"fatal", FatalLevel, "fatal"},
-		{"panic", PanicLevel, "panic"},
-		{"disabled", Disabled, "disabled"},
-		{"nolevel", NoLevel, ""},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got, err := tt.l.MarshalText(); err != nil {
-				t.Errorf("MarshalText couldn't marshal: %v", tt.l)
-			} else if string(got) != tt.want {
-				t.Errorf("String() = %v, want %v", string(got), tt.want)
-			}
-		})
-	}
-}
-
-func TestParseLevel(t *testing.T) {
-	type args struct {
-		levelStr string
-	}
-	tests := []struct {
-		name    string
-		args    args
-		want    Level
-		wantErr bool
-	}{
-		{"trace", args{"trace"}, TraceLevel, false},
-		{"debug", args{"debug"}, DebugLevel, false},
-		{"info", args{"info"}, InfoLevel, false},
-		{"warn", args{"warn"}, WarnLevel, false},
-		{"error", args{"error"}, ErrorLevel, false},
-		{"fatal", args{"fatal"}, FatalLevel, false},
-		{"panic", args{"panic"}, PanicLevel, false},
-		{"disabled", args{"disabled"}, Disabled, false},
-		{"nolevel", args{""}, NoLevel, false},
-		{"-1", args{"-1"}, TraceLevel, false},
-		{"-2", args{"-2"}, Level(-2), false},
-		{"-3", args{"-3"}, Level(-3), false},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := ParseLevel(tt.args.levelStr)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("ParseLevel() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if got != tt.want {
-				t.Errorf("ParseLevel() got = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestUnmarshalTextLevel(t *testing.T) {
-	type args struct {
-		levelStr string
-	}
-	tests := []struct {
-		name    string
-		args    args
-		want    Level
-		wantErr bool
-	}{
-		{"trace", args{"trace"}, TraceLevel, false},
-		{"debug", args{"debug"}, DebugLevel, false},
-		{"info", args{"info"}, InfoLevel, false},
-		{"warn", args{"warn"}, WarnLevel, false},
-		{"error", args{"error"}, ErrorLevel, false},
-		{"fatal", args{"fatal"}, FatalLevel, false},
-		{"panic", args{"panic"}, PanicLevel, false},
-		{"disabled", args{"disabled"}, Disabled, false},
-		{"nolevel", args{""}, NoLevel, false},
-		{"-1", args{"-1"}, TraceLevel, false},
-		{"-2", args{"-2"}, Level(-2), false},
-		{"-3", args{"-3"}, Level(-3), false},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			var l Level
-			err := l.UnmarshalText([]byte(tt.args.levelStr))
-			if (err != nil) != tt.wantErr {
-				t.Errorf("UnmarshalText() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if l != tt.want {
-				t.Errorf("UnmarshalText() got = %v, want %v", l, tt.want)
-			}
-		})
-	}
-}
-
-func TestHTMLNoEscaping(t *testing.T) {
-	out := &bytes.Buffer{}
-	log := New(out)
-	log.Log().Interface("head", "<test>").Send()
-	if got, want := decodeIfBinaryToString(out.Bytes()), `{"head":"<test>"}`+"\n"; got != want {
-		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
-	}
-}

not_go112.go

@@ -1,5 +0,0 @@
-// +build !go1.12
-
-package zerolog
-
-const contextCallerSkipFrameCount = 3

pkgerrors/stacktrace.go

@@ -42,32 +42,15 @@ func frameField(f errors.Frame, s *state, c rune) string {
 
 // MarshalStack implements pkg/errors stack trace marshaling.
 //
-// zerolog.ErrorStackMarshaler = MarshalStack
+//   zerolog.ErrorStackMarshaler = MarshalStack
 func MarshalStack(err error) interface{} {
 	type stackTracer interface {
 		StackTrace() errors.StackTrace
 	}
-	var sterr stackTracer
-	var ok bool
-	for err != nil {
-		sterr, ok = err.(stackTracer)
-		if ok {
-			break
-		}
-
-		u, ok := err.(interface {
-			Unwrap() error
-		})
-		if !ok {
-			return nil
-		}
-
-		err = u.Unwrap()
-	}
-	if sterr == nil {
+	sterr, ok := err.(stackTracer)
+	if !ok {
 		return nil
 	}
-
 	st := sterr.StackTrace()
 	s := &state{}
 	out := make([]map[string]string, 0, len(st))

pkgerrors/stacktrace_test.go

@@ -4,7 +4,6 @@ package pkgerrors
 
 import (
 	"bytes"
-	"fmt"
 	"regexp"
 	"testing"
 
@@ -18,59 +17,11 @@ func TestLogStack(t *testing.T) {
 	out := &bytes.Buffer{}
 	log := zerolog.New(out)
 
-	err := fmt.Errorf("from error: %w", errors.New("error message"))
+	err := errors.Wrap(errors.New("error message"), "from error")
 	log.Log().Stack().Err(err).Msg("")
 
 	got := out.String()
-	want := `\{"stack":\[\{"func":"TestLogStack","line":"21","source":"stacktrace_test.go"\},.*\],"error":"from error: error message"\}\n`
-	if ok, _ := regexp.MatchString(want, got); !ok {
-		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
-	}
-}
-
-func TestLogStackFields(t *testing.T) {
-	zerolog.ErrorStackMarshaler = MarshalStack
-
-	out := &bytes.Buffer{}
-	log := zerolog.New(out)
-
-	err := fmt.Errorf("from error: %w", errors.New("error message"))
-	log.Log().Stack().Fields([]interface{}{"error", err}).Msg("")
-
-	got := out.String()
-	want := `\{"error":"from error: error message","stack":\[\{"func":"TestLogStackFields","line":"37","source":"stacktrace_test.go"\},.*\]\}\n`
-	if ok, _ := regexp.MatchString(want, got); !ok {
-		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
-	}
-}
-
-func TestLogStackFromContext(t *testing.T) {
-	zerolog.ErrorStackMarshaler = MarshalStack
-
-	out := &bytes.Buffer{}
-	log := zerolog.New(out).With().Stack().Logger() // calling Stack() on log context instead of event
-
-	err := fmt.Errorf("from error: %w", errors.New("error message"))
-	log.Log().Err(err).Msg("") // not explicitly calling Stack()
-
-	got := out.String()
-	want := `\{"stack":\[\{"func":"TestLogStackFromContext","line":"53","source":"stacktrace_test.go"\},.*\],"error":"from error: error message"\}\n`
-	if ok, _ := regexp.MatchString(want, got); !ok {
-		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
-	}
-}
-
-func TestLogStackFromContextWith(t *testing.T) {
-	zerolog.ErrorStackMarshaler = MarshalStack
-
-	err := fmt.Errorf("from error: %w", errors.New("error message"))
-	out := &bytes.Buffer{}
-	log := zerolog.New(out).With().Stack().Err(err).Logger() // calling Stack() on log context instead of event
-
-	log.Error().Msg("")
-
-	got := out.String()
-	want := `\{"level":"error","stack":\[\{"func":"TestLogStackFromContextWith","line":"66","source":"stacktrace_test.go"\},.*\],"error":"from error: error message"\}\n`
+	want := `\{"stack":\[\{"func":"TestLogStack","line":"20","source":"stacktrace_test.go"\},.*\],"error":"from error: error message"\}\n`
 	if ok, _ := regexp.MatchString(want, got); !ok {
 		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
 	}

sampler.go

@@ -38,7 +38,7 @@ func (s RandomSampler) Sample(lvl Level) bool {
 }
 
 // BasicSampler is a sampler that will send every Nth events, regardless of
-// their level.
+// there level.
 type BasicSampler struct {
 	N       uint32
 	counter uint32
@@ -46,15 +46,8 @@ type BasicSampler struct {
 
 // Sample implements the Sampler interface.
 func (s *BasicSampler) Sample(lvl Level) bool {
-	n := s.N
-	if n == 0 {
-		return false
-	}
-	if n == 1 {
-		return true
-	}
 	c := atomic.AddUint32(&s.counter, 1)
-	return c%n == 1
+	return c%s.N == s.N-1
 }
 
 // BurstSampler lets Burst events pass per Period then pass the decision to
@@ -87,10 +80,10 @@ func (s *BurstSampler) Sample(lvl Level) bool {
 }
 
 func (s *BurstSampler) inc() uint32 {
-	now := TimestampFunc().UnixNano()
+	now := time.Now().UnixNano()
 	resetAt := atomic.LoadInt64(&s.resetAt)
 	var c uint32
-	if now >= resetAt {
+	if now > resetAt {
 		c = 1
 		atomic.StoreUint32(&s.counter, c)
 		newResetAt := now + s.Period.Nanoseconds()
@@ -107,15 +100,11 @@ func (s *BurstSampler) inc() uint32 {
 
 // LevelSampler applies a different sampler for each level.
 type LevelSampler struct {
-	TraceSampler, DebugSampler, InfoSampler, WarnSampler, ErrorSampler Sampler
+	DebugSampler, InfoSampler, WarnSampler, ErrorSampler Sampler
 }
 
 func (s LevelSampler) Sample(lvl Level) bool {
 	switch lvl {
-	case TraceLevel:
-		if s.TraceSampler != nil {
-			return s.TraceSampler.Sample(lvl)
-		}
 	case DebugLevel:
 		if s.DebugSampler != nil {
 			return s.DebugSampler.Sample(lvl)

sampler_test.go

@@ -1,4 +1,3 @@
-//go:build !binary_log
 // +build !binary_log
 
 package zerolog
@@ -29,13 +28,6 @@ var samplers = []struct {
 		},
 		100, 20, 20,
 	},
-	{
-		"BasicSampler_0",
-		func() Sampler {
-			return &BasicSampler{N: 0}
-		},
-		100, 0, 0,
-	},
 	{
 		"RandomSampler",
 		func() Sampler {
@@ -43,13 +35,6 @@ var samplers = []struct {
 		},
 		100, 10, 30,
 	},
-	{
-		"RandomSampler_0",
-		func() Sampler {
-			return RandomSampler(0)
-		},
-		100, 0, 0,
-	},
 	{
 		"BurstSampler",
 		func() Sampler {
@@ -57,13 +42,6 @@ var samplers = []struct {
 		},
 		100, 20, 20,
 	},
-	{
-		"BurstSampler_0",
-		func() Sampler {
-			return &BurstSampler{Burst: 0, Period: time.Second}
-		},
-		100, 0, 0,
-	},
 	{
 		"BurstSamplerNext",
 		func() Sampler {
@@ -104,34 +82,3 @@ func BenchmarkSamplers(b *testing.B) {
 		})
 	}
 }
-
-func TestBurst(t *testing.T) {
-	sampler := &BurstSampler{Burst: 1, Period: time.Second}
-
-	t0 := time.Now()
-	now := t0
-	mockedTime := func() time.Time {
-		return now
-	}
-
-	TimestampFunc = mockedTime
-	defer func() { TimestampFunc = time.Now }()
-
-	scenario := []struct {
-		tm   time.Time
-		want bool
-	}{
-		{t0, true},
-		{t0.Add(time.Second - time.Nanosecond), false},
-		{t0.Add(time.Second), true},
-		{t0.Add(time.Second + time.Nanosecond), false},
-	}
-
-	for i, step := range scenario {
-		now = step.tm
-		got := sampler.Sample(NoLevel)
-		if got != step.want {
-			t.Errorf("step %d (t=%s): expect %t got %t", i, step.tm, step.want, got)
-		}
-	}
-}

syslog.go

@@ -7,10 +7,6 @@ import (
 	"io"
 )
 
-// See http://cee.mitre.org/language/1.0-beta1/clt.html#syslog
-// or https://www.rsyslog.com/json-elasticsearch/
-const ceePrefix = "@cee:"
-
 // SyslogWriter is an interface matching a syslog.Writer struct.
 type SyslogWriter interface {
 	io.Writer
@@ -23,67 +19,39 @@ type SyslogWriter interface {
 }
 
 type syslogWriter struct {
-	w      SyslogWriter
-	prefix string
+	w SyslogWriter
 }
 
 // SyslogLevelWriter wraps a SyslogWriter and call the right syslog level
 // method matching the zerolog level.
 func SyslogLevelWriter(w SyslogWriter) LevelWriter {
-	return syslogWriter{w, ""}
-}
-
-// SyslogCEEWriter wraps a SyslogWriter with a SyslogLevelWriter that adds a
-// MITRE CEE prefix for JSON syslog entries, compatible with rsyslog 
-// and syslog-ng JSON logging support. 
-// See https://www.rsyslog.com/json-elasticsearch/
-func SyslogCEEWriter(w SyslogWriter) LevelWriter {
-	return syslogWriter{w, ceePrefix}
+	return syslogWriter{w}
 }
 
 func (sw syslogWriter) Write(p []byte) (n int, err error) {
-	var pn int
-	if sw.prefix != "" {
-		pn, err = sw.w.Write([]byte(sw.prefix))
-		if err != nil {
-			return pn, err
-		}
-	}
-	n, err = sw.w.Write(p)
-	return pn + n, err
+	return sw.w.Write(p)
 }
 
 // WriteLevel implements LevelWriter interface.
 func (sw syslogWriter) WriteLevel(level Level, p []byte) (n int, err error) {
 	switch level {
-	case TraceLevel:
 	case DebugLevel:
-		err = sw.w.Debug(sw.prefix + string(p))
+		err = sw.w.Debug(string(p))
 	case InfoLevel:
-		err = sw.w.Info(sw.prefix + string(p))
+		err = sw.w.Info(string(p))
 	case WarnLevel:
-		err = sw.w.Warning(sw.prefix + string(p))
+		err = sw.w.Warning(string(p))
 	case ErrorLevel:
-		err = sw.w.Err(sw.prefix + string(p))
+		err = sw.w.Err(string(p))
 	case FatalLevel:
-		err = sw.w.Emerg(sw.prefix + string(p))
+		err = sw.w.Emerg(string(p))
 	case PanicLevel:
-		err = sw.w.Crit(sw.prefix + string(p))
+		err = sw.w.Crit(string(p))
 	case NoLevel:
-		err = sw.w.Info(sw.prefix + string(p))
+		err = sw.w.Info(string(p))
 	default:
 		panic("invalid level")
 	}
-	// Any CEE prefix is not part of the message, so we don't include its length
 	n = len(p)
 	return
 }
-
-// Call the underlying writer's Close method if it is an io.Closer. Otherwise
-// does nothing.
-func (sw syslogWriter) Close() error {
-	if c, ok := sw.w.(io.Closer); ok {
-		return c.Close()
-	}
-	return nil
-}

syslog_test.go

@@ -3,12 +3,8 @@
 
 package zerolog
 
-import (
-	"bytes"
-	"reflect"
-	"strings"
-	"testing"
-)
+import "testing"
+import "reflect"
 
 type syslogEvent struct {
 	level string
@@ -21,10 +17,6 @@ type syslogTestWriter struct {
 func (w *syslogTestWriter) Write(p []byte) (int, error) {
 	return 0, nil
 }
-func (w *syslogTestWriter) Trace(m string) error {
-	w.events = append(w.events, syslogEvent{"Trace", m})
-	return nil
-}
 func (w *syslogTestWriter) Debug(m string) error {
 	w.events = append(w.events, syslogEvent{"Debug", m})
 	return nil
@@ -53,7 +45,6 @@ func (w *syslogTestWriter) Crit(m string) error {
 func TestSyslogWriter(t *testing.T) {
 	sw := &syslogTestWriter{}
 	log := New(SyslogLevelWriter(sw))
-	log.Trace().Msg("trace")
 	log.Debug().Msg("debug")
 	log.Info().Msg("info")
 	log.Warn().Msg("warn")
@@ -70,39 +61,3 @@ func TestSyslogWriter(t *testing.T) {
 		t.Errorf("Invalid syslog message routing: want %v, got %v", want, got)
 	}
 }
-
-type testCEEwriter struct {
-	buf *bytes.Buffer
-}
-
-// Only implement one method as we're just testing the prefixing
-func (c testCEEwriter) Debug(m string) error { return nil }
-
-func (c testCEEwriter) Info(m string) error {
-	_, err := c.buf.Write([]byte(m))
-	return err
-}
-
-func (c testCEEwriter) Warning(m string) error { return nil }
-
-func (c testCEEwriter) Err(m string) error { return nil }
-
-func (c testCEEwriter) Emerg(m string) error { return nil }
-
-func (c testCEEwriter) Crit(m string) error { return nil }
-
-func (c testCEEwriter) Write(b []byte) (int, error) {
-	return c.buf.Write(b)
-}
-
-func TestSyslogWriter_WithCEE(t *testing.T) {
-	var buf bytes.Buffer
-	sw := testCEEwriter{&buf}
-	log := New(SyslogCEEWriter(sw))
-	log.Info().Str("key", "value").Msg("message string")
-	got := buf.String()
-	want := "@cee:{"
-	if !strings.HasPrefix(got, want) {
-		t.Errorf("Bad CEE message start: want %v, got %v", want, got)
-	}
-}

writer.go

@@ -1,12 +1,7 @@
 package zerolog
 
 import (
-	"bytes"
 	"io"
-	"path"
-	"runtime"
-	"strconv"
-	"strings"
 	"sync"
 )
 
@@ -17,39 +12,30 @@ type LevelWriter interface {
 	WriteLevel(level Level, p []byte) (n int, err error)
 }
 
-// LevelWriterAdapter adapts an io.Writer to support the LevelWriter interface.
-type LevelWriterAdapter struct {
+type levelWriterAdapter struct {
 	io.Writer
 }
 
-// WriteLevel simply writes everything to the adapted writer, ignoring the level.
-func (lw LevelWriterAdapter) WriteLevel(l Level, p []byte) (n int, err error) {
+func (lw levelWriterAdapter) WriteLevel(l Level, p []byte) (n int, err error) {
 	return lw.Write(p)
 }
 
-// Call the underlying writer's Close method if it is an io.Closer. Otherwise
-// does nothing.
-func (lw LevelWriterAdapter) Close() error {
-	if closer, ok := lw.Writer.(io.Closer); ok {
-		return closer.Close()
-	}
-	return nil
-}
-
 type syncWriter struct {
 	mu sync.Mutex
 	lw LevelWriter
 }
 
 // SyncWriter wraps w so that each call to Write is synchronized with a mutex.
-// This syncer can be used to wrap the call to writer's Write method if it is
-// not thread safe. Note that you do not need this wrapper for os.File Write
-// operations on POSIX and Windows systems as they are already thread-safe.
+// This syncer can be the call to writer's Write method is not thread safe.
+// Note that os.File Write operation is using write() syscall which is supposed
+// to be thread-safe on POSIX systems. So there is no need to use this with
+// os.File on such systems as zerolog guaranties to issue a single Write call
+// per log event.
 func SyncWriter(w io.Writer) io.Writer {
 	if lw, ok := w.(LevelWriter); ok {
 		return &syncWriter{lw: lw}
 	}
-	return &syncWriter{lw: LevelWriterAdapter{w}}
+	return &syncWriter{lw: levelWriterAdapter{w}}
 }
 
 // Write implements the io.Writer interface.
@@ -66,59 +52,36 @@ func (s *syncWriter) WriteLevel(l Level, p []byte) (n int, err error) {
 	return s.lw.WriteLevel(l, p)
 }
 
-func (s *syncWriter) Close() error {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	if closer, ok := s.lw.(io.Closer); ok {
-		return closer.Close()
-	}
-	return nil
-}
-
 type multiLevelWriter struct {
 	writers []LevelWriter
 }
 
 func (t multiLevelWriter) Write(p []byte) (n int, err error) {
 	for _, w := range t.writers {
-		if _n, _err := w.Write(p); err == nil {
-			n = _n
-			if _err != nil {
-				err = _err
-			} else if _n != len(p) {
-				err = io.ErrShortWrite
-			}
+		n, err = w.Write(p)
+		if err != nil {
+			return
+		}
+		if n != len(p) {
+			err = io.ErrShortWrite
+			return
 		}
 	}
-	return n, err
+	return len(p), nil
 }
 
 func (t multiLevelWriter) WriteLevel(l Level, p []byte) (n int, err error) {
 	for _, w := range t.writers {
-		if _n, _err := w.WriteLevel(l, p); err == nil {
-			n = _n
-			if _err != nil {
-				err = _err
-			} else if _n != len(p) {
-				err = io.ErrShortWrite
-			}
+		n, err = w.WriteLevel(l, p)
+		if err != nil {
+			return
+		}
+		if n != len(p) {
+			err = io.ErrShortWrite
+			return
 		}
 	}
-	return n, err
-}
-
-// Calls close on all the underlying writers that are io.Closers. If any of the
-// Close methods return an error, the remainder of the closers are not closed
-// and the error is returned.
-func (t multiLevelWriter) Close() error {
-	for _, w := range t.writers {
-		if closer, ok := w.(io.Closer); ok {
-			if err := closer.Close(); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
+	return len(p), nil
 }
 
 // MultiLevelWriter creates a writer that duplicates its writes to all the
@@ -130,226 +93,8 @@ func MultiLevelWriter(writers ...io.Writer) LevelWriter {
 		if lw, ok := w.(LevelWriter); ok {
 			lwriters = append(lwriters, lw)
 		} else {
-			lwriters = append(lwriters, LevelWriterAdapter{w})
+			lwriters = append(lwriters, levelWriterAdapter{w})
 		}
 	}
 	return multiLevelWriter{lwriters}
 }
-
-// TestingLog is the logging interface of testing.TB.
-type TestingLog interface {
-	Log(args ...interface{})
-	Logf(format string, args ...interface{})
-	Helper()
-}
-
-// TestWriter is a writer that writes to testing.TB.
-type TestWriter struct {
-	T TestingLog
-
-	// Frame skips caller frames to capture the original file and line numbers.
-	Frame int
-}
-
-// NewTestWriter creates a writer that logs to the testing.TB.
-func NewTestWriter(t TestingLog) TestWriter {
-	return TestWriter{T: t}
-}
-
-// Write to testing.TB.
-func (t TestWriter) Write(p []byte) (n int, err error) {
-	t.T.Helper()
-
-	n = len(p)
-
-	// Strip trailing newline because t.Log always adds one.
-	p = bytes.TrimRight(p, "\n")
-
-	// Try to correct the log file and line number to the caller.
-	if t.Frame > 0 {
-		_, origFile, origLine, _ := runtime.Caller(1)
-		_, frameFile, frameLine, ok := runtime.Caller(1 + t.Frame)
-		if ok {
-			erase := strings.Repeat("\b", len(path.Base(origFile))+len(strconv.Itoa(origLine))+3)
-			t.T.Logf("%s%s:%d: %s", erase, path.Base(frameFile), frameLine, p)
-			return n, err
-		}
-	}
-	t.T.Log(string(p))
-
-	return n, err
-}
-
-// ConsoleTestWriter creates an option that correctly sets the file frame depth for testing.TB log.
-func ConsoleTestWriter(t TestingLog) func(w *ConsoleWriter) {
-	return func(w *ConsoleWriter) {
-		w.Out = TestWriter{T: t, Frame: 6}
-	}
-}
-
-// FilteredLevelWriter writes only logs at Level or above to Writer.
-//
-// It should be used only in combination with MultiLevelWriter when you
-// want to write to multiple destinations at different levels. Otherwise
-// you should just set the level on the logger and filter events early.
-// When using MultiLevelWriter then you set the level on the logger to
-// the lowest of the levels you use for writers.
-type FilteredLevelWriter struct {
-	Writer LevelWriter
-	Level  Level
-}
-
-// Write writes to the underlying Writer.
-func (w *FilteredLevelWriter) Write(p []byte) (int, error) {
-	return w.Writer.Write(p)
-}
-
-// WriteLevel calls WriteLevel of the underlying Writer only if the level is equal
-// or above the Level.
-func (w *FilteredLevelWriter) WriteLevel(level Level, p []byte) (int, error) {
-	if level >= w.Level {
-		return w.Writer.WriteLevel(level, p)
-	}
-	return len(p), nil
-}
-
-// Call the underlying writer's Close method if it is an io.Closer. Otherwise
-// does nothing.
-func (w *FilteredLevelWriter) Close() error {
-	if closer, ok := w.Writer.(io.Closer); ok {
-		return closer.Close()
-	}
-	return nil
-}
-
-var triggerWriterPool = &sync.Pool{
-	New: func() interface{} {
-		return bytes.NewBuffer(make([]byte, 0, 1024))
-	},
-}
-
-// TriggerLevelWriter buffers log lines at the ConditionalLevel or below
-// until a trigger level (or higher) line is emitted. Log lines with level
-// higher than ConditionalLevel are always written out to the destination
-// writer. If trigger never happens, buffered log lines are never written out.
-//
-// It can be used to configure "log level per request".
-type TriggerLevelWriter struct {
-	// Destination writer. If LevelWriter is provided (usually), its WriteLevel is used
-	// instead of Write.
-	io.Writer
-
-	// ConditionalLevel is the level (and below) at which lines are buffered until
-	// a trigger level (or higher) line is emitted. Usually this is set to DebugLevel.
-	ConditionalLevel Level
-
-	// TriggerLevel is the lowest level that triggers the sending of the conditional
-	// level lines. Usually this is set to ErrorLevel.
-	TriggerLevel Level
-
-	buf       *bytes.Buffer
-	triggered bool
-	mu        sync.Mutex
-}
-
-func (w *TriggerLevelWriter) WriteLevel(l Level, p []byte) (n int, err error) {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-
-	// At first trigger level or above log line, we flush the buffer and change the
-	// trigger state to triggered.
-	if !w.triggered && l >= w.TriggerLevel {
-		err := w.trigger()
-		if err != nil {
-			return 0, err
-		}
-	}
-
-	// Unless triggered, we buffer everything at and below ConditionalLevel.
-	if !w.triggered && l <= w.ConditionalLevel {
-		if w.buf == nil {
-			w.buf = triggerWriterPool.Get().(*bytes.Buffer)
-		}
-
-		// We prefix each log line with a byte with the level.
-		// Hopefully we will never have a level value which equals a newline
-		// (which could interfere with reconstruction of log lines in the trigger method).
-		w.buf.WriteByte(byte(l))
-		w.buf.Write(p)
-		return len(p), nil
-	}
-
-	// Anything above ConditionalLevel is always passed through.
-	// Once triggered, everything is passed through.
-	if lw, ok := w.Writer.(LevelWriter); ok {
-		return lw.WriteLevel(l, p)
-	}
-	return w.Write(p)
-}
-
-// trigger expects lock to be held.
-func (w *TriggerLevelWriter) trigger() error {
-	if w.triggered {
-		return nil
-	}
-	w.triggered = true
-
-	if w.buf == nil {
-		return nil
-	}
-
-	p := w.buf.Bytes()
-	for len(p) > 0 {
-		// We do not use bufio.Scanner here because we already have full buffer
-		// in the memory and we do not want extra copying from the buffer to
-		// scanner's token slice, nor we want to hit scanner's token size limit,
-		// and we also want to preserve newlines.
-		i := bytes.IndexByte(p, '\n')
-		line := p[0 : i+1]
-		p = p[i+1:]
-		// We prefixed each log line with a byte with the level.
-		level := Level(line[0])
-		line = line[1:]
-		var err error
-		if lw, ok := w.Writer.(LevelWriter); ok {
-			_, err = lw.WriteLevel(level, line)
-		} else {
-			_, err = w.Write(line)
-		}
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// Trigger forces flushing the buffer and change the trigger state to
-// triggered, if the writer has not already been triggered before.
-func (w *TriggerLevelWriter) Trigger() error {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-
-	return w.trigger()
-}
-
-// Close closes the writer and returns the buffer to the pool.
-func (w *TriggerLevelWriter) Close() error {
-	w.mu.Lock()
-	defer w.mu.Unlock()
-
-	if w.buf == nil {
-		return nil
-	}
-
-	// We return the buffer only if it has not grown above the limit.
-	// This prevents accumulation of large buffers in the pool just
-	// because occasionally a large buffer might be needed.
-	if w.buf.Cap() <= TriggerLevelWriterBufferReuseLimit {
-		w.buf.Reset()
-		triggerWriterPool.Put(w.buf)
-	}
-	w.buf = nil
-
-	return nil
-}

writer_test.go

@@ -1,13 +1,9 @@
-//go:build !binary_log && !windows
-// +build !binary_log,!windows
+// +build !binary_log
+// +build !windows
 
 package zerolog
 
 import (
-	"bytes"
-	"errors"
-	"fmt"
-	"io"
 	"reflect"
 	"testing"
 )
@@ -31,222 +27,3 @@ func TestMultiSyslogWriter(t *testing.T) {
 		t.Errorf("Invalid syslog message routing: want %v, got %v", want, got)
 	}
 }
-
-var writeCalls int
-
-type mockedWriter struct {
-	wantErr bool
-}
-
-func (c mockedWriter) Write(p []byte) (int, error) {
-	writeCalls++
-
-	if c.wantErr {
-		return -1, errors.New("Expected error")
-	}
-
-	return len(p), nil
-}
-
-// Tests that a new writer is only used if it actually works.
-func TestResilientMultiWriter(t *testing.T) {
-	tests := []struct {
-		name    string
-		writers []io.Writer
-	}{
-		{
-			name: "All valid writers",
-			writers: []io.Writer{
-				mockedWriter{
-					wantErr: false,
-				},
-				mockedWriter{
-					wantErr: false,
-				},
-			},
-		},
-		{
-			name: "All invalid writers",
-			writers: []io.Writer{
-				mockedWriter{
-					wantErr: true,
-				},
-				mockedWriter{
-					wantErr: true,
-				},
-			},
-		},
-		{
-			name: "First invalid writer",
-			writers: []io.Writer{
-				mockedWriter{
-					wantErr: true,
-				},
-				mockedWriter{
-					wantErr: false,
-				},
-			},
-		},
-		{
-			name: "First valid writer",
-			writers: []io.Writer{
-				mockedWriter{
-					wantErr: false,
-				},
-				mockedWriter{
-					wantErr: true,
-				},
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		writers := tt.writers
-		multiWriter := MultiLevelWriter(writers...)
-
-		logger := New(multiWriter).With().Timestamp().Logger().Level(InfoLevel)
-		logger.Info().Msg("Test msg")
-
-		if len(writers) != writeCalls {
-			t.Errorf("Expected %d writers to have been called but only %d were.", len(writers), writeCalls)
-		}
-		writeCalls = 0
-	}
-}
-
-type testingLog struct {
-	testing.TB
-	buf bytes.Buffer
-}
-
-func (t *testingLog) Log(args ...interface{}) {
-	if _, err := t.buf.WriteString(fmt.Sprint(args...)); err != nil {
-		t.Error(err)
-	}
-}
-
-func (t *testingLog) Logf(format string, args ...interface{}) {
-	if _, err := t.buf.WriteString(fmt.Sprintf(format, args...)); err != nil {
-		t.Error(err)
-	}
-}
-
-func TestTestWriter(t *testing.T) {
-	tests := []struct {
-		name  string
-		write []byte
-		want  []byte
-	}{{
-		name:  "newline",
-		write: []byte("newline\n"),
-		want:  []byte("newline"),
-	}, {
-		name:  "oneline",
-		write: []byte("oneline"),
-		want:  []byte("oneline"),
-	}, {
-		name:  "twoline",
-		write: []byte("twoline\n\n"),
-		want:  []byte("twoline"),
-	}}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			tb := &testingLog{TB: t} // Capture TB log buffer.
-			w := TestWriter{T: tb}
-
-			n, err := w.Write(tt.write)
-			if err != nil {
-				t.Error(err)
-			}
-			if n != len(tt.write) {
-				t.Errorf("Expected %d write length but got %d", len(tt.write), n)
-			}
-			p := tb.buf.Bytes()
-			if !bytes.Equal(tt.want, p) {
-				t.Errorf("Expected %q, got %q.", tt.want, p)
-			}
-
-			log := New(NewConsoleWriter(ConsoleTestWriter(t)))
-			log.Info().Str("name", tt.name).Msg("Success!")
-
-			tb.buf.Reset()
-		})
-	}
-
-}
-
-func TestFilteredLevelWriter(t *testing.T) {
-	buf := bytes.Buffer{}
-	writer := FilteredLevelWriter{
-		Writer: LevelWriterAdapter{&buf},
-		Level:  InfoLevel,
-	}
-	_, err := writer.WriteLevel(DebugLevel, []byte("no"))
-	if err != nil {
-		t.Error(err)
-	}
-	_, err = writer.WriteLevel(InfoLevel, []byte("yes"))
-	if err != nil {
-		t.Error(err)
-	}
-	p := buf.Bytes()
-	if want := "yes"; !bytes.Equal([]byte(want), p) {
-		t.Errorf("Expected %q, got %q.", want, p)
-	}
-}
-
-type testWrite struct {
-	Level
-	Line []byte
-}
-
-func TestTriggerLevelWriter(t *testing.T) {
-	tests := []struct {
-		write []testWrite
-		want  []byte
-		all   []byte
-	}{{
-		[]testWrite{
-			{DebugLevel, []byte("no\n")},
-			{InfoLevel, []byte("yes\n")},
-		},
-		[]byte("yes\n"),
-		[]byte("yes\nno\n"),
-	}, {
-		[]testWrite{
-			{DebugLevel, []byte("yes1\n")},
-			{InfoLevel, []byte("yes2\n")},
-			{ErrorLevel, []byte("yes3\n")},
-			{DebugLevel, []byte("yes4\n")},
-		},
-		[]byte("yes2\nyes1\nyes3\nyes4\n"),
-		[]byte("yes2\nyes1\nyes3\nyes4\n"),
-	}}
-
-	for k, tt := range tests {
-		t.Run(fmt.Sprintf("case=%d", k), func(t *testing.T) {
-			buf := bytes.Buffer{}
-			writer := TriggerLevelWriter{Writer: LevelWriterAdapter{&buf}, ConditionalLevel: DebugLevel, TriggerLevel: ErrorLevel}
-			t.Cleanup(func() { writer.Close() })
-			for _, w := range tt.write {
-				_, err := writer.WriteLevel(w.Level, w.Line)
-				if err != nil {
-					t.Error(err)
-				}
-			}
-			p := buf.Bytes()
-			if want := tt.want; !bytes.Equal([]byte(want), p) {
-				t.Errorf("Expected %q, got %q.", want, p)
-			}
-			err := writer.Trigger()
-			if err != nil {
-				t.Error(err)
-			}
-			p = buf.Bytes()
-			if want := tt.all; !bytes.Equal([]byte(want), p) {
-				t.Errorf("Expected %q, got %q.", want, p)
-			}
-		})
-	}
-}