feat: properly support error capturing (#1075)

Author: giortzisg

CHANGELOG.md

@@ -2,10 +2,30 @@
 
 ## 0.36.0
 
+The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.36.0.
+
 ### Breaking Changes
 
 - Behavioral change for the `MaxBreadcrumbs` client option. Removed the hard limit of 100 breadcrumbs, allowing users to set a larger limit and also changed the default limit from 30 to 100 ([#1106](https://github.com/getsentry/sentry-go/pull/1106)))
 
+- The changes to error handling ([#1075](https://github.com/getsentry/sentry-go/pull/1075)) will affect issue grouping. It is expected that any wrapped and complex errors will be grouped under a new issue group.
+
+### Features
+
+- Add support for improved issue grouping with enhanced error chain handling ([#1075](https://github.com/getsentry/sentry-go/pull/1075))
+
+  The SDK now provides better handling of complex error scenarios, particularly when dealing with multiple related errors or error chains. This feature automatically detects and properly structures errors created with Go's `errors.Join()` function and other multi-error patterns.
+
+  ```go
+  // Multiple errors are now properly grouped and displayed in Sentry
+  err1 := errors.New("err1")
+  err2 := errors.New("err2") 
+  combinedErr := errors.Join(err1, err2)
+  
+  // When captured, these will be shown as related exceptions in Sentry
+  sentry.CaptureException(combinedErr)
+  ```
+
 ## 0.35.3
 
 The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.35.3.

client.go

@@ -28,7 +28,7 @@ const (
 	// is of little use when debugging production errors with Sentry. The Sentry UI
 	// is not optimized for long chains either. The top-level error together with a
 	// stack trace is often the most useful information.
-	maxErrorDepth = 10
+	maxErrorDepth = 100
 
 	// defaultMaxSpans limits the default number of recorded spans per transaction. The limit is
 	// meant to bound memory usage and prevent too large transaction events that

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:           MechanismTypeUnwrap,
+						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:           MechanismTypeUnwrap,
+						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,
 					},
 				},
 			},

exception.go

@@ -0,0 +1,103 @@
+package sentry
+
+import (
+	"fmt"
+	"reflect"
+	"slices"
+)
+
+const (
+	MechanismTypeGeneric string = "generic"
+	MechanismTypeChained string = "chained"
+	MechanismTypeUnwrap  string = "unwrap"
+	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
+
+	_, isExceptionGroup := err.(interface{ Unwrap() []error })
+
+	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, MechanismTypeUnwrap, visited, maxErrorDepth, currentDepth+1)
+		}
+	case interface{ Cause() error }:
+		cause := v.Cause()
+		if cause != nil {
+			convertErrorDFS(cause, exceptions, &currentID, MechanismSourceCause, visited, maxErrorDepth, currentDepth+1)
+		}
+	}
+}