Enhancements (#12)

- Updated to make it a 100% drop-in replacement for the std Go library errors package
- Updated to make error chain work with std Go errors Unwrap, As, and Is interfaces. It's 100% inter-operable with std Go wrapping.
- Added RegisterErrorFormatFn to allow custom formatting of error output.
- Optimized default error printing.
- Updated output format to include full path to the file to clearly delineate where the error happened if the file name is the same.

Author: Dean Karn

.github/workflows/go.yml

@@ -0,0 +1,35 @@
+name: Lint & Test
+on: [push, pull_request]
+jobs:
+  test:
+    strategy:
+      matrix:
+        go-version: [1.14.x,1.13.x]
+        platform: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - name: Install Go
+        uses: actions/setup-go@v1
+        with:
+          go-version: ${{ matrix.go-version }}
+
+      - name: Priming Cache
+        uses: actions/cache@v1
+        with:
+          path: ~/go/pkg/mod
+          key: ${{ runner.os }}-v1-go-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-v1-go-
+
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - name: Lint
+        if: matrix.platform == 'ubuntu-latest' && matrix.go-version == '1.14.x'
+        run: |
+          export PATH=$PATH:$(go env GOPATH)/bin # temporary fix. See https://github.com/actions/setup-go/issues/14
+          go get -u golang.org/x/lint/golint
+          golint -set_exit_status ./...
+
+      - name: Test
+        run: go test ./...

.travis.yml

@@ -13,6 +13,6 @@ test:
 	$(GOCMD) test -cover -race ./...
 
 bench:
-	$(GOCMD) test -bench=. -benchmem ./...
+	$(GOCMD) test -run=NONE -bench=. -benchmem ./...
 
 .PHONY: test lint linters-install

Makefile

@@ -1,20 +1,22 @@
 Package errors
 ============
-![Project status](https://img.shields.io/badge/version-5.0.1-green.svg)
+![Project status](https://img.shields.io/badge/version-5.1.0-green.svg)
 [![Build Status](https://travis-ci.org/go-playground/errors.svg?branch=master)](https://travis-ci.org/go-playground/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)
+[![GoDoc](https://godoc.org/github.com/go-playground/errors?status.svg)](https://pkg.go.dev/github.com/go-playground/errors/v5)
 ![License](https://img.shields.io/dub/l/vibe-d.svg)
 
 Package errors is an errors wrapping package to help propagate and chain errors as well as attach
 stack traces, tags(additional information) and even a Type classification system to categorize errors into types eg. Permanent vs Transient.
 
+It is a drop in replacement for the std Go [errors](https://golang.org/pkg/errors/) package.
+It is also 100% compatible with the Is, As and Unwrap interfaces used within the std library and can be mixed with the built-in error wrapping.
 
 Common Questions
 
 Why another package?
 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:
+- I think that the programs generating the original error(s) should be responsible for adding internal metadata and details to them. Ultimately developers are concerned with:
   - If the error is Transient or Permanent for retries.
   - Additional details for logging.
 
@@ -83,28 +85,6 @@ func level2(value string) error {
 }
 ```
 
-or using stack only
-
-```go
-package main
-
-import (
-	"fmt"
-
-	"github.com/go-playground/errors/v5"
-)
-
-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()
-	fmt.Printf("Function: %s File: %s Line: %d\n", frame.Function(), frame.File(), frame.Line())
-
-	// and still have access to the underlying runtime.Frame
-	fmt.Printf("%+v\n", frame.Frame)
-}
-```
-
 Package Versioning
 ----------
 Using Go modules and proper semantic version releases (as always).

README.md

@@ -5,10 +5,11 @@ import (
 	"io"
 
 	"github.com/go-playground/errors/v5"
+	nestedpackagee "github.com/go-playground/errors/v5/_examples/basic/nestedpackage"
 )
 
 func main() {
-	err := level1("testing error")
+	err := level1Function("1")
 	fmt.Println(err)
 	if errors.HasType(err, "Permanent") {
 		// os.Exit(1)
@@ -32,14 +33,14 @@ func main() {
 	}
 }
 
-func level1(value string) error {
-	if err := level2(value); err != nil {
+func level1Function(userID string) error {
+	if err := level2Function(userID); err != nil {
 		return errors.Wrap(err, "level2 call failed")
 	}
 	return nil
 }
 
-func level2(value string) error {
-	err := io.EOF
-	return errors.Wrap(err, "failed to do something").AddTypes("Permanent").AddTags(errors.T("value", value))
+func level2Function(userID string) error {
+	err := nestedpackagee.GetUser(userID)
+	return errors.Wrap(err, "GetUser something went wrong")
 }

_examples/basic/main.go

@@ -0,0 +1,12 @@
+package nestedpackagee
+
+import (
+	"io"
+
+	"github.com/go-playground/errors/v5"
+)
+
+func GetUser(userID string) error {
+	err := io.EOF
+	return errors.Wrap(err, "failed to do something").AddTypes("Permanent").AddTags(errors.T("user_id", userID))
+}

_examples/basic/nestedpackage/nested.go

@@ -4,18 +4,48 @@ import (
 	"testing"
 )
 
-func BenchmarkError(b *testing.B) {
+func BenchmarkErrorNew(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_ = New("base error")
+	}
+}
+
+func BenchmarkErrorParallelNew(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			_ = New("base error")
+		}
+	})
+}
+
+func BenchmarkErrorPrint(b *testing.B) {
 	err := New("base error")
 	for i := 0; i < b.N; i++ {
 		_ = err.Error()
 	}
 }
 
-func BenchmarkErrorParallel(b *testing.B) {
+func BenchmarkErrorParallelPrint(b *testing.B) {
 	err := New("base error")
 	b.RunParallel(func(pb *testing.PB) {
 		for pb.Next() {
 			_ = err.Error()
 		}
 	})
 }
+
+func BenchmarkErrorPrintWithTagsAndTypes(b *testing.B) {
+	err := New("base error").AddTag("key", "value").AddTypes("Permanent", "Other")
+	for i := 0; i < b.N; i++ {
+		_ = err.Error()
+	}
+}
+
+func BenchmarkErrorParallelPrintWithTagsAndTypes(b *testing.B) {
+	err := New("base error").AddTag("key", "value").AddTypes("Permanent", "Other")
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			_ = err.Error()
+		}
+	})
+}