Cause - Last error with stack

[marczahn]

Hi,

Let's assume we have some nested errors:

function sthBuiltInWhichReturnsAPlainError() error {
    return someBuiltErrorWithoutStack
}

func customFunctionWhichWrapsErrors() error {
    err := sthBuiltInWhichReturnsAPlainError()
    if err != nil {
        return errors.Wrap(err, "something happened")
    }
}

err := customFunctionWhichWrapsErrors()
errors.Cause(err) // <- Here I get the someBuiltErrorWithoutStack which has no stack

I would like to have the "last" error which has a stack. In this case it would be the one that is returned by customFunctionWhichWrapsErrors. But when I call errors.Cause I get the someBuiltErrorWithoutStack since this is the last one in the nesting.

Is this somehow possible without writing custom code?

[dcormier]

Is this somehow possible without writing custom code?

It isn't possible today. I just needed ~exactly~ something similar to that and ended up writing this:

func Stack(err error) errors.StackTrace {
	type causer interface {
		Cause() error
	}

	type stackTracer interface {
		StackTrace() errors.StackTrace
	}

	switch err := err.(type) {
	case stackTracer:
		return err.StackTrace()

	case causer:
		return Stack(err.Cause())
	}

	return nil
}

If it returns != nil, you'll want to run that through an appropriate format specifier to get the appropriate stack string. See the docs on errors.StackTrace.Format() to see what the options are.

[puellanivis]

This code example would return the first StackTrace. (It tests for stackTracer implementation before causer).

The original post wants to find the last StackTrace in the chain, rather than the first.

[dcormier]

Yup. I wrote it to do what I needed. But it wouldn't take much to change it to return the stack from the last error that had one.

[wangsai-silence]

func Stack(err error) errors.StackTrace {
	type causer interface {
		Cause() error
	}

	type stackTracer interface {
		StackTrace() errors.StackTrace
	}

	var stackErr error

	for {
		if _, ok := err.(stackTracer); ok {
			stackErr = err
		}

		if causer, ok := err.(causer); ok {
			err = causer.Cause()
		} else {
			break
		}
	}

	if stackErr != nil {
		return stackErr.(stackTracer).StackTrace()
	}

	return nil
}

works to me.