fix: add fallback on non hashable errors (#1113)

Author: giortzisg

exception.go

@@ -13,10 +13,40 @@ const (
 	MechanismSourceCause string = "cause"
 )
 
+type visited struct {
+	comparable map[error]struct{}
+	msgs       map[string]struct{}
+}
+
+func (v *visited) seenError(err error) bool {
+	t := reflect.TypeOf(err)
+	if t == nil {
+		return false
+	}
+
+	if t.Comparable() {
+		if _, ok := v.comparable[err]; ok {
+			return true
+		}
+		v.comparable[err] = struct{}{}
+		return false
+	}
+
+	key := t.String() + err.Error()
+	if _, ok := v.msgs[key]; ok {
+		return true
+	}
+	v.msgs[key] = struct{}{}
+	return false
+}
+
 func convertErrorToExceptions(err error, maxErrorDepth int) []Exception {
 	var exceptions []Exception
-	visited := make(map[error]bool)
-	convertErrorDFS(err, &exceptions, nil, "", visited, maxErrorDepth, 0)
+	vis := &visited{
+		make(map[error]struct{}),
+		make(map[string]struct{}),
+	}
+	convertErrorDFS(err, &exceptions, nil, "", vis, 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.
@@ -37,15 +67,14 @@ func convertErrorToExceptions(err error, maxErrorDepth int) []Exception {
 	return exceptions
 }
 
-func convertErrorDFS(err error, exceptions *[]Exception, parentID *int, source string, visited map[error]bool, maxErrorDepth int, currentDepth int) {
+func convertErrorDFS(err error, exceptions *[]Exception, parentID *int, source string, visited *visited, maxErrorDepth int, currentDepth int) {
 	if err == nil {
 		return
 	}
 
-	if visited[err] {
+	if visited.seenError(err) {
 		return
 	}
-	visited[err] = true
 
 	_, isExceptionGroup := err.(interface{ Unwrap() []error })
 

exception_test.go

@@ -377,3 +377,21 @@ func TestCircularReferenceProtection(t *testing.T) {
 		})
 	}
 }
+
+// unhashableSliceError is a non-comparable error type.
+type unhashableSliceError []string
+
+func (e unhashableSliceError) Error() string {
+	return "unhashable slice error"
+}
+
+func TestConvertErrorToExceptions_UnhashableError_NoPanic(t *testing.T) {
+	defer func() {
+		if r := recover(); r != nil {
+			t.Fatalf("convertErrorToExceptions panicked for unhashable error: %v", r)
+		}
+	}()
+
+	err := unhashableSliceError{"a", "b"}
+	_ = convertErrorToExceptions(err, -1)
+}