feat(core): Add ignoreTransactions option

packages/core/src/integrations/inboundfilters.ts

@@ -10,6 +10,7 @@ export interface InboundFiltersOptions {
   allowUrls: Array<string | RegExp>;
   denyUrls: Array<string | RegExp>;
   ignoreErrors: Array<string | RegExp>;
+  ignoreTransactions: Array<string | RegExp>;
   ignoreInternal: boolean;
 }
 
@@ -63,6 +64,7 @@ export function _mergeOptions(
       ...(clientOptions.ignoreErrors || []),
       ...DEFAULT_IGNORE_ERRORS,
     ],
+    ignoreTransactions: [...(internalOptions.ignoreTransactions || []), ...(clientOptions.ignoreTransactions || [])],
     ignoreInternal: internalOptions.ignoreInternal !== undefined ? internalOptions.ignoreInternal : true,
   };
 }
@@ -81,6 +83,13 @@ export function _shouldDropEvent(event: Event, options: Partial<InboundFiltersOp
       );
     return true;
   }
+  if (_isIgnoredTransaction(event, options.ignoreTransactions)) {
+    __DEBUG_BUILD__ &&
+      logger.warn(
+        `Event dropped due to being matched by \`ignoreTransactions\` option.\nEvent: ${getEventDescription(event)}`,
+      );
+    return true;
+  }
   if (_isDeniedUrl(event, options.denyUrls)) {
     __DEBUG_BUILD__ &&
       logger.warn(
@@ -111,6 +120,15 @@ function _isIgnoredError(event: Event, ignoreErrors?: Array<string | RegExp>): b
   return _getPossibleEventMessages(event).some(message => stringMatchesSomePattern(message, ignoreErrors));
 }
 
+function _isIgnoredTransaction(event: Event, ignoreTransactions?: Array<string | RegExp>): boolean {
+  if (event.type !== 'transaction' || !ignoreTransactions || !ignoreTransactions.length) {
+    return false;
+  }
+
+  const name = event.transaction;
+  return name ? stringMatchesSomePattern(name, ignoreTransactions) : false;
+}
+
 function _isDeniedUrl(event: Event, denyUrls?: Array<string | RegExp>): boolean {
   // TODO: Use Glob instead?
   if (!denyUrls || !denyUrls.length) {

packages/core/test/lib/integrations/inboundfilters.test.ts

@@ -179,6 +179,17 @@ const MALFORMED_EVENT: Event = {
 
 const TRANSACTION_EVENT: Event = {
   message: 'transaction message',
+  transaction: 'transaction name',
+  type: 'transaction',
+};
+
+const TRANSACTION_EVENT_2: Event = {
+  transaction: 'transaction name 2',
+  type: 'transaction',
+};
+
+const TRANSACTION_EVENT_3: Event = {
+  transaction: 'other name',
   type: 'transaction',
 };
 
@@ -284,6 +295,58 @@ describe('InboundFilters', () => {
     });
   });
 
+  describe('ignoreTransactions', () => {
+    it('string filter with partial match', () => {
+      const eventProcessor = createInboundFiltersEventProcessor({
+        ignoreTransactions: ['name'],
+      });
+      expect(eventProcessor(TRANSACTION_EVENT, {})).toBe(null);
+    });
+
+    it('ignores error event for filtering', () => {
+      const eventProcessor = createInboundFiltersEventProcessor({
+        ignoreTransactions: ['capture'],
+      });
+      expect(eventProcessor(MESSAGE_EVENT, {})).toBe(MESSAGE_EVENT);
+    });
+
+    it('string filter with exact match', () => {
+      const eventProcessor = createInboundFiltersEventProcessor({
+        ignoreTransactions: ['transaction name'],
+      });
+      expect(eventProcessor(TRANSACTION_EVENT, {})).toBe(null);
+    });
+
+    it('regexp filter with partial match', () => {
+      const eventProcessor = createInboundFiltersEventProcessor({
+        ignoreTransactions: [/name/],
+      });
+      expect(eventProcessor(TRANSACTION_EVENT, {})).toBe(null);
+    });
+
+    it('regexp filter with exact match', () => {
+      const eventProcessor = createInboundFiltersEventProcessor({
+        ignoreTransactions: [/^transaction name$/],
+      });
+      expect(eventProcessor(TRANSACTION_EVENT, {})).toBe(null);
+      expect(eventProcessor(TRANSACTION_EVENT_2, {})).toBe(TRANSACTION_EVENT_2);
+    });
+
+    it('can use multiple filters', () => {
+      const eventProcessor = createInboundFiltersEventProcessor({
+        ignoreTransactions: ['transaction name 2', /transaction/],
+      });
+      expect(eventProcessor(TRANSACTION_EVENT, {})).toBe(null);
+      expect(eventProcessor(TRANSACTION_EVENT_2, {})).toBe(null);
+      expect(eventProcessor(TRANSACTION_EVENT_3, {})).toBe(TRANSACTION_EVENT_3);
+    });
+
+    it('uses default filters', () => {
+      const eventProcessor = createInboundFiltersEventProcessor();
+      expect(eventProcessor(TRANSACTION_EVENT, {})).toBe(TRANSACTION_EVENT);
+    });
+  });
+
   describe('denyUrls/allowUrls', () => {
     it('should filter captured message based on its stack trace using string filter', () => {
       const eventProcessorDeny = createInboundFiltersEventProcessor({

packages/types/src/options.ts

@@ -162,6 +162,12 @@ export interface ClientOptions<TO extends BaseTransportOptions = BaseTransportOp
    */
   ignoreErrors?: Array<string | RegExp>;
 
+  /**
+   * A pattern for transaction names which should not be sent to Sentry.
+   * By default, all transactions will be sent.
+   */
+  ignoreTransactions?: Array<string | RegExp>;
+
   /**
    * A URL to an envelope tunnel endpoint. An envelope tunnel is an HTTP endpoint
    * that accepts Sentry envelopes for forwarding. This can be used to force data