From 825e9a1235465d351aea5fe4f9900eca2c70450f Mon Sep 17 00:00:00 2001
From: Alex Grintsvayg <git@grin.io>
Date: Mon, 8 Jan 2018 16:05:26 -0500
Subject: [PATCH] add Wrap(), Base(), HasTrace()

---
 errors.go | 39 ++++++++++++++++++++++++++++++++-------
 1 file changed, 32 insertions(+), 7 deletions(-)

diff --git a/errors.go b/errors.go
index 8ad2ece..50bd80c 100644
--- a/errors.go
+++ b/errors.go
@@ -1,11 +1,17 @@
 package errors
 
 import (
+	base "errors"
 	"fmt"
 
 	"github.com/go-errors/errors"
 )
 
+// interop with pkg/errors
+type causer interface {
+	Cause() error
+}
+
 // Err intelligently creates/handles errors, while preserving the stack trace.
 // It works with errors from github.com/pkg/errors too.
 func Err(err interface{}, fmtParams ...interface{}) error {
@@ -13,10 +19,6 @@ func Err(err interface{}, fmtParams ...interface{}) error {
 		return nil
 	}
 
-	type causer interface {
-		Cause() error
-	}
-
 	if _, ok := err.(causer); ok {
 		err = fmt.Errorf("%+v", err)
 	} else if errString, ok := err.(string); ok && len(fmtParams) > 0 {
@@ -26,6 +28,19 @@ func Err(err interface{}, fmtParams ...interface{}) error {
 	return errors.Wrap(err, 1)
 }
 
+// Wrap calls errors.Wrap, in case you want to skip a different amount
+func Wrap(err interface{}, skip int) *errors.Error {
+	if err == nil {
+		return nil
+	}
+
+	if _, ok := err.(causer); ok {
+		err = fmt.Errorf("%+v", err)
+	}
+
+	return errors.Wrap(err, skip+1)
+}
+
 // Is compares two wrapped errors to determine if the underlying errors are the same
 func Is(e error, original error) bool {
 	return errors.Is(e, original)
@@ -44,14 +59,24 @@ func Trace(err error) string {
 	if err == nil {
 		return ""
 	}
-	return string(errors.Wrap(Err(err), 0).Stack())
+	return string(Err(err).(*errors.Error).Stack())
 }
 
-
 // FullTrace returns the error type, message, and stack trace
 func FullTrace(err error) string {
 	if err == nil {
 		return ""
 	}
-	return errors.Wrap(Err(err), 0).ErrorStack()
+	return Err(err).(*errors.Error).ErrorStack()
+}
+
+// Base returns a simple error with no stack trace attached
+func Base(text string) error {
+	return base.New(text)
+}
+
+// HasTrace checks if error has a trace attached
+func HasTrace(err error) bool {
+	_, ok := err.(*errors.Error)
+	return ok
 }