feat: support IgnoreTransactions client option

client.go

@@ -9,6 +9,7 @@
 	"math/rand"
 	"net/http"
 	"os"
+	"regexp"
 	"sort"
 	"strings"
 	"sync"
@@ -136,10 +137,13 @@
 	// The sample rate for profiling traces in the range [0.0, 1.0].
 	// This is relative to TracesSampleRate - it is a ratio of profiled traces out of all sampled traces.
 	ProfilesSampleRate float64
-	// List of regexp strings that will be used to match against event's message
-	// and if applicable, caught errors type and value.
-	// If the match is found, then a whole event will be dropped.
+	// List of regexp strings that will be used to match against an event's
+	// message and if applicable, the caught error's type and value.  If a match
+	// is found, then the whole event will be dropped.
 	IgnoreErrors []string
+	// List of regexp strings that will be used to match against a transaction's
+	// name.  If a match is found, then the transaction  will be dropped.
+	IgnoreTransactions []string
 	// If this flag is enabled, certain personally identifiable information (PII) is added by active integrations.
 	// By default, no such data is sent.
 	SendDefaultPII bool
@@ -226,13 +230,15 @@
 // Client is the underlying processor that is used by the main API and Hub
 // instances. It must be created with NewClient.
 type Client struct {
-	mu              sync.RWMutex
-	options         ClientOptions
-	dsn             *Dsn
-	eventProcessors []EventProcessor
-	integrations    []Integration
-	sdkIdentifier   string
-	sdkVersion      string
+	mu                 sync.RWMutex
+	options            ClientOptions
+	dsn                *Dsn
+	eventProcessors    []EventProcessor
+	integrations       []Integration
+	sdkIdentifier      string
+	sdkVersion         string
+	ignoreErrors       []*regexp.Regexp
+	ignoreTransactions []*regexp.Regexp
 	// Transport is read-only. Replacing the transport of an existing client is
 	// not supported, create a new client instead.
 	Transport Transport
@@ -328,11 +334,31 @@
 		}
 	}
 
+	ignoreErrorsRegexes := make([]*regexp.Regexp, len(options.IgnoreErrors))
+	for i, re := range options.IgnoreErrors {
+		compiled, err := regexp.Compile(re)
+		if err != nil {
+			return nil, err
+		}
+		ignoreErrorsRegexes[i] = compiled
+	}
+
+	ignoreTransactionsRegexes := make([]*regexp.Regexp, len(options.IgnoreTransactions))
+	for i, re := range options.IgnoreTransactions {
+		compiled, err := regexp.Compile(re)
+		if err != nil {
+			return nil, err
+		}
+		ignoreTransactionsRegexes[i] = compiled
+	}
+
 	client := Client{
-		options:       options,
-		dsn:           dsn,
-		sdkIdentifier: sdkIdentifier,
-		sdkVersion:    SDKVersion,
+		options:            options,
+		dsn:                dsn,
+		sdkIdentifier:      sdkIdentifier,
+		sdkVersion:         SDKVersion,
+		ignoreErrors:       ignoreErrorsRegexes,
+		ignoreTransactions: ignoreTransactionsRegexes,
 	}
 
 	client.setupTransport()
@@ -627,6 +653,22 @@
 		}
 	}
 
+	if event.Type == transactionType {
+		for _, re := range client.ignoreTransactions {
+			if re.MatchString(event.Transaction) {
+				Logger.Println("Transaction dropped due to IgnoreTransactions match.")
+				return nil
+			}
+		}
+	} else {
+		for _, re := range client.ignoreErrors {
+			if re.MatchString(event.Message) {
+				Logger.Println("Event dropped due to IgnoreErrors match.")
+				return nil
+			}
+		}
+	}
+
 	client.Transport.SendEvent(event)
 
 	return &event.EventID

client_test.go

@@ -552,6 +552,115 @@ func TestBeforeSendTransactionIsCalled(t *testing.T) {
 	assertEqual(t, lastEvent.Contexts["trace"]["span_id"], transaction.SpanID)
 }
 
+func TestIgnoreErrors(t *testing.T) {
+	tests := []struct {
+		name         string
+		ignoreErrors []string
+		message      string
+		expectDrop   bool
+	}{
+		{
+			name:         "No Match",
+			message:      "Foo",
+			ignoreErrors: []string{"Bar", "Baz"},
+			expectDrop:   false,
+		},
+		{
+			name:         "Partial Match",
+			message:      "FooBar",
+			ignoreErrors: []string{"Foo", "Baz"},
+			expectDrop:   true,
+		},
+		{
+			name:         "Exact Match",
+			message:      "Foo Bar",
+			ignoreErrors: []string{"\\bFoo\\b", "Baz"},
+			expectDrop:   true,
+		},
+		{
+			name:         "Wildcard Match",
+			message:      "Foo",
+			ignoreErrors: []string{"F*", "Bar"},
+			expectDrop:   true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			scope := &ScopeMock{}
+			transport := &TransportMock{}
+			client, err := NewClient(ClientOptions{
+				Transport:    transport,
+				IgnoreErrors: tt.ignoreErrors,
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			client.CaptureMessage(tt.message, nil, scope)
+
+			dropped := transport.lastEvent == nil
+			if !(tt.expectDrop == dropped) {
+				t.Error("expected event to be dropped")
+			}
+		})
+	}
+}
+
+func TestIgnoreTransactions(t *testing.T) {
+	tests := []struct {
+		name               string
+		ignoreTransactions []string
+		transaction        string
+		expectDrop         bool
+	}{
+		{
+			name:               "No Match",
+			transaction:        "Foo",
+			ignoreTransactions: []string{"Bar", "Baz"},
+			expectDrop:         false,
+		},
+		{
+			name:               "Partial Match",
+			transaction:        "FooBar",
+			ignoreTransactions: []string{"Foo", "Baz"},
+			expectDrop:         true,
+		},
+		{
+			name:               "Exact Match",
+			transaction:        "Foo Bar",
+			ignoreTransactions: []string{"\\bFoo\\b", "Baz"},
+			expectDrop:         true,
+		},
+		{
+			name:               "Wildcard Match",
+			transaction:        "Foo",
+			ignoreTransactions: []string{"F*", "Bar"},
+			expectDrop:         true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			transport := &TransportMock{}
+			ctx := NewTestContext(ClientOptions{
+				EnableTracing:      true,
+				TracesSampleRate:   1.0,
+				Transport:          transport,
+				IgnoreTransactions: tt.ignoreTransactions,
+			})
+
+			transaction := StartTransaction(ctx,
+				tt.transaction,
+			)
+			transaction.Finish()
+
+			dropped := transport.lastEvent == nil
+			if !(tt.expectDrop == dropped) {
+				t.Error("expected event to be dropped")
+			}
+		})
+	}
+}
+
 func TestSampleRate(t *testing.T) {
 	tests := []struct {
 		SampleRate float64