this PR is a redesign of the way eris wraps external errors. instead of unwrapping them and disguising them as root errors, it simply wraps them to maintain all error context. closes #82 and closes #81.

Is your feature request related to a problem? Please describe. When getting errors from other libraries that use github.com/pkg/errors or forks of it, I noticed that the error is just flattened by calling error.Error() and then returning a rootError. This is fine for custom errors, but pkg/errors is very widespread and integration with it would make the created errors more complete.

Describe the solution you'd like It would be nice if eris tries to unpack the error instead of just turning it into string, by recursively calling Unpack. As pkg/errors is very popular, checking for the old func Cause() error in addition to func Unpack() error would be great.

Not just errors from pkg/errors but any error in general that implements Unpack makes sense to unpack in my opinion.

Not sure how to unmangle the stack trace though.

Describe alternatives you've considered

Additional context

Is your feature request related to a problem? Please describe. I would like to call eris.Wrap inside a utility Logging function but have it attribute the stack to where my function is called vs where .Wrap is called. (e.g. a typical skip level arg)

Describe the solution you'd like I would prefer to call eris.Wrap inside mypackage.LogError instead of passing it in. But have eris skip a stack level and report one level above instead of inside my utility function.

So imagine I have mypackage.LogError(eris.Wrap(err, "blah")); But instead I want to hide the eris.Wrap call inside mypackage.LogError(err, "blah") so that I don't have to litter my code with eris.Wrap everywhere. I want to tell eris.Wrap to skip the immediate stack frame and record the one above as the frame.

Describe alternatives you've considered Putting mypackage.LogError(eris.Wrap()) all over my code.

Additional context Add any other context or screenshots about the feature request here.

For completion, we should offer an As method like the one in Go 1.13 errors (https://golang.org/pkg/errors/#As). We should try to make this more reliable than Go's version by preventing panics: "As will panic if target is not a non-nil pointer to either a type that implements error, or to any interface type." Seems like we could just return false in these cases instead.

When logging to Sentry, error chain trace is missing. Text representation of wrapped errors is there, but no File:Location trace. Using provided example:

go run examples/sentry/example.go -dsn=<Valid Sentry DSN>

Results in Sentry FULL mode:

EXCEPTION(most recent call first)

*eris.rootError
test
*eris.wrapError
wrap 1: test
*eris.wrapError
wrap 2: wrap 1: test
*eris.wrapError
wrap 3: wrap 2: wrap 1: test

example.go in main at line 54
	})
	if initErr != nil {
		log.Fatalf("failed to initialize Sentry: %v", initErr)
	}
	sentry.CaptureException(err)
	sentry.Flush(time.Second * 5)
}

Results in Sentry RAW mode:

EXCEPTION(most recent call first)

*eris.wrapError: wrap 3: wrap 2: wrap 1: test
  File "example.go", line 54, in main
    sentry.CaptureException(err)

Is your feature request related to a problem? Please describe. Currently, it is not possible to show/hide a certain part of the error frame. For ex., only show the method name or line number instead of a complete frame.

Describe the solution you'd like One solution could be to provide some utility methods for the format object, like format.Show(file, method, line) and users can pass format.Show(true, true, false).

Describe alternatives you've considered Another solution could be to have an object like options and users could pass options.line = false or something like that.

Describe the bug eris.As does not work as intended when wrapping with eris.Wrap()

To Reproduce Run this program:

package main

import (
	"errors"
	"fmt"

	"github.com/rotisserie/eris"
)

type X struct {
}

func (X) Error() string {
	return "X"
}

func main() {
	original := X{}

	wrap1std := fmt.Errorf("wrap1: %w", original)
	wrap2std := fmt.Errorf("wrap2: %w", wrap1std)

	wrap1eris := eris.Wrap(original, "wrap1")
	wrap2eris := eris.Wrap(wrap1eris, "wrap2")

	var x X
	fmt.Println(errors.As(wrap2std, &x))
	fmt.Println(errors.As(wrap2eris, &x))

	fmt.Println(eris.As(wrap2std, &x))
	fmt.Println(eris.As(wrap2eris, &x))
}

Expected behavior The program should output true 4 times. Instead it outputs:

true
true
true
false

Go: 1.16.5 Eris: github.com/rotisserie/[email protected]

When eris.Wrap is used on an external error to add a stacktrace, only its error message is preserved. The external error might already contain context information which is lost.

Possible solution: Add a field of type error to eris.rootError and return its value on Unwrap

Alternative: Expose funcs for creating a stacktrace to add an eris.Stack to the external error type (only applicable for owned types)

When using a custom error and then wrapping that error with eris.Wrap it's not possible to use errors.As to identify if error is made of target, even if Unwrap is implemented.

package main

import (
	"errors"
	"fmt"

	"github.com/rotisserie/eris"
)

type AnError struct {
	Msg string
	Err error
}

func (ae AnError) Error() string {
	return ae.Msg
}

func (ae AnError) Unwrap() error {
	return ae.Err
}

func main() {
	aerror := AnError{Msg: "invalid", Err: eris.New("eris test error")}
	berr := eris.Wrap(aerror, "the error")

	switch {
	case errors.As(berr, &AnError{}):
		fmt.Println("anerror")
	}
}

I expected this code should print "anerror", if I instead wrap the error with fmt.Errorf and %w, it works as expected.

In the doc comment you have the example code

if eris.Is(err, NotFound) || eris.Cause(err) == NotFound 

I think the second half is redundant. The only way Is returns false is if it reaches the end of the chain, which means that the last error in the chain would already have been compared to NotFound.

Describe the bug The go.mod file contains the path "github.com/morningvera/eris" instead of "github.com/rotisserie/eris".

To Reproduce go get github.com/rotisserie/eris

Expected behavior The module is installed.

Is your feature request related to a problem? Please describe. I'm using a message queue that utilizes gob/encoding for encoding arbitrary data into messages. I have messages that need to persist errors between various points of interaction. I would like a simple way of including errors in this, while maintaining all the stack traces and various benefits eris provides.

Describe the solution you'd like Provide a companion API to eris.ToJSON and eris.ToString (or at least just JSON). Ideally, these functions would take the output of eris.ToJSON and when passed into the new eris.FromJSON, we get back an error (that implements the interface) and has all the relevant stack/external info from wrapping errors.

Alternatively, you could add a companion method to eris.Unpack called eris.Pack that would take an UnpackedError and return a regular error, again keeping all the information.

Describe alternatives you've considered Manually JSON encoding/decoding, however after crossing this boundary, no code can access the eris functions like eris.Cause, which are very useful for unwrapping.

Thanks for considering.

Is your feature request related to a problem? Please describe.

Implement new API to have only one error package to manage all common errors related cases/problems. With this change, I don't have to import other errors packages and eris would become the ultimate solution for almost all error handling cases.

Describe the solution you'd like

Add/Import more functions and functionalities to this pkg. I've prepared a go docs:

  // Wraps adds additional context to all error types while maintaining the type of the original error.
  //
  // This is a convenience method for wrapping errors with stack trace and is otherwise the same as Wrap(err, "").
  func Wraps(err error) error

  // Append is a helper function that will append more errors onto an Error in order to create a larger multi-error.
  func Append(err error, errs ...error) error

  // WrappedErrors returns the list of errors that this Error is wrapping.
  func WrappedErrors(err error) []error

  // Group is a collection of goroutines that returns errors that need to be coalesced.
  type Group struct {
    // if true group will continue execution until the last goroutine is finished.
    // It will return multierror in case of more than one error, which can be 
    // turn into the slice with WrappedErrors.
    ContinueOnError bool
  }

  // WithContext returns a new Group and an associated Context derived from ctx.
  func WithContext(ctx context.Context) (*Group, context.Context)

  // Go calls the given function in a new goroutine. It can work in two modes
  //
  // 1. The first call to return a non-nil error cancels the group
  //
  // 2. If the function returns an error it is added to the
  // group multierror which is returned by Wait.
  //
  // You can control this behavour by setting ContinueOnError in Group.
  func (g *Group) Go(f func() error)

  // Wait blocks until all function calls from the Go method have returned, then returns either
  // the first non-nill error (if any) or multierror. This depends on ContinueOnError setting.
  func (g *Group) Wait() error

Describe alternatives you've considered

Still using other packages like github.com/hashicorp/go-multierror or golang.org/x/sync/errgroup

Additional context

I know maybe this Issue should be split into smaller ones but I thought it would be easier to gather all this into one Issue.

One real example that shows how multerror and Wraps can be used.

// This is a version with comments. Below you can find two versions to compare readability.
func (p *Postgres) ExecuteInTx(ctx context.Context, fn func(tx *Tx) error) error {
    tx, err := p.BeginTx(ctx)
    if err != nil {
        // just save a stacktrace without any message
        // it would be nice to have a function like pkgerros WithStack()
        // maybe with shorter name (eris.Stack() or eris.Wraps()),
        // to tell that I want to capture only a stack without any message.
        // right now I use Wrap for this.
        return eris.Wrap(err, "")
    }

    if err := fn(tx); err != nil {
        if rerr := tx.Rollback(ctx); rerr != nil {
            // "github.com/hashicorp/go-multierror"
            // It would be great to have api to combine
            // multiple errors into one. Ofc I can use
            // eris.Wrap here but it seems a bit overkill
            // to have two calls in stacktrace when in fact
            // I just need two error messages combined into one.
            // This can be used also in many other places
            err = multierror.Append(err, rerr)
        }

        return eris.Wrap(err, "") // eris.Wraps()
    }

    return eris.Wrap(tx.Commit(ctx), "") // eris.Wraps())
}

// This is version with external package and Wrap
func (p *Postgres) ExecuteInTx(ctx context.Context, fn func(tx *Tx) error) error {
    tx, err := p.BeginTx(ctx)
    if err != nil {
        return eris.Wrap(err, "")
    }

    if err := fn(tx); err != nil {
        if rerr := tx.Rollback(ctx); rerr != nil {
            err = multierror.Append(err, rerr)
        }

        return eris.Wrap(err, "")
    }

    return eris.Wrap(tx.Commit(ctx), "")
}

// This is version with eris only.
func (p *Postgres) ExecuteInTx(ctx context.Context, fn func(tx *Tx) error) error {
    tx, err := p.BeginTx(ctx)
    if err != nil {
        return eris.Wraps(err)
    }

    if err := fn(tx); err != nil {
        if rerr := tx.Rollback(ctx); rerr != nil {
            err = eris.Append(err, rerr)
        }

        return eris.Wraps(err)
    }

    return eris.Wraps(tx.Commit(ctx))
}