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...)