.github/workflows/test.yml

@@ -4,17 +4,17 @@ jobs:
   test:
     strategy:
       matrix:
-        go-version: [1.18.x, 1.19.x]
+        go-version: [1.15.x, 1.16.x]
         os: [ubuntu-latest, macos-latest]
     runs-on: ${{ matrix.os }}
     steps:
     - name: Install Go
-      uses: actions/setup-go@v4
+      uses: actions/setup-go@v2
       with:
         go-version: ${{ matrix.go-version }}
     - name: Checkout code
-      uses: actions/checkout@v3
+      uses: actions/checkout@v2
-    - uses: actions/cache@v3
+    - uses: actions/cache@v2
       with:
         path: ~/go/pkg/mod
         key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}

README.md

@@ -1,12 +1,6 @@
-###zlog
-
-opinionated defaults on zerolog
-
-
-
 # Zero Allocation JSON Logger
 
-[![godoc](http://img.shields.io/badge/godoc-reference-blue.svg?style=flat)](https://godoc.org/tuxpa.in/a/zlog) [![license](http://img.shields.io/badge/license-MIT-red.svg?style=flat)](https://raw.githubusercontent.com/rs/zlog/master/LICENSE) [![Build Status](https://travis-ci.org/rs/zlog.svg?branch=master)](https://travis-ci.org/rs/zlog) [![Coverage](http://gocover.io/_badge/tuxpa.in/a/zlog)](http://gocover.io/tuxpa.in/a/zlog)
+[![godoc](http://img.shields.io/badge/godoc-reference-blue.svg?style=flat)](https://godoc.org/git.tuxpa.in/a/zlog) [![license](http://img.shields.io/badge/license-MIT-red.svg?style=flat)](https://raw.githubusercontent.com/rs/zlog/master/LICENSE) [![Build Status](https://travis-ci.org/rs/zlog.svg?branch=master)](https://travis-ci.org/rs/zlog) [![Coverage](http://gocover.io/_badge/git.tuxpa.in/a/zlog)](http://gocover.io/git.tuxpa.in/a/zlog)
 
 The zlog package provides a fast and simple logger dedicated to JSON output.
 
@@ -20,7 +14,7 @@ To keep the code base and the API simple, zlog focuses on efficient structured l
 
 ## Who uses zlog
 
-Find out [who uses zlog](https://tuxpa.in/a/zlog/wiki/Who-uses-zlog) and add your company / project to the list.
+Find out [who uses zlog](https://git.tuxpa.in/a/zlog/wiki/Who-uses-zlog) and add your company / project to the list.
 
 ## Features
 
@@ -30,7 +24,7 @@ Find out [who uses zlog](https://tuxpa.in/a/zlog/wiki/Who-uses-zlog) and add you
 * [Sampling](#log-sampling)
 * [Hooks](#hooks)
 * [Contextual fields](#contextual-logging)
-* [`context.Context` integration](#contextcontext-integration)
+* `context.Context` integration
 * [Integration with `net/http`](#integration-with-nethttp)
 * [JSON and CBOR encoding formats](#binary-encoding)
 * [Pretty logging for development](#pretty-logging)
@@ -39,21 +33,21 @@ Find out [who uses zlog](https://tuxpa.in/a/zlog/wiki/Who-uses-zlog) and add you
 ## Installation
 
 ```bash
-go get -u tuxpa.in/a/zlog/log
+go get -u git.tuxpa.in/a/zlog/log
 ```
 
 ## Getting Started
 
 ### Simple Logging Example
 
-For simple logging, import the global logger package **tuxpa.in/a/zlog/log**
+For simple logging, import the global logger package **git.tuxpa.in/a/zlog/log**
 
 ```go
 package main
 
 import (
-    "tuxpa.in/a/zlog"
+    "git.tuxpa.in/a/zlog"
-    "tuxpa.in/a/zlog/log"
+    "git.tuxpa.in/a/zlog/log"
 )
 
 func main() {
@@ -76,8 +70,8 @@ func main() {
 package main
 
 import (
-    "tuxpa.in/a/zlog"
+    "git.tuxpa.in/a/zlog"
-    "tuxpa.in/a/zlog/log"
+    "git.tuxpa.in/a/zlog/log"
 )
 
 func main() {
@@ -87,7 +81,7 @@ func main() {
         Str("Scale", "833 cents").
         Float64("Interval", 833.09).
         Msg("Fibonacci is everywhere")
-
+    
     log.Debug().
         Str("Name", "Tom").
         Send()
@@ -107,8 +101,8 @@ func main() {
 package main
 
 import (
-    "tuxpa.in/a/zlog"
+    "git.tuxpa.in/a/zlog"
-    "tuxpa.in/a/zlog/log"
+    "git.tuxpa.in/a/zlog/log"
 )
 
 func main() {
@@ -144,8 +138,8 @@ package main
 import (
     "flag"
 
-    "tuxpa.in/a/zlog"
+    "git.tuxpa.in/a/zlog"
-    "tuxpa.in/a/zlog/log"
+    "git.tuxpa.in/a/zlog/log"
 )
 
 func main() {
@@ -195,8 +189,8 @@ You may choose to log without a specific level by using the `Log` method. You ma
 package main
 
 import (
-    "tuxpa.in/a/zlog"
+    "git.tuxpa.in/a/zlog"
-    "tuxpa.in/a/zlog/log"
+    "git.tuxpa.in/a/zlog/log"
 )
 
 func main() {
@@ -220,8 +214,8 @@ package main
 import (
 	"errors"
 
-	"tuxpa.in/a/zlog"
+	"git.tuxpa.in/a/zlog"
-	"tuxpa.in/a/zlog/log"
+	"git.tuxpa.in/a/zlog/log"
 )
 
 func main() {
@@ -238,17 +232,17 @@ func main() {
 
 #### Error Logging with Stacktrace
 
-Using `github.com/pkg/errors`, you can add a formatted stacktrace to your errors.
+Using `github.com/pkg/errors`, you can add a formatted stacktrace to your errors. 
 
 ```go
 package main
 
 import (
 	"github.com/pkg/errors"
-	"tuxpa.in/a/zlog/pkgerrors"
+	"git.tuxpa.in/a/zlog/pkgerrors"
 
-	"tuxpa.in/a/zlog"
+	"git.tuxpa.in/a/zlog"
-	"tuxpa.in/a/zlog/log"
+	"git.tuxpa.in/a/zlog/log"
 )
 
 func main() {
@@ -292,8 +286,8 @@ package main
 import (
     "errors"
 
-    "tuxpa.in/a/zlog"
+    "git.tuxpa.in/a/zlog"
-    "tuxpa.in/a/zlog/log"
+    "git.tuxpa.in/a/zlog/log"
 )
 
 func main() {
@@ -417,7 +411,7 @@ log.Info().Msg("hello world")
 Equivalent of `Lshortfile`:
 
 ```go
-zlog.CallerMarshalFunc = func(pc uintptr, file string, line int) string {
+zlog.CallerMarshalFunc = func(file string, line int) string {
     short := file
     for i := len(file) - 1; i > 0; i-- {
         if file[i] == '/' {
@@ -505,7 +499,7 @@ log.Ctx(ctx).Info().Msg("hello world")
 ### Set as standard logger output
 
 ```go
-stdlog := zlog.New(os.Stdout).With().
+log := zlog.New(os.Stdout).With().
     Str("foo", "bar").
     Logger()
 
@@ -517,33 +511,9 @@ stdlog.Print("hello world")
 // Output: {"foo":"bar","message":"hello world"}
 ```
 
-### context.Context integration
-
-The `Logger` instance could be attached to `context.Context` values with `logger.WithContext(ctx)`
-and extracted from it using `zerolog.Ctx(ctx)`.
-
-Example to add logger to context:
-```go
-// this code attach logger instance to context fields
-ctx := context.Background()
-logger := zerolog.New(os.Stdout)
-ctx = logger.WithContext(ctx)
-someFunc(ctx)
-```
-
-Extracting logger from context:
-```go
-func someFunc(ctx context.Context) {
-  // get logger from context. if it's nill, then `zerolog.DefaultContextLogger` is returned,
-  // if `DefaultContextLogger` is nil, then disabled logger returned.
-  logger := zerolog.Ctx(ctx)
-  logger.Info().Msg("Hello")
-}
-```
-
 ### Integration with `net/http`
 
-The `tuxpa.in/a/zlog/hlog` package provides some helpers to integrate zlog with `http.Handler`.
+The `git.tuxpa.in/a/zlog/hlog` package provides some helpers to integrate zlog with `http.Handler`.
 
 In this example we use [alice](https://github.com/justinas/alice) to install logger for better readability.
 
@@ -595,7 +565,7 @@ if err := http.ListenAndServe(":8080", nil); err != nil {
 ```
 
 ## Multiple Log Output
-`zlog.MultiLevelWriter` may be used to send the log message to multiple outputs.
+`zlog.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() {
@@ -626,7 +596,7 @@ Some settings can be changed and will be applied to all loggers:
 * `zlog.ErrorFieldName`: Can be set to customize `Err` field name.
 * `zlog.TimeFieldFormat`: Can be set to customize `Time` field value formatting. If set with `zlog.TimeFormatUnix`, `zlog.TimeFormatUnixMs` or `zlog.TimeFormatUnixMicro`, times are formated as UNIX timestamp.
 * `zlog.DurationFieldUnit`: Can be set to customize the unit for time.Duration type fields added by `Dur` (default: `time.Millisecond`).
-* `zlog.DurationFieldInteger`: If set to `true`, `Dur` fields are formatted as integers instead of floats (default: `false`).
+* `zlog.DurationFieldInteger`: If set to `true`, `Dur` fields are formatted as integers instead of floats (default: `false`). 
 * `zlog.ErrorHandler`: Called whenever zlog 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
@@ -655,11 +625,7 @@ Most fields are also available in the slice format (`Strs` for `[]string`, `Errs
 
 ## Binary Encoding
 
-<<<<<<< HEAD
 In addition to the default JSON encoding, `zlog` 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:
-=======
-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:
->>>>>>> github
 
 ```bash
 go build -tags binary_log .

array.go

@@ -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,19 +67,19 @@ 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
@@ -115,97 +115,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)
 	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)
 	return a
 }
 
-// Time appends t formatted as string using zlog.TimeFieldFormat.
+// Time append append t formatted as string using zlog.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)
 	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)

cmd/lint/go.mod

@@ -1,4 +1,4 @@
-module tuxpa.in/a/zlog/cmd/lint
+module git.tuxpa.in/a/zlog/cmd/lint
 
 go 1.15
 

cmd/lint/lint.go

@@ -30,7 +30,7 @@ func init() {
 	flag.Parse()
 
 	// add zlog to recursively ignored packages
-	recursivelyIgnoredPkgs = append(recursivelyIgnoredPkgs, "tuxpa.in/a/zlog")
+	recursivelyIgnoredPkgs = append(recursivelyIgnoredPkgs, "git.tuxpa.in/a/zlog")
 	args := flag.Args()
 	if len(args) != 1 {
 		fmt.Fprintln(os.Stderr, "you must provide exactly one package path")
@@ -49,14 +49,14 @@ func main() {
 		os.Exit(1)
 	}
 
-	// get the tuxpa.in/a/zlog.Event type
+	// get the git.tuxpa.in/a/zlog.Event type
 	event := getEvent(p)
 	if event == nil {
-		fmt.Fprintln(os.Stderr, "Error: tuxpa.in/a/zlog.Event declaration not found, maybe zlog is not imported in the scanned package?")
+		fmt.Fprintln(os.Stderr, "Error: git.tuxpa.in/a/zlog.Event declaration not found, maybe zlog is not imported in the scanned package?")
 		os.Exit(1)
 	}
 
-	// get all selections (function calls) with the tuxpa.in/a/zlog.Event (or pointer) receiver
+	// get all selections (function calls) with the git.tuxpa.in/a/zlog.Event (or pointer) receiver
 	selections := getSelectionsWithReceiverType(p, event)
 
 	// print the violations (if any)
@@ -80,7 +80,7 @@ func main() {
 
 func getEvent(p *loader.Program) types.Type {
 	for _, pkg := range p.AllPackages {
-		if strings.HasSuffix(pkg.Pkg.Path(), "tuxpa.in/a/zlog") {
+		if strings.HasSuffix(pkg.Pkg.Path(), "git.tuxpa.in/a/zlog") {
 			for _, d := range pkg.Defs {
 				if d != nil && d.Name() == "Event" {
 					return d.Type()

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,26 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"io"
-	"os"
-
-	"tuxpa.in/a/zlog"
-)
-
-func isInputFromPipe() bool {
-	fileInfo, _ := os.Stdin.Stat()
-	return fileInfo.Mode()&os.ModeCharDevice == 0
-}
-
-func main() {
-	if !isInputFromPipe() {
-		fmt.Println("The command is intended to work with pipes.")
-		fmt.Println("Usage: app_with_zerolog |  2> >(prettylog)")
-		os.Exit(1)
-		return
-	}
-
-	writer := zlog.NewConsoleWriter()
-	_, _ = io.Copy(writer, os.Stdin)
-}

console.go

@@ -74,8 +74,6 @@ type ConsoleWriter struct {
 	FormatFieldValue    Formatter
 	FormatErrFieldName  Formatter
 	FormatErrFieldValue Formatter
-
-	FormatExtra func(map[string]interface{}, *bytes.Buffer) error
 }
 
 // NewConsoleWriter creates and initializes a new ConsoleWriter.
@@ -130,18 +128,10 @@ func (w ConsoleWriter) Write(p []byte) (n int, err error) {
 
 	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
 }
@@ -231,7 +221,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 {
@@ -337,31 +327,27 @@ func consoleDefaultFormatTimestamp(timeFormat string, noColor bool) Formatter {
 		t := "<nil>"
 		switch tt := i.(type) {
 		case string:
-			ts, err := time.ParseInLocation(TimeFieldFormat, tt, time.Local)
+			ts, err := time.Parse(TimeFieldFormat, tt)
 			if err != nil {
 				t = tt
 			} else {
-				t = ts.Local().Format(timeFormat)
+				t = ts.Format(timeFormat)
 			}
 		case json.Number:
 			i, err := tt.Int64()
 			if err != nil {
 				t = tt.String()
 			} else {
-				var sec, nsec int64
+				var sec, nsec int64 = i, 0
-
 				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)
+					nsec = int64(time.Duration(i) * time.Millisecond)
-				default:
+					sec = 0
-					sec, nsec = i, 0
+				case TimeFormatUnixMicro:
+					nsec = int64(time.Duration(i) * time.Microsecond)
+					sec = 0
 				}
-
+				ts := time.Unix(sec, nsec).UTC()
-				ts := time.Unix(sec, nsec)
 				t = ts.Format(timeFormat)
 			}
 		}
@@ -389,7 +375,7 @@ func consoleDefaultFormatLevel(noColor bool) Formatter {
 			case LevelPanicValue:
 				l = colorize(colorize("PNC", colorRed, noColor), colorBold, noColor)
 			default:
-				l = colorize(ll, colorBold, noColor)
+				l = colorize("???", colorBold, noColor)
 			}
 		} else {
 			if i == nil {

console_test.go

@@ -9,7 +9,7 @@ import (
 	"testing"
 	"time"
 
-	"tuxpa.in/a/zlog"
+	"git.tuxpa.in/a/zlog"
 )
 
 func ExampleConsoleWriter() {
@@ -108,14 +108,13 @@ func TestConsoleWriter(t *testing.T) {
 		buf := &bytes.Buffer{}
 		w := zlog.ConsoleWriter{Out: buf, NoColor: true}
 
-		ts := time.Unix(0, 0)
+		d := time.Unix(0, 0).UTC().Format(time.RFC3339)
-		d := ts.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"
+		expectedOutput := "12:00AM DBG Foobar foo=bar\n"
 		actualOutput := buf.String()
 		if actualOutput != expectedOutput {
 			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
@@ -137,7 +136,7 @@ func TestConsoleWriter(t *testing.T) {
 			t.Errorf("Unexpected error when writing output: %s", err)
 		}
 
-		expectedOutput := time.Unix(1234, 0).Format(time.StampMilli) + " DBG Foobar foo=bar\n"
+		expectedOutput := "Jan  1 00:20:34.000 DBG Foobar foo=bar\n"
 		actualOutput := buf.String()
 		if actualOutput != expectedOutput {
 			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
@@ -159,7 +158,7 @@ func TestConsoleWriter(t *testing.T) {
 			t.Errorf("Unexpected error when writing output: %s", err)
 		}
 
-		expectedOutput := time.Unix(1234, 567000000).Format(time.StampMilli) + " DBG Foobar foo=bar\n"
+		expectedOutput := "Jan  1 00:20:34.567 DBG Foobar foo=bar\n"
 		actualOutput := buf.String()
 		if actualOutput != expectedOutput {
 			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
@@ -181,7 +180,7 @@ func TestConsoleWriter(t *testing.T) {
 			t.Errorf("Unexpected error when writing output: %s", err)
 		}
 
-		expectedOutput := time.Unix(1234, 567891000).Format(time.StampMicro) + " DBG Foobar foo=bar\n"
+		expectedOutput := "Jan  1 00:20:34.567891 DBG Foobar foo=bar\n"
 		actualOutput := buf.String()
 		if actualOutput != expectedOutput {
 			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
@@ -240,8 +239,7 @@ func TestConsoleWriter(t *testing.T) {
 		buf := &bytes.Buffer{}
 		w := zlog.ConsoleWriter{Out: buf, NoColor: true}
 
-		ts := time.Unix(0, 0)
+		d := time.Unix(0, 0).UTC().Format(time.RFC3339)
-		d := ts.UTC().Format(time.RFC3339)
 		evt := `{"time": "` + d + `", "level": "error", "message": "Foobar", "aaa": "bbb", "error": "Error"}`
 		// t.Log(evt)
 
@@ -250,7 +248,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)
@@ -266,8 +264,7 @@ func TestConsoleWriter(t *testing.T) {
 			t.Fatalf("Cannot get working directory: %s", err)
 		}
 
-		ts := time.Unix(0, 0)
+		d := time.Unix(0, 0).UTC().Format(time.RFC3339)
-		d := ts.UTC().Format(time.RFC3339)
 		evt := `{"time": "` + d + `", "level": "debug", "message": "Foobar", "foo": "bar", "caller": "` + cwd + `/foo/bar.go"}`
 		// t.Log(evt)
 
@@ -276,7 +273,7 @@ func TestConsoleWriter(t *testing.T) {
 			t.Errorf("Unexpected error when writing output: %s", err)
 		}
 
-		expectedOutput := ts.Format(time.Kitchen) + " DBG foo/bar.go > Foobar foo=bar\n"
+		expectedOutput := "12:00AM DBG foo/bar.go > Foobar foo=bar\n"
 		actualOutput := buf.String()
 		if actualOutput != expectedOutput {
 			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
@@ -308,8 +305,7 @@ func TestConsoleWriterConfiguration(t *testing.T) {
 		buf := &bytes.Buffer{}
 		w := zlog.ConsoleWriter{Out: buf, NoColor: true, TimeFormat: time.RFC3339}
 
-		ts := time.Unix(0, 0)
+		d := time.Unix(0, 0).UTC().Format(time.RFC3339)
-		d := ts.UTC().Format(time.RFC3339)
 		evt := `{"time": "` + d + `", "level": "info", "message": "Foobar"}`
 
 		_, err := w.Write([]byte(evt))
@@ -317,7 +313,7 @@ func TestConsoleWriterConfiguration(t *testing.T) {
 			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)
@@ -375,55 +371,6 @@ func TestConsoleWriterConfiguration(t *testing.T) {
 			t.Errorf("Unexpected output %q, want: %q", actualOutput, expectedOutput)
 		}
 	})
-
-	t.Run("Sets FormatExtra", func(t *testing.T) {
-		buf := &bytes.Buffer{}
-		w := zlog.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("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 := zlog.TimeFieldFormat
-		defer func() {
-			zlog.TimeFieldFormat = of
-		}()
-		zlog.TimeFieldFormat = timeFormat
-
-		buf := &bytes.Buffer{}
-		w := zlog.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) {

context.go

@@ -329,9 +329,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 zlog.TimeFieldFormat.
+// Timestamp adds the current local time as UNIX timestamp to the logger context with the "time" key.
 // To customize the key name, change zlog.TimestampFieldName.
-// To customize the time format, change zlog.TimeFieldFormat.
 //
 // NOTE: It won't dedupe the "time" key if the *Context has one already.
 func (c Context) Timestamp() Context {

ctx.go

@@ -14,15 +14,10 @@ func init() {
 
 type ctxKey struct{}
 
-// WithContext returns a copy of ctx with the receiver attached. The Logger
+// WithContext returns a copy of ctx with l associated. If an instance of Logger
-// attached to the provided Context (if any) will not be effected.  If the
+// is already in the context, the context is not updated.
-// 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.
 //
-// Note: to modify the existing Logger attached to a Context (instead of
+// For instance, to add a field to an existing logger in the context, use this
-// replacing it in a new Context), use UpdateContext with the following
 // notation:
 //
 //     ctx := r.Context()
@@ -30,9 +25,13 @@ 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 {
+	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
 	}

diode/diode.go

@@ -8,7 +8,7 @@ import (
 	"sync"
 	"time"
 
-	"tuxpa.in/a/zlog/diode/internal/diodes"
+	"git.tuxpa.in/a/zlog/diode/internal/diodes"
 )
 
 var bufPool = &sync.Pool{

diode/diode_example_test.go

@@ -6,8 +6,8 @@ import (
 	"fmt"
 	"os"
 
-	"tuxpa.in/a/zlog"
+	"git.tuxpa.in/a/zlog"
-	"tuxpa.in/a/zlog/diode"
+	"git.tuxpa.in/a/zlog/diode"
 )
 
 func ExampleNewWriter() {

diode/diode_test.go

@@ -9,9 +9,9 @@ import (
 	"testing"
 	"time"
 
-	"tuxpa.in/a/zlog"
+	"git.tuxpa.in/a/zlog"
-	"tuxpa.in/a/zlog/diode"
+	"git.tuxpa.in/a/zlog/diode"
-	"tuxpa.in/a/zlog/internal/cbor"
+	"git.tuxpa.in/a/zlog/internal/cbor"
 )
 
 func TestNewWriter(t *testing.T) {
@@ -30,14 +30,6 @@ func TestNewWriter(t *testing.T) {
 	}
 }
 
-func TestClose(t *testing.T) {
-	buf := bytes.Buffer{}
-	w := diode.NewWriter(&buf, 1000, 0, func(missed int) {})
-	log := zlog.New(w)
-	log.Print("test")
-	w.Close()
-}
-
 func Benchmark(b *testing.B) {
 	log.SetOutput(ioutil.Discard)
 	defer log.SetOutput(os.Stderr)

diode/internal/diodes/waiter.go

@@ -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_cbor.go

@@ -5,7 +5,7 @@ package zlog
 // This file contains bindings to do binary encoding.
 
 import (
-	"tuxpa.in/a/zlog/internal/cbor"
+	"git.tuxpa.in/a/zlog/internal/cbor"
 )
 
 var (
@@ -24,9 +24,6 @@ func init() {
 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

@@ -1,4 +1,3 @@
-//go:build !binary_log
 // +build !binary_log
 
 package zlog
@@ -7,8 +6,7 @@ package zlog
 // JSON encoded byte stream.
 
 import (
-	"encoding/base64"
+	"git.tuxpa.in/a/zlog/internal/json"
-	"tuxpa.in/a/zlog/internal/json"
 )
 
 var (
@@ -27,17 +25,6 @@ func init() {
 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

@@ -318,18 +318,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 {
@@ -719,11 +707,6 @@ func (e *Event) TimeDiff(key string, t time.Time, start time.Time) *Event {
 	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 {
@@ -736,15 +719,6 @@ 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 {
@@ -770,11 +744,11 @@ 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 + e.skipFrame)
 	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), CallerMarshalFunc(file, line))
 	return e
 }
 

globals.go

@@ -19,10 +19,6 @@ const (
 	// 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"
 )
 
 var (
@@ -65,7 +61,7 @@ var (
 	CallerSkipFrameCount = 2
 
 	// CallerMarshalFunc allows customization of global caller marshaling
-	CallerMarshalFunc = func(pc uintptr, file string, line int) string {
+	CallerMarshalFunc = func(file string, line int) string {
 		return file + ":" + strconv.Itoa(line)
 	}
 
@@ -85,7 +81,7 @@ var (
 	InterfaceMarshalFunc = json.Marshal
 
 	// 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
+	// TimeFormatUnix, TimeFormatUnixMs or TimeFormatUnixMicro, the time is formatted as a UNIX
 	// timestamp as integer.
 	TimeFieldFormat = time.RFC3339
 

go.mod

@@ -1,12 +1,10 @@
-module tuxpa.in/a/zlog
+module git.tuxpa.in/a/zlog
 
 go 1.15
 
 require (
-	github.com/coreos/go-systemd/v22 v22.5.0
+	github.com/coreos/go-systemd/v22 v22.3.3-0.20220203105225-a9a7ef127534
 	github.com/mattn/go-colorable v0.1.12
 	github.com/pkg/errors v0.9.1
-	github.com/rs/xid v1.5.0
+	github.com/rs/xid v1.3.0
-	github.com/rs/zerolog v1.28.0
-	golang.org/x/sys v0.0.0-20220915200043-7b5979e65e41 // indirect
 )

go.sum

@@ -1,6 +1,7 @@
+github.com/coreos/go-systemd/v22 v22.3.2 h1:D9/bQk5vlXQFZ6Kwuu6zaiXJ9oTPe68++AzAJc1DzSI=
+github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
+github.com/coreos/go-systemd/v22 v22.3.3-0.20220203105225-a9a7ef127534 h1:rtAn27wIbmOGUs7RIbVgPEjb31ehTVniDwPGXyMxm5U=
 github.com/coreos/go-systemd/v22 v22.3.3-0.20220203105225-a9a7ef127534/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
-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.12 h1:jF+Du6AlPIjs2BiUiQlKOX0rt3SujHxPnksPKZbaA40=
 github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
@@ -8,12 +9,8 @@ github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9
 github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
 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.4.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
+github.com/rs/xid v1.3.0 h1:6NjYksEUlhurdVehpc7S7dk6DAmcKv8V9gG0FsVN2U4=
-github.com/rs/xid v1.5.0 h1:mKX4bl4iPYJtEIxp6CYiUuLQ/8DYMoz0PUdtGgMFRVc=
+github.com/rs/xid v1.3.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
-github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
-github.com/rs/zerolog v1.28.0 h1:MirSo27VyNi7RJYP3078AA1+Cyzd2GB66qy3aUHvsWY=
-github.com/rs/zerolog v1.28.0/go.mod h1:NILgTygv/Uej1ra5XxGf82ZFSLk58MFGAUS2o6usyD0=
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6 h1:foEbQz/B0Oz6YIqu/69kfXPYeFQAuuMYFkjaqXzl5Wo=
 golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220915200043-7b5979e65e41 h1:ohgcoMbSofXygzo6AD2I1kz3BFmW1QArPYTtwEM3UXc=
-golang.org/x/sys v0.0.0-20220915200043-7b5979e65e41/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

hlog/hlog.go

@@ -7,9 +7,9 @@ import (
 	"time"
 
 	"github.com/rs/xid"
-	"tuxpa.in/a/zlog"
+	"git.tuxpa.in/a/zlog"
-	"tuxpa.in/a/zlog/hlog/internal/mutil"
+	"git.tuxpa.in/a/zlog/hlog/internal/mutil"
-	"tuxpa.in/a/zlog/log"
+	"git.tuxpa.in/a/zlog/log"
 )
 
 // FromRequest gets the logger in the request's context.
@@ -121,20 +121,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 := zlog.Ctx(r.Context())
-			log.UpdateContext(func(c zlog.Context) zlog.Context {
-				return c.Str(fieldKey, r.Proto)
-			})
-			next.ServeHTTP(w, r)
-		})
-	}
-}
-
 type idKey struct{}
 
 // IDFromRequest returns the unique id associated to the request if any.

hlog/hlog_example_test.go

@@ -9,8 +9,8 @@ import (
 
 	"net/http/httptest"
 
-	"tuxpa.in/a/zlog"
+	"git.tuxpa.in/a/zlog"
-	"tuxpa.in/a/zlog/hlog"
+	"git.tuxpa.in/a/zlog/hlog"
 )
 
 // fake alice to avoid dep

hlog/hlog_test.go

@@ -1,4 +1,3 @@
-//go:build go1.7
 // +build go1.7
 
 package hlog
@@ -15,8 +14,8 @@ import (
 	"testing"
 
 	"github.com/rs/xid"
-	"tuxpa.in/a/zlog"
+	"git.tuxpa.in/a/zlog"
-	"tuxpa.in/a/zlog/internal/cbor"
+	"git.tuxpa.in/a/zlog/internal/cbor"
 )
 
 func decodeIfBinary(out *bytes.Buffer) string {
@@ -201,22 +200,6 @@ func TestCustomHeaderHandler(t *testing.T) {
 	}
 }
 
-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(zlog.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 TestCombinedHandlers(t *testing.T) {
 	out := &bytes.Buffer{}
 	r := &http.Request{

internal/cbor/cbor.go

@@ -26,8 +26,7 @@ const (
 	additionalTypeBreak   byte = 31
 
 	// Tag Sub-types.
-	additionalTypeTimestamp    byte = 01
+	additionalTypeTimestamp byte = 01
-	additionalTypeEmbeddedCBOR byte = 63
 
 	// Extended Tags - from https://www.iana.org/assignments/cbor-tags/cbor-tags.xhtml
 	additionalTypeTagNetworkAddr   uint16 = 260

internal/cbor/decode_stream.go

@@ -5,7 +5,6 @@ package cbor
 import (
 	"bufio"
 	"bytes"
-	"encoding/base64"
 	"fmt"
 	"io"
 	"math"
@@ -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)
@@ -375,20 +349,6 @@ 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:

internal/cbor/examples/genLog.go

@@ -8,7 +8,7 @@ import (
 	"os"
 	"time"
 
-	"tuxpa.in/a/zlog"
+	"git.tuxpa.in/a/zlog"
 )
 
 func writeLog(fname string, count int, useCompress bool) {

internal/cbor/string.go

@@ -93,25 +93,3 @@ func AppendEmbeddedJSON(dst, s []byte) []byte {
 	}
 	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)
-	} else {
-		dst = appendCborTypePrefix(dst, major, uint64(l))
-	}
-	return append(dst, s...)
-}

internal/cbor/types.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"math"
 	"net"
-	"reflect"
 )
 
 // AppendNil inserts a 'Nil' object into the dst byte array.
@@ -439,14 +438,6 @@ func (e Encoder) AppendInterface(dst []byte, i interface{}) []byte {
 	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)

internal/json/time.go

@@ -7,10 +7,9 @@ import (
 
 const (
 	// Import from zlog/global.go
-	timeFormatUnix      = ""
+	timeFormatUnix   = ""
-	timeFormatUnixMs    = "UNIXMS"
+	timeFormatUnixMs = "UNIXMS"
 	timeFormatUnixMicro = "UNIXMICRO"
-	timeFormatUnixNano  = "UNIXNANO"
 )
 
 // AppendTime formats the input time with the given format
@@ -23,8 +22,6 @@ func (e Encoder) AppendTime(dst []byte, t time.Time, format string) []byte {
 		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), '"')
 }
@@ -36,11 +33,7 @@ func (Encoder) AppendTimes(dst []byte, vals []time.Time, format string) []byte {
 	case timeFormatUnix:
 		return appendUnixTimes(dst, vals)
 	case timeFormatUnixMs:
-		return appendUnixNanoTimes(dst, vals, 1000000)
+		return appendUnixMsTimes(dst, vals)
-	case timeFormatUnixMicro:
-		return appendUnixNanoTimes(dst, vals, 1000)
-	case timeFormatUnixNano:
-		return appendUnixNanoTimes(dst, vals, 1)
 	}
 	if len(vals) == 0 {
 		return append(dst, '[', ']')
@@ -71,15 +64,15 @@ func appendUnixTimes(dst []byte, vals []time.Time) []byte {
 	return dst
 }
 
-func appendUnixNanoTimes(dst []byte, vals []time.Time, div int64) []byte {
+func appendUnixMsTimes(dst []byte, vals []time.Time) []byte {
 	if len(vals) == 0 {
 		return append(dst, '[', ']')
 	}
 	dst = append(dst, '[')
-	dst = strconv.AppendInt(dst, vals[0].UnixNano()/div, 10)
+	dst = strconv.AppendInt(dst, vals[0].UnixNano()/1000000, 10)
 	if len(vals) > 1 {
 		for _, t := range vals[1:] {
-			dst = strconv.AppendInt(append(dst, ','), t.UnixNano()/div, 10)
+			dst = strconv.AppendInt(append(dst, ','), t.UnixNano()/1000000, 10)
 		}
 	}
 	dst = append(dst, ']')

internal/json/types.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"math"
 	"net"
-	"reflect"
 	"strconv"
 )
 
@@ -370,14 +369,6 @@ func (e Encoder) AppendInterface(dst []byte, i interface{}) []byte {
 	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 {

internal/json/types_test.go

@@ -166,28 +166,6 @@ 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

journald/journald.go

@@ -25,8 +25,8 @@ import (
 	"strings"
 
 	"github.com/coreos/go-systemd/v22/journal"
-	"tuxpa.in/a/zlog"
+	"git.tuxpa.in/a/zlog"
-	"tuxpa.in/a/zlog/internal/cbor"
+	"git.tuxpa.in/a/zlog/internal/cbor"
 )
 
 const defaultJournalDPrio = journal.PriNotice
@@ -102,7 +102,7 @@ func (w journalWriter) Write(p []byte) (n int, err error) {
 		case json.Number:
 			args[jKey] = fmt.Sprint(value)
 		default:
-			b, err := zlog.InterfaceMarshalFunc(value)
+			b, err := json.Marshal(value)
 			if err != nil {
 				args[jKey] = fmt.Sprintf("[error: %v]", err)
 			} else {

journald/journald_test.go

@@ -7,8 +7,8 @@ import (
 	"io"
 	"testing"
 
-	"tuxpa.in/a/zlog"
+	"git.tuxpa.in/a/zlog"
-	"tuxpa.in/a/zlog/journald"
+	"git.tuxpa.in/a/zlog/journald"
 )
 
 func ExampleNewJournalDWriter() {

log.go

@@ -2,109 +2,108 @@
 //
 // A global Logger can be use for simple logging:
 //
-//	import "tuxpa.in/a/zlog/log"
+//     import "git.tuxpa.in/a/zlog/log"
 //
-//	log.Info().Msg("hello world")
+//     log.Info().Msg("hello world")
-//	// Output: {"time":1494567715,"level":"info","message":"hello world"}
+//     // Output: {"time":1494567715,"level":"info","message":"hello world"}
 //
-// NOTE: To import the global logger, import the "log" subpackage "tuxpa.in/a/zlog/log".
+// NOTE: To import the global logger, import the "log" subpackage "git.tuxpa.in/a/zlog/log".
 //
 // Fields can be added to log messages:
 //
-//	log.Info().Str("foo", "bar").Msg("hello world")
+//     log.Info().Str("foo", "bar").Msg("hello world")
-//	// Output: {"time":1494567715,"level":"info","message":"hello world","foo":"bar"}
+//     // Output: {"time":1494567715,"level":"info","message":"hello world","foo":"bar"}
 //
 // Create logger instance to manage different outputs:
 //
-//	logger := zlog.New(os.Stderr).With().Timestamp().Logger()
+//     logger := zlog.New(os.Stderr).With().Timestamp().Logger()
-//	logger.Info().
+//     logger.Info().
-//	       Str("foo", "bar").
+//            Str("foo", "bar").
-//	       Msg("hello world")
+//            Msg("hello world")
-//	// Output: {"time":1494567715,"level":"info","message":"hello world","foo":"bar"}
+//     // Output: {"time":1494567715,"level":"info","message":"hello world","foo":"bar"}
 //
 // Sub-loggers let you chain loggers with additional context:
 //
-//	sublogger := log.With().Str("component": "foo").Logger()
+//     sublogger := log.With().Str("component": "foo").Logger()
-//	sublogger.Info().Msg("hello world")
+//     sublogger.Info().Msg("hello world")
-//	// Output: {"time":1494567715,"level":"info","message":"hello world","component":"foo"}
+//     // Output: {"time":1494567715,"level":"info","message":"hello world","component":"foo"}
 //
 // Level logging
 //
-//	zlog.SetGlobalLevel(zlog.InfoLevel)
+//     zlog.SetGlobalLevel(zlog.InfoLevel)
 //
-//	log.Debug().Msg("filtered out message")
+//     log.Debug().Msg("filtered out message")
-//	log.Info().Msg("routed message")
+//     log.Info().Msg("routed message")
 //
-//	if e := log.Debug(); e.Enabled() {
+//     if e := log.Debug(); e.Enabled() {
-//	    // Compute log output only if enabled.
+//         // Compute log output only if enabled.
-//	    value := compute()
+//         value := compute()
-//	    e.Str("foo": value).Msg("some debug message")
+//         e.Str("foo": value).Msg("some debug message")
-//	}
+//     }
-//	// Output: {"level":"info","time":1494567715,"routed message"}
+//     // Output: {"level":"info","time":1494567715,"routed message"}
 //
 // Customize automatic field names:
 //
-//	log.TimestampFieldName = "t"
+//     log.TimestampFieldName = "t"
-//	log.LevelFieldName = "p"
+//     log.LevelFieldName = "p"
-//	log.MessageFieldName = "m"
+//     log.MessageFieldName = "m"
 //
-//	log.Info().Msg("hello world")
+//     log.Info().Msg("hello world")
-//	// Output: {"t":1494567715,"p":"info","m":"hello world"}
+//     // Output: {"t":1494567715,"p":"info","m":"hello world"}
 //
 // Log with no level and message:
 //
-//	log.Log().Str("foo","bar").Msg("")
+//     log.Log().Str("foo","bar").Msg("")
-//	// Output: {"time":1494567715,"foo":"bar"}
+//     // Output: {"time":1494567715,"foo":"bar"}
 //
 // Add contextual fields to global Logger:
 //
-//	log.Logger = log.With().Str("foo", "bar").Logger()
+//     log.Logger = log.With().Str("foo", "bar").Logger()
 //
 // Sample logs:
 //
-//	sampled := log.Sample(&zlog.BasicSampler{N: 10})
+//     sampled := log.Sample(&zlog.BasicSampler{N: 10})
-//	sampled.Info().Msg("will be logged every 10 messages")
+//     sampled.Info().Msg("will be logged every 10 messages")
 //
 // Log with contextual hooks:
 //
-//	// Create the hook:
+//     // Create the hook:
-//	type SeverityHook struct{}
+//     type SeverityHook struct{}
 //
-//	func (h SeverityHook) Run(e *zlog.Event, level zlog.Level, msg string) {
+//     func (h SeverityHook) Run(e *zlog.Event, level zlog.Level, msg string) {
-//	     if level != zlog.NoLevel {
+//          if level != zlog.NoLevel {
-//	         e.Str("severity", level.String())
+//              e.Str("severity", level.String())
-//	     }
+//          }
-//	}
+//     }
 //
-//	// And use it:
+//     // And use it:
-//	var h SeverityHook
+//     var h SeverityHook
-//	log := zlog.New(os.Stdout).Hook(h)
+//     log := zlog.New(os.Stdout).Hook(h)
-//	log.Warn().Msg("")
+//     log.Warn().Msg("")
-//	// Output: {"level":"warn","severity":"warn"}
+//     // Output: {"level":"warn","severity":"warn"}
 //
-// # Caveats
+//
+// Caveats
 //
 // There is no fields deduplication out-of-the-box.
 // Using the same key multiple times creates new key in final JSON each time.
 //
-//	logger := zlog.New(os.Stderr).With().Timestamp().Logger()
+//     logger := zlog.New(os.Stderr).With().Timestamp().Logger()
-//	logger.Info().
+//     logger.Info().
-//	       Timestamp().
+//            Timestamp().
-//	       Msg("dup")
+//            Msg("dup")
-//	// Output: {"level":"info","time":1494567715,"time":1494567715,"message":"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.
 package zlog
 
 import (
-	"errors"
 	"fmt"
 	"io"
 	"io/ioutil"
 	"os"
 	"strconv"
-	"strings"
 )
 
 // Level defines log levels.
@@ -160,24 +159,24 @@ func (l Level) String() string {
 // ParseLevel converts a level string into a zlog Level value.
 // returns an error if the input string does not match known values.
 func ParseLevel(levelStr string) (Level, error) {
-	switch {
+	switch levelStr {
-	case strings.EqualFold(levelStr, LevelFieldMarshalFunc(TraceLevel)):
+	case LevelFieldMarshalFunc(TraceLevel):
 		return TraceLevel, nil
-	case strings.EqualFold(levelStr, LevelFieldMarshalFunc(DebugLevel)):
+	case LevelFieldMarshalFunc(DebugLevel):
 		return DebugLevel, nil
-	case strings.EqualFold(levelStr, LevelFieldMarshalFunc(InfoLevel)):
+	case LevelFieldMarshalFunc(InfoLevel):
 		return InfoLevel, nil
-	case strings.EqualFold(levelStr, LevelFieldMarshalFunc(WarnLevel)):
+	case LevelFieldMarshalFunc(WarnLevel):
 		return WarnLevel, nil
-	case strings.EqualFold(levelStr, LevelFieldMarshalFunc(ErrorLevel)):
+	case LevelFieldMarshalFunc(ErrorLevel):
 		return ErrorLevel, nil
-	case strings.EqualFold(levelStr, LevelFieldMarshalFunc(FatalLevel)):
+	case LevelFieldMarshalFunc(FatalLevel):
 		return FatalLevel, nil
-	case strings.EqualFold(levelStr, LevelFieldMarshalFunc(PanicLevel)):
+	case LevelFieldMarshalFunc(PanicLevel):
 		return PanicLevel, nil
-	case strings.EqualFold(levelStr, LevelFieldMarshalFunc(Disabled)):
+	case LevelFieldMarshalFunc(Disabled):
 		return Disabled, nil
-	case strings.EqualFold(levelStr, LevelFieldMarshalFunc(NoLevel)):
+	case LevelFieldMarshalFunc(NoLevel):
 		return NoLevel, nil
 	}
 	i, err := strconv.Atoi(levelStr)
@@ -190,21 +189,6 @@ func ParseLevel(levelStr string) (Level, error) {
 	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
-}
-
 // 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
@@ -308,9 +292,7 @@ func (l Logger) Sample(s Sampler) Logger {
 
 // Hook returns a logger with the h Hook.
 func (l Logger) Hook(h Hook) Logger {
-	newHooks := make([]Hook, len(l.hooks), len(l.hooks)+1)
+	l.hooks = append(l.hooks, h)
-	copy(newHooks, l.hooks)
-	l.hooks = append(newHooks, h)
 	return l
 }
 

log/log.go

@@ -8,17 +8,15 @@ import (
 	"os"
 	"time"
 
-	"github.com/rs/zerolog"
+	"git.tuxpa.in/a/zlog"
-	"tuxpa.in/a/zlog"
 )
 
 // Logger is the global logger.
-var Logger = zlog.New(nil).Output(
+var Logger = zlog.New(os.Stderr).With().Timestamp().Logger()
-	zerolog.ConsoleWriter{
+
-		Out:        os.Stderr,
+func init() {
-		TimeFormat: time.RFC3339,
+	zlog.TimeFieldFormat = time.RFC3339Nano
-	},
+}
-).With().Timestamp().Logger()
 
 // Output duplicates the global logger and sets w as its output.
 func Output(w io.Writer) zlog.Logger {
@@ -107,7 +105,7 @@ func Fatal() *zlog.Event {
 }
 
 func Fatalf(format string, args ...interface{}) {
-	Logger.Fatal().Msgf(format, args...)
+	Logger.Fatal().Msgf(format, args)
 }
 
 func Fatalln(args ...interface{}) {
@@ -123,7 +121,7 @@ func Panic() *zlog.Event {
 }
 
 func Panicf(format string, args ...interface{}) {
-	Logger.Panic().Msgf(format, args...)
+	Logger.Panic().Msgf(format, args)
 }
 
 func Panicln(args ...interface{}) {

log/log_example_test.go

@@ -9,8 +9,8 @@ import (
 	"os"
 	"time"
 
-	"tuxpa.in/a/zlog"
+	"git.tuxpa.in/a/zlog"
-	"tuxpa.in/a/zlog/log"
+	"git.tuxpa.in/a/zlog/log"
 )
 
 // setup would normally be an init() function, however, there seems

log_example_test.go

@@ -10,7 +10,7 @@ import (
 	"os"
 	"time"
 
-	"tuxpa.in/a/zlog"
+	"git.tuxpa.in/a/zlog"
 )
 
 func ExampleNew() {

log_test.go

@@ -320,7 +320,6 @@ func TestFields(t *testing.T) {
 		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")).
@@ -345,7 +344,7 @@ func TestFields(t *testing.T) {
 		Time("time", time.Time{}).
 		TimeDiff("diff", now, now.Add(-10*time.Second)).
 		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","stringer":"127.0.0.1","stringer_nil":null,"bytes":"bar","hex":"12ef","json":{"some":"json"},"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 {
 		t.Errorf("invalid log output:\ngot:  %v\nwant: %v", got, want)
 	}
 }
@@ -783,7 +782,7 @@ func TestCallerMarshalFunc(t *testing.T) {
 
 	// test default behaviour this is really brittle due to the line numbers
 	// actually mattering for validation
-	pc, file, line, _ := runtime.Caller(0)
+	_, 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 {
@@ -794,16 +793,16 @@ func TestCallerMarshalFunc(t *testing.T) {
 	// 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 {
+	CallerMarshalFunc = func(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)
+		return file + ":" + strconv.Itoa(line)
 	}
-	pc, file, line, _ = runtime.Caller(0)
+	_, file, line, _ = runtime.Caller(0)
-	caller = CallerMarshalFunc(pc, file, line+2)
+	caller = CallerMarshalFunc(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)
@@ -908,33 +907,6 @@ func TestLevel_String(t *testing.T) {
 	}
 }
 
-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
@@ -971,41 +943,3 @@ func TestParseLevel(t *testing.T) {
 		})
 	}
 }
-
-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)
-			}
-		})
-	}
-}

pkgerrors/stacktrace.go

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

pkgerrors/stacktrace_test.go

@@ -4,12 +4,11 @@ package pkgerrors
 
 import (
 	"bytes"
-	"fmt"
 	"regexp"
 	"testing"
 
 	"github.com/pkg/errors"
-	"tuxpa.in/a/zlog"
+	"git.tuxpa.in/a/zlog"
 )
 
 func TestLogStack(t *testing.T) {
@@ -18,11 +17,11 @@ func TestLogStack(t *testing.T) {
 	out := &bytes.Buffer{}
 	log := zlog.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`
+	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)
 	}
@@ -34,11 +33,11 @@ func TestLogStackFromContext(t *testing.T) {
 	out := &bytes.Buffer{}
 	log := zlog.New(out).With().Stack().Logger() // calling Stack() on log context instead of event
 
-	err := fmt.Errorf("from error: %w", errors.New("error message"))
+	err := errors.Wrap(errors.New("error message"), "from error")
 	log.Log().Err(err).Msg("") // not explicitly calling Stack()
 
 	got := out.String()
-	want := `\{"stack":\[\{"func":"TestLogStackFromContext","line":"37","source":"stacktrace_test.go"\},.*\],"error":"from error: error message"\}\n`
+	want := `\{"stack":\[\{"func":"TestLogStackFromContext","line":"36","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)
 	}