4.0.0 Updates

- rewrote stack frame logic from scratch.
- updated how built in helpers can be used with just an import.
- updated helpers not allowing multiple of the same handler to be
registered.

Author: Dean Karn

Makefile

@@ -1,14 +1,13 @@
 GOCMD=go
 
 linters-install:
-	@gometalinter --version >/dev/null 2>&1 || { \
+	@golangci-lint --version >/dev/null 2>&1 || { \
 		echo "installing linting tools..."; \
-		$(GOCMD) get github.com/alecthomas/gometalinter; \
-		gometalinter --install; \
+		$(GOCMD) get github.com/golangci/golangci-lint/cmd/golangci-lint; \
 	}
 
 lint: linters-install
-	gometalinter --vendor --disable-all --enable=vet --enable=vetshadow --enable=golint --enable=megacheck --enable=ineffassign --enable=misspell --enable=errcheck --enable=goconst ./...
+	golangci-lint run
 
 test:
 	$(GOCMD) test -cover -race ./...

README.md

@@ -1,6 +1,6 @@
 Package errors
 ============
-![Project status](https://img.shields.io/badge/version-3.3.0-green.svg)
+![Project status](https://img.shields.io/badge/version-4.0.0-green.svg)
 [![Build Status](https://semaphoreci.com/api/v1/joeybloggs/errors/branches/master/badge.svg)](https://semaphoreci.com/joeybloggs/errors)
 [![Go Report Card](https://goreportcard.com/badge/github.com/go-playground/errors)](https://goreportcard.com/report/github.com/go-playground/errors)
 [![GoDoc](https://godoc.org/github.com/go-playground/errors?status.svg)](https://godoc.org/github.com/go-playground/errors)
@@ -13,12 +13,18 @@ stack traces, tags(additional information) and even a Type classification system
 Common Questions
 
 Why another package?
-Because IMO most of the existing packages either don't take the error handling far enough, too far or down right unfriendly to use/consume. 
+There are two main reasons.
+- I think that the programs generating the original error(s) should be responsible for handling them, even though this package allows access to the original error, and that the callers are mainly interested in:
+  - If the error is Transient or Permanent for retries.
+  - Additional details for logging.
+
+- IMO most of the existing packages either don't take the error handling far enough, too far or down right unfriendly to use/consume. 
 
 Features
 --------
 - [x] works with go-playground/log, the Tags will be added as Field Key Values and Types will be concatenated as well when using `WithError`
 - [x] helpers to extract and classify error types using `RegisterHelper(...)`, many already existing such as ioerrors, neterrors, awserrors...
+- [x] built in helpers only need to be imported, eg. `_ github.com/go-playground/errors/helpers/neterrors` allowing libraries to register their own helpers not needing the caller to do or guess what needs to be imported.
 
 Installation
 ------------
@@ -44,15 +50,24 @@ func main() {
 	fmt.Println(err)
 	if errors.HasType(err, "Permanent") {
 		// os.Exit(1)
+		fmt.Println("it is a permanent error")
 	}
 
 	// root error
 	cause := errors.Cause(err)
-	fmt.Println(cause)
+	fmt.Println("CAUSE:", cause)
 
 	// can even still inspect the internal error
 	fmt.Println(errors.Cause(err) == io.EOF) // will extract the cause for you
 	fmt.Println(errors.Cause(cause) == io.EOF)
+
+	// and still in a switch
+	switch errors.Cause(err) {
+	case io.EOF:
+		fmt.Println("EOF error")
+	default:
+		fmt.Println("unknown error")
+	}
 }
 
 func level1(value string) error {
@@ -63,7 +78,7 @@ func level1(value string) error {
 }
 
 func level2(value string) error {
-	err := fmt.Errorf("this is an %s", "error")
+	err := io.EOF
 	return errors.Wrap(err, "failed to do something").AddTypes("Permanent").AddTags(errors.T("value", value))
 }
 ```
@@ -76,35 +91,23 @@ package main
 import (
 	"fmt"
 
-	"strings"
-
 	"github.com/go-playground/errors"
 )
 
 func main() {
 	// maybe you just want to grab a stack trace and process on your own like go-playground/log
 	// uses it to produce a stack trace log message
 	frame := errors.Stack()
-	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]
-	}
+	fmt.Printf("Function: %s File: %s Line: %d\n", frame.Function(), frame.File(), frame.Line())
 
-	fmt.Printf("Name: %s File: %s Line: %s\n", name, file, line)
+	// and still have access to the underlying runtime.Frame
+	fmt.Printf("%+v\n", frame.Frame)
 }
 ```
 
 Package Versioning
 ----------
-I'm jumping on the vendoring bandwagon, you should vendor this package as I will not
-be creating different version with gopkg.in like allot of my other libraries.
-
-Why? because my time is spread pretty thin maintaining all of the libraries I have + LIFE,
-it is so freeing not to worry about it and will help me keep pouring out bigger and better
-things for you the community.
+Using Go modules and proper semantic version releases (as always).
 
 License
 ------

_examples/basic/main.go

@@ -12,15 +12,24 @@ func main() {
 	fmt.Println(err)
 	if errors.HasType(err, "Permanent") {
 		// os.Exit(1)
+		fmt.Println("it is a permanent error")
 	}
 
 	// root error
 	cause := errors.Cause(err)
-	fmt.Println(cause)
+	fmt.Println("CAUSE:", cause)
 
 	// can even still inspect the internal error
 	fmt.Println(errors.Cause(err) == io.EOF) // will extract the cause for you
 	fmt.Println(errors.Cause(cause) == io.EOF)
+
+	// and still in a switch
+	switch errors.Cause(err) {
+	case io.EOF:
+		fmt.Println("EOF error")
+	default:
+		fmt.Println("unknown error")
+	}
 }
 
 func level1(value string) error {
@@ -31,6 +40,6 @@ func level1(value string) error {
 }
 
 func level2(value string) error {
-	err := fmt.Errorf("this is an %s", "error")
+	err := io.EOF
 	return errors.Wrap(err, "failed to do something").AddTypes("Permanent").AddTags(errors.T("value", value))
 }

_examples/helpers/main.go _examples/helpers/built-in/main.go_examples/helpers/main.go renamed to _examples/helpers/built-in/main.go

@@ -5,11 +5,11 @@ import (
 	"net"
 
 	"github.com/go-playground/errors"
-	"github.com/go-playground/errors/helpers/neterrors"
+	// init function handles registration automatically
+	_ "github.com/go-playground/errors/helpers/neterrors"
 )
 
 func main() {
-	errors.RegisterHelper(neterrors.NETErrors)
 	_, err := net.ResolveIPAddr("tcp", "foo")
 	if err != nil {
 		err = errors.Wrap(err, "failed to perform operation")

_examples/helpers/custom/main.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	"fmt"
+	"net"
+
+	"github.com/go-playground/errors"
+)
+
+func main() {
+	errors.RegisterHelper(MyCustomErrHandler)
+	_, err := net.ResolveIPAddr("tcp", "foo")
+	if err != nil {
+		err = errors.Wrap(err, "failed to perform operation")
+	}
+
+	// all that extra context, types and tags captured for free
+	// there are more helpers and you can even create your own.
+	fmt.Println(err)
+}
+
+// MyCustomErrHandler helps classify my errors
+func MyCustomErrHandler(c errors.Chain, err error) (cont bool) {
+	switch err.(type) {
+	case net.UnknownNetworkError:
+		_ = c.AddTypes("io").AddTag("additional", "details")
+		return
+		//case net.Other:
+		//	...
+		//	return
+	}
+	return true
+}

_examples/stack/main.go

@@ -3,22 +3,15 @@ package main
 import (
 	"fmt"
 
-	"strings"
-
 	"github.com/go-playground/errors"
 )
 
 func main() {
 	// maybe you just want to grab a stack trace and process on your own like go-playground/log
 	// uses it to produce a stack trace log message
 	frame := errors.Stack()
-	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]
-	}
+	fmt.Printf("Function: %s File: %s Line: %d\n", frame.Function(), frame.File(), frame.Line())
 
-	fmt.Printf("Name: %s File: %s Line: %s\n", name, file, line)
+	// and still have access to the underlying runtime.Frame
+	fmt.Printf("%+v\n", frame.Frame)
 }

chain.go

@@ -10,7 +10,7 @@ func T(key string, value interface{}) Tag {
 	return Tag{Key: key, Value: value}
 }
 
-// Tag contains a single key value conbination
+// Tag contains a single key value combination
 // to be attached to your error
 type Tag struct {
 	Key   string
@@ -21,7 +21,7 @@ func newLink(err error, prefix string, skipFrames int) *Link {
 	return &Link{
 		Err:    err,
 		Prefix: prefix,
-		Source: st(skipFrames),
+		Source: StackLevel(skipFrames),
 	}
 
 }
@@ -57,12 +57,12 @@ type Link struct {
 	Tags []Tag
 
 	// Source contains the name, file and lines obtained from the stack trace
-	Source string
+	Source Frame
 }
 
 // formatError prints a single Links error
 func (l *Link) formatError() string {
-	line := fmt.Sprintf("source=%s ", l.Source)
+	line := fmt.Sprintf("source=%s: %s:%d ", l.Source.Function(), l.Source.File(), l.Source.Line())
 
 	if l.Prefix != "" {
 		line += l.Prefix
@@ -114,5 +114,5 @@ func (c Chain) AddTypes(typ ...string) Chain {
 
 // Wrap adds another contextual prefix to the error chain
 func (c Chain) Wrap(prefix string) Chain {
-	return wrap(c, prefix, 0)
+	return wrap(c, prefix, 3)
 }

errors.go

@@ -3,6 +3,7 @@ package errors
 import (
 	"errors"
 	"fmt"
+	"reflect"
 )
 
 var (
@@ -13,37 +14,42 @@ var (
 // errors will run all registered helpers until a match is found.
 // NOTE helpers are run in the order they are added.
 func RegisterHelper(helper Helper) {
+	for i := 0; i < len(helpers); i++ {
+		if reflect.ValueOf(helpers[i]).Pointer() == reflect.ValueOf(helper).Pointer() {
+			return
+		}
+	}
 	helpers = append(helpers, helper)
 }
 
 // New creates an error with the provided text and automatically wraps it with line information.
 func New(s string) Chain {
-	return wrap(errors.New(s), "", 0)
+	return wrap(errors.New(s), "", 3)
 }
 
 // Newf creates an error with the provided text and automatically wraps it with line information.
 // it also accepts a varadic for optional message formatting.
 func Newf(format string, a ...interface{}) Chain {
-	return wrap(fmt.Errorf(format, a...), "", 0)
+	return wrap(fmt.Errorf(format, a...), "", 3)
 }
 
 // Wrap encapsulates the error, stores a contextual prefix and automatically obtains
 // a stack trace.
 func Wrap(err error, prefix string) Chain {
-	return wrap(err, prefix, 0)
+	return wrap(err, prefix, 3)
 }
 
 // Wrapf encapsulates the error, stores a contextual prefix and automatically obtains
 // a stack trace.
 // it also accepts a varadic for prefix formatting.
 func Wrapf(err error, prefix string, a ...interface{}) Chain {
-	return wrap(err, fmt.Sprintf(prefix, a...), 0)
+	return wrap(err, fmt.Sprintf(prefix, a...), 3)
 }
 
 // WrapSkipFrames is a special version of Wrap that skips extra n frames when determining error location.
 // Normally only used when wrapping the library
 func WrapSkipFrames(err error, prefix string, n uint) Chain {
-	return wrap(err, prefix, int(n))
+	return wrap(err, prefix, int(n)+3)
 }
 
 func wrap(err error, prefix string, skipFrames int) (c Chain) {

errors_test.go

@@ -59,8 +59,9 @@ func TestWrap(t *testing.T) {
 
 	for i, tt := range tests {
 		link := tt.err.current()
-		if !strings.HasSuffix(link.Source, tt.suf) || !strings.HasPrefix(link.Source, tt.pre) {
-			t.Fatalf("IDX: %d want %s<path>%s got %s", i, tt.pre, tt.suf, link.Source)
+		source := fmt.Sprintf("%s: %s:%d", link.Source.Function(), link.Source.File(), link.Source.Line())
+		if !strings.HasSuffix(source, tt.suf) || !strings.HasPrefix(source, tt.pre) {
+			t.Fatalf("IDX: %d want %s<path>%s got %s", i, tt.pre, tt.suf, source)
 		}
 	}
 }
@@ -158,8 +159,8 @@ func TestCause2(t *testing.T) {
 }
 
 func TestHelpers(t *testing.T) {
-	fn := func(w Chain, err error) (cont bool) {
-		w.AddTypes("Test").AddTags(T("test", "tag")).AddTag("foo", "bar")
+	fn := func(w Chain, _ error) (cont bool) {
+		_ = w.AddTypes("Test").AddTags(T("test", "tag")).AddTag("foo", "bar")
 		return false
 	}
 	RegisterHelper(fn)

helpers.go

@@ -1,6 +1,6 @@
 package errors
 
 // Helper is a function which will automatically extract Type and Tag information based on the supplied err and
-// add it to the supplied *Link error; this can be used independently or by registering using errors.REgisterHelper(...),
+// add it to the supplied *Link error; this can be used independently or by registering using errors.RegisterHelper(...),
 // which will run the registered helper every time errors.Wrap(...) is called.
 type Helper func(Chain, error) bool