Add TraceCaller interface for extensibility

Signed-off-by: Steve Coffman <steve@khanacademy.org>

errtrace.go

@@ -118,3 +118,15 @@ func (e *errTrace) Format(s fmt.State, verb rune) {
 
 	fmt.Fprintf(s, fmt.FormatString(s, verb), e.err)
 }
+
+// TraceCall returns the program counter for the location in this frame.
+func (e *errTrace) TraceCall() uintptr {
+	return e.pc
+}
+
+type TraceCaller interface {
+	TraceCall() uintptr
+}
+
+// compile time TraceCaller interface check
+var _ TraceCaller = &errTrace{}

unwrap.go

@@ -9,18 +9,36 @@ 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.(TraceCaller)
 	if !ok {
 		return runtime.Frame{}, err, false
 	}
 
-	frames := runtime.CallersFrames([]uintptr{e.pc})
+	wrapErr := UnwrapOnce(err)
+	frames := runtime.CallersFrames([]uintptr{e.TraceCall()})
 	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.
+//
+// It supports both errors implementing causer (`Cause()` method, from
+// github.com/pkg/errors) and `Wrapper` (`Unwrap()` method, from the
+// Go 2 error proposal).
+func UnwrapOnce(err error) error {
+	switch e := err.(type) {
+	case interface{ Cause() error }:
+		return e.Cause()
+	case interface{ Unwrap() error }:
+		return e.Unwrap()
+	}
+
+	return nil
 }

unwrap_test.go

@@ -53,3 +53,52 @@ func TestUnwrapFrame_badPC(t *testing.T) {
 		t.Errorf("inner: got %v, want %v", inner, giveErr)
 	}
 }
+
+func TestUnwrapOnce(t *testing.T) {
+	rootErr := New("root")
+	var errTrace *errTrace
+	errors.As(rootErr, &errTrace)
+	unwrapped := errTrace.err
+	wrapper := Wrap(rootErr)
+
+	type want struct {
+		wantErr     bool
+		matchErr    error
+		matchString string
+	}
+	tests := []struct {
+		name string
+		arg  error
+		want want
+	}{
+		{
+			name: "unwrap wrapped provides root",
+			arg:  wrapper,
+			want: want{
+				wantErr:     true,
+				matchErr:    rootErr,
+				matchString: "root",
+			},
+		},
+		{
+			name: "unwrap root provides unwrapped",
+			arg:  rootErr,
+			want: want{
+				wantErr:     true,
+				matchErr:    unwrapped,
+				matchString: "root",
+			},
+		},
+		{name: "unwrap nil provides nil"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := UnwrapOnce(tt.arg)
+			if (err != nil) != tt.want.wantErr {
+				t.Errorf("UnwrapOnce() error = %v, but wantErr %v", err, tt.want.wantErr)
+			} else if !errors.Is(err, tt.want.matchErr) {
+				t.Errorf("UnwrapOnce() error = %v, does not match matchErr %v", err, tt.want.matchErr)
+			}
+		})
+	}
+}