Merge feature/panic-stack-trace-chained

Author: PeterIvanov

panic.go

@@ -38,33 +38,29 @@ func ErrorFromPanic(recoverResult interface{}) (error, bool) {
 	}
 
 	if wrapper, ok := err.(*panicErrorWrapper); ok {
-		return wrapper.errorWithStackTrace, true
+		return wrapper.inner, true
 	}
 
 	return err, true
 }
 
 func newPanicErrorWrapper(err error) *panicErrorWrapper {
-	originalError, errWithStackTrace := err, err
-	if typedErr, ok := errWithStackTrace.(*Error); !ok || typedErr.stackTrace == nil {
-		builder := NewErrorBuilder(panicPayloadWrap).WithConditionallyFormattedMessage("").WithCause(err)
-		errWithStackTrace = builder.Create()
-	}
-
 	return &panicErrorWrapper{
-		originalError:       originalError,
-		errorWithStackTrace: errWithStackTrace,
+		inner: NewErrorBuilder(panicPayloadWrap).
+			WithConditionallyFormattedMessage("panic").
+			WithCause(err).
+			EnhanceStackTrace().
+			Create(),
 	}
 }
 
+// panicErrorWrapper is designed for the original stack trace not to be lost in any way it may be handled
 type panicErrorWrapper struct {
-	originalError       error
-	errorWithStackTrace error
+	inner error
 }
 
-// Original error is used, as the wrapped one contains only the same stack trace as the panic
 func (w *panicErrorWrapper) Error() string {
-	return fmt.Sprintf("%+v", w.originalError)
+	return fmt.Sprintf("%+v", w.inner)
 }
 
 func (w *panicErrorWrapper) String() string {

panic_test.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/require"
 )
@@ -29,8 +30,7 @@ func TestPanicErrorx(t *testing.T) {
 		output := fmt.Sprintf("%v", r)
 
 		require.Contains(t, output, "awful", output)
-		// original error was non-errorx, no use of adding panic callstack to message
-		require.NotContains(t, output, "errorx.funcWithBadPanic()", output)
+		require.Contains(t, output, "errorx.funcWithBadPanic()", output)
 	}()
 
 	funcWithBadPanic()
@@ -111,3 +111,69 @@ func funcWithBadPanic() {
 func funcWithBadErr() error {
 	return errors.New("awful")
 }
+
+func TestPanicChain(t *testing.T) {
+	ch0 := make(chan error, 1)
+	ch1 := make(chan error, 1)
+
+	go doMischief(ch1)
+	go doMoreMischief(ch0, ch1)
+
+	select {
+	case err := <-ch0:
+		require.Error(t, err)
+		require.False(t, IsOfType(err, AssertionFailed))
+		output := fmt.Sprintf("%+v", err)
+		require.Contains(t, output, "mischiefProper", output)
+		require.Contains(t, output, "mischiefAsPanic", output)
+		require.Contains(t, output, "doMischief", output)
+		require.Contains(t, output, "handleMischief", output)
+		require.NotContains(t, output, "doMoreMischief", output) // stack trace is only enhanced in Panic, not in user code
+		t.Log(output)
+	case <-time.After(time.Second):
+		require.Fail(t, "expected error")
+	}
+}
+
+func doMoreMischief(ch0 chan error, ch1 chan error) {
+	defer func() {
+		if e := recover(); e != nil {
+			err, ok := ErrorFromPanic(e)
+			if ok {
+				ch0 <- Decorate(err, "hop 2")
+				return
+			}
+		}
+		ch0 <- AssertionFailed.New("test failed")
+	}()
+
+	handleMischief(ch1)
+}
+
+func handleMischief(ch chan error) {
+	err := <-ch
+	Panic(Decorate(err, "handle"))
+}
+
+func doMischief(ch chan error) {
+	defer func() {
+		if e := recover(); e != nil {
+			err, ok := ErrorFromPanic(e)
+			if ok {
+				ch <- Decorate(err, "hop 1")
+				return
+			}
+		}
+		ch <- AssertionFailed.New("test failed")
+	}()
+
+	mischiefAsPanic()
+}
+
+func mischiefAsPanic() {
+	Panic(mischiefProper())
+}
+
+func mischiefProper() error {
+	return ExternalError.New("mischief")
+}