get first stack trace info.

errors.go

@@ -280,3 +280,40 @@ func Cause(err error) error {
 	}
 	return err
 }
+
+// Stack returns the earliest/deepest StackTrace attached to any of
+// the errors in the chain of Causes. If the error does not implement
+// Cause, the original error will be returned. If the error is nil,
+// nil will be returned without further investigation.
+
+func Stack(err error) StackTrace {
+	type causer interface {
+		Cause() error
+	}
+
+	type stackTracer interface {
+		StackTrace() StackTrace
+	}
+
+	var topStackInfo StackTrace
+
+	for {
+		stackErr, ok := err.(stackTracer)
+		if ok {
+			topStackInfo = stackErr.StackTrace()
+		}
+
+		causer, ok := err.(causer)
+		if !ok {
+			break
+		}
+
+		err = causer.Cause()
+	}
+
+	if topStackInfo != nil {
+		return topStackInfo
+	}
+
+	return nil
+}

errors_test.go

@@ -106,6 +106,66 @@ func TestCause(t *testing.T) {
 	}
 }
 
+func printStack(tracer StackTrace) string {
+	var logInfo string
+	for _, f := range tracer {
+		logInfo += fmt.Sprintf("%+s:%d ", f, f)
+	}
+	return logInfo
+}
+
+func TestStack(t *testing.T) {
+	type stackTracer interface {
+		StackTrace() StackTrace
+	}
+
+	x := New("error")
+	y := x.(stackTracer).StackTrace()
+
+	tests := []struct {
+		err  error
+		want StackTrace
+	}{
+		{
+			err:  nil,
+			want: nil,
+		}, {
+			err:  (error)(nil),
+			want: nil,
+		}, {
+			err:  io.EOF,
+			want: nil,
+		}, {
+			err:  WithStack(x),
+			want: y,
+		}, {
+			err:  WithStack(WithStack(x)),
+			want: y,
+		}, {
+			err:  Wrap(WithStack(WithStack(x)), "test wrap"),
+			want: y,
+		}, {
+			err:  Cause(Wrap(WithStack(WithStack(x)), "test wrap")),
+			want: y,
+		},
+	}
+
+	for i, tt := range tests {
+		got := Stack(tt.err)
+		if got == nil || tt.want == nil {
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("test %d: got %#v, want %#v", i+1, got, tt.want)
+			}
+
+			continue
+		}
+
+		if !reflect.DeepEqual(printStack(got), printStack(tt.want)) {
+			t.Errorf("test %d: got %#v, want %#v", i+1, printStack(got), printStack(tt.want))
+		}
+	}
+}
+
 func TestWrapfNil(t *testing.T) {
 	got := Wrapf(nil, "no error")
 	if got != nil {