tsdb/errors.MultiError: support errors.As (#16544)

* tsdb/errors.MultiError: implement Unwrap

the multierror was hiding some errors in Mimir. I also added unit tests because I had them handy from a similar change I and yuri did in XXX and some time ago

---------

Signed-off-by: Dimitar Dimitrov <dimitar.dimitrov@grafana.com>
Co-authored-by: Arve Knudsen <arve.knudsen@gmail.com>

tsdb/errors/errors.go

@@ -94,6 +94,11 @@ func (es nonNilMultiError) Is(target error) bool {
 	return false
 }
 
+// Unwrap returns the list of errors contained in the multiError.
+func (es nonNilMultiError) Unwrap() []error {
+	return es.errs
+}
+
 // CloseAll closes all given closers while recording error in MultiError.
 func CloseAll(cs []io.Closer) error {
 	errs := NewMulti()

tsdb/errors/errors_test.go

@@ -0,0 +1,172 @@
+// Copyright 2025 The Prometheus Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package errors
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestMultiError_Is(t *testing.T) {
+	customErr1 := errors.New("test error 1")
+	customErr2 := errors.New("test error 2")
+
+	testCases := map[string]struct {
+		sourceErrors []error
+		target       error
+		is           bool
+	}{
+		"adding a context cancellation doesn't lose the information": {
+			sourceErrors: []error{context.Canceled},
+			target:       context.Canceled,
+			is:           true,
+		},
+		"adding multiple context cancellations doesn't lose the information": {
+			sourceErrors: []error{context.Canceled, context.Canceled},
+			target:       context.Canceled,
+			is:           true,
+		},
+		"adding wrapped context cancellations doesn't lose the information": {
+			sourceErrors: []error{errors.New("some error"), fmt.Errorf("some message: %w", context.Canceled)},
+			target:       context.Canceled,
+			is:           true,
+		},
+		"adding a nil error doesn't lose the information": {
+			sourceErrors: []error{errors.New("some error"), fmt.Errorf("some message: %w", context.Canceled), nil},
+			target:       context.Canceled,
+			is:           true,
+		},
+		"errors with no context cancellation error are not a context canceled error": {
+			sourceErrors: []error{errors.New("first error"), errors.New("second error")},
+			target:       context.Canceled,
+			is:           false,
+		},
+		"no errors are not a context canceled error": {
+			sourceErrors: nil,
+			target:       context.Canceled,
+			is:           false,
+		},
+		"no errors are a nil error": {
+			sourceErrors: nil,
+			target:       nil,
+			is:           true,
+		},
+		"nested multi-error contains customErr1": {
+			sourceErrors: []error{
+				customErr1,
+				NewMulti(
+					customErr2,
+					fmt.Errorf("wrapped %w", context.Canceled),
+				).Err(),
+			},
+			target: customErr1,
+			is:     true,
+		},
+		"nested multi-error contains customErr2": {
+			sourceErrors: []error{
+				customErr1,
+				NewMulti(
+					customErr2,
+					fmt.Errorf("wrapped %w", context.Canceled),
+				).Err(),
+			},
+			target: customErr2,
+			is:     true,
+		},
+		"nested multi-error contains wrapped context.Canceled": {
+			sourceErrors: []error{
+				customErr1,
+				NewMulti(
+					customErr2,
+					fmt.Errorf("wrapped %w", context.Canceled),
+				).Err(),
+			},
+			target: context.Canceled,
+			is:     true,
+		},
+		"nested multi-error does not contain context.DeadlineExceeded": {
+			sourceErrors: []error{
+				customErr1,
+				NewMulti(
+					customErr2,
+					fmt.Errorf("wrapped %w", context.Canceled),
+				).Err(),
+			},
+			target: context.DeadlineExceeded,
+			is:     false, // make sure we still return false in valid cases
+		},
+	}
+
+	for testName, testCase := range testCases {
+		t.Run(testName, func(t *testing.T) {
+			mErr := NewMulti(testCase.sourceErrors...)
+			require.Equal(t, testCase.is, errors.Is(mErr.Err(), testCase.target))
+		})
+	}
+}
+
+func TestMultiError_As(t *testing.T) {
+	tE1 := testError{"error cause 1"}
+	tE2 := testError{"error cause 2"}
+	var target testError
+	testCases := map[string]struct {
+		sourceErrors []error
+		target       error
+		as           bool
+	}{
+		"MultiError containing only a testError can be cast to that testError": {
+			sourceErrors: []error{tE1},
+			target:       tE1,
+			as:           true,
+		},
+		"MultiError containing multiple testErrors can be cast to the first testError added": {
+			sourceErrors: []error{tE1, tE2},
+			target:       tE1,
+			as:           true,
+		},
+		"MultiError containing multiple errors can be cast to the first testError added": {
+			sourceErrors: []error{context.Canceled, tE1, context.DeadlineExceeded, tE2},
+			target:       tE1,
+			as:           true,
+		},
+		"MultiError not containing a testError cannot be cast to a testError": {
+			sourceErrors: []error{context.Canceled, context.DeadlineExceeded},
+			as:           false,
+		},
+	}
+
+	for testName, testCase := range testCases {
+		t.Run(testName, func(t *testing.T) {
+			mErr := NewMulti(testCase.sourceErrors...).Err()
+			if testCase.as {
+				require.ErrorAs(t, mErr, &target)
+				require.Equal(t, testCase.target, target)
+			} else {
+				require.NotErrorAs(t, mErr, &target)
+			}
+		})
+	}
+}
+
+type testError struct {
+	cause string
+}
+
+func (e testError) Error() string {
+	return fmt.Sprintf("testError[cause: %s]", e.cause)
+}