feat: properly support error capturing

client_test.go

@@ -164,23 +164,27 @@ func TestCaptureException(t *testing.T) {
 			err:  pkgErrors.WithStack(&customErr{}),
 			want: []Exception{
 				{
-					Type:  "*sentry.customErr",
-					Value: "wat",
+					Type:       "*sentry.customErr",
+					Value:      "wat",
+					Stacktrace: nil,
 					Mechanism: &Mechanism{
-						Type:             "generic",
-						ExceptionID:      0,
-						IsExceptionGroup: true,
+						Type:             MechanismTypeChained,
+						ExceptionID:      1,
+						ParentID:         Pointer(0),
+						Source:           "cause",
+						IsExceptionGroup: false,
 					},
 				},
 				{
 					Type:       "*errors.withStack",
 					Value:      "wat",
 					Stacktrace: &Stacktrace{Frames: []Frame{}},
 					Mechanism: &Mechanism{
-						Type:             "generic",
-						ExceptionID:      1,
-						ParentID:         Pointer(0),
-						IsExceptionGroup: true,
+						Type:             MechanismTypeGeneric,
+						ExceptionID:      0,
+						ParentID:         nil,
+						Source:           "",
+						IsExceptionGroup: false,
 					},
 				},
 			},
@@ -201,23 +205,27 @@ func TestCaptureException(t *testing.T) {
 			err:  &customErrWithCause{cause: &customErr{}},
 			want: []Exception{
 				{
-					Type:  "*sentry.customErr",
-					Value: "wat",
+					Type:       "*sentry.customErr",
+					Value:      "wat",
+					Stacktrace: nil,
 					Mechanism: &Mechanism{
-						Type:             "generic",
-						ExceptionID:      0,
-						IsExceptionGroup: true,
+						Type:             MechanismTypeChained,
+						ExceptionID:      1,
+						ParentID:         Pointer(0),
+						Source:           "cause",
+						IsExceptionGroup: false,
 					},
 				},
 				{
 					Type:       "*sentry.customErrWithCause",
 					Value:      "err",
 					Stacktrace: &Stacktrace{Frames: []Frame{}},
 					Mechanism: &Mechanism{
-						Type:             "generic",
-						ExceptionID:      1,
-						ParentID:         Pointer(0),
-						IsExceptionGroup: true,
+						Type:             MechanismTypeGeneric,
+						ExceptionID:      0,
+						ParentID:         nil,
+						Source:           "",
+						IsExceptionGroup: false,
 					},
 				},
 			},
@@ -227,23 +235,27 @@ func TestCaptureException(t *testing.T) {
 			err:  wrappedError{original: errors.New("original")},
 			want: []Exception{
 				{
-					Type:  "*errors.errorString",
-					Value: "original",
+					Type:       "*errors.errorString",
+					Value:      "original",
+					Stacktrace: nil,
 					Mechanism: &Mechanism{
-						Type:             "generic",
-						ExceptionID:      0,
-						IsExceptionGroup: true,
+						Type:             MechanismTypeChained,
+						ExceptionID:      1,
+						ParentID:         Pointer(0),
+						Source:           "cause",
+						IsExceptionGroup: false,
 					},
 				},
 				{
 					Type:       "sentry.wrappedError",
 					Value:      "wrapped: original",
 					Stacktrace: &Stacktrace{Frames: []Frame{}},
 					Mechanism: &Mechanism{
-						Type:             "generic",
-						ExceptionID:      1,
-						ParentID:         Pointer(0),
-						IsExceptionGroup: true,
+						Type:             MechanismTypeGeneric,
+						ExceptionID:      0,
+						ParentID:         nil,
+						Source:           "",
+						IsExceptionGroup: false,
 					},
 				},
 			},

error_group.go

@@ -0,0 +1,108 @@
+package sentry
+
+import (
+	"fmt"
+	"reflect"
+	"slices"
+)
+
+const (
+	MechanismTypeGeneric string = "generic"
+	MechanismTypeChained string = "chained"
+
+	MechanismSourceCause string = "cause"
+)
+
+func convertErrorToExceptions(err error, maxErrorDepth int) []Exception {
+	var exceptions []Exception
+	visited := make(map[error]bool)
+	convertErrorDFS(err, &exceptions, nil, "", visited, maxErrorDepth, 0)
+
+	// mechanism type is used for debugging purposes, but since we can't really distinguish the origin of who invoked
+	// captureException, we set it to nil if the error is not chained.
+	if len(exceptions) == 1 {
+		exceptions[0].Mechanism = nil
+	}
+
+	slices.Reverse(exceptions)
+
+	// Add a trace of the current stack to the top level(outermost) error in a chain if
+	// it doesn't have a stack trace yet.
+	// We only add to the most recent error to avoid duplication and because the
+	// current stack is most likely unrelated to errors deeper in the chain.
+	if len(exceptions) > 0 && exceptions[len(exceptions)-1].Stacktrace == nil {
+		exceptions[len(exceptions)-1].Stacktrace = NewStacktrace()
+	}
+
+	return exceptions
+}
+
+func convertErrorDFS(err error, exceptions *[]Exception, parentID *int, source string, visited map[error]bool, maxErrorDepth int, currentDepth int) {
+	if err == nil {
+		return
+	}
+
+	if visited[err] {
+		return
+	}
+	visited[err] = true
+
+	var isExceptionGroup bool
+
+	switch err.(type) {
+	case interface{ Unwrap() []error }:
+		isExceptionGroup = true
+	}
+
+	exception := Exception{
+		Value:      err.Error(),
+		Type:       reflect.TypeOf(err).String(),
+		Stacktrace: ExtractStacktrace(err),
+	}
+
+	currentID := len(*exceptions)
+
+	var mechanismType string
+
+	if parentID == nil {
+		mechanismType = MechanismTypeGeneric
+		source = ""
+	} else {
+		mechanismType = MechanismTypeChained
+	}
+
+	exception.Mechanism = &Mechanism{
+		Type:             mechanismType,
+		ExceptionID:      currentID,
+		ParentID:         parentID,
+		Source:           source,
+		IsExceptionGroup: isExceptionGroup,
+	}
+
+	*exceptions = append(*exceptions, exception)
+
+	if maxErrorDepth >= 0 && currentDepth >= maxErrorDepth {
+		return
+	}
+
+	switch v := err.(type) {
+	case interface{ Unwrap() []error }:
+		unwrapped := v.Unwrap()
+		for i := range unwrapped {
+			if unwrapped[i] != nil {
+				childSource := fmt.Sprintf("errors[%d]", i)
+				convertErrorDFS(unwrapped[i], exceptions, &currentID, childSource, visited, maxErrorDepth, currentDepth+1)
+			}
+		}
+	case interface{ Unwrap() error }:
+		unwrapped := v.Unwrap()
+		if unwrapped != nil {
+			convertErrorDFS(unwrapped, exceptions, &currentID, MechanismSourceCause, visited, maxErrorDepth, currentDepth+1)
+		}
+	case interface{ Cause() error }:
+		cause := v.Cause()
+		if cause != nil {
+			convertErrorDFS(cause, exceptions, &currentID, MechanismSourceCause, visited, maxErrorDepth, currentDepth+1)
+		}
+	}
+}