grpcerrors: Ensure errors from errors.Join are preserved

Adds support for the `Unwrap() []error` interface used by `errors.Join`
so that roundtripping through grpcerrors preserves types.

Signed-off-by: Brian Goff <[email protected]>

Author: cpuguy83

util/grpcerrors/grpcerrors.go

@@ -252,9 +252,21 @@ func (e *withCodeError) Unwrap() error {
 
 func each(err error, fn func(error)) {
 	fn(err)
-	if wrapped, ok := err.(interface {
+
+	type singleUnwrapper interface {
 		Unwrap() error
-	}); ok {
-		each(wrapped.Unwrap(), fn)
+	}
+
+	type multiUnwrapper interface {
+		Unwrap() []error
+	}
+
+	switch e := err.(type) {
+	case singleUnwrapper:
+		each(e.Unwrap(), fn)
+	case multiUnwrapper:
+		for _, err := range e.Unwrap() {
+			each(err, fn)
+		}
 	}
 }

util/grpcerrors/grpcerrors_test.go

@@ -2,10 +2,11 @@ package grpcerrors_test
 
 import (
 	"context"
+	stderrors "errors"
 	"fmt"
-	"strings"
 	"testing"
 
+	"github.com/moby/buildkit/solver/errdefs"
 	"github.com/moby/buildkit/util/grpcerrors"
 	"github.com/pkg/errors"
 	"github.com/stretchr/testify/assert"
@@ -65,6 +66,50 @@ func TestFromGRPCPreserveUnknownTypes(t *testing.T) {
 		reDecodedErr := grpcerrors.FromGRPC(reEncodedErr)
 		assertErrorProperties(t, reDecodedErr)
 	})
+
+}
+
+func TestFromGRPCPreserveUnknownTypes_WithJoin(t *testing.T) {
+	t.Parallel()
+	const (
+		unknownType  = "type.googleapis.com/unknown.Type"
+		unknownValue = "unknown value"
+
+		errMessage = "something failed"
+		errCode    = codes.Internal
+	)
+	raw := &anypb.Any{
+		TypeUrl: unknownType,
+		Value:   []byte(unknownValue),
+	}
+
+	pb := &spb.Status{
+		Code:    int32(errCode),
+		Message: errMessage,
+		Details: []*anypb.Any{raw},
+	}
+
+	// Decode the original status into a Go error, then join it with a typed error
+	decodedErr := grpcerrors.FromGRPC(status.FromProto(pb).Err())
+	// Create a typed error (errdefs.Solve) and wrap a base error with it
+	typed := &errdefs.Solve{InputIDs: []string{"typed-input"}}
+	typedErr := typed.WrapError(stderrors.New("typed-base"))
+	joined := stderrors.Join(decodedErr, typedErr)
+
+	// Re-encode and decode the joined error and ensure the unknown detail is preserved
+	reEncoded := grpcerrors.ToGRPC(context.TODO(), joined)
+	reDecoded := grpcerrors.FromGRPC(reEncoded)
+
+	require.Error(t, reDecoded)
+
+	// Ensure the typed error was preserved by finding the SolveError in the decoded error
+	var se *errdefs.SolveError
+	require.True(t, stderrors.As(reDecoded, &se))
+	require.NotNil(t, se)
+	assert.Equal(t, []string{"typed-input"}, se.Solve.InputIDs)
+
+	// And ensure the original unknown detail is still present
+	assert.ErrorContains(t, reDecoded, errMessage)
 }
 
 func TestToGRPCMessage(t *testing.T) {
@@ -79,10 +124,15 @@ func TestToGRPCMessage(t *testing.T) {
 		t.Parallel()
 		err := errors.New("something")
 		wrapped := errors.Wrap(grpcerrors.ToGRPC(context.TODO(), err), "extra context")
+
+		anotherErr := errors.New("another error")
+		joined := stderrors.Join(wrapped, anotherErr)
+
 		// Check that wrapped.Error() starts with "extra context"
-		assert.True(t, strings.HasPrefix(wrapped.Error(), "extra context"), "expected wrapped error to start with 'extra context'")
-		encoded := grpcerrors.ToGRPC(context.TODO(), wrapped)
+		encoded := grpcerrors.ToGRPC(context.TODO(), joined)
 		decoded := grpcerrors.FromGRPC(encoded)
-		assert.Equal(t, wrapped.Error(), decoded.Error())
+
+		assert.ErrorContains(t, decoded, wrapped.Error())
+		assert.ErrorContains(t, decoded, anotherErr.Error())
 	})
 }