Deprecate experimental/errorsource and remove experimental/errorsource/httpclient (#1150)

* Experimental error source: Deprecate and remove

* Update

* Fix errors

* Fix lint

* Update tests

* Update experimental/errorsource/error_source_middleware.go

Co-authored-by: Will Browne <[email protected]>

* Update experimental/errorsource/error_source_middleware.go

Co-authored-by: Will Browne <[email protected]>

* Update experimental/errorsource/error_source_middleware.go

Co-authored-by: Will Browne <[email protected]>

* Don't prepend error source before error

* Update tests to reflect changes from previous commit

---------

Co-authored-by: Will Browne <[email protected]>

Author: ivanahuckova

backend/error_source.go

@@ -2,13 +2,15 @@ package backend
 
 import (
 	"context"
+	"errors"
 	"fmt"
 
 	"github.com/grafana/grafana-plugin-sdk-go/experimental/status"
 )
 
 // ErrorSource type defines the source of the error
 type ErrorSource = status.Source
+type ErrorWithSource = status.ErrorWithSource
 
 const (
 	// ErrorSourcePlugin error originates from plugin.
@@ -21,6 +23,10 @@ const (
 	DefaultErrorSource = status.SourcePlugin
 )
 
+func NewErrorWithSource(err error, source ErrorSource) ErrorWithSource {
+	return status.NewErrorWithSource(err, source)
+}
+
 // ErrorSourceFromHTTPStatus returns an [ErrorSource] based on provided HTTP status code.
 func ErrorSourceFromHTTPStatus(statusCode int) ErrorSource {
 	return status.SourceFromHTTPStatus(statusCode)
@@ -43,6 +49,11 @@ func DownstreamError(err error) error {
 	return status.DownstreamError(err)
 }
 
+// PluginError creates a new error with status [ErrorSourcePlugin].
+func PluginError(err error) error {
+	return status.PluginError(err)
+}
+
 // DownstreamErrorf creates a new error with status [ErrorSourceDownstream] and formats
 // according to a format specifier and returns the string as a value that satisfies error.
 func DownstreamErrorf(format string, a ...any) error {
@@ -75,3 +86,18 @@ func WithErrorSource(ctx context.Context, s ErrorSource) error {
 func WithDownstreamErrorSource(ctx context.Context) error {
 	return status.WithDownstreamSource(ctx)
 }
+
+// Response returns an error DataResponse with error and source of the error if present.
+// If the error does not have a source, it keeps the ErrorSource empty.
+func ErrorResponseWithErrorSource(err error) DataResponse {
+	var e ErrorWithSource
+	if errors.As(err, &e) {
+		return DataResponse{
+			Error:       e,
+			ErrorSource: e.ErrorSource(),
+		}
+	}
+	return DataResponse{
+		Error: err,
+	}
+}

backend/gtime/gtime.go

@@ -7,7 +7,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/grafana/grafana-plugin-sdk-go/experimental/errorsource"
+	"github.com/grafana/grafana-plugin-sdk-go/backend"
 )
 
 var dateUnitPattern = regexp.MustCompile(`^(\d+)([dwMy])$`)
@@ -17,7 +17,7 @@ var dateUnitPattern = regexp.MustCompile(`^(\d+)([dwMy])$`)
 func ParseInterval(inp string) (time.Duration, error) {
 	dur, period, err := parse(inp)
 	if err != nil {
-		return 0, errorsource.DownstreamError(err, false)
+		return 0, backend.DownstreamError(err)
 	}
 	if period == "" {
 		return dur, nil
@@ -39,15 +39,15 @@ func ParseInterval(inp string) (time.Duration, error) {
 		return now.AddDate(num, 0, 0).Sub(now), nil
 	}
 
-	return 0, errorsource.DownstreamError(fmt.Errorf("invalid interval %q", inp), false)
+	return 0, backend.DownstreamError(fmt.Errorf("invalid interval %q", inp))
 }
 
 // ParseDuration parses a duration with support for all units that Grafana uses.
 // Durations are independent of wall time.
 func ParseDuration(inp string) (time.Duration, error) {
 	dur, period, err := parse(inp)
 	if err != nil {
-		return 0, errorsource.DownstreamError(err, false)
+		return 0, backend.DownstreamError(err)
 	}
 	if period == "" {
 		return dur, nil
@@ -71,7 +71,7 @@ func ParseDuration(inp string) (time.Duration, error) {
 		return dur * year, nil
 	}
 
-	return 0, errorsource.DownstreamError(fmt.Errorf("invalid duration %q", inp), false)
+	return 0, backend.DownstreamError(fmt.Errorf("invalid duration %q", inp))
 }
 
 func parse(inp string) (time.Duration, string, error) {

backend/httpclient/error_source_middleware.go

@@ -11,14 +11,17 @@ const ErrorSourceMiddlewareName = "ErrorSource"
 
 // ErrorSourceMiddleware inspect the response error and wraps it in a [status.DownstreamError] if [status.IsDownstreamHTTPError] returns true.
 func ErrorSourceMiddleware() Middleware {
-	return NamedMiddlewareFunc(ErrorSourceMiddlewareName, func(_ Options, next http.RoundTripper) http.RoundTripper {
-		return RoundTripperFunc(func(req *http.Request) (*http.Response, error) {
-			res, err := next.RoundTrip(req)
-			if err != nil && status.IsDownstreamHTTPError(err) {
-				return res, status.DownstreamError(err)
-			}
+	return NamedMiddlewareFunc(ErrorSourceMiddlewareName, ErrorSourceRoundTripper)
+}
+
+// ErrorSourceRoundTripper inspect the response error and wraps it in a [status.DownstreamError] if [status.IsDownstreamHTTPError] returns true.
+func ErrorSourceRoundTripper(_ Options, next http.RoundTripper) http.RoundTripper {
+	return RoundTripperFunc(func(req *http.Request) (*http.Response, error) {
+		res, err := next.RoundTrip(req)
+		if err != nil && status.IsDownstreamHTTPError(err) {
+			return res, status.DownstreamError(err)
+		}
 
-			return res, err
-		})
+		return res, err
 	})
 }

backend/proxy/secure_socks_proxy_test.go

@@ -350,7 +350,7 @@ func TestInstrumentedSocksDialer(t *testing.T) {
 		c, err := cd.DialContext(context.Background(), "n", "addr")
 		assert.Nil(t, c)
 		assert.NotNil(t, err)
-		assert.Equal(t, "downstream error: custom error", err.Error())
+		assert.Equal(t, "custom error", err.Error())
 	})
 }
 

data/sqlutil/scanrow.go

@@ -5,7 +5,7 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/grafana/grafana-plugin-sdk-go/experimental/errorsource"
+	"github.com/grafana/grafana-plugin-sdk-go/backend"
 )
 
 // A ScanRow is a container for SQL metadata for a single row.
@@ -62,7 +62,7 @@ func MakeScanRow(colTypes []*sql.ColumnType, colNames []string, converters ...Co
 	seen := map[string]int{}
 	for i, name := range colNames {
 		if j, ok := seen[name]; ok {
-			return nil, errorsource.DownstreamError(fmt.Errorf(`duplicate column names are not allowed, found identical name "%v" at column indices %v and %v`, name, j, i), false)
+			return nil, backend.DownstreamError(fmt.Errorf(`duplicate column names are not allowed, found identical name "%v" at column indices %v and %v`, name, j, i))
 		}
 		seen[name] = i
 	}

experimental/errorsource/error_source.go

@@ -6,103 +6,73 @@ import (
 	"github.com/grafana/grafana-plugin-sdk-go/backend"
 )
 
-func New(err error, source backend.ErrorSource, status backend.Status) Error {
-	return Error{err: err, source: source, status: status}
-}
-
-// Error captures error source and implements the error interface
-type Error struct {
-	source backend.ErrorSource
-	status backend.Status
-
-	err error
-}
+type Error = backend.ErrorWithSource
 
-// Error implements the interface
-func (r Error) Error() string {
-	return r.err.Error()
-}
-
-// Unwrap implements the interface
-func (r Error) Unwrap() error {
-	return r.err
-}
-
-// Source provides the error source
-func (r Error) Source() backend.ErrorSource {
-	return r.source
-}
-
-func (r Error) ErrorSource() backend.ErrorSource {
-	return r.source
+// New creates a new error with the source
+// Deprecated: use backend.NewErrorWithSource instead
+func New(err error, source backend.ErrorSource, _ backend.Status) Error {
+	// We are not using status here, but we are keeping it for compatibility
+	return backend.NewErrorWithSource(err, source)
 }
 
 // PluginError will apply the source as plugin
-func PluginError(err error, override bool) error {
+// Deprecated: use backend.PluginError instead
+func PluginError(err error, _ bool) error {
 	if err != nil {
-		return SourceError(backend.ErrorSourcePlugin, err, override)
+		return backend.PluginError(err)
 	}
 	return nil
 }
 
 // DownstreamError will apply the source as downstream
-func DownstreamError(err error, override bool) error {
+// Deprecated: use backend.DownstreamError instead
+func DownstreamError(err error, _ bool) error {
 	if err != nil {
-		return SourceError(backend.ErrorSourceDownstream, err, override)
+		return backend.DownstreamError(err)
 	}
 	return nil
 }
 
 // SourceError returns an error with the source
 // If source is already defined, it will return it, or you can override
+// Deprecated: Use backend.DownstreamError or backend.PluginError instead
 func SourceError(source backend.ErrorSource, err error, override bool) Error {
 	var sourceError Error
 	if errors.As(err, &sourceError) && !override {
 		return sourceError // already has a source
 	}
-	return Error{
-		source: source,
-		err:    err,
-	}
+	return New(err, source, 0)
 }
 
 // Response returns an error DataResponse given status, source of the error and message.
+// Deprecated: Use backend.ErrorResponseWithErrorSource instead
 func Response(err error) backend.DataResponse {
-	var e Error
-	if !errors.As(err, &e) {
-		// generic error, default to "plugin" error source
-		return backend.DataResponse{
-			Error:       err,
-			ErrorSource: backend.ErrorSourcePlugin,
-			Status:      backend.StatusUnknown,
-		}
-	}
-	return backend.DataResponse{
-		Error:       err,
-		ErrorSource: e.source,
-		Status:      e.status,
-	}
+	return backend.ErrorResponseWithErrorSource(err)
 }
 
 // FromStatus returns error source from status
+// Deprecated: Use backend.ErrorSourceFromHTTPStatus instead
 func FromStatus(status backend.Status) backend.ErrorSource {
 	return backend.ErrorSourceFromHTTPStatus(int(status))
 }
 
 // AddPluginErrorToResponse adds the error as plugin error source to the response
 // if the error already has a source, the existing source will be used
+// Deprecated: Use backend.ErrorResponse instead
 func AddPluginErrorToResponse(refID string, response *backend.QueryDataResponse, err error) *backend.QueryDataResponse {
 	return AddErrorToResponse(refID, response, PluginError(err, false))
 }
 
 // AddDownstreamErrorToResponse adds the error as downstream source to the response
 // if the error already has a source, the existing source will be used
+// Deprecated: Use backend.ErrorResponse instead and set the response directly
 func AddDownstreamErrorToResponse(refID string, response *backend.QueryDataResponse, err error) *backend.QueryDataResponse {
 	return AddErrorToResponse(refID, response, DownstreamError(err, false))
 }
 
 // AddErrorToResponse adds the error to the response
+// Deprecated: Use backend.ErrorResponse instead and set the response directly
 func AddErrorToResponse(refID string, response *backend.QueryDataResponse, err error) *backend.QueryDataResponse {
-	response.Responses[refID] = Response(err)
+	response.Responses[refID] = backend.ErrorResponseWithErrorSource(err)
 	return response
 }

experimental/errorsource/error_source_middleware.go

@@ -6,15 +6,18 @@ import (
 
 	"github.com/grafana/grafana-plugin-sdk-go/backend"
 	"github.com/grafana/grafana-plugin-sdk-go/backend/httpclient"
-	"github.com/grafana/grafana-plugin-sdk-go/experimental/status"
 )
 
 // Middleware captures error source metric
+// Deprecated: If you are using sdk httpclient, this is already included in the default middleware.
+// If you are not using the sdk httpclient, you should use httpclient.ErrorSourceMiddleware instead.
 func Middleware(plugin string) httpclient.Middleware {
 	return httpclient.NamedMiddlewareFunc(plugin, RoundTripper)
 }
 
 // RoundTripper returns the error source
+// Deprecated: If you are using sdk httpclient, this is already included in the default middleware.
+// If you are not using the sdk httpclient, you should use httpclient.ErrorSourceRoundTripper instead.
 func RoundTripper(_ httpclient.Options, next http.RoundTripper) http.RoundTripper {
 	return httpclient.RoundTripperFunc(func(req *http.Request) (*http.Response, error) {
 		res, err := next.RoundTrip(req)
@@ -23,11 +26,11 @@ func RoundTripper(_ httpclient.Options, next http.RoundTripper) http.RoundTrippe
 			if err == nil {
 				err = errors.New(res.Status)
 			}
-			return res, Error{source: errorSource, err: err}
+			return res, backend.NewErrorWithSource(err, errorSource)
 		}
 
-		if status.IsDownstreamHTTPError(err) {
-			return res, Error{source: backend.ErrorSourceDownstream, err: err}
+		if backend.IsDownstreamHTTPError(err) {
+			return res, backend.NewErrorWithSource(err, backend.ErrorSourceDownstream)
 		}
 
 		return res, err

experimental/errorsource/error_source_test.go

@@ -20,21 +20,18 @@ func TestResponse(t *testing.T) {
 		{
 			name:            "generic error",
 			err:             errors.New("other"),
-			expStatus:       backend.StatusUnknown,
 			expErrorMessage: "other",
-			expErrorSource:  backend.ErrorSourcePlugin,
+			expErrorSource:  "",
 		},
 		{
 			name:            "downstream error",
 			err:             DownstreamError(errors.New("bad gateway"), false),
-			expStatus:       0,
 			expErrorMessage: "bad gateway",
 			expErrorSource:  backend.ErrorSourceDownstream,
 		},
 		{
 			name:            "plugin error",
 			err:             PluginError(errors.New("internal error"), false),
-			expStatus:       0,
 			expErrorMessage: "internal error",
 			expErrorSource:  backend.ErrorSourcePlugin,
 		},
@@ -78,7 +75,6 @@ func TestResponseWithOptions(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			res := Response(tc.err)
 			require.Error(t, res.Error)
-			require.Equal(t, tc.expStatus, res.Status)
 			require.Equal(t, tc.expErrorMessage, res.Error.Error())
 			require.Equal(t, tc.expErrorSource, res.ErrorSource)
 		})