Add TraceCaller interface for extensibility for #104

errtrace.go

@@ -69,7 +69,7 @@ func wrap(err error, callerPC uintptr) error {
 }
 
 // Format writes the return trace for given error to the writer.
-// The output takes a fromat similar to the following:
+// The output takes a format similar to the following:
 //
 //	<error message>
 //
@@ -79,6 +79,8 @@ func wrap(err error, callerPC uintptr) error {
 //		<file>:<line>
 //	[...]
 //
+// Any error that has a method `TracePC() uintptr` will
+// contribute to the trace.
 // If the error doesn't have a return trace attached to it,
 // only the error message is reported.
 // If the error is comprised of multiple errors (e.g. with [errors.Join]),
@@ -90,6 +92,8 @@ func Format(w io.Writer, target error) (err error) {
 }
 
 // FormatString writes the return trace for err to a string.
+// Any error that has a method `TracePC() uintptr` will
+// contribute to the trace.
 // See [Format] for details of the output format.
 func FormatString(target error) string {
 	var s strings.Builder
@@ -118,3 +122,16 @@ func (e *errTrace) Format(s fmt.State, verb rune) {
 
 	fmt.Fprintf(s, fmt.FormatString(s, verb), e.err)
 }
+
+// TracePC returns the program counter for the location
+// in the frame that the error originated with.
+//
+// The returned PC is intended to be used with
+// runtime.CallersFrames or runtime.FuncForPC
+// to aid in generating the error return trace
+func (e *errTrace) TracePC() uintptr {
+	return e.pc
+}
+
+// compile time tracePCprovider interface check
+var _ interface{ TracePC() uintptr } = &errTrace{}

unwrap.go

@@ -9,18 +9,30 @@ import "runtime"
 //
 // You can use this for structured access to trace information.
 func UnwrapFrame(err error) (frame runtime.Frame, inner error, ok bool) { //nolint:revive // error is intentionally middle return
-	e, ok := err.(*errTrace)
+	e, ok := err.(interface{ TracePC() uintptr })
 	if !ok {
 		return runtime.Frame{}, err, false
 	}
 
-	frames := runtime.CallersFrames([]uintptr{e.pc})
+	wrapErr := unwrapOnce(err)
+	frames := runtime.CallersFrames([]uintptr{e.TracePC()})
 	f, _ := frames.Next()
 	if f == (runtime.Frame{}) {
 		// Unlikely, but if PC didn't yield a frame,
 		// just return the inner error.
-		return runtime.Frame{}, e.err, false
+		return runtime.Frame{}, wrapErr, false
 	}
 
-	return f, e.err, true
+	return f, wrapErr, true
+}
+
+// unwrapOnce accesses the direct cause of the error if any, otherwise
+// returns nil.
+func unwrapOnce(err error) error {
+	switch e := err.(type) {
+	case interface{ Unwrap() error }:
+		return e.Unwrap()
+	}
+
+	return nil
 }