support multi-cause errors in go 1.20

Go 1.20 introduces the idea of an error with multiple causes instead
of a single chain. This commit updates the errors library to properly
encode, decode, and format these error types.

For encoding and decoding we use the existing `EncodedLeaf` type and
embellish it with a `causes` field. This is done in order to keep the
encoding/decoding backwards compatible. `EncodedLeaf` types containing
multiple causes when decided by earlier versions will simply see an
opaque leaf with a message inside. The reason the `EncodedWrapper`
is not used here is because the wrapper already contains a mandatory
single `cause` field that we cannot fill with the multi-errors. A
new type cannot be used because it would not be decodable by older
versions of this library.

Author: dhartunian

errbase/adapters_test.go

@@ -64,7 +64,33 @@ func TestAdaptGoSingleWrapErr(t *testing.T) {
 	tt := testutils.T{T: t}
 	// The library preserves the cause. It's not possible to preserve the fmt
 	// string.
+	tt.CheckEqual(newErr.Error(), origErr.Error())
+	tt.CheckContains(newErr.Error(), "hello")
+}
+
+func TestAdaptBaseGoJoinErr(t *testing.T) {
+	origErr := goErr.Join(goErr.New("hello"), goErr.New("world"))
+	t.Logf("start err: %# v", pretty.Formatter(origErr))
+
+	newErr := network(t, origErr)
+
+	tt := testutils.T{T: t}
+	// The library preserves the error message.
+	tt.CheckEqual(newErr.Error(), origErr.Error())
+
+}
+
+func TestAdaptGoMultiWrapErr(t *testing.T) {
+	origErr := fmt.Errorf("an error %w and also %w", goErr.New("hello"), goErr.New("world"))
+	t.Logf("start err: %# v", pretty.Formatter(origErr))
+
+	newErr := network(t, origErr)
+
+	tt := testutils.T{T: t}
+	// The library preserves the causes. It's not possible to preserve the fmt string.
+	tt.CheckEqual(newErr.Error(), origErr.Error())
 	tt.CheckContains(newErr.Error(), "hello")
+	tt.CheckContains(newErr.Error(), "world")
 }
 
 func TestAdaptPkgWithMessage(t *testing.T) {

errbase/decode.go

@@ -66,12 +66,18 @@ func decodeLeaf(ctx context.Context, enc *errorspb.EncodedErrorLeaf) error {
 		}
 	}
 
+	causes := make([]error, len(enc.Causes))
+	for i, e := range enc.Causes {
+		causes[i] = DecodeError(ctx, *e)
+	}
+
 	// No decoder and no error type: we'll keep what we received and
 	// make it ready to re-encode exactly (if the error leaves over the
 	// network again).
 	return &opaqueLeaf{
 		msg:     enc.Message,
 		details: enc.Details,
+		causes:  causes,
 	}
 }
 

errbase/encode.go

@@ -33,12 +33,15 @@ func EncodeError(ctx context.Context, err error) EncodedError {
 	if cause := UnwrapOnce(err); cause != nil {
 		return encodeWrapper(ctx, err, cause)
 	}
+	if causes := UnwrapMulti(err); causes != nil {
+		return encodeLeaf(ctx, err, causes)
+	}
 	// Not a causer.
-	return encodeLeaf(ctx, err)
+	return encodeLeaf(ctx, err, nil)
 }
 
 // encodeLeaf encodes a leaf error.
-func encodeLeaf(ctx context.Context, err error) EncodedError {
+func encodeLeaf(ctx context.Context, err error, causes []error) EncodedError {
 	var msg string
 	var details errorspb.EncodedErrorDetails
 
@@ -74,11 +77,18 @@ func encodeLeaf(ctx context.Context, err error) EncodedError {
 		details.FullDetails = encodeAsAny(ctx, err, payload)
 	}
 
+	cs := make([]*EncodedError, len(causes))
+	for i, ee := range causes {
+		ee := EncodeError(ctx, ee)
+		cs[i] = &ee
+	}
+
 	return EncodedError{
 		Error: &errorspb.EncodedError_Leaf{
 			Leaf: &errorspb.EncodedErrorLeaf{
 				Message: msg,
 				Details: details,
+				Causes:  cs,
 			},
 		},
 	}
@@ -120,6 +130,7 @@ func encodeWrapper(ctx context.Context, err, cause error) EncodedError {
 	if e, ok := err.(*opaqueWrapper); ok {
 		msg, ownError = extractPrefix(err, cause)
 		details = e.details
+		ownError = e.ownsErrorString
 	} else {
 		details.OriginalTypeName, details.ErrorTypeMark.FamilyName, details.ErrorTypeMark.Extension = getTypeDetails(err, false /*onlyFamily*/)
 

errbase/opaque.go

@@ -28,6 +28,7 @@ import (
 type opaqueLeaf struct {
 	msg     string
 	details errorspb.EncodedErrorDetails
+	causes  []error
 }
 
 var _ error = (*opaqueLeaf)(nil)
@@ -73,6 +74,9 @@ func (e *opaqueWrapper) SafeDetails() []string { return e.details.ReportablePayl
 func (e *opaqueLeaf) Format(s fmt.State, verb rune)    { FormatError(e, s, verb) }
 func (e *opaqueWrapper) Format(s fmt.State, verb rune) { FormatError(e, s, verb) }
 
+// opaque leaf can be a multi-wrapper
+func (e *opaqueLeaf) Unwrap() []error { return e.causes }
+
 func (e *opaqueLeaf) SafeFormatError(p Printer) (next error) {
 	p.Print(e.msg)
 	if p.Detail() {

errbase/unwrap.go

@@ -27,6 +27,16 @@ package errbase
 // It supports both errors implementing causer (`Cause()` method, from
 // github.com/pkg/errors) and `Wrapper` (`Unwrap()` method, from the
 // Go 2 error proposal).
+//
+// UnwrapOnce treats multi-errors (those implementing the
+// `Unwrap() []error` interface as leaf-nodes since they cannot
+// reasonably be iterated through to a single cause. These errors
+// are typically constructed as a result of `fmt.Errorf` which results
+// in a `wrapErrors` instance that contains an interpolated error
+// string along with a list of causes.
+//
+// The go stdlib does not define output on `Unwrap()` for a multi-cause
+// error, so we default to nil here.
 func UnwrapOnce(err error) (cause error) {
 	switch e := err.(type) {
 	case interface{ Cause() error }:
@@ -39,6 +49,7 @@ func UnwrapOnce(err error) (cause error) {
 
 // UnwrapAll accesses the root cause object of the error.
 // If the error has no cause (leaf error), it is returned directly.
+// UnwrapAll treats multi-errors as leaf nodes.
 func UnwrapAll(err error) error {
 	for {
 		if cause := UnwrapOnce(err); cause != nil {
@@ -49,3 +60,12 @@ func UnwrapAll(err error) error {
 	}
 	return err
 }
+
+// UnwrapMulti access the slice of causes that an error contains, if it is a
+// multi-error.
+func UnwrapMulti(err error) []error {
+	if me, ok := err.(interface{ Unwrap() []error }); ok {
+		return me.Unwrap()
+	}
+	return nil
+}

errbase/unwrap_test.go

@@ -16,6 +16,7 @@ package errbase_test
 
 import (
 	"errors"
+	"fmt"
 	"testing"
 
 	"github.com/cockroachdb/errors/errbase"
@@ -58,6 +59,18 @@ func TestMixedErrorWrapping(t *testing.T) {
 	tt.CheckEqual(errbase.UnwrapAll(err3), err)
 }
 
+func TestMultiErrorUnwrap(t *testing.T) {
+	tt := testutils.T{T: t}
+
+	err := errors.New("hello")
+	err2 := pkgErr.WithMessage(err, "woo")
+	err3 := fmt.Errorf("%w %w", err, err2)
+
+	tt.CheckEqual(errbase.UnwrapOnce(err3), nil)
+	tt.CheckEqual(errbase.UnwrapAll(err3), err3)
+	tt.CheckDeepEqual(errbase.UnwrapMulti(err3), []error{err, err2})
+}
+
 type myWrapper struct{ cause error }
 
 func (w *myWrapper) Error() string { return w.cause.Error() }