feat(reporter/sentry): filtering funcs to set custom error level on sentry

reporter/sentry/options.go

@@ -1,37 +1,55 @@
 package sentry
 
 import (
+	"context"
+	"io"
 	"os"
 	"strings"
 	"time"
 
 	"github.com/getsentry/sentry-go"
+	uerrors "github.com/upfluence/errors"
+	"github.com/upfluence/errors/base"
 	"github.com/upfluence/errors/reporter"
 )
 
-var defaultOptions = Options{
-	Tags: make(map[string]string),
-	SentryOptions: sentry.ClientOptions{
-		Dsn:            os.Getenv("SENTRY_DSN"),
-		Environment:    os.Getenv("ENV"),
-		SendDefaultPII: true,
-	},
-	TagWhitelist: toStringMap(
-		[]string{reporter.RemoteIP, reporter.RemotePort, reporter.DomainKey},
-	),
-	Timeout: time.Minute,
-	TagBlacklist: []func(string) bool{
-		stringEqual(reporter.TransactionKey),
-		stringEqual(reporter.UserEmailKey),
-		stringEqual(reporter.UserIDKey),
-		stringEqual(reporter.HTTPRequestProtoKey),
-		stringEqual(reporter.HTTPRequestPathKey),
-		stringEqual(reporter.HTTPRequestHostKey),
-		stringEqual(reporter.HTTPRequestMethodKey),
-		stringEqual(reporter.HTTPRequestBodyKey),
-		stringPrefix(reporter.HTTPRequestHeaderKeyPrefix),
-		stringPrefix(reporter.HTTPRequestQueryValuesKeyPrefix),
-	},
+type ErrorLevelMapper func(error) sentry.Level
+
+var defaultErrorLevelMappers = []ErrorLevelMapper{
+	ErrorIsLevel(context.DeadlineExceeded, sentry.LevelWarning),
+	ErrorIsLevel(context.Canceled, sentry.LevelWarning),
+	ErrorIsLevel(io.EOF, sentry.LevelWarning),
+	ErrorCauseTextContainsLevel("net/http: TLS handshake timeout", sentry.LevelWarning),
+	ErrorCauseTextContainsLevel("operation was canceled", sentry.LevelWarning),
+	ErrorCauseTextContainsLevel("EOF", sentry.LevelWarning),
+}
+
+func defaultOptions() Options {
+	return Options{
+		Tags: make(map[string]string),
+		SentryOptions: sentry.ClientOptions{
+			Dsn:            os.Getenv("SENTRY_DSN"),
+			Environment:    os.Getenv("ENV"),
+			SendDefaultPII: true,
+		},
+		TagWhitelist: toStringMap(
+			[]string{reporter.RemoteIP, reporter.RemotePort, reporter.DomainKey},
+		),
+		Timeout: time.Minute,
+		TagBlacklist: []func(string) bool{
+			stringEqual(reporter.TransactionKey),
+			stringEqual(reporter.UserEmailKey),
+			stringEqual(reporter.UserIDKey),
+			stringEqual(reporter.HTTPRequestProtoKey),
+			stringEqual(reporter.HTTPRequestPathKey),
+			stringEqual(reporter.HTTPRequestHostKey),
+			stringEqual(reporter.HTTPRequestMethodKey),
+			stringEqual(reporter.HTTPRequestBodyKey),
+			stringPrefix(reporter.HTTPRequestHeaderKeyPrefix),
+			stringPrefix(reporter.HTTPRequestQueryValuesKeyPrefix),
+		},
+		ErrorLevelMappers: defaultErrorLevelMappers,
+	}
 }
 
 func stringEqual(x string) func(string) bool {
@@ -52,6 +70,44 @@ func toStringMap(vs []string) map[string]struct{} {
 	return res
 }
 
+// ErrorIsLevel creates an ErrorLevelMapper of the passed level that checks if
+// reported errors are the same as the given sentinel error
+func ErrorIsLevel(sentinel error, level sentry.Level) ErrorLevelMapper {
+	return func(err error) sentry.Level {
+		if uerrors.Is(err, sentinel) {
+			return level
+		}
+
+		return ""
+	}
+}
+
+// ErrorIsOfTypeLevel creates an ErrorLevelMapper of the passed level that checks
+// if reported errors are of the passed generic type
+func ErrorIsOfTypeLevel[T error](level sentry.Level) ErrorLevelMapper {
+	return func(err error) sentry.Level {
+		if uerrors.IsOfType[T](err) {
+			return level
+		}
+
+		return ""
+	}
+}
+
+// ErrorCauseTextContainsLevel creates an ErrorLevelMapper of the passed level that checks
+// if reported errors' cause's Error() text contains the passed string
+func ErrorCauseTextContainsLevel(errorText string, level sentry.Level) ErrorLevelMapper {
+	return func(err error) sentry.Level {
+		rootCause := base.UnwrapAll(err).Error()
+
+		if strings.Contains(rootCause, errorText) {
+			return level
+		}
+
+		return ""
+	}
+}
+
 type Options struct {
 	Tags map[string]string
 
@@ -60,6 +116,8 @@ type Options struct {
 
 	TagWhitelist map[string]struct{}
 	TagBlacklist []func(string) bool
+
+	ErrorLevelMappers []ErrorLevelMapper
 }
 
 func (o Options) client() (*sentry.Client, error) {
@@ -74,10 +132,25 @@ func (o Options) client() (*sentry.Client, error) {
 
 type Option func(*Options)
 
+// WithTags allows for custom tags to be given to the Reporter
 func WithTags(tags map[string]string) Option {
 	return func(opts *Options) {
 		for k, v := range tags {
 			opts.Tags[k] = v
 		}
 	}
 }
+
+// AppendErrorLevelMappers adds the passed funcs to the ErrorLevelMappers of the Reporter
+func AppendErrorLevelMappers(funcs ...ErrorLevelMapper) Option {
+	return func(opts *Options) {
+		opts.ErrorLevelMappers = append(opts.ErrorLevelMappers, funcs...)
+	}
+}
+
+// ReplaceErrorLevelMappers replaces the ErrorLevelMappers of the Reporter with the passed ones
+func ReplaceErrorLevelMappers(funcs []ErrorLevelMapper) Option {
+	return func(opts *Options) {
+		opts.ErrorLevelMappers = funcs
+	}
+}

reporter/sentry/reporter.go

@@ -30,13 +30,14 @@ type Reporter struct {
 
 	tagWhitelist []func(string) bool
 	tagBlacklist []func(string) bool
+	levelMappers []ErrorLevelMapper
 
 	timeout time.Duration
 }
 
 // NewReporter creates a new Sentry reporter with the given options.
 func NewReporter(os ...Option) (*Reporter, error) {
-	var opts = defaultOptions
+	var opts = defaultOptions()
 
 	for _, o := range os {
 		o(&opts)
@@ -58,6 +59,7 @@ func NewReporter(os ...Option) (*Reporter, error) {
 		},
 		tagBlacklist: opts.TagBlacklist,
 		timeout:      opts.Timeout,
+		levelMappers: opts.ErrorLevelMappers,
 	}, nil
 }
 
@@ -121,26 +123,26 @@ func (r *Reporter) buildEvent(err error, opts reporter.ReportOptions) *sentry.Ev
 		return nil
 	}
 
-	ts := tags.GetTags(err)
+	errorTags := tags.GetTags(err)
 
-	if ts == nil && len(opts.Tags) > 0 {
-		ts = make(map[string]interface{}, len(opts.Tags))
+	if errorTags == nil && len(opts.Tags) > 0 {
+		errorTags = make(map[string]interface{}, len(opts.Tags))
 	}
 
 	for k, v := range opts.Tags {
-		if _, ok := ts[k]; !ok {
-			ts[k] = v
+		if _, ok := errorTags[k]; !ok {
+			errorTags[k] = v
 		}
 	}
 
 	evt := sentry.NewEvent()
 
-	evt.Level = sentry.LevelError
+	evt.Level = r.computeLevel(err)
 	evt.Timestamp = time.Now()
 	evt.Message = err.Error()
-	evt.Transaction = transactionName(ts)
-	evt.User = buildUser(ts)
-	evt.Request = buildRequest(ts)
+	evt.Transaction = transactionName(errorTags)
+	evt.User = buildUser(errorTags)
+	evt.Request = buildRequest(errorTags)
 
 	cause := base.UnwrapAll(err)
 
@@ -153,7 +155,7 @@ func (r *Reporter) buildEvent(err error, opts reporter.ReportOptions) *sentry.Ev
 		},
 	}
 
-	for k, v := range ts {
+	for k, v := range errorTags {
 		r.appendTag(k, v, evt)
 	}
 
@@ -164,6 +166,16 @@ func (r *Reporter) buildEvent(err error, opts reporter.ReportOptions) *sentry.Ev
 	return evt
 }
 
+func (r *Reporter) computeLevel(err error) sentry.Level {
+	for _, errFunc := range r.levelMappers {
+		if level := errFunc(err); level != "" {
+			return level
+		}
+	}
+
+	return sentry.LevelError
+}
+
 func extractStacktrace(err error, n int) *sentry.Stacktrace {
 	var s sentry.Stacktrace
 

reporter/sentry/reporter_test.go

@@ -1,6 +1,7 @@
 package sentry
 
 import (
+	"context"
 	"io"
 	"regexp"
 	"testing"
@@ -13,6 +14,10 @@ import (
 	"github.com/upfluence/errors/reporter"
 )
 
+type mockError struct{}
+
+func (*mockError) Error() string { return "mock" }
+
 func TestBuildEvent(t *testing.T) {
 	for _, tt := range []struct {
 		name string
@@ -163,6 +168,95 @@ func TestBuildEvent(t *testing.T) {
 				assert.Equal(t, evt.Tags, map[string]string{"foo": "bar", "domain": "github.com/upfluence/errors/reporter/sentry"})
 			},
 		},
+		{
+			name:      "simple sentinel error with severity func",
+			err:       io.EOF,
+			modifiers: []func(*Reporter){},
+			evtfn: func(t *testing.T, evt *sentry.Event) {
+				assert.Equal(
+					t,
+					sentry.LevelWarning,
+					evt.Level,
+				)
+			},
+		},
+		{
+			name:      "wrapped sentinel error with severity func",
+			err:       errors.Wrap(context.DeadlineExceeded, "it took too long, boss"),
+			modifiers: []func(*Reporter){},
+			evtfn: func(t *testing.T, evt *sentry.Event) {
+				assert.Equal(
+					t,
+					sentry.LevelWarning,
+					evt.Level,
+				)
+			},
+		},
+		{
+			name:      "simple text error with severity func",
+			err:       errors.New("net/http: TLS handshake timeout with extra bells and whistles"),
+			modifiers: []func(*Reporter){},
+			evtfn: func(t *testing.T, evt *sentry.Event) {
+				assert.Equal(
+					t,
+					sentry.LevelWarning,
+					evt.Level,
+				)
+			},
+		},
+		{
+			name: "wrapped text error with severity func",
+			err: errors.Wrap(
+				errors.New("net/http: TLS handshake timeout with extra bells and whistles"),
+				"more bells and whistles",
+			),
+			modifiers: []func(*Reporter){},
+			evtfn: func(t *testing.T, evt *sentry.Event) {
+				assert.Equal(
+					t,
+					sentry.LevelWarning,
+					evt.Level,
+				)
+			},
+		},
+		{
+			name: "simple error type",
+			err:  &mockError{},
+			modifiers: []func(*Reporter){
+				func(r *Reporter) {
+					r.levelMappers = append(
+						r.levelMappers,
+						ErrorIsOfTypeLevel[*mockError](sentry.LevelDebug),
+					)
+				},
+			},
+			evtfn: func(t *testing.T, evt *sentry.Event) {
+				assert.Equal(
+					t,
+					sentry.LevelDebug,
+					evt.Level,
+				)
+			},
+		},
+		{
+			name: "wrapped error type",
+			err:  errors.Wrap(&mockError{}, "i am being mocked"),
+			modifiers: []func(*Reporter){
+				func(r *Reporter) {
+					r.levelMappers = append(
+						r.levelMappers,
+						ErrorIsOfTypeLevel[*mockError](sentry.LevelDebug),
+					)
+				},
+			},
+			evtfn: func(t *testing.T, evt *sentry.Event) {
+				assert.Equal(
+					t,
+					sentry.LevelDebug,
+					evt.Level,
+				)
+			},
+		},
 	} {
 		t.Run(tt.name, func(t *testing.T) {
 			r, err := NewReporter(tt.opts...)