Added error helps for classification and information

Author: Dean Karn

README.md

@@ -1,6 +1,6 @@
 Package errors
 ============
-![Project status](https://img.shields.io/badge/version-1.0.0-green.svg)
+![Project status](https://img.shields.io/badge/version-1.1.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)
@@ -18,6 +18,7 @@ Because IMO most of the existing packages either don't take the error handling f
 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...
 
 Installation
 ------------

_examples/helpers/main.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"fmt"
+	"net"
+
+	"github.com/go-playground/errors"
+	"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")
+	}
+
+	// all that extra context, types and tags captured for free
+	// there are more helpers and you can even create your own.
+	fmt.Println(err)
+}

errors.go

@@ -1,15 +1,33 @@
 package errors
 
+var (
+	helpers []Helper
+)
+
+// RegisterHelper adds a new helper function to extract Type and Tag information.
+// 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) {
+	helpers = append(helpers, helper)
+}
+
 // Wrap encapsulates the error, stores a contextual prefix and automatically obtains
 // a stack trace.
-func Wrap(err error, prefix string) *Wrapped {
-	if w, ok := err.(*Wrapped); ok {
+func Wrap(err error, prefix string) (w *Wrapped) {
+	var ok bool
+	if w, ok = err.(*Wrapped); ok {
 		w.Errors = append(w.Errors, newWrapped(err, prefix))
-		return w
+	} else {
+		w = &Wrapped{
+			Errors: []*Wrapped{newWrapped(err, prefix)},
+		}
 	}
-	return &Wrapped{
-		Errors: []*Wrapped{newWrapped(err, prefix)},
+	for _, h := range helpers {
+		if !h(w, err) {
+			break
+		}
 	}
+	return
 }
 
 // HasType is a helper function that will recurse up from the root error and check that the provided type

errors_test.go

@@ -119,3 +119,16 @@ func TestIsErr(t *testing.T) {
 		t.Fatalf("want %t got %t", true, false)
 	}
 }
+
+func TestHelpers(t *testing.T) {
+	fn := func(w *Wrapped, err error) (cont bool) {
+		w.WithTypes("Test").WithTags(T("test", "tag")).WithTag("foo", "bar")
+		return false
+	}
+	RegisterHelper(fn)
+
+	err := Wrap(io.EOF, "prefix")
+	if !HasType(err, "Test") {
+		t.Errorf("Expected to have type 'Test'")
+	}
+}

helpers.go

@@ -0,0 +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 *Wrapped 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(*Wrapped, error) bool

helpers/awserrors/awserrors.go

@@ -0,0 +1,31 @@
+package awserrors
+
+import (
+	"github.com/aws/aws-sdk-go/aws/awserr"
+	"github.com/go-playground/errors"
+)
+
+// AWSErrors helps classify io related errors
+func AWSErrors(w *errors.Wrapped, err error) (cont bool) {
+	switch e := err.(type) {
+	case awserr.BatchError:
+		w.WithTypes("Transient", "Batch").WithTags(errors.T("aws_error_code", e.Code()))
+		return
+
+	case awserr.BatchedErrors:
+		w.WithTypes("Transient", "Batch")
+		return
+
+	case awserr.RequestFailure:
+		w.WithTypes("Transient", "Request").WithTags(
+			errors.T("status_code", e.StatusCode()),
+			errors.T("request_id", e.RequestID()),
+		)
+		return
+
+	case awserr.Error:
+		w.WithTypes("General", "Error").WithTags(errors.T("aws_error_code", e.Code()))
+		return
+	}
+	return true
+}

helpers/ioerrors/ioerrors.go

@@ -0,0 +1,32 @@
+package ioerrors
+
+import (
+	"io"
+
+	"github.com/go-playground/errors"
+)
+
+// IOErrors helps classify io related errors
+func IOErrors(w *errors.Wrapped, err error) (cont bool) {
+	switch err {
+	case io.EOF:
+		w.WithTypes("io")
+		return
+	case io.ErrClosedPipe:
+		w.WithTypes("Permanent", "io")
+		return
+	case io.ErrNoProgress:
+		w.WithTypes("Permanent", "io")
+		return
+	case io.ErrShortBuffer:
+		w.WithTypes("Permanent", "io")
+		return
+	case io.ErrShortWrite:
+		w.WithTypes("Permanent", "io")
+		return
+	case io.ErrUnexpectedEOF:
+		w.WithTypes("Transient", "io")
+		return
+	}
+	return true
+}

helpers/neterrors/neterrors.go

@@ -0,0 +1,75 @@
+package neterrors
+
+import (
+	"net"
+
+	"github.com/go-playground/errors"
+)
+
+// NETErrors helps classify io related errors
+func NETErrors(w *errors.Wrapped, err error) (cont bool) {
+	switch e := err.(type) {
+	case *net.AddrError:
+		tp := "Permanent"
+		if e.Temporary() {
+			tp = "Transient"
+		}
+		w.WithTypes(tp, "net").WithTags(
+			errors.T("addr", e.Addr),
+			errors.T("is_timeout", e.Timeout()),
+			errors.T("is_temporary", e.Temporary()),
+		)
+		return false
+
+	case *net.DNSError:
+		tp := "Permanent"
+		if e.Temporary() {
+			tp = "Transient"
+		}
+		w.WithTypes(tp, "net").WithTags(
+			errors.T("name", e.Name),
+			errors.T("server", e.Server),
+			errors.T("is_timeout", e.Timeout()),
+			errors.T("is_temporary", e.Temporary()),
+		)
+		return false
+
+	case *net.ParseError:
+		w.WithTypes("Permanent", "net").WithTags(
+			errors.T("type", e.Type),
+			errors.T("text", e.Text),
+		)
+		return false
+
+	case *net.OpError:
+		tp := "Permanent"
+		if e.Temporary() {
+			tp = "Transient"
+		}
+		w.WithTypes(tp, "net").WithTags(
+			errors.T("op", e.Op),
+			errors.T("net", e.Net),
+			errors.T("addr", e.Addr),
+			errors.T("local_addr", e.Source),
+			errors.T("is_timeout", e.Timeout()),
+			errors.T("is_temporary", e.Temporary()),
+		)
+		return false
+	case net.UnknownNetworkError:
+		tp := "Permanent"
+		if e.Temporary() {
+			tp = "Transient"
+		}
+		w.WithTypes(tp, "net").WithTags(
+			errors.T("is_timeout", e.Timeout()),
+			errors.T("is_temporary", e.Temporary()),
+		)
+	}
+
+	switch err {
+	case net.ErrWriteToConnected:
+		w.WithTypes("Transient", "net")
+		return false
+	}
+	return true
+}

wrapped.go

@@ -23,6 +23,7 @@ func newWrapped(err error, prefix string) *Wrapped {
 		Prefix: prefix,
 		Source: st(),
 	}
+
 }
 
 // Wrapped contains a single error entry, unless it's the top level error, in