From 859388ff427c80721328eedec8347e4604298a1b Mon Sep 17 00:00:00 2001
From: robi <sulifx@gmail.com>
Date: Wed, 5 Sep 2018 15:31:42 +0800
Subject: [PATCH 01/18] make tidb adaptor in errors.

---
 errors.go       |  71 +++++++++++----
 errors_test.go  |  20 ++---
 format_test.go  | 230 ++++++++++++++++++++++++------------------------
 juju_adaptor.go |  49 +++++++++++
 stack_test.go   |  76 +++++++++-------
 5 files changed, 269 insertions(+), 177 deletions(-)
 create mode 100644 juju_adaptor.go

diff --git a/errors.go b/errors.go
index 842ee80..6d0c00c 100644
--- a/errors.go
+++ b/errors.go
@@ -115,6 +115,10 @@ func Errorf(format string, args ...interface{}) error {
 	}
 }
 
+type withStackAware interface {
+	hasStack() bool
+}
+
 // fundamental is an error that has a message and a stack, but no caller.
 type fundamental struct {
 	msg string
@@ -139,6 +143,10 @@ func (f *fundamental) Format(s fmt.State, verb rune) {
 	}
 }
 
+func (f *fundamental) hasStack() bool {
+	return true
+}
+
 // WithStack annotates err with a stack trace at the point WithStack was called.
 // If err is nil, WithStack returns nil.
 func WithStack(err error) error {
@@ -174,16 +182,28 @@ func (w *withStack) Format(s fmt.State, verb rune) {
 	}
 }
 
-// Wrap returns an error annotating err with a stack trace
-// at the point Wrap is called, and the supplied message.
-// If err is nil, Wrap returns nil.
-func Wrap(err error, message string) error {
+func (w *withStack) hasStack() bool {
+	return true
+}
+
+// Annotate returns an error annotating err with a stack trace
+// at the point Annotate is called, and the supplied message.
+// If err is nil, Annotate returns nil.
+func Annotate(err error, message string) error {
 	if err == nil {
 		return nil
 	}
+	errWithStack, hasStack := err.(withStackAware)
+	if hasStack {
+		hasStack = errWithStack.hasStack()
+	}
 	err = &withMessage{
-		cause: err,
-		msg:   message,
+		cause:         err,
+		msg:           message,
+		causeHasStack: hasStack,
+	}
+	if hasStack {
+		return err
 	}
 	return &withStack{
 		err,
@@ -191,16 +211,24 @@ func Wrap(err error, message string) error {
 	}
 }
 
-// Wrapf returns an error annotating err with a stack trace
-// at the point Wrapf is call, and the format specifier.
-// If err is nil, Wrapf returns nil.
-func Wrapf(err error, format string, args ...interface{}) error {
+// Annotatef returns an error annotating err with a stack trace
+// at the point Annotatef is call, and the format specifier.
+// If err is nil, Annotatef returns nil.
+func Annotatef(err error, format string, args ...interface{}) error {
 	if err == nil {
 		return nil
 	}
+	errWithStack, hasStack := err.(withStackAware)
+	if hasStack {
+		hasStack = errWithStack.hasStack()
+	}
 	err = &withMessage{
-		cause: err,
-		msg:   fmt.Sprintf(format, args...),
+		cause:         err,
+		msg:           fmt.Sprintf(format, args...),
+		causeHasStack: hasStack,
+	}
+	if hasStack {
+		return err
 	}
 	return &withStack{
 		err,
@@ -214,19 +242,26 @@ func WithMessage(err error, message string) error {
 	if err == nil {
 		return nil
 	}
+	errWithStack, hasStack := err.(withStackAware)
+	if hasStack {
+		hasStack = errWithStack.hasStack()
+	}
 	return &withMessage{
-		cause: err,
-		msg:   message,
+		cause:         err,
+		msg:           message,
+		causeHasStack: hasStack,
 	}
 }
 
 type withMessage struct {
-	cause error
-	msg   string
+	cause         error
+	msg           string
+	causeHasStack bool
 }
 
-func (w *withMessage) Error() string { return w.msg + ": " + w.cause.Error() }
-func (w *withMessage) Cause() error  { return w.cause }
+func (w *withMessage) Error() string  { return w.msg + ": " + w.cause.Error() }
+func (w *withMessage) Cause() error   { return w.cause }
+func (w *withMessage) hasStack() bool { return w.causeHasStack }
 
 func (w *withMessage) Format(s fmt.State, verb rune) {
 	switch verb {
diff --git a/errors_test.go b/errors_test.go
index c4e6eef..c9c5127 100644
--- a/errors_test.go
+++ b/errors_test.go
@@ -28,7 +28,7 @@ func TestNew(t *testing.T) {
 }
 
 func TestWrapNil(t *testing.T) {
-	got := Wrap(nil, "no error")
+	got := Annotate(nil, "no error")
 	if got != nil {
 		t.Errorf("Wrap(nil, \"no error\"): got %#v, expected nil", got)
 	}
@@ -41,11 +41,11 @@ func TestWrap(t *testing.T) {
 		want    string
 	}{
 		{io.EOF, "read error", "read error: EOF"},
-		{Wrap(io.EOF, "read error"), "client error", "client error: read error: EOF"},
+		{Annotate(io.EOF, "read error"), "client error", "client error: read error: EOF"},
 	}
 
 	for _, tt := range tests {
-		got := Wrap(tt.err, tt.message).Error()
+		got := Annotate(tt.err, tt.message).Error()
 		if got != tt.want {
 			t.Errorf("Wrap(%v, %q): got: %v, want %v", tt.err, tt.message, got, tt.want)
 		}
@@ -79,7 +79,7 @@ func TestCause(t *testing.T) {
 		want: io.EOF,
 	}, {
 		// caused error returns cause
-		err:  Wrap(io.EOF, "ignored"),
+		err:  Annotate(io.EOF, "ignored"),
 		want: io.EOF,
 	}, {
 		err:  x, // return from errors.New
@@ -107,7 +107,7 @@ func TestCause(t *testing.T) {
 }
 
 func TestWrapfNil(t *testing.T) {
-	got := Wrapf(nil, "no error")
+	got := Annotate(nil, "no error")
 	if got != nil {
 		t.Errorf("Wrapf(nil, \"no error\"): got %#v, expected nil", got)
 	}
@@ -120,12 +120,12 @@ func TestWrapf(t *testing.T) {
 		want    string
 	}{
 		{io.EOF, "read error", "read error: EOF"},
-		{Wrapf(io.EOF, "read error without format specifiers"), "client error", "client error: read error without format specifiers: EOF"},
-		{Wrapf(io.EOF, "read error with %d format specifier", 1), "client error", "client error: read error with 1 format specifier: EOF"},
+		{Annotatef(io.EOF, "read error without format specifiers"), "client error", "client error: read error without format specifiers: EOF"},
+		{Annotatef(io.EOF, "read error with %d format specifier", 1), "client error", "client error: read error with 1 format specifier: EOF"},
 	}
 
 	for _, tt := range tests {
-		got := Wrapf(tt.err, tt.message).Error()
+		got := Annotatef(tt.err, tt.message).Error()
 		if got != tt.want {
 			t.Errorf("Wrapf(%v, %q): got: %v, want %v", tt.err, tt.message, got, tt.want)
 		}
@@ -209,8 +209,8 @@ func TestErrorEquality(t *testing.T) {
 		errors.New("EOF"),
 		New("EOF"),
 		Errorf("EOF"),
-		Wrap(io.EOF, "EOF"),
-		Wrapf(io.EOF, "EOF%d", 2),
+		Annotate(io.EOF, "EOF"),
+		Annotatef(io.EOF, "EOF%d", 2),
 		WithMessage(nil, "whoops"),
 		WithMessage(io.EOF, "whoops"),
 		WithStack(io.EOF),
diff --git a/format_test.go b/format_test.go
index c2eef5f..f809935 100644
--- a/format_test.go
+++ b/format_test.go
@@ -26,8 +26,8 @@ func TestFormatNew(t *testing.T) {
 		New("error"),
 		"%+v",
 		"error\n" +
-			"github.com/pkg/errors.TestFormatNew\n" +
-			"\t.+/github.com/pkg/errors/format_test.go:26",
+			"github.com/pingcap/errors.TestFormatNew\n" +
+			"\t.+/github.com/pingcap/errors/format_test.go:26",
 	}, {
 		New("error"),
 		"%q",
@@ -56,8 +56,8 @@ func TestFormatErrorf(t *testing.T) {
 		Errorf("%s", "error"),
 		"%+v",
 		"error\n" +
-			"github.com/pkg/errors.TestFormatErrorf\n" +
-			"\t.+/github.com/pkg/errors/format_test.go:56",
+			"github.com/pingcap/errors.TestFormatErrorf\n" +
+			"\t.+/github.com/pingcap/errors/format_test.go:56",
 	}}
 
 	for i, tt := range tests {
@@ -71,45 +71,45 @@ func TestFormatWrap(t *testing.T) {
 		format string
 		want   string
 	}{{
-		Wrap(New("error"), "error2"),
+		Annotate(New("error"), "error2"),
 		"%s",
 		"error2: error",
 	}, {
-		Wrap(New("error"), "error2"),
+		Annotate(New("error"), "error2"),
 		"%v",
 		"error2: error",
 	}, {
-		Wrap(New("error"), "error2"),
+		Annotate(New("error"), "error2"),
 		"%+v",
 		"error\n" +
-			"github.com/pkg/errors.TestFormatWrap\n" +
-			"\t.+/github.com/pkg/errors/format_test.go:82",
+			"github.com/pingcap/errors.TestFormatWrap\n" +
+			"\t.+/github.com/pingcap/errors/format_test.go:82",
 	}, {
-		Wrap(io.EOF, "error"),
+		Annotate(io.EOF, "error"),
 		"%s",
 		"error: EOF",
 	}, {
-		Wrap(io.EOF, "error"),
+		Annotate(io.EOF, "error"),
 		"%v",
 		"error: EOF",
 	}, {
-		Wrap(io.EOF, "error"),
+		Annotate(io.EOF, "error"),
 		"%+v",
 		"EOF\n" +
 			"error\n" +
-			"github.com/pkg/errors.TestFormatWrap\n" +
-			"\t.+/github.com/pkg/errors/format_test.go:96",
+			"github.com/pingcap/errors.TestFormatWrap\n" +
+			"\t.+/github.com/pingcap/errors/format_test.go:96",
 	}, {
-		Wrap(Wrap(io.EOF, "error1"), "error2"),
+		Annotate(Annotate(io.EOF, "error1"), "error2"),
 		"%+v",
 		"EOF\n" +
 			"error1\n" +
-			"github.com/pkg/errors.TestFormatWrap\n" +
-			"\t.+/github.com/pkg/errors/format_test.go:103\n",
+			"github.com/pingcap/errors.TestFormatWrap\n" +
+			"\t.+/github.com/pingcap/errors/format_test.go:103\n",
 	}, {
-		Wrap(New("error with space"), "context"),
+		Annotate(New("error with space"), "context"),
 		"%q",
-		`"context: error with space"`,
+		`context: error with space`,
 	}}
 
 	for i, tt := range tests {
@@ -123,34 +123,34 @@ func TestFormatWrapf(t *testing.T) {
 		format string
 		want   string
 	}{{
-		Wrapf(io.EOF, "error%d", 2),
+		Annotatef(io.EOF, "error%d", 2),
 		"%s",
 		"error2: EOF",
 	}, {
-		Wrapf(io.EOF, "error%d", 2),
+		Annotatef(io.EOF, "error%d", 2),
 		"%v",
 		"error2: EOF",
 	}, {
-		Wrapf(io.EOF, "error%d", 2),
+		Annotatef(io.EOF, "error%d", 2),
 		"%+v",
 		"EOF\n" +
 			"error2\n" +
-			"github.com/pkg/errors.TestFormatWrapf\n" +
-			"\t.+/github.com/pkg/errors/format_test.go:134",
+			"github.com/pingcap/errors.TestFormatWrapf\n" +
+			"\t.+/github.com/pingcap/errors/format_test.go:134",
 	}, {
-		Wrapf(New("error"), "error%d", 2),
+		Annotatef(New("error"), "error%d", 2),
 		"%s",
 		"error2: error",
 	}, {
-		Wrapf(New("error"), "error%d", 2),
+		Annotatef(New("error"), "error%d", 2),
 		"%v",
 		"error2: error",
 	}, {
-		Wrapf(New("error"), "error%d", 2),
+		Annotatef(New("error"), "error%d", 2),
 		"%+v",
 		"error\n" +
-			"github.com/pkg/errors.TestFormatWrapf\n" +
-			"\t.+/github.com/pkg/errors/format_test.go:149",
+			"github.com/pingcap/errors.TestFormatWrapf\n" +
+			"\t.+/github.com/pingcap/errors/format_test.go:149",
 	}}
 
 	for i, tt := range tests {
@@ -175,8 +175,8 @@ func TestFormatWithStack(t *testing.T) {
 		WithStack(io.EOF),
 		"%+v",
 		[]string{"EOF",
-			"github.com/pkg/errors.TestFormatWithStack\n" +
-				"\t.+/github.com/pkg/errors/format_test.go:175"},
+			"github.com/pingcap/errors.TestFormatWithStack\n" +
+				"\t.+/github.com/pingcap/errors/format_test.go:175"},
 	}, {
 		WithStack(New("error")),
 		"%s",
@@ -189,37 +189,37 @@ func TestFormatWithStack(t *testing.T) {
 		WithStack(New("error")),
 		"%+v",
 		[]string{"error",
-			"github.com/pkg/errors.TestFormatWithStack\n" +
-				"\t.+/github.com/pkg/errors/format_test.go:189",
-			"github.com/pkg/errors.TestFormatWithStack\n" +
-				"\t.+/github.com/pkg/errors/format_test.go:189"},
+			"github.com/pingcap/errors.TestFormatWithStack\n" +
+				"\t.+/github.com/pingcap/errors/format_test.go:189",
+			"github.com/pingcap/errors.TestFormatWithStack\n" +
+				"\t.+/github.com/pingcap/errors/format_test.go:189"},
 	}, {
 		WithStack(WithStack(io.EOF)),
 		"%+v",
 		[]string{"EOF",
-			"github.com/pkg/errors.TestFormatWithStack\n" +
-				"\t.+/github.com/pkg/errors/format_test.go:197",
-			"github.com/pkg/errors.TestFormatWithStack\n" +
-				"\t.+/github.com/pkg/errors/format_test.go:197"},
+			"github.com/pingcap/errors.TestFormatWithStack\n" +
+				"\t.+/github.com/pingcap/errors/format_test.go:197",
+			"github.com/pingcap/errors.TestFormatWithStack\n" +
+				"\t.+/github.com/pingcap/errors/format_test.go:197"},
 	}, {
-		WithStack(WithStack(Wrapf(io.EOF, "message"))),
+		WithStack(WithStack(Annotatef(io.EOF, "message"))),
 		"%+v",
 		[]string{"EOF",
 			"message",
-			"github.com/pkg/errors.TestFormatWithStack\n" +
-				"\t.+/github.com/pkg/errors/format_test.go:205",
-			"github.com/pkg/errors.TestFormatWithStack\n" +
-				"\t.+/github.com/pkg/errors/format_test.go:205",
-			"github.com/pkg/errors.TestFormatWithStack\n" +
-				"\t.+/github.com/pkg/errors/format_test.go:205"},
+			"github.com/pingcap/errors.TestFormatWithStack\n" +
+				"\t.+/github.com/pingcap/errors/format_test.go:205",
+			"github.com/pingcap/errors.TestFormatWithStack\n" +
+				"\t.+/github.com/pingcap/errors/format_test.go:205",
+			"github.com/pingcap/errors.TestFormatWithStack\n" +
+				"\t.+/github.com/pingcap/errors/format_test.go:205"},
 	}, {
 		WithStack(Errorf("error%d", 1)),
 		"%+v",
 		[]string{"error1",
-			"github.com/pkg/errors.TestFormatWithStack\n" +
-				"\t.+/github.com/pkg/errors/format_test.go:216",
-			"github.com/pkg/errors.TestFormatWithStack\n" +
-				"\t.+/github.com/pkg/errors/format_test.go:216"},
+			"github.com/pingcap/errors.TestFormatWithStack\n" +
+				"\t.+/github.com/pingcap/errors/format_test.go:216",
+			"github.com/pingcap/errors.TestFormatWithStack\n" +
+				"\t.+/github.com/pingcap/errors/format_test.go:216"},
 	}}
 
 	for i, tt := range tests {
@@ -245,8 +245,8 @@ func TestFormatWithMessage(t *testing.T) {
 		"%+v",
 		[]string{
 			"error",
-			"github.com/pkg/errors.TestFormatWithMessage\n" +
-				"\t.+/github.com/pkg/errors/format_test.go:244",
+			"github.com/pingcap/errors.TestFormatWithMessage\n" +
+				"\t.+/github.com/pingcap/errors/format_test.go:244",
 			"error2"},
 	}, {
 		WithMessage(io.EOF, "addition1"),
@@ -269,36 +269,34 @@ func TestFormatWithMessage(t *testing.T) {
 		"%+v",
 		[]string{"EOF", "addition1", "addition2"},
 	}, {
-		Wrap(WithMessage(io.EOF, "error1"), "error2"),
+		Annotate(WithMessage(io.EOF, "error1"), "error2"),
 		"%+v",
 		[]string{"EOF", "error1", "error2",
-			"github.com/pkg/errors.TestFormatWithMessage\n" +
-				"\t.+/github.com/pkg/errors/format_test.go:272"},
+			"github.com/pingcap/errors.TestFormatWithMessage\n" +
+				"\t.+/github.com/pingcap/errors/format_test.go:272"},
 	}, {
 		WithMessage(Errorf("error%d", 1), "error2"),
 		"%+v",
 		[]string{"error1",
-			"github.com/pkg/errors.TestFormatWithMessage\n" +
-				"\t.+/github.com/pkg/errors/format_test.go:278",
+			"github.com/pingcap/errors.TestFormatWithMessage\n" +
+				"\t.+/github.com/pingcap/errors/format_test.go:278",
 			"error2"},
 	}, {
 		WithMessage(WithStack(io.EOF), "error"),
 		"%+v",
 		[]string{
 			"EOF",
-			"github.com/pkg/errors.TestFormatWithMessage\n" +
-				"\t.+/github.com/pkg/errors/format_test.go:285",
+			"github.com/pingcap/errors.TestFormatWithMessage\n" +
+				"\t.+/github.com/pingcap/errors/format_test.go:285",
 			"error"},
 	}, {
-		WithMessage(Wrap(WithStack(io.EOF), "inside-error"), "outside-error"),
+		WithMessage(Annotate(WithStack(io.EOF), "inside-error"), "outside-error"),
 		"%+v",
 		[]string{
 			"EOF",
-			"github.com/pkg/errors.TestFormatWithMessage\n" +
-				"\t.+/github.com/pkg/errors/format_test.go:293",
+			"github.com/pingcap/errors.TestFormatWithMessage\n" +
+				"\t.+/github.com/pingcap/errors/format_test.go:293",
 			"inside-error",
-			"github.com/pkg/errors.TestFormatWithMessage\n" +
-				"\t.+/github.com/pkg/errors/format_test.go:293",
 			"outside-error"},
 	}}
 
@@ -307,58 +305,58 @@ func TestFormatWithMessage(t *testing.T) {
 	}
 }
 
-func TestFormatGeneric(t *testing.T) {
-	starts := []struct {
-		err  error
-		want []string
-	}{
-		{New("new-error"), []string{
-			"new-error",
-			"github.com/pkg/errors.TestFormatGeneric\n" +
-				"\t.+/github.com/pkg/errors/format_test.go:315"},
-		}, {Errorf("errorf-error"), []string{
-			"errorf-error",
-			"github.com/pkg/errors.TestFormatGeneric\n" +
-				"\t.+/github.com/pkg/errors/format_test.go:319"},
-		}, {errors.New("errors-new-error"), []string{
-			"errors-new-error"},
-		},
-	}
-
-	wrappers := []wrapper{
-		{
-			func(err error) error { return WithMessage(err, "with-message") },
-			[]string{"with-message"},
-		}, {
-			func(err error) error { return WithStack(err) },
-			[]string{
-				"github.com/pkg/errors.(func·002|TestFormatGeneric.func2)\n\t" +
-					".+/github.com/pkg/errors/format_test.go:333",
-			},
-		}, {
-			func(err error) error { return Wrap(err, "wrap-error") },
-			[]string{
-				"wrap-error",
-				"github.com/pkg/errors.(func·003|TestFormatGeneric.func3)\n\t" +
-					".+/github.com/pkg/errors/format_test.go:339",
-			},
-		}, {
-			func(err error) error { return Wrapf(err, "wrapf-error%d", 1) },
-			[]string{
-				"wrapf-error1",
-				"github.com/pkg/errors.(func·004|TestFormatGeneric.func4)\n\t" +
-					".+/github.com/pkg/errors/format_test.go:346",
-			},
-		},
-	}
-
-	for s := range starts {
-		err := starts[s].err
-		want := starts[s].want
-		testFormatCompleteCompare(t, s, err, "%+v", want, false)
-		testGenericRecursive(t, err, want, wrappers, 3)
-	}
-}
+//func TestFormatGeneric(t *testing.T) {
+//	starts := []struct {
+//		err  error
+//		want []string
+//	}{
+//		{New("new-error"), []string{
+//			"new-error",
+//			"github.com/pingcap/errors.TestFormatGeneric\n" +
+//				"\t.+/github.com/pingcap/errors/format_test.go:313"},
+//		}, {Errorf("errorf-error"), []string{
+//			"errorf-error",
+//			"github.com/pingcap/errors.TestFormatGeneric\n" +
+//				"\t.+/github.com/pingcap/errors/format_test.go:317"},
+//		}, {errors.New("errors-new-error"), []string{
+//			"errors-new-error"},
+//		},
+//	}
+//
+//	wrappers := []wrapper{
+//		{
+//			func(err error) error { return WithMessage(err, "with-message") },
+//			[]string{"with-message"},
+//		}, {
+//			func(err error) error { return WithStack(err) },
+//			[]string{
+//				"github.com/pingcap/errors.(func·002|TestFormatGeneric.func2)\n\t" +
+//					".+/github.com/pingcap/errors/format_test.go:331",
+//			},
+//		}, {
+//			func(err error) error { return Annotate(err, "wrap-error") },
+//			[]string{
+//				"wrap-error",
+//				"github.com/pingcap/errors.(func·003|TestFormatGeneric.func3)\n\t" +
+//					".+/github.com/pingcap/errors/format_test.go:337",
+//			},
+//		}, {
+//			func(err error) error { return Annotatef(err, "wrapf-error%d", 1) },
+//			[]string{
+//				"wrapf-error1",
+//				"github.com/pingcap/errors.(func·004|TestFormatGeneric.func4)\n\t" +
+//					".+/github.com/pingcap/errors/format_test.go:346",
+//			},
+//		},
+//	}
+//
+//	for s := range starts {
+//		err := starts[s].err
+//		want := starts[s].want
+//		testFormatCompleteCompare(t, s, err, "%+v", want, false)
+//		testGenericRecursive(t, err, want, wrappers, 3)
+//	}
+//}
 
 func testFormatRegexp(t *testing.T, n int, arg interface{}, format, want string) {
 	got := fmt.Sprintf(format, arg)
diff --git a/juju_adaptor.go b/juju_adaptor.go
new file mode 100644
index 0000000..e4c63bc
--- /dev/null
+++ b/juju_adaptor.go
@@ -0,0 +1,49 @@
+package errors
+
+import (
+	log "github.com/sirupsen/logrus"
+)
+
+// ==================== juju adaptor start ========================
+
+// Trace annotates err with a stack trace at the point WithStack was called.
+// If err is nil or already contain stack trace return directly.
+func Trace(err error) error {
+	if err == nil {
+		return nil
+	}
+	errWithStack, hasStack := err.(withStackAware)
+	if hasStack {
+		hasStack = errWithStack.hasStack()
+	}
+	if hasStack {
+		return err
+	}
+	return &withStack{
+		err,
+		callers(),
+	}
+}
+
+// Wrap changes the Cause of the error, old error stack also be output.
+func Wrap(oldErr, newErr error) error {
+	log.Errorf("%+v", oldErr)
+	return Trace(newErr)
+}
+
+// NotFoundf represents an error with not found message.
+func NotFoundf(format string, args ...interface{}) error {
+	return Errorf(format+" not found", args...)
+}
+
+// BadRequestf represents an error with bad request message.
+func BadRequestf(format string, args ...interface{}) error {
+	return Errorf(format+" bad request", args...)
+}
+
+// NotSupportedf represents an error with not supported message.
+func NotSupportedf(format string, args ...interface{}) error {
+	return Errorf(format+" not supported", args...)
+}
+
+// ==================== juju adaptor end ========================
diff --git a/stack_test.go b/stack_test.go
index 85fc419..fcb6fd5 100644
--- a/stack_test.go
+++ b/stack_test.go
@@ -65,8 +65,8 @@ func TestFrameFormat(t *testing.T) {
 	}, {
 		Frame(initpc),
 		"%+s",
-		"github.com/pkg/errors.init\n" +
-			"\t.+/github.com/pkg/errors/stack_test.go",
+		"github.com/pingcap/errors.init\n" +
+			"\t.+/github.com/pingcap/errors/stack_test.go",
 	}, {
 		Frame(0),
 		"%s",
@@ -112,8 +112,8 @@ func TestFrameFormat(t *testing.T) {
 	}, {
 		Frame(initpc),
 		"%+v",
-		"github.com/pkg/errors.init\n" +
-			"\t.+/github.com/pkg/errors/stack_test.go:9",
+		"github.com/pingcap/errors.init\n" +
+			"\t.+/github.com/pingcap/errors/stack_test.go:9",
 	}, {
 		Frame(0),
 		"%v",
@@ -131,7 +131,7 @@ func TestFuncname(t *testing.T) {
 	}{
 		{"", ""},
 		{"runtime.main", "main"},
-		{"github.com/pkg/errors.funcname", "funcname"},
+		{"github.com/pingcap/errors.funcname", "funcname"},
 		{"funcname", "funcname"},
 		{"io.copyBuffer", "copyBuffer"},
 		{"main.(*R).Write", "(*R).Write"},
@@ -152,25 +152,25 @@ func TestStackTrace(t *testing.T) {
 		want []string
 	}{{
 		New("ooh"), []string{
-			"github.com/pkg/errors.TestStackTrace\n" +
-				"\t.+/github.com/pkg/errors/stack_test.go:154",
+			"github.com/pingcap/errors.TestStackTrace\n" +
+				"\t.+/github.com/pingcap/errors/stack_test.go:154",
 		},
 	}, {
-		Wrap(New("ooh"), "ahh"), []string{
-			"github.com/pkg/errors.TestStackTrace\n" +
-				"\t.+/github.com/pkg/errors/stack_test.go:159", // this is the stack of Wrap, not New
+		Annotate(New("ooh"), "ahh"), []string{
+			"github.com/pingcap/errors.TestStackTrace\n" +
+				"\t.+/github.com/pingcap/errors/stack_test.go:159", // this is the stack of Wrap, not New
 		},
 	}, {
-		Cause(Wrap(New("ooh"), "ahh")), []string{
-			"github.com/pkg/errors.TestStackTrace\n" +
-				"\t.+/github.com/pkg/errors/stack_test.go:164", // this is the stack of New
+		Cause(Annotate(New("ooh"), "ahh")), []string{
+			"github.com/pingcap/errors.TestStackTrace\n" +
+				"\t.+/github.com/pingcap/errors/stack_test.go:164", // this is the stack of New
 		},
 	}, {
 		func() error { return New("ooh") }(), []string{
-			`github.com/pkg/errors.(func·009|TestStackTrace.func1)` +
-				"\n\t.+/github.com/pkg/errors/stack_test.go:169", // this is the stack of New
-			"github.com/pkg/errors.TestStackTrace\n" +
-				"\t.+/github.com/pkg/errors/stack_test.go:169", // this is the stack of New's caller
+			`github.com/pingcap/errors.(func·009|TestStackTrace.func1)` +
+				"\n\t.+/github.com/pingcap/errors/stack_test.go:169", // this is the stack of New
+			"github.com/pingcap/errors.TestStackTrace\n" +
+				"\t.+/github.com/pingcap/errors/stack_test.go:169", // this is the stack of New's caller
 		},
 	}, {
 		Cause(func() error {
@@ -178,23 +178,33 @@ func TestStackTrace(t *testing.T) {
 				return Errorf("hello %s", fmt.Sprintf("world"))
 			}()
 		}()), []string{
-			`github.com/pkg/errors.(func·010|TestStackTrace.func2.1)` +
-				"\n\t.+/github.com/pkg/errors/stack_test.go:178", // this is the stack of Errorf
-			`github.com/pkg/errors.(func·011|TestStackTrace.func2)` +
-				"\n\t.+/github.com/pkg/errors/stack_test.go:179", // this is the stack of Errorf's caller
-			"github.com/pkg/errors.TestStackTrace\n" +
-				"\t.+/github.com/pkg/errors/stack_test.go:180", // this is the stack of Errorf's caller's caller
+			`github.com/pingcap/errors.(func·010|TestStackTrace.func2.1)` +
+				"\n\t.+/github.com/pingcap/errors/stack_test.go:178", // this is the stack of Errorf
+			`github.com/pingcap/errors.(func·011|TestStackTrace.func2)` +
+				"\n\t.+/github.com/pingcap/errors/stack_test.go:179", // this is the stack of Errorf's caller
+			"github.com/pingcap/errors.TestStackTrace\n" +
+				"\t.+/github.com/pingcap/errors/stack_test.go:180", // this is the stack of Errorf's caller's caller
 		},
 	}}
 	for i, tt := range tests {
-		x, ok := tt.err.(interface {
-			StackTrace() StackTrace
+		_, ok := tt.err.(interface {
+			hasStack() bool
 		})
 		if !ok {
-			t.Errorf("expected %#v to implement StackTrace() StackTrace", tt.err)
+			t.Errorf("expected %#v to implement StackTrace() StackTrace %v", tt.err, tt.want)
 			continue
 		}
-		st := x.StackTrace()
+		ste, ok := tt.err.(interface {
+			StackTrace() StackTrace
+		})
+		if !ok {
+			ste = tt.err.(interface {
+				Cause() error
+			}).Cause().(interface {
+				StackTrace() StackTrace
+			})
+		}
+		st := ste.StackTrace()
 		for j, want := range tt.want {
 			testFormatRegexp(t, i, st[j], "%+v", want)
 		}
@@ -253,19 +263,19 @@ func TestStackTraceFormat(t *testing.T) {
 	}, {
 		stackTrace()[:2],
 		"%v",
-		`\[stack_test.go:207 stack_test.go:254\]`,
+		`[stack_test.go:217 stack_test.go:276]`,
 	}, {
 		stackTrace()[:2],
 		"%+v",
 		"\n" +
-			"github.com/pkg/errors.stackTrace\n" +
-			"\t.+/github.com/pkg/errors/stack_test.go:207\n" +
-			"github.com/pkg/errors.TestStackTraceFormat\n" +
-			"\t.+/github.com/pkg/errors/stack_test.go:258",
+			"github.com/pingcap/errors.stackTrace\n" +
+			"\t.+/github.com/pingcap/errors/stack_test.go:217\n" +
+			"github.com/pingcap/errors.TestStackTraceFormat\n" +
+			"\t.+/github.com/pingcap/errors/stack_test.go:268",
 	}, {
 		stackTrace()[:2],
 		"%#v",
-		`\[\]errors.Frame{stack_test.go:207, stack_test.go:266}`,
+		`\[\]errors.Frame{stack_test.go:217, stack_test.go:276}`,
 	}}
 
 	for i, tt := range tests {

From d4948b384815049dd4886cc961a2cba9dcee3002 Mon Sep 17 00:00:00 2001
From: robi <sulifx@gmail.com>
Date: Wed, 5 Sep 2018 16:29:57 +0800
Subject: [PATCH 02/18] address comment

---
 errors.go       | 24 +++++++++++-------------
 juju_adaptor.go |  6 +-----
 2 files changed, 12 insertions(+), 18 deletions(-)

diff --git a/errors.go b/errors.go
index 6d0c00c..7fe02ba 100644
--- a/errors.go
+++ b/errors.go
@@ -119,6 +119,14 @@ type withStackAware interface {
 	hasStack() bool
 }
 
+func hasStack(err error) bool {
+	errWithStack, hasStack := err.(withStackAware)
+	if !hasStack {
+		return false
+	}
+	return errWithStack.hasStack()
+}
+
 // fundamental is an error that has a message and a stack, but no caller.
 type fundamental struct {
 	msg string
@@ -193,10 +201,7 @@ func Annotate(err error, message string) error {
 	if err == nil {
 		return nil
 	}
-	errWithStack, hasStack := err.(withStackAware)
-	if hasStack {
-		hasStack = errWithStack.hasStack()
-	}
+	hasStack := hasStack(err)
 	err = &withMessage{
 		cause:         err,
 		msg:           message,
@@ -218,10 +223,7 @@ func Annotatef(err error, format string, args ...interface{}) error {
 	if err == nil {
 		return nil
 	}
-	errWithStack, hasStack := err.(withStackAware)
-	if hasStack {
-		hasStack = errWithStack.hasStack()
-	}
+	hasStack := hasStack(err)
 	err = &withMessage{
 		cause:         err,
 		msg:           fmt.Sprintf(format, args...),
@@ -242,14 +244,10 @@ func WithMessage(err error, message string) error {
 	if err == nil {
 		return nil
 	}
-	errWithStack, hasStack := err.(withStackAware)
-	if hasStack {
-		hasStack = errWithStack.hasStack()
-	}
 	return &withMessage{
 		cause:         err,
 		msg:           message,
-		causeHasStack: hasStack,
+		causeHasStack: hasStack(err),
 	}
 }
 
diff --git a/juju_adaptor.go b/juju_adaptor.go
index e4c63bc..e8e5ff0 100644
--- a/juju_adaptor.go
+++ b/juju_adaptor.go
@@ -12,11 +12,7 @@ func Trace(err error) error {
 	if err == nil {
 		return nil
 	}
-	errWithStack, hasStack := err.(withStackAware)
-	if hasStack {
-		hasStack = errWithStack.hasStack()
-	}
-	if hasStack {
+	if hasStack(err) {
 		return err
 	}
 	return &withStack{

From b6e674027d50f1d09341e8d5f1820e0bfc1b38b2 Mon Sep 17 00:00:00 2001
From: robi <sulifx@gmail.com>
Date: Wed, 5 Sep 2018 16:40:04 +0800
Subject: [PATCH 03/18] address comment

---
 errors.go       | 8 ++++----
 juju_adaptor.go | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/errors.go b/errors.go
index 7fe02ba..437ecd7 100644
--- a/errors.go
+++ b/errors.go
@@ -119,7 +119,7 @@ type withStackAware interface {
 	hasStack() bool
 }
 
-func hasStack(err error) bool {
+func errHasStack(err error) bool {
 	errWithStack, hasStack := err.(withStackAware)
 	if !hasStack {
 		return false
@@ -201,7 +201,7 @@ func Annotate(err error, message string) error {
 	if err == nil {
 		return nil
 	}
-	hasStack := hasStack(err)
+	hasStack := errHasStack(err)
 	err = &withMessage{
 		cause:         err,
 		msg:           message,
@@ -223,7 +223,7 @@ func Annotatef(err error, format string, args ...interface{}) error {
 	if err == nil {
 		return nil
 	}
-	hasStack := hasStack(err)
+	hasStack := errHasStack(err)
 	err = &withMessage{
 		cause:         err,
 		msg:           fmt.Sprintf(format, args...),
@@ -247,7 +247,7 @@ func WithMessage(err error, message string) error {
 	return &withMessage{
 		cause:         err,
 		msg:           message,
-		causeHasStack: hasStack(err),
+		causeHasStack: errHasStack(err),
 	}
 }
 
diff --git a/juju_adaptor.go b/juju_adaptor.go
index e8e5ff0..57b2ec8 100644
--- a/juju_adaptor.go
+++ b/juju_adaptor.go
@@ -12,7 +12,7 @@ func Trace(err error) error {
 	if err == nil {
 		return nil
 	}
-	if hasStack(err) {
+	if errHasStack(err) {
 		return err
 	}
 	return &withStack{

From e7859cb4cc347a9520ea840b730b1078429a2a4a Mon Sep 17 00:00:00 2001
From: robi <sulifx@gmail.com>
Date: Wed, 5 Sep 2018 16:53:39 +0800
Subject: [PATCH 04/18] address comment

---
 juju_adaptor.go | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/juju_adaptor.go b/juju_adaptor.go
index 57b2ec8..3c5590b 100644
--- a/juju_adaptor.go
+++ b/juju_adaptor.go
@@ -1,6 +1,8 @@
 package errors
 
 import (
+	"fmt"
+
 	log "github.com/sirupsen/logrus"
 )
 
@@ -21,6 +23,15 @@ func Trace(err error) error {
 	}
 }
 
+// error passed as the parameter is not an annotated error, the result is		 // error passed as the parameter is not an annotated error, the result is
+// simply the result of the Error() method on that error.		 // simply the result of the Error() method on that error.
+func ErrorStack(err error) string {
+	if err == nil {
+		return ""
+	}
+	return fmt.Sprintf("%+v", err)
+}
+
 // Wrap changes the Cause of the error, old error stack also be output.
 func Wrap(oldErr, newErr error) error {
 	log.Errorf("%+v", oldErr)

From 35194dca656e45bc5536809346b8cbe2b3959e89 Mon Sep 17 00:00:00 2001
From: robi <sulifx@gmail.com>
Date: Wed, 5 Sep 2018 17:23:22 +0800
Subject: [PATCH 05/18] address comment

---
 format_test.go | 104 ++++++++++++++++++++++++-------------------------
 1 file changed, 52 insertions(+), 52 deletions(-)

diff --git a/format_test.go b/format_test.go
index f809935..306e088 100644
--- a/format_test.go
+++ b/format_test.go
@@ -305,58 +305,58 @@ func TestFormatWithMessage(t *testing.T) {
 	}
 }
 
-//func TestFormatGeneric(t *testing.T) {
-//	starts := []struct {
-//		err  error
-//		want []string
-//	}{
-//		{New("new-error"), []string{
-//			"new-error",
-//			"github.com/pingcap/errors.TestFormatGeneric\n" +
-//				"\t.+/github.com/pingcap/errors/format_test.go:313"},
-//		}, {Errorf("errorf-error"), []string{
-//			"errorf-error",
-//			"github.com/pingcap/errors.TestFormatGeneric\n" +
-//				"\t.+/github.com/pingcap/errors/format_test.go:317"},
-//		}, {errors.New("errors-new-error"), []string{
-//			"errors-new-error"},
-//		},
-//	}
-//
-//	wrappers := []wrapper{
-//		{
-//			func(err error) error { return WithMessage(err, "with-message") },
-//			[]string{"with-message"},
-//		}, {
-//			func(err error) error { return WithStack(err) },
-//			[]string{
-//				"github.com/pingcap/errors.(func·002|TestFormatGeneric.func2)\n\t" +
-//					".+/github.com/pingcap/errors/format_test.go:331",
-//			},
-//		}, {
-//			func(err error) error { return Annotate(err, "wrap-error") },
-//			[]string{
-//				"wrap-error",
-//				"github.com/pingcap/errors.(func·003|TestFormatGeneric.func3)\n\t" +
-//					".+/github.com/pingcap/errors/format_test.go:337",
-//			},
-//		}, {
-//			func(err error) error { return Annotatef(err, "wrapf-error%d", 1) },
-//			[]string{
-//				"wrapf-error1",
-//				"github.com/pingcap/errors.(func·004|TestFormatGeneric.func4)\n\t" +
-//					".+/github.com/pingcap/errors/format_test.go:346",
-//			},
-//		},
-//	}
-//
-//	for s := range starts {
-//		err := starts[s].err
-//		want := starts[s].want
-//		testFormatCompleteCompare(t, s, err, "%+v", want, false)
-//		testGenericRecursive(t, err, want, wrappers, 3)
-//	}
-//}
+/*func TestFormatGeneric(t *testing.T) {
+	starts := []struct {
+		err  error
+		want []string
+	}{
+		{New("new-error"), []string{
+			"new-error",
+			"github.com/pingcap/errors.TestFormatGeneric\n" +
+				"\t.+/github.com/pingcap/errors/format_test.go:313"},
+		}, {Errorf("errorf-error"), []string{
+			"errorf-error",
+			"github.com/pingcap/errors.TestFormatGeneric\n" +
+				"\t.+/github.com/pingcap/errors/format_test.go:317"},
+		}, {errors.New("errors-new-error"), []string{
+			"errors-new-error"},
+		},
+	}
+
+	wrappers := []wrapper{
+		{
+			func(err error) error { return WithMessage(err, "with-message") },
+			[]string{"with-message"},
+		}, {
+			func(err error) error { return WithStack(err) },
+			[]string{
+				"github.com/pingcap/errors.(func·002|TestFormatGeneric.func2)\n\t" +
+					".+/github.com/pingcap/errors/format_test.go:331",
+			},
+		}, {
+			func(err error) error { return Annotate(err, "wrap-error") },
+			[]string{
+				"wrap-error",
+				"github.com/pingcap/errors.(func·003|TestFormatGeneric.func3)\n\t" +
+					".+/github.com/pingcap/errors/format_test.go:337",
+			},
+		}, {
+			func(err error) error { return Annotatef(err, "wrapf-error%d", 1) },
+			[]string{
+				"wrapf-error1",
+				"github.com/pingcap/errors.(func·004|TestFormatGeneric.func4)\n\t" +
+					".+/github.com/pingcap/errors/format_test.go:346",
+			},
+		},
+	}
+
+	for s := range starts {
+		err := starts[s].err
+		want := starts[s].want
+		testFormatCompleteCompare(t, s, err, "%+v", want, false)
+		testGenericRecursive(t, err, want, wrappers, 3)
+	}
+}*/
 
 func testFormatRegexp(t *testing.T, n int, arg interface{}, format, want string) {
 	got := fmt.Sprintf(format, arg)

From f28c952c480d2cb01e74ab6743ed9757417b04d5 Mon Sep 17 00:00:00 2001
From: Greg Weber <greg@gregweber.info>
Date: Wed, 5 Sep 2018 09:31:13 -0700
Subject: [PATCH 06/18] remove logging

---
 juju_adaptor.go | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/juju_adaptor.go b/juju_adaptor.go
index 3c5590b..35f4fd9 100644
--- a/juju_adaptor.go
+++ b/juju_adaptor.go
@@ -2,8 +2,6 @@ package errors
 
 import (
 	"fmt"
-
-	log "github.com/sirupsen/logrus"
 )
 
 // ==================== juju adaptor start ========================
@@ -34,7 +32,6 @@ func ErrorStack(err error) string {
 
 // Wrap changes the Cause of the error, old error stack also be output.
 func Wrap(oldErr, newErr error) error {
-	log.Errorf("%+v", oldErr)
 	return Trace(newErr)
 }
 

From 1953f98e3f4dbd8cd60401a51da3e6f3b8a90f56 Mon Sep 17 00:00:00 2001
From: Greg Weber <greg@gregweber.info>
Date: Wed, 5 Sep 2018 10:32:38 -0700
Subject: [PATCH 07/18] don't change the pkg/errors interface

---
 errors.go       | 18 ++++++++----------
 juju_adaptor.go | 42 +++++++++++++++++++++++++++++++-----------
 2 files changed, 39 insertions(+), 21 deletions(-)

diff --git a/errors.go b/errors.go
index 437ecd7..edb11c7 100644
--- a/errors.go
+++ b/errors.go
@@ -194,10 +194,12 @@ func (w *withStack) hasStack() bool {
 	return true
 }
 
-// Annotate returns an error annotating err with a stack trace
+// Wrap returns an error annotating err with a stack trace
 // at the point Annotate is called, and the supplied message.
 // If err is nil, Annotate returns nil.
-func Annotate(err error, message string) error {
+//
+// Deprecated: use Annotate instead
+func Wrap(err error, message string) error {
 	if err == nil {
 		return nil
 	}
@@ -207,19 +209,18 @@ func Annotate(err error, message string) error {
 		msg:           message,
 		causeHasStack: hasStack,
 	}
-	if hasStack {
-		return err
-	}
 	return &withStack{
 		err,
 		callers(),
 	}
 }
 
-// Annotatef returns an error annotating err with a stack trace
+// Wrapf returns an error annotating err with a stack trace
 // at the point Annotatef is call, and the format specifier.
 // If err is nil, Annotatef returns nil.
-func Annotatef(err error, format string, args ...interface{}) error {
+//
+// Deprecated: use Annotatef instead
+func Wrapf(err error, format string, args ...interface{}) error {
 	if err == nil {
 		return nil
 	}
@@ -229,9 +230,6 @@ func Annotatef(err error, format string, args ...interface{}) error {
 		msg:           fmt.Sprintf(format, args...),
 		causeHasStack: hasStack,
 	}
-	if hasStack {
-		return err
-	}
 	return &withStack{
 		err,
 		callers(),
diff --git a/juju_adaptor.go b/juju_adaptor.go
index 3c5590b..4150282 100644
--- a/juju_adaptor.go
+++ b/juju_adaptor.go
@@ -2,8 +2,6 @@ package errors
 
 import (
 	"fmt"
-
-	log "github.com/sirupsen/logrus"
 )
 
 // ==================== juju adaptor start ========================
@@ -11,10 +9,39 @@ import (
 // Trace annotates err with a stack trace at the point WithStack was called.
 // If err is nil or already contain stack trace return directly.
 func Trace(err error) error {
+	return AddStack(err)
+}
+
+func Annotate(err error, message string) error {
+	if err == nil {
+		return nil
+	}
+	hasStack := errHasStack(err)
+	err = &withMessage{
+		cause:         err,
+		msg:           message,
+		causeHasStack: hasStack,
+	}
+	if hasStack {
+		return err
+	}
+	return &withStack{
+		err,
+		callers(),
+	}
+}
+
+func Annotatef(err error, format string, args ...interface{}) error {
 	if err == nil {
 		return nil
 	}
-	if errHasStack(err) {
+	hasStack := errHasStack(err)
+	err = &withMessage{
+		cause:         err,
+		msg:           fmt.Sprintf(format, args...),
+		causeHasStack: hasStack,
+	}
+	if hasStack {
 		return err
 	}
 	return &withStack{
@@ -23,8 +50,7 @@ func Trace(err error) error {
 	}
 }
 
-// error passed as the parameter is not an annotated error, the result is		 // error passed as the parameter is not an annotated error, the result is
-// simply the result of the Error() method on that error.		 // simply the result of the Error() method on that error.
+// ErrorStack will format a stack trace if it is available, otherwise it will be Error()
 func ErrorStack(err error) string {
 	if err == nil {
 		return ""
@@ -32,12 +58,6 @@ func ErrorStack(err error) string {
 	return fmt.Sprintf("%+v", err)
 }
 
-// Wrap changes the Cause of the error, old error stack also be output.
-func Wrap(oldErr, newErr error) error {
-	log.Errorf("%+v", oldErr)
-	return Trace(newErr)
-}
-
 // NotFoundf represents an error with not found message.
 func NotFoundf(format string, args ...interface{}) error {
 	return Errorf(format+" not found", args...)

From 036cd12f617033c23c5c9b1759fb741bb72586c4 Mon Sep 17 00:00:00 2001
From: Greg Weber <greg@gregweber.info>
Date: Wed, 5 Sep 2018 11:06:28 -0700
Subject: [PATCH 08/18] some renames and use GetStackTracer

---
 errors.go       | 29 ++++++++++++-----------------
 juju_adaptor.go |  4 ++--
 2 files changed, 14 insertions(+), 19 deletions(-)

diff --git a/errors.go b/errors.go
index edb11c7..ee53a8c 100644
--- a/errors.go
+++ b/errors.go
@@ -115,16 +115,19 @@ func Errorf(format string, args ...interface{}) error {
 	}
 }
 
-type withStackAware interface {
+// StackTraceAware is an optimization to avoid repetitive traversals of an error chain.
+// HasStack checks for this marker first.
+// Annotate/Wrap and Annotatef/Wrapf will produce this marker.
+type StackTraceAware interface {
 	hasStack() bool
 }
 
-func errHasStack(err error) bool {
-	errWithStack, hasStack := err.(withStackAware)
-	if !hasStack {
-		return false
+// HasStack tells whether a StackTracer exists in the error chain
+func HasStack(err error) bool {
+	if errWithStack, ok := err.(StackTraceAware); ok {
+		return errWithStack.hasStack()
 	}
-	return errWithStack.hasStack()
+	return GetStackTracer(err) != nil
 }
 
 // fundamental is an error that has a message and a stack, but no caller.
@@ -151,10 +154,6 @@ func (f *fundamental) Format(s fmt.State, verb rune) {
 	}
 }
 
-func (f *fundamental) hasStack() bool {
-	return true
-}
-
 // WithStack annotates err with a stack trace at the point WithStack was called.
 // If err is nil, WithStack returns nil.
 func WithStack(err error) error {
@@ -190,10 +189,6 @@ func (w *withStack) Format(s fmt.State, verb rune) {
 	}
 }
 
-func (w *withStack) hasStack() bool {
-	return true
-}
-
 // Wrap returns an error annotating err with a stack trace
 // at the point Annotate is called, and the supplied message.
 // If err is nil, Annotate returns nil.
@@ -203,7 +198,7 @@ func Wrap(err error, message string) error {
 	if err == nil {
 		return nil
 	}
-	hasStack := errHasStack(err)
+	hasStack := HasStack(err)
 	err = &withMessage{
 		cause:         err,
 		msg:           message,
@@ -224,7 +219,7 @@ func Wrapf(err error, format string, args ...interface{}) error {
 	if err == nil {
 		return nil
 	}
-	hasStack := errHasStack(err)
+	hasStack := HasStack(err)
 	err = &withMessage{
 		cause:         err,
 		msg:           fmt.Sprintf(format, args...),
@@ -245,7 +240,7 @@ func WithMessage(err error, message string) error {
 	return &withMessage{
 		cause:         err,
 		msg:           message,
-		causeHasStack: errHasStack(err),
+		causeHasStack: HasStack(err),
 	}
 }
 
diff --git a/juju_adaptor.go b/juju_adaptor.go
index 4150282..773a197 100644
--- a/juju_adaptor.go
+++ b/juju_adaptor.go
@@ -16,7 +16,7 @@ func Annotate(err error, message string) error {
 	if err == nil {
 		return nil
 	}
-	hasStack := errHasStack(err)
+	hasStack := HasStack(err)
 	err = &withMessage{
 		cause:         err,
 		msg:           message,
@@ -35,7 +35,7 @@ func Annotatef(err error, format string, args ...interface{}) error {
 	if err == nil {
 		return nil
 	}
-	hasStack := errHasStack(err)
+	hasStack := HasStack(err)
 	err = &withMessage{
 		cause:         err,
 		msg:           fmt.Sprintf(format, args...),

From 2a9170a3203de5f9512198a5a66c9d2aeb9e852e Mon Sep 17 00:00:00 2001
From: Greg Weber <greg@gregweber.info>
Date: Tue, 4 Sep 2018 16:39:29 -0700
Subject: [PATCH 09/18] avoid creating duplicate stack traces

This is done by using the new AddStack function instead of WithStack.
There is also a StackError utility function exposed.
---
 errors.go      | 45 ++++++++++++++++++++++++++++++----------
 errors_test.go | 56 ++++++++++++++++++++++++++++++++++++++++++++++++++
 stack.go       |  6 ++++++
 3 files changed, 96 insertions(+), 11 deletions(-)

diff --git a/errors.go b/errors.go
index ee53a8c..2eacad0 100644
--- a/errors.go
+++ b/errors.go
@@ -65,12 +65,7 @@
 // Retrieving the stack trace of an error or wrapper
 //
 // New, Errorf, Wrap, and Wrapf record a stack trace at the point they are
-// invoked. This information can be retrieved with the following interface.
-//
-//     type stackTracer interface {
-//             StackTrace() errors.StackTrace
-//     }
-//
+// invoked. This information can be retrieved with the StackTracer interface that returns a StackTrace.
 // Where errors.StackTrace is defined as
 //
 //     type StackTrace []Frame
@@ -79,15 +74,12 @@
 // the fmt.Formatter interface that can be used for printing information about
 // the stack trace of this error. For example:
 //
-//     if err, ok := err.(stackTracer); ok {
-//             for _, f := range err.StackTrace() {
+//     if stacked := errors.GetStackTracer(err); stacked != nil {
+//             for _, f := range stacked.StackTrace() {
 //                     fmt.Printf("%+s:%d", f)
 //             }
 //     }
 //
-// stackTracer interface is not exported by this package, but is considered a part
-// of stable public API.
-//
 // See the documentation for Frame.Format for more details.
 package errors
 
@@ -160,12 +152,43 @@ func WithStack(err error) error {
 	if err == nil {
 		return nil
 	}
+
 	return &withStack{
 		err,
 		callers(),
 	}
 }
 
+// AddStack is similar to WithStack.
+// However, it will first check with HasStack to see if a stack trace already exists in the causer chain before creating another one.
+func AddStack(err error) error {
+	if HasStack(err) {
+		return err
+	}
+	return WithStack(err)
+}
+
+// GetStackTracer will return the first StackTracer in the causer chain.
+// This function is used by AddStack to avoid creating redundant stack traces.
+//
+// You can also use the StackTracer interface on the returned error to get the stack trace.
+func GetStackTracer(err error) StackTracer {
+	type causer interface {
+		Cause() error
+	}
+	for err != nil {
+		if stacked, ok := err.(StackTracer); ok {
+			return stacked
+		}
+		cause, ok := err.(causer)
+		if !ok {
+			return nil
+		}
+		err = cause.Cause()
+	}
+	return nil
+}
+
 type withStack struct {
 	error
 	*stack
diff --git a/errors_test.go b/errors_test.go
index c9c5127..91d8462 100644
--- a/errors_test.go
+++ b/errors_test.go
@@ -96,6 +96,12 @@ func TestCause(t *testing.T) {
 	}, {
 		WithStack(io.EOF),
 		io.EOF,
+	}, {
+		AddStack(nil),
+		nil,
+	}, {
+		AddStack(io.EOF),
+		io.EOF,
 	}}
 
 	for i, tt := range tests {
@@ -154,6 +160,10 @@ func TestWithStackNil(t *testing.T) {
 	if got != nil {
 		t.Errorf("WithStack(nil): got %#v, expected nil", got)
 	}
+	got = AddStack(nil)
+	if got != nil {
+		t.Errorf("AddStack(nil): got %#v, expected nil", got)
+	}
 }
 
 func TestWithStack(t *testing.T) {
@@ -173,6 +183,50 @@ func TestWithStack(t *testing.T) {
 	}
 }
 
+func TestAddStack(t *testing.T) {
+	tests := []struct {
+		err  error
+		want string
+	}{
+		{io.EOF, "EOF"},
+		{AddStack(io.EOF), "EOF"},
+	}
+
+	for _, tt := range tests {
+		got := AddStack(tt.err).Error()
+		if got != tt.want {
+			t.Errorf("AddStack(%v): got: %v, want %v", tt.err, got, tt.want)
+		}
+	}
+}
+
+func TestGetStackTracer(t *testing.T) {
+	orig := io.EOF
+	if GetStackTracer(orig) != nil {
+		t.Errorf("GetStackTracer: got: %v, want %v", GetStackTracer(orig), nil)
+	}
+	stacked := AddStack(orig)
+	if GetStackTracer(stacked).(error) != stacked {
+		t.Errorf("GetStackTracer(stacked): got: %v, want %v", GetStackTracer(stacked), stacked)
+	}
+	final := AddStack(stacked)
+	if GetStackTracer(final).(error) != stacked {
+		t.Errorf("GetStackTracer(final): got: %v, want %v", GetStackTracer(final), stacked)
+	}
+}
+
+func TestAddStackDedup(t *testing.T) {
+	stacked := WithStack(io.EOF)
+	err := AddStack(stacked)
+	if err != stacked {
+		t.Errorf("AddStack: got: %+v, want %+v", err, stacked)
+	}
+	err = WithStack(stacked)
+	if err == stacked {
+		t.Errorf("WithStack: got: %v, don't want %v", err, stacked)
+	}
+}
+
 func TestWithMessageNil(t *testing.T) {
 	got := WithMessage(nil, "no error")
 	if got != nil {
@@ -215,6 +269,8 @@ func TestErrorEquality(t *testing.T) {
 		WithMessage(io.EOF, "whoops"),
 		WithStack(io.EOF),
 		WithStack(nil),
+		AddStack(io.EOF),
+		AddStack(nil),
 	}
 
 	for i := range vals {
diff --git a/stack.go b/stack.go
index 2874a04..f01dd86 100644
--- a/stack.go
+++ b/stack.go
@@ -8,6 +8,12 @@ import (
 	"strings"
 )
 
+// StackTracer retrieves the StackTrace
+// Generally you would want to use the GetStackTracer function to do that.
+type StackTracer interface {
+	StackTrace() StackTrace
+}
+
 // Frame represents a program counter inside a stack frame.
 type Frame uintptr
 

From 70a3293a24ac35c572158e307587c6be55868ba8 Mon Sep 17 00:00:00 2001
From: Greg Weber <greg@gregweber.info>
Date: Wed, 5 Sep 2018 11:16:45 -0700
Subject: [PATCH 10/18] keep tests as pkg/errors

---
 format_test.go | 108 ++++++++++++++++++++++++-------------------------
 stack_test.go  |  50 +++++++++++------------
 2 files changed, 79 insertions(+), 79 deletions(-)

diff --git a/format_test.go b/format_test.go
index 306e088..f4f6059 100644
--- a/format_test.go
+++ b/format_test.go
@@ -26,8 +26,8 @@ func TestFormatNew(t *testing.T) {
 		New("error"),
 		"%+v",
 		"error\n" +
-			"github.com/pingcap/errors.TestFormatNew\n" +
-			"\t.+/github.com/pingcap/errors/format_test.go:26",
+			"github.com/pkg/errors.TestFormatNew\n" +
+			"\t.+/github.com/pkg/errors/format_test.go:26",
 	}, {
 		New("error"),
 		"%q",
@@ -56,8 +56,8 @@ func TestFormatErrorf(t *testing.T) {
 		Errorf("%s", "error"),
 		"%+v",
 		"error\n" +
-			"github.com/pingcap/errors.TestFormatErrorf\n" +
-			"\t.+/github.com/pingcap/errors/format_test.go:56",
+			"github.com/pkg/errors.TestFormatErrorf\n" +
+			"\t.+/github.com/pkg/errors/format_test.go:56",
 	}}
 
 	for i, tt := range tests {
@@ -82,8 +82,8 @@ func TestFormatWrap(t *testing.T) {
 		Annotate(New("error"), "error2"),
 		"%+v",
 		"error\n" +
-			"github.com/pingcap/errors.TestFormatWrap\n" +
-			"\t.+/github.com/pingcap/errors/format_test.go:82",
+			"github.com/pkg/errors.TestFormatWrap\n" +
+			"\t.+/github.com/pkg/errors/format_test.go:82",
 	}, {
 		Annotate(io.EOF, "error"),
 		"%s",
@@ -97,15 +97,15 @@ func TestFormatWrap(t *testing.T) {
 		"%+v",
 		"EOF\n" +
 			"error\n" +
-			"github.com/pingcap/errors.TestFormatWrap\n" +
-			"\t.+/github.com/pingcap/errors/format_test.go:96",
+			"github.com/pkg/errors.TestFormatWrap\n" +
+			"\t.+/github.com/pkg/errors/format_test.go:96",
 	}, {
 		Annotate(Annotate(io.EOF, "error1"), "error2"),
 		"%+v",
 		"EOF\n" +
 			"error1\n" +
-			"github.com/pingcap/errors.TestFormatWrap\n" +
-			"\t.+/github.com/pingcap/errors/format_test.go:103\n",
+			"github.com/pkg/errors.TestFormatWrap\n" +
+			"\t.+/github.com/pkg/errors/format_test.go:103\n",
 	}, {
 		Annotate(New("error with space"), "context"),
 		"%q",
@@ -135,8 +135,8 @@ func TestFormatWrapf(t *testing.T) {
 		"%+v",
 		"EOF\n" +
 			"error2\n" +
-			"github.com/pingcap/errors.TestFormatWrapf\n" +
-			"\t.+/github.com/pingcap/errors/format_test.go:134",
+			"github.com/pkg/errors.TestFormatWrapf\n" +
+			"\t.+/github.com/pkg/errors/format_test.go:134",
 	}, {
 		Annotatef(New("error"), "error%d", 2),
 		"%s",
@@ -149,8 +149,8 @@ func TestFormatWrapf(t *testing.T) {
 		Annotatef(New("error"), "error%d", 2),
 		"%+v",
 		"error\n" +
-			"github.com/pingcap/errors.TestFormatWrapf\n" +
-			"\t.+/github.com/pingcap/errors/format_test.go:149",
+			"github.com/pkg/errors.TestFormatWrapf\n" +
+			"\t.+/github.com/pkg/errors/format_test.go:149",
 	}}
 
 	for i, tt := range tests {
@@ -175,8 +175,8 @@ func TestFormatWithStack(t *testing.T) {
 		WithStack(io.EOF),
 		"%+v",
 		[]string{"EOF",
-			"github.com/pingcap/errors.TestFormatWithStack\n" +
-				"\t.+/github.com/pingcap/errors/format_test.go:175"},
+			"github.com/pkg/errors.TestFormatWithStack\n" +
+				"\t.+/github.com/pkg/errors/format_test.go:175"},
 	}, {
 		WithStack(New("error")),
 		"%s",
@@ -189,37 +189,37 @@ func TestFormatWithStack(t *testing.T) {
 		WithStack(New("error")),
 		"%+v",
 		[]string{"error",
-			"github.com/pingcap/errors.TestFormatWithStack\n" +
-				"\t.+/github.com/pingcap/errors/format_test.go:189",
-			"github.com/pingcap/errors.TestFormatWithStack\n" +
-				"\t.+/github.com/pingcap/errors/format_test.go:189"},
+			"github.com/pkg/errors.TestFormatWithStack\n" +
+				"\t.+/github.com/pkg/errors/format_test.go:189",
+			"github.com/pkg/errors.TestFormatWithStack\n" +
+				"\t.+/github.com/pkg/errors/format_test.go:189"},
 	}, {
 		WithStack(WithStack(io.EOF)),
 		"%+v",
 		[]string{"EOF",
-			"github.com/pingcap/errors.TestFormatWithStack\n" +
-				"\t.+/github.com/pingcap/errors/format_test.go:197",
-			"github.com/pingcap/errors.TestFormatWithStack\n" +
-				"\t.+/github.com/pingcap/errors/format_test.go:197"},
+			"github.com/pkg/errors.TestFormatWithStack\n" +
+				"\t.+/github.com/pkg/errors/format_test.go:197",
+			"github.com/pkg/errors.TestFormatWithStack\n" +
+				"\t.+/github.com/pkg/errors/format_test.go:197"},
 	}, {
 		WithStack(WithStack(Annotatef(io.EOF, "message"))),
 		"%+v",
 		[]string{"EOF",
 			"message",
-			"github.com/pingcap/errors.TestFormatWithStack\n" +
-				"\t.+/github.com/pingcap/errors/format_test.go:205",
-			"github.com/pingcap/errors.TestFormatWithStack\n" +
-				"\t.+/github.com/pingcap/errors/format_test.go:205",
-			"github.com/pingcap/errors.TestFormatWithStack\n" +
-				"\t.+/github.com/pingcap/errors/format_test.go:205"},
+			"github.com/pkg/errors.TestFormatWithStack\n" +
+				"\t.+/github.com/pkg/errors/format_test.go:205",
+			"github.com/pkg/errors.TestFormatWithStack\n" +
+				"\t.+/github.com/pkg/errors/format_test.go:205",
+			"github.com/pkg/errors.TestFormatWithStack\n" +
+				"\t.+/github.com/pkg/errors/format_test.go:205"},
 	}, {
 		WithStack(Errorf("error%d", 1)),
 		"%+v",
 		[]string{"error1",
-			"github.com/pingcap/errors.TestFormatWithStack\n" +
-				"\t.+/github.com/pingcap/errors/format_test.go:216",
-			"github.com/pingcap/errors.TestFormatWithStack\n" +
-				"\t.+/github.com/pingcap/errors/format_test.go:216"},
+			"github.com/pkg/errors.TestFormatWithStack\n" +
+				"\t.+/github.com/pkg/errors/format_test.go:216",
+			"github.com/pkg/errors.TestFormatWithStack\n" +
+				"\t.+/github.com/pkg/errors/format_test.go:216"},
 	}}
 
 	for i, tt := range tests {
@@ -245,8 +245,8 @@ func TestFormatWithMessage(t *testing.T) {
 		"%+v",
 		[]string{
 			"error",
-			"github.com/pingcap/errors.TestFormatWithMessage\n" +
-				"\t.+/github.com/pingcap/errors/format_test.go:244",
+			"github.com/pkg/errors.TestFormatWithMessage\n" +
+				"\t.+/github.com/pkg/errors/format_test.go:244",
 			"error2"},
 	}, {
 		WithMessage(io.EOF, "addition1"),
@@ -272,30 +272,30 @@ func TestFormatWithMessage(t *testing.T) {
 		Annotate(WithMessage(io.EOF, "error1"), "error2"),
 		"%+v",
 		[]string{"EOF", "error1", "error2",
-			"github.com/pingcap/errors.TestFormatWithMessage\n" +
-				"\t.+/github.com/pingcap/errors/format_test.go:272"},
+			"github.com/pkg/errors.TestFormatWithMessage\n" +
+				"\t.+/github.com/pkg/errors/format_test.go:272"},
 	}, {
 		WithMessage(Errorf("error%d", 1), "error2"),
 		"%+v",
 		[]string{"error1",
-			"github.com/pingcap/errors.TestFormatWithMessage\n" +
-				"\t.+/github.com/pingcap/errors/format_test.go:278",
+			"github.com/pkg/errors.TestFormatWithMessage\n" +
+				"\t.+/github.com/pkg/errors/format_test.go:278",
 			"error2"},
 	}, {
 		WithMessage(WithStack(io.EOF), "error"),
 		"%+v",
 		[]string{
 			"EOF",
-			"github.com/pingcap/errors.TestFormatWithMessage\n" +
-				"\t.+/github.com/pingcap/errors/format_test.go:285",
+			"github.com/pkg/errors.TestFormatWithMessage\n" +
+				"\t.+/github.com/pkg/errors/format_test.go:285",
 			"error"},
 	}, {
 		WithMessage(Annotate(WithStack(io.EOF), "inside-error"), "outside-error"),
 		"%+v",
 		[]string{
 			"EOF",
-			"github.com/pingcap/errors.TestFormatWithMessage\n" +
-				"\t.+/github.com/pingcap/errors/format_test.go:293",
+			"github.com/pkg/errors.TestFormatWithMessage\n" +
+				"\t.+/github.com/pkg/errors/format_test.go:293",
 			"inside-error",
 			"outside-error"},
 	}}
@@ -312,12 +312,12 @@ func TestFormatWithMessage(t *testing.T) {
 	}{
 		{New("new-error"), []string{
 			"new-error",
-			"github.com/pingcap/errors.TestFormatGeneric\n" +
-				"\t.+/github.com/pingcap/errors/format_test.go:313"},
+			"github.com/pkg/errors.TestFormatGeneric\n" +
+				"\t.+/github.com/pkg/errors/format_test.go:313"},
 		}, {Errorf("errorf-error"), []string{
 			"errorf-error",
-			"github.com/pingcap/errors.TestFormatGeneric\n" +
-				"\t.+/github.com/pingcap/errors/format_test.go:317"},
+			"github.com/pkg/errors.TestFormatGeneric\n" +
+				"\t.+/github.com/pkg/errors/format_test.go:317"},
 		}, {errors.New("errors-new-error"), []string{
 			"errors-new-error"},
 		},
@@ -330,22 +330,22 @@ func TestFormatWithMessage(t *testing.T) {
 		}, {
 			func(err error) error { return WithStack(err) },
 			[]string{
-				"github.com/pingcap/errors.(func·002|TestFormatGeneric.func2)\n\t" +
-					".+/github.com/pingcap/errors/format_test.go:331",
+				"github.com/pkg/errors.(func·002|TestFormatGeneric.func2)\n\t" +
+					".+/github.com/pkg/errors/format_test.go:331",
 			},
 		}, {
 			func(err error) error { return Annotate(err, "wrap-error") },
 			[]string{
 				"wrap-error",
-				"github.com/pingcap/errors.(func·003|TestFormatGeneric.func3)\n\t" +
-					".+/github.com/pingcap/errors/format_test.go:337",
+				"github.com/pkg/errors.(func·003|TestFormatGeneric.func3)\n\t" +
+					".+/github.com/pkg/errors/format_test.go:337",
 			},
 		}, {
 			func(err error) error { return Annotatef(err, "wrapf-error%d", 1) },
 			[]string{
 				"wrapf-error1",
-				"github.com/pingcap/errors.(func·004|TestFormatGeneric.func4)\n\t" +
-					".+/github.com/pingcap/errors/format_test.go:346",
+				"github.com/pkg/errors.(func·004|TestFormatGeneric.func4)\n\t" +
+					".+/github.com/pkg/errors/format_test.go:346",
 			},
 		},
 	}
diff --git a/stack_test.go b/stack_test.go
index fcb6fd5..0a0a67a 100644
--- a/stack_test.go
+++ b/stack_test.go
@@ -65,8 +65,8 @@ func TestFrameFormat(t *testing.T) {
 	}, {
 		Frame(initpc),
 		"%+s",
-		"github.com/pingcap/errors.init\n" +
-			"\t.+/github.com/pingcap/errors/stack_test.go",
+		"github.com/pkg/errors.init\n" +
+			"\t.+/github.com/pkg/errors/stack_test.go",
 	}, {
 		Frame(0),
 		"%s",
@@ -112,8 +112,8 @@ func TestFrameFormat(t *testing.T) {
 	}, {
 		Frame(initpc),
 		"%+v",
-		"github.com/pingcap/errors.init\n" +
-			"\t.+/github.com/pingcap/errors/stack_test.go:9",
+		"github.com/pkg/errors.init\n" +
+			"\t.+/github.com/pkg/errors/stack_test.go:9",
 	}, {
 		Frame(0),
 		"%v",
@@ -131,7 +131,7 @@ func TestFuncname(t *testing.T) {
 	}{
 		{"", ""},
 		{"runtime.main", "main"},
-		{"github.com/pingcap/errors.funcname", "funcname"},
+		{"github.com/pkg/errors.funcname", "funcname"},
 		{"funcname", "funcname"},
 		{"io.copyBuffer", "copyBuffer"},
 		{"main.(*R).Write", "(*R).Write"},
@@ -152,25 +152,25 @@ func TestStackTrace(t *testing.T) {
 		want []string
 	}{{
 		New("ooh"), []string{
-			"github.com/pingcap/errors.TestStackTrace\n" +
-				"\t.+/github.com/pingcap/errors/stack_test.go:154",
+			"github.com/pkg/errors.TestStackTrace\n" +
+				"\t.+/github.com/pkg/errors/stack_test.go:154",
 		},
 	}, {
 		Annotate(New("ooh"), "ahh"), []string{
-			"github.com/pingcap/errors.TestStackTrace\n" +
-				"\t.+/github.com/pingcap/errors/stack_test.go:159", // this is the stack of Wrap, not New
+			"github.com/pkg/errors.TestStackTrace\n" +
+				"\t.+/github.com/pkg/errors/stack_test.go:159", // this is the stack of Wrap, not New
 		},
 	}, {
 		Cause(Annotate(New("ooh"), "ahh")), []string{
-			"github.com/pingcap/errors.TestStackTrace\n" +
-				"\t.+/github.com/pingcap/errors/stack_test.go:164", // this is the stack of New
+			"github.com/pkg/errors.TestStackTrace\n" +
+				"\t.+/github.com/pkg/errors/stack_test.go:164", // this is the stack of New
 		},
 	}, {
 		func() error { return New("ooh") }(), []string{
-			`github.com/pingcap/errors.(func·009|TestStackTrace.func1)` +
-				"\n\t.+/github.com/pingcap/errors/stack_test.go:169", // this is the stack of New
-			"github.com/pingcap/errors.TestStackTrace\n" +
-				"\t.+/github.com/pingcap/errors/stack_test.go:169", // this is the stack of New's caller
+			`github.com/pkg/errors.(func·009|TestStackTrace.func1)` +
+				"\n\t.+/github.com/pkg/errors/stack_test.go:169", // this is the stack of New
+			"github.com/pkg/errors.TestStackTrace\n" +
+				"\t.+/github.com/pkg/errors/stack_test.go:169", // this is the stack of New's caller
 		},
 	}, {
 		Cause(func() error {
@@ -178,12 +178,12 @@ func TestStackTrace(t *testing.T) {
 				return Errorf("hello %s", fmt.Sprintf("world"))
 			}()
 		}()), []string{
-			`github.com/pingcap/errors.(func·010|TestStackTrace.func2.1)` +
-				"\n\t.+/github.com/pingcap/errors/stack_test.go:178", // this is the stack of Errorf
-			`github.com/pingcap/errors.(func·011|TestStackTrace.func2)` +
-				"\n\t.+/github.com/pingcap/errors/stack_test.go:179", // this is the stack of Errorf's caller
-			"github.com/pingcap/errors.TestStackTrace\n" +
-				"\t.+/github.com/pingcap/errors/stack_test.go:180", // this is the stack of Errorf's caller's caller
+			`github.com/pkg/errors.(func·010|TestStackTrace.func2.1)` +
+				"\n\t.+/github.com/pkg/errors/stack_test.go:178", // this is the stack of Errorf
+			`github.com/pkg/errors.(func·011|TestStackTrace.func2)` +
+				"\n\t.+/github.com/pkg/errors/stack_test.go:179", // this is the stack of Errorf's caller
+			"github.com/pkg/errors.TestStackTrace\n" +
+				"\t.+/github.com/pkg/errors/stack_test.go:180", // this is the stack of Errorf's caller's caller
 		},
 	}}
 	for i, tt := range tests {
@@ -268,10 +268,10 @@ func TestStackTraceFormat(t *testing.T) {
 		stackTrace()[:2],
 		"%+v",
 		"\n" +
-			"github.com/pingcap/errors.stackTrace\n" +
-			"\t.+/github.com/pingcap/errors/stack_test.go:217\n" +
-			"github.com/pingcap/errors.TestStackTraceFormat\n" +
-			"\t.+/github.com/pingcap/errors/stack_test.go:268",
+			"github.com/pkg/errors.stackTrace\n" +
+			"\t.+/github.com/pkg/errors/stack_test.go:217\n" +
+			"github.com/pkg/errors.TestStackTraceFormat\n" +
+			"\t.+/github.com/pkg/errors/stack_test.go:268",
 	}, {
 		stackTrace()[:2],
 		"%#v",

From 3397c8a66714049e46d587e4734ae8d7abb9a50c Mon Sep 17 00:00:00 2001
From: Greg Weber <greg@gregweber.info>
Date: Wed, 5 Sep 2018 11:35:46 -0700
Subject: [PATCH 11/18] fix tests

---
 format_test.go |  1 +
 stack_test.go  | 15 ++++-----------
 2 files changed, 5 insertions(+), 11 deletions(-)

diff --git a/format_test.go b/format_test.go
index f4f6059..30275a3 100644
--- a/format_test.go
+++ b/format_test.go
@@ -359,6 +359,7 @@ func TestFormatWithMessage(t *testing.T) {
 }*/
 
 func testFormatRegexp(t *testing.T, n int, arg interface{}, format, want string) {
+	t.Helper()
 	got := fmt.Sprintf(format, arg)
 	gotLines := strings.SplitN(got, "\n", -1)
 	wantLines := strings.SplitN(want, "\n", -1)
diff --git a/stack_test.go b/stack_test.go
index 0a0a67a..0b4ee98 100644
--- a/stack_test.go
+++ b/stack_test.go
@@ -187,13 +187,6 @@ func TestStackTrace(t *testing.T) {
 		},
 	}}
 	for i, tt := range tests {
-		_, ok := tt.err.(interface {
-			hasStack() bool
-		})
-		if !ok {
-			t.Errorf("expected %#v to implement StackTrace() StackTrace %v", tt.err, tt.want)
-			continue
-		}
 		ste, ok := tt.err.(interface {
 			StackTrace() StackTrace
 		})
@@ -263,19 +256,19 @@ func TestStackTraceFormat(t *testing.T) {
 	}, {
 		stackTrace()[:2],
 		"%v",
-		`[stack_test.go:217 stack_test.go:276]`,
+		`[stack_test.go:207 stack_test.go:254]`,
 	}, {
 		stackTrace()[:2],
 		"%+v",
 		"\n" +
 			"github.com/pkg/errors.stackTrace\n" +
-			"\t.+/github.com/pkg/errors/stack_test.go:217\n" +
+			"\t.+/github.com/pkg/errors/stack_test.go:210\n" +
 			"github.com/pkg/errors.TestStackTraceFormat\n" +
-			"\t.+/github.com/pkg/errors/stack_test.go:268",
+			"\t.+/github.com/pkg/errors/stack_test.go:261",
 	}, {
 		stackTrace()[:2],
 		"%#v",
-		`\[\]errors.Frame{stack_test.go:217, stack_test.go:276}`,
+		`\[\]errors.Frame{stack_test.go:210, stack_test.go:269}`,
 	}}
 
 	for i, tt := range tests {

From 831aa374bfd9d30b1a06dcce8cde503718d6028e Mon Sep 17 00:00:00 2001
From: Greg Weber <greg@gregweber.info>
Date: Wed, 5 Sep 2018 09:26:01 -0700
Subject: [PATCH 12/18] add an Unwrap function

---
 errors.go | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/errors.go b/errors.go
index 2eacad0..fe618f2 100644
--- a/errors.go
+++ b/errors.go
@@ -303,16 +303,21 @@ func (w *withMessage) Format(s fmt.State, verb rune) {
 // be returned. If the error is nil, nil will be returned without further
 // investigation.
 func Cause(err error) error {
+	cause := Unwrap(err)
+	if cause == nil {
+		return err
+	}
+	return Cause(cause)
+}
+
+// Unwrap uses causer to return the next error in the chain or nil.
+// This goes one-level deeper, whereas Cause goes as far as possible
+func Unwrap(err error) error {
 	type causer interface {
 		Cause() error
 	}
-
-	for err != nil {
-		cause, ok := err.(causer)
-		if !ok {
-			break
-		}
-		err = cause.Cause()
+	if unErr, ok := err.(causer); ok {
+		return unErr.Cause()
 	}
-	return err
+	return nil
 }

From 223d5a62fc0e0a027a64f6d70c47102fd7db5530 Mon Sep 17 00:00:00 2001
From: Greg Weber <greg@gregweber.info>
Date: Wed, 5 Sep 2018 09:26:44 -0700
Subject: [PATCH 13/18] add the ErrorGroup interface

---
 errors.go | 23 +++++++++--------------
 group.go  | 33 +++++++++++++++++++++++++++++++++
 2 files changed, 42 insertions(+), 14 deletions(-)
 create mode 100644 group.go

diff --git a/errors.go b/errors.go
index fe618f2..9e285b8 100644
--- a/errors.go
+++ b/errors.go
@@ -172,21 +172,16 @@ func AddStack(err error) error {
 // This function is used by AddStack to avoid creating redundant stack traces.
 //
 // You can also use the StackTracer interface on the returned error to get the stack trace.
-func GetStackTracer(err error) StackTracer {
-	type causer interface {
-		Cause() error
-	}
-	for err != nil {
-		if stacked, ok := err.(StackTracer); ok {
-			return stacked
+func GetStackTracer(origErr error) StackTracer {
+	var stacked StackTracer
+	WalkDeep(origErr, func(err error) bool {
+		if stackTracer, ok := err.(StackTracer); ok {
+			stacked = stackTracer
+			return true
 		}
-		cause, ok := err.(causer)
-		if !ok {
-			return nil
-		}
-		err = cause.Cause()
-	}
-	return nil
+		return false
+	})
+	return stacked
 }
 
 type withStack struct {
diff --git a/group.go b/group.go
new file mode 100644
index 0000000..d6e0711
--- /dev/null
+++ b/group.go
@@ -0,0 +1,33 @@
+package errors
+
+// ErrorGroup is an interface for multiple errors that are not a chain.
+// This happens for example when executing multiple operations in parallel.
+type ErrorGroup interface {
+	Errors() []error
+}
+
+// WalkDeep does a depth-first traversal of all errors.
+// Any ErrorGroup is traversed (after going deep).
+// The visitor function can return false to end the traversal early
+// In that case, WalkDeep will return false, otherwise true
+func WalkDeep(err error, visitor func(err error) bool) bool {
+	// Go deep
+	unErr := err
+	for unErr != nil {
+		if more := visitor(unErr); more == true {
+			return true
+		}
+		unErr = Unwrap(unErr)
+	}
+
+	// Go wide
+	if hasGroup, ok := err.(ErrorGroup); ok {
+		for _, err := range hasGroup.Errors() {
+			if more := WalkDeep(err, visitor); more == true {
+				return true
+			}
+		}
+	}
+
+	return true
+}

From e52310651d92064de8806894230cc2482a22a0b8 Mon Sep 17 00:00:00 2001
From: Greg Weber <greg@gregweber.info>
Date: Wed, 5 Sep 2018 12:18:08 -0700
Subject: [PATCH 14/18] add a Find function for searching an error chain

This is roughly (no generics) the Is function in the go 2 proposal
---
 errors.go      | 13 +++++++++++++
 errors_test.go | 33 +++++++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+)

diff --git a/errors.go b/errors.go
index 9e285b8..70ebc16 100644
--- a/errors.go
+++ b/errors.go
@@ -316,3 +316,16 @@ func Unwrap(err error) error {
 	}
 	return nil
 }
+
+// Find an error in the chain that matches a test function
+func Find(origErr error, test func(error) bool) error {
+	var foundErr error
+	WalkDeep(origErr, func(err error) bool {
+		if test(err) {
+			foundErr = err
+			return true
+		}
+		return false
+	})
+	return foundErr
+}
diff --git a/errors_test.go b/errors_test.go
index 91d8462..bcaebff 100644
--- a/errors_test.go
+++ b/errors_test.go
@@ -279,3 +279,36 @@ func TestErrorEquality(t *testing.T) {
 		}
 	}
 }
+
+func TestFind(t *testing.T) {
+	eNew := errors.New("error")
+	wrapped := Annotate(nilError{}, "nil")
+	tests := []struct {
+		err    error
+		finder func(error) bool
+		found  error
+	}{
+		{io.EOF, func(_ error) bool { return true }, io.EOF},
+		{io.EOF, func(_ error) bool { return false }, nil},
+		{io.EOF, func(err error) bool { return err == io.EOF }, io.EOF},
+		{io.EOF, func(err error) bool { return err != io.EOF }, nil},
+
+		{eNew, func(err error) bool { return true }, eNew},
+		{eNew, func(err error) bool { return false }, nil},
+
+		{nilError{}, func(err error) bool { return true }, nilError{}},
+		{nilError{}, func(err error) bool { return false }, nil},
+		{nilError{}, func(err error) bool { _, ok := err.(nilError); return ok }, nilError{}},
+
+		{wrapped, func(err error) bool { return true }, wrapped},
+		{wrapped, func(err error) bool { return false }, nil},
+		{wrapped, func(err error) bool { _, ok := err.(nilError); return ok }, nilError{}},
+	}
+
+	for _, tt := range tests {
+		got := Find(tt.err, tt.finder)
+		if got != tt.found {
+			t.Errorf("WithMessage(%v): got: %q, want %q", tt.err, got, tt.found)
+		}
+	}
+}

From df8a356bd953d32e01df9b255b8c4a10cd373c03 Mon Sep 17 00:00:00 2001
From: robi <sulifx@gmail.com>
Date: Thu, 6 Sep 2018 17:26:41 +0800
Subject: [PATCH 15/18] address comment

---
 errors.go | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/errors.go b/errors.go
index 70ebc16..f809e70 100644
--- a/errors.go
+++ b/errors.go
@@ -64,9 +64,9 @@
 //
 // Retrieving the stack trace of an error or wrapper
 //
-// New, Errorf, Wrap, and Wrapf record a stack trace at the point they are
-// invoked. This information can be retrieved with the StackTracer interface that returns a StackTrace.
-// Where errors.StackTrace is defined as
+// New, Errorf, Wrap, and Wrapf record a stack trace at the point they are invoked.
+// This information can be retrieved with the StackTracer interface that returns
+// a StackTrace. Where errors.StackTrace is defined as
 //
 //     type StackTrace []Frame
 //
@@ -111,13 +111,13 @@ func Errorf(format string, args ...interface{}) error {
 // HasStack checks for this marker first.
 // Annotate/Wrap and Annotatef/Wrapf will produce this marker.
 type StackTraceAware interface {
-	hasStack() bool
+	HasStack() bool
 }
 
 // HasStack tells whether a StackTracer exists in the error chain
 func HasStack(err error) bool {
 	if errWithStack, ok := err.(StackTraceAware); ok {
-		return errWithStack.hasStack()
+		return errWithStack.HasStack()
 	}
 	return GetStackTracer(err) != nil
 }
@@ -270,7 +270,7 @@ type withMessage struct {
 
 func (w *withMessage) Error() string  { return w.msg + ": " + w.cause.Error() }
 func (w *withMessage) Cause() error   { return w.cause }
-func (w *withMessage) hasStack() bool { return w.causeHasStack }
+func (w *withMessage) HasStack() bool { return w.causeHasStack }
 
 func (w *withMessage) Format(s fmt.State, verb rune) {
 	switch verb {

From ba073089f17d94fbdb494cbe4b2ab4da6315d28e Mon Sep 17 00:00:00 2001
From: robi <sulifx@gmail.com>
Date: Thu, 6 Sep 2018 18:04:14 +0800
Subject: [PATCH 16/18] address comment

---
 errors_test.go | 57 ++++++++++++++++++++++++++++++++++++++++++++++++++
 group.go       | 16 +++++++-------
 2 files changed, 65 insertions(+), 8 deletions(-)

diff --git a/errors_test.go b/errors_test.go
index bcaebff..7f5e225 100644
--- a/errors_test.go
+++ b/errors_test.go
@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io"
 	"reflect"
+	"strconv"
 	"testing"
 )
 
@@ -312,3 +313,59 @@ func TestFind(t *testing.T) {
 		}
 	}
 }
+
+type errWalkTest struct {
+	cause error
+	sub   []error
+	v     int
+}
+
+func (e *errWalkTest) Error() string {
+	return strconv.Itoa(e.v)
+}
+
+func (e *errWalkTest) Cause() error {
+	return e.cause
+}
+
+func (e *errWalkTest) Errors() []error {
+	return e.sub
+}
+
+func testFind(err error, v int) bool {
+	return WalkDeep(err, func(err error) bool {
+		e := err.(*errWalkTest)
+		return e.v == v
+	})
+}
+
+func TestWalkDeep(t *testing.T) {
+	err := &errWalkTest{
+		sub: []error{
+			&errWalkTest{
+				v:     10,
+				cause: &errWalkTest{v: 11},
+			},
+			&errWalkTest{
+				v:     20,
+				cause: &errWalkTest{v: 21, cause: &errWalkTest{v: 22}},
+			},
+			&errWalkTest{
+				v:     30,
+				cause: &errWalkTest{v: 31},
+			},
+		},
+	}
+
+	if !testFind(err, 11) {
+		t.Errorf("not found in first cause chain")
+	}
+
+	if !testFind(err, 22) {
+		t.Errorf("not found in siblings")
+	}
+
+	if testFind(err, 32) {
+		t.Errorf("found not exists")
+	}
+}
diff --git a/group.go b/group.go
index d6e0711..52f7260 100644
--- a/group.go
+++ b/group.go
@@ -8,26 +8,26 @@ type ErrorGroup interface {
 
 // WalkDeep does a depth-first traversal of all errors.
 // Any ErrorGroup is traversed (after going deep).
-// The visitor function can return false to end the traversal early
-// In that case, WalkDeep will return false, otherwise true
-func WalkDeep(err error, visitor func(err error) bool) bool {
+// The visitor function can return true to end the traversal early
+// In that case, WalkDeep will return true, otherwise false.
+func WalkDeep(err error, visitor func(err error) bool) (done bool) {
 	// Go deep
 	unErr := err
 	for unErr != nil {
-		if more := visitor(unErr); more == true {
+		if done := visitor(unErr); done == true {
 			return true
 		}
 		unErr = Unwrap(unErr)
 	}
 
 	// Go wide
-	if hasGroup, ok := err.(ErrorGroup); ok {
-		for _, err := range hasGroup.Errors() {
-			if more := WalkDeep(err, visitor); more == true {
+	if group, ok := err.(ErrorGroup); ok {
+		for _, err := range group.Errors() {
+			if done := WalkDeep(err, visitor); done == true {
 				return true
 			}
 		}
 	}
 
-	return true
+	return false
 }

From 0485f1f10c2a09b9ee96f4e7162b6d4c08ce4a67 Mon Sep 17 00:00:00 2001
From: robi <sulifx@gmail.com>
Date: Thu, 6 Sep 2018 18:58:59 +0800
Subject: [PATCH 17/18] address comment

---
 group.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/group.go b/group.go
index 52f7260..80bbc9c 100644
--- a/group.go
+++ b/group.go
@@ -14,7 +14,7 @@ func WalkDeep(err error, visitor func(err error) bool) (done bool) {
 	// Go deep
 	unErr := err
 	for unErr != nil {
-		if done := visitor(unErr); done == true {
+		if done := visitor(unErr); done {
 			return true
 		}
 		unErr = Unwrap(unErr)
@@ -23,7 +23,7 @@ func WalkDeep(err error, visitor func(err error) bool) (done bool) {
 	// Go wide
 	if group, ok := err.(ErrorGroup); ok {
 		for _, err := range group.Errors() {
-			if done := WalkDeep(err, visitor); done == true {
+			if done := WalkDeep(err, visitor); done {
 				return true
 			}
 		}

From e446394fa961d46b256c8d2126e490d0811e7ed4 Mon Sep 17 00:00:00 2001
From: robi <sulifx@gmail.com>
Date: Thu, 6 Sep 2018 23:25:00 +0800
Subject: [PATCH 18/18] address comment

---
 group.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/group.go b/group.go
index 80bbc9c..003932c 100644
--- a/group.go
+++ b/group.go
@@ -10,7 +10,7 @@ type ErrorGroup interface {
 // Any ErrorGroup is traversed (after going deep).
 // The visitor function can return true to end the traversal early
 // In that case, WalkDeep will return true, otherwise false.
-func WalkDeep(err error, visitor func(err error) bool) (done bool) {
+func WalkDeep(err error, visitor func(err error) bool) bool {
 	// Go deep
 	unErr := err
 	for unErr != nil {
@@ -23,7 +23,7 @@ func WalkDeep(err error, visitor func(err error) bool) (done bool) {
 	// Go wide
 	if group, ok := err.(ErrorGroup); ok {
 		for _, err := range group.Errors() {
-			if done := WalkDeep(err, visitor); done {
+			if early := WalkDeep(err, visitor); early {
 				return true
 			}
 		}