Merge pull request #15 from go-playground/configurable-witherror

Configurable WithError function

Author: Dean Karn

README.md

@@ -1,5 +1,5 @@
 ## log
-<img align="right" src="https://raw.githubusercontent.com/go-playground/log/master/logo.png">![Project status](https://img.shields.io/badge/version-5.0.2-green.svg)
+<img align="right" src="https://raw.githubusercontent.com/go-playground/log/master/logo.png">![Project status](https://img.shields.io/badge/version-6.0.0-green.svg)
 [![Build Status](https://semaphoreci.com/api/v1/joeybloggs/log/branches/master/badge.svg)](https://semaphoreci.com/joeybloggs/log)
 [![Coverage Status](https://coveralls.io/repos/github/go-playground/log/badge.svg?branch=master)](https://coveralls.io/github/go-playground/log?branch=master)
 [![Go Report Card](https://goreportcard.com/badge/github.com/go-playground/log)](https://goreportcard.com/report/github.com/go-playground/log)
@@ -21,6 +21,9 @@ Features
 - [x] Handlers are simple to write + easy to register
 - [x] Logger is a singleton ( one of the few instances a singleton is desired ) so the root package registers which handlers are used and any libraries just follow suit.
 - [x] Convenient context helpers `GetContext` & `SetContext`
+- [x] Works with go-playground/errors extracting types and tags when used with `WithError`, is the default
+- [x] Works with pkg/errors when used with `WithError`, must set using `SetWithErrFn`
+- [x] Works with segmentio/errors-go extracting types and tags when used with `WithError`, must set using `SetWithErrFn`
 
 Installation
 -----------

entry.go

@@ -2,10 +2,7 @@ package log
 
 import (
 	"fmt"
-	"strings"
 	"time"
-
-	"github.com/pkg/errors"
 )
 
 // Fields is the type to send to WithFields
@@ -48,154 +45,130 @@ func (e Entry) WithFields(fields ...Field) Entry {
 	return ne
 }
 
-// WithTrace withh add duration of how long the between this function call and
-// the susequent log
+// WithTrace with add duration of how long the between this function call and
+// the subsequent log
 func (e Entry) WithTrace() Entry {
 	e.start = time.Now()
 	return e
 }
 
 // WithError add a minimal stack trace to the log Entry
 func (e Entry) WithError(err error) Entry {
-	return e.withError(err)
-}
-
-// WithError add a minimal stack trace to the log Entry
-func (e Entry) withError(err error) Entry {
-	ne := newEntry(e)
-	ne.Fields = append(ne.Fields, Field{Key: "error", Value: err.Error()})
-
-	var frame errors.Frame
-
-	if s, ok := err.(stackTracer); ok {
-		frame = s.StackTrace()[0]
-	} else {
-		frame = errors.WithStack(err).(stackTracer).StackTrace()[2:][0]
-	}
-
-	name := fmt.Sprintf("%n", frame)
-	file := fmt.Sprintf("%+s", frame)
-	line := fmt.Sprintf("%d", frame)
-	parts := strings.Split(file, "\n\t")
-	if len(parts) > 1 {
-		file = parts[1]
-	}
-	ne.Fields = append(ne.Fields, Field{Key: "source", Value: fmt.Sprintf("%s: %s:%s", name, file, line)})
-	return ne
+	return withErrFn(e, err)
 }
 
 // Debug logs a debug entry
 func (e Entry) Debug(v ...interface{}) {
 	e.Message = fmt.Sprint(v...)
 	e.Level = DebugLevel
-	handleEntry(e)
+	HandleEntry(e)
 }
 
 // Debugf logs a debug entry with formatting
 func (e Entry) Debugf(s string, v ...interface{}) {
 	e.Message = fmt.Sprintf(s, v...)
 	e.Level = DebugLevel
-	handleEntry(e)
+	HandleEntry(e)
 }
 
 // Info logs a normal. information, entry
 func (e Entry) Info(v ...interface{}) {
 	e.Message = fmt.Sprint(v...)
 	e.Level = InfoLevel
-	handleEntry(e)
+	HandleEntry(e)
 }
 
 // Infof logs a normal. information, entry with formatting
 func (e Entry) Infof(s string, v ...interface{}) {
 	e.Message = fmt.Sprintf(s, v...)
 	e.Level = InfoLevel
-	handleEntry(e)
+	HandleEntry(e)
 }
 
 // Notice logs a notice log entry
 func (e Entry) Notice(v ...interface{}) {
 	e.Message = fmt.Sprint(v...)
 	e.Level = NoticeLevel
-	handleEntry(e)
+	HandleEntry(e)
 }
 
 // Noticef logs a notice log entry with formatting
 func (e Entry) Noticef(s string, v ...interface{}) {
 	e.Message = fmt.Sprintf(s, v...)
 	e.Level = NoticeLevel
-	handleEntry(e)
+	HandleEntry(e)
 }
 
 // Warn logs a warn log entry
 func (e Entry) Warn(v ...interface{}) {
 	e.Message = fmt.Sprint(v...)
 	e.Level = WarnLevel
-	handleEntry(e)
+	HandleEntry(e)
 }
 
 // Warnf logs a warn log entry with formatting
 func (e Entry) Warnf(s string, v ...interface{}) {
 	e.Message = fmt.Sprintf(s, v...)
 	e.Level = WarnLevel
-	handleEntry(e)
+	HandleEntry(e)
 }
 
 // Panic logs a panic log entry
 func (e Entry) Panic(v ...interface{}) {
 	e.Message = fmt.Sprint(v...)
 	e.Level = PanicLevel
-	handleEntry(e)
+	HandleEntry(e)
 	exitFunc(1)
 }
 
 // Panicf logs a panic log entry with formatting
 func (e Entry) Panicf(s string, v ...interface{}) {
 	e.Message = fmt.Sprintf(s, v...)
 	e.Level = PanicLevel
-	handleEntry(e)
+	HandleEntry(e)
 	exitFunc(1)
 }
 
 // Alert logs an alert log entry
 func (e Entry) Alert(v ...interface{}) {
 	e.Message = fmt.Sprint(v...)
 	e.Level = AlertLevel
-	handleEntry(e)
+	HandleEntry(e)
 }
 
 // Alertf logs an alert log entry with formatting
 func (e Entry) Alertf(s string, v ...interface{}) {
 	e.Message = fmt.Sprintf(s, v...)
 	e.Level = AlertLevel
-	handleEntry(e)
+	HandleEntry(e)
 }
 
 // Fatal logs a fatal log entry
 func (e Entry) Fatal(v ...interface{}) {
 	e.Message = fmt.Sprint(v...)
 	e.Level = FatalLevel
-	handleEntry(e)
+	HandleEntry(e)
 	exitFunc(1)
 }
 
 // Fatalf logs a fatal log entry with formatting
 func (e Entry) Fatalf(s string, v ...interface{}) {
 	e.Message = fmt.Sprintf(s, v...)
 	e.Level = FatalLevel
-	handleEntry(e)
+	HandleEntry(e)
 	exitFunc(1)
 }
 
 // Error logs an error log entry
 func (e Entry) Error(v ...interface{}) {
 	e.Message = fmt.Sprint(v...)
 	e.Level = ErrorLevel
-	handleEntry(e)
+	HandleEntry(e)
 }
 
 // Errorf logs an error log entry with formatting
 func (e Entry) Errorf(s string, v ...interface{}) {
 	e.Message = fmt.Sprintf(s, v...)
 	e.Level = ErrorLevel
-	handleEntry(e)
+	HandleEntry(e)
 }

errors.go

@@ -0,0 +1,52 @@
+package log
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/go-playground/errors"
+)
+
+func errorsWithError(e Entry, err error) Entry {
+	ne := newEntry(e)
+
+	if w, ok := err.(*errors.Wrapped); ok {
+		cause := errors.Cause(w).(*errors.Wrapped)
+		ne.Fields = append(ne.Fields, Field{Key: "error", Value: fmt.Sprintf("%s: %s", cause.Prefix, cause.Err)})
+		ne.Fields = append(ne.Fields, Field{Key: "source", Value: cause.Source})
+		if len(w.Errors) > 0 {
+			// top level error
+			types := make([]string, 0, len(w.Errors))
+			for _, e := range w.Errors {
+				for _, tag := range e.Tags {
+					ne.Fields = append(ne.Fields, Field{Key: tag.Key, Value: tag.Value})
+				}
+				types = append(types, e.Types...)
+			}
+			if len(types) > 0 {
+				ne.Fields = append(ne.Fields, Field{Key: "types", Value: strings.Join(types, ",")})
+			}
+		} else {
+			// not top level, probably cause
+			for _, tag := range w.Tags {
+				ne.Fields = append(ne.Fields, Field{Key: tag.Key, Value: tag.Value})
+			}
+			if len(w.Types) > 0 {
+				ne.Fields = append(ne.Fields, Field{Key: "types", Value: strings.Join(w.Types, ",")})
+			}
+		}
+
+	} else {
+		ne.Fields = append(ne.Fields, Field{Key: "error", Value: err.Error()})
+		frame := errors.StackLevel(2)
+		name := fmt.Sprintf("%n", frame)
+		file := fmt.Sprintf("%+s", frame)
+		line := fmt.Sprintf("%d", frame)
+		parts := strings.Split(file, "\n\t")
+		if len(parts) > 1 {
+			file = parts[1]
+		}
+		ne.Fields = append(ne.Fields, Field{Key: "source", Value: fmt.Sprintf("%s: %s:%s", name, file, line)})
+	}
+	return ne
+}

errors/pkg/pkg.go

@@ -0,0 +1,45 @@
+package pkg
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/go-playground/log"
+	"github.com/pkg/errors"
+)
+
+type stackTracer interface {
+	StackTrace() errors.StackTrace
+}
+
+// ErrorsWithError is a custom WithError function that can be used by using log's
+// SetWithErrorFn function.
+func ErrorsWithError(e log.Entry, err error) log.Entry {
+	// normally would call newEntry, but instead will shallow copy
+	// because it's not exposed.
+	ne := new(log.Entry)
+	*ne = *(&e)
+
+	flds := make([]log.Field, 0, len(e.Fields))
+	flds = append(flds, e.Fields...)
+	flds = append(flds, log.Field{Key: "error", Value: err.Error()})
+	ne.Fields = flds
+
+	var frame errors.Frame
+
+	if s, ok := err.(stackTracer); ok {
+		frame = s.StackTrace()[0]
+	} else {
+		frame = errors.WithStack(err).(stackTracer).StackTrace()[2:][0]
+	}
+
+	name := fmt.Sprintf("%n", frame)
+	file := fmt.Sprintf("%+s", frame)
+	line := fmt.Sprintf("%d", frame)
+	parts := strings.Split(file, "\n\t")
+	if len(parts) > 1 {
+		file = parts[1]
+	}
+	ne.Fields = append(ne.Fields, log.Field{Key: "source", Value: fmt.Sprintf("%s: %s:%s", name, file, line)})
+	return *ne
+}

errors/pkg/pkg_test.go

@@ -0,0 +1,54 @@
+package pkg
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"strings"
+	"testing"
+
+	"github.com/go-playground/log"
+	"github.com/pkg/errors"
+)
+
+type testHandler struct {
+	writer io.Writer
+}
+
+func (th *testHandler) Log(e log.Entry) {
+	s := e.Level.String() + " "
+	s += e.Message
+
+	for _, f := range e.Fields {
+		s += fmt.Sprintf(" %s=%v", f.Key, f.Value)
+	}
+	s += "\n"
+	if _, err := th.writer.Write([]byte(s)); err != nil {
+		panic(err)
+	}
+}
+
+func TestWrappedError(t *testing.T) {
+	log.SetExitFunc(func(int) {})
+	log.SetWithErrorFn(ErrorsWithError)
+	buff := new(bytes.Buffer)
+	th := &testHandler{
+		writer: buff,
+	}
+	log.AddHandler(th, log.AllLevels...)
+
+	err := fmt.Errorf("this is an %s", "error")
+	err = errors.Wrap(err, "prefix")
+	log.WithError(err).Error("test")
+	expected := "pkg_test.go:41\n"
+	if !strings.HasSuffix(buff.String(), expected) {
+		t.Errorf("got %s Expected %s", buff.String(), expected)
+	}
+	buff.Reset()
+	expected = "pkg_test.go:50\n"
+	err = fmt.Errorf("this is an %s", "error")
+	log.WithError(err).Error("test")
+	if !strings.HasSuffix(buff.String(), expected) {
+		t.Errorf("got %s Expected %s", buff.String(), expected)
+	}
+}