adds stacktrace behavior identical to the one provided by pkg/errors

Author: darwayne

builder_gen_opts.go

@@ -1,5 +1,10 @@
 package errutil
 
+import (
+	"fmt"
+	"strings"
+)
+
 // New creates a new error with the ability to add multiple behavior to that error
 // e.g.
 //
@@ -13,6 +18,9 @@ func New(err error, opts ...OptsFunc) error {
 	if len(e.opts.Tags) > 0 {
 		e.error = NewTagged(err, e.opts.Tags...)
 	}
+	if e.opts.StackTrace != nil {
+		e.error = NewStacked(err, *e.opts.StackTrace+1)
+	}
 
 	return e
 }
@@ -36,6 +44,7 @@ type Opts struct {
 	TooLarge     bool
 	RateLimit    bool
 	Tags         []Tag
+	StackTrace   *int
 }
 
 type multiKindErr struct {
@@ -56,6 +65,21 @@ func (m multiKindErr) Exists() bool {
 	return m.opts.Exists
 }
 
+func (m multiKindErr) Format(s fmt.State, verb rune) {
+	if formatter, ok := m.error.(fmt.Formatter); ok {
+		formatter.Format(s, verb)
+		return
+	} else {
+		var builder strings.Builder
+		builder.WriteString("%")
+		if s.Flag('+') {
+			builder.WriteRune('+')
+		}
+		builder.WriteRune(verb)
+		fmt.Fprintf(s, builder.String(), m.error)
+	}
+}
+
 func (m multiKindErr) NotFound() bool {
 	return m.opts.NotFound
 }

errors.go

@@ -107,6 +107,11 @@ func TestNewError(t *testing.T) {
 		})
 
 	})
+
+	t.Run("should generate stack trace when option provided", func(t *testing.T) {
+		err := New(errors.New("hey there"), WithStackTrace(0))
+		fmt.Printf("%+v\n", err)
+	})
 }
 
 var allFuncs = []CheckerFn{

errors_test.go

@@ -104,6 +104,20 @@ func IsTaggable(err error) bool {
 	return IsTaggable(errors.Unwrap(err))
 }
 
+// IsStackTraceable checks if an error exhibits taggable behavior
+func IsStackTraceable(err error) bool {
+	if err == nil {
+		return false
+	}
+
+	var e StackTraceable
+	if errors.As(err, &e) {
+		return true
+	}
+
+	return IsStackTraceable(errors.Unwrap(err))
+}
+
 // GetTags returns all the tags for a given error
 func GetTags(err error) []Tag {
 	var tags []Tag

functions.go

@@ -2,7 +2,10 @@ module github.com/darwayne/errutil
 
 go 1.17
 
-require github.com/darwayne/builder-gen v1.6.0
+require (
+	github.com/darwayne/builder-gen v1.6.0
+	github.com/pkg/errors v0.9.1
+)
 
 require (
 	golang.org/x/mod v0.3.0 // indirect

go.mod

@@ -1,5 +1,7 @@
 github.com/darwayne/builder-gen v1.6.0 h1:eGEeNIcQiu7zKMklOe5cl0TuRmC9uq18FelMeOkSvZ8=
 github.com/darwayne/builder-gen v1.6.0/go.mod h1:mGpbS+5yboRzmqxmN8XpkqeptLqxHB57YUaJdG5DgEU=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=

go.sum

@@ -1,5 +1,7 @@
 package errutil
 
+import "github.com/pkg/errors"
+
 // AccessDenier determines if an error exhibits access denied behavior
 type AccessDenier interface {
 	AccessDenied() bool
@@ -34,3 +36,8 @@ type TooLarge interface {
 type Taggable interface {
 	Tags() []Tag
 }
+
+// StackTraceable determines if an error exhibits stacktrace behavior from the pkg/errors package
+type StackTraceable interface {
+	StackTrace() errors.StackTrace
+}

interfaces.go

@@ -0,0 +1,79 @@
+package errutil
+
+import (
+	"fmt"
+	"github.com/pkg/errors"
+	"io"
+	"runtime"
+)
+
+func NewStacked(err error, skip ...int) error {
+	if err == nil {
+		return nil
+	}
+
+	return &Stacked{
+		error: err,
+		stack: Callers(skip...),
+	}
+}
+
+type Stacked struct {
+	error
+	*stack
+}
+
+func (w *Stacked) Unwrap() error { return w.error }
+
+func (w *Stacked) Format(s fmt.State, verb rune) {
+	switch verb {
+	case 'v':
+		if s.Flag('+') {
+			fmt.Fprintf(s, "%+v", w.error)
+			w.stack.Format(s, verb)
+			return
+		}
+		fallthrough
+	case 's':
+		io.WriteString(s, w.Error())
+	case 'q':
+		fmt.Fprintf(s, "%q", w.Error())
+	}
+}
+
+// stack represents a stack of program counters.
+type stack []uintptr
+
+func (s *stack) Format(st fmt.State, verb rune) {
+	switch verb {
+	case 'v':
+		switch {
+		case st.Flag('+'):
+			for _, pc := range *s {
+				f := errors.Frame(pc)
+				fmt.Fprintf(st, "\n%+v", f)
+			}
+		}
+	}
+}
+
+func (s *stack) StackTrace() errors.StackTrace {
+	f := make([]errors.Frame, len(*s))
+	for i := 0; i < len(f); i++ {
+		f[i] = errors.Frame((*s)[i])
+	}
+	return f
+}
+
+func Callers(skip ...int) *stack {
+	const depth = 32
+	var pcs [depth]uintptr
+	s := 0
+	if len(skip) > 0 {
+		s = skip[0]
+	}
+
+	n := runtime.Callers(s+3, pcs[:])
+	var st stack = pcs[0:n]
+	return &st
+}