fix(go.sum): update ResolveSpec dependency to v1.0.87

vendor/github.com/getsentry/sentry-go/exception.go

@@ -0,0 +1,129 @@
+package sentry
+
+import (
+	"fmt"
+	"reflect"
+	"slices"
+)
+
+const (
+	MechanismTypeGeneric string = "generic"
+	MechanismTypeChained string = "chained"
+	MechanismTypeUnwrap  string = "unwrap"
+	MechanismSourceCause string = "cause"
+)
+
+type visited struct {
+	ptrs map[uintptr]struct{}
+	msgs map[string]struct{}
+}
+
+func (v *visited) seenError(err error) bool {
+	t := reflect.ValueOf(err)
+	if t.Kind() == reflect.Ptr && !t.IsNil() {
+		ptr := t.Pointer()
+		if _, ok := v.ptrs[ptr]; ok {
+			return true
+		}
+		v.ptrs[ptr] = 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
+	vis := &visited{
+		ptrs: make(map[uintptr]struct{}),
+		msgs: 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.
+	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 *visited, maxErrorDepth int, currentDepth int) {
+	if err == nil {
+		return
+	}
+
+	if visited.seenError(err) {
+		return
+	}
+
+	_, 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)
+		}
+	}
+}