union type options object, improve filtering performance

Author: Lms24

packages/core/src/client.ts

@@ -1296,7 +1296,7 @@ function processBeforeSend(
       const rootSpanJson = convertTransactionEventToSpanJson(processedEvent);
 
       // 1.1 If the root span should be ignored, drop the whole transaction
-      if (shouldIgnoreSpan(rootSpanJson, ignoreSpans)) {
+      if (ignoreSpans?.length && shouldIgnoreSpan(rootSpanJson, ignoreSpans)) {
         // dropping the whole transaction!
         return null;
       }
@@ -1320,7 +1320,7 @@ function processBeforeSend(
 
         for (const span of initialSpans) {
           // 2.a If the child span should be ignored, reparent it to the root span
-          if (shouldIgnoreSpan(span, ignoreSpans)) {
+          if (ignoreSpans?.length && shouldIgnoreSpan(span, ignoreSpans)) {
             reparentChildSpans(initialSpans, span);
             continue;
           }

packages/core/src/envelope.ts

@@ -125,7 +125,9 @@ export function createSpanEnvelope(spans: [SentrySpan, ...SentrySpan[]], client?
 
   const { beforeSendSpan, ignoreSpans } = client?.getOptions() || {};
 
-  const filteredSpans = ignoreSpans ? spans.filter(span => !shouldIgnoreSpan(spanToJSON(span), ignoreSpans)) : spans;
+  const filteredSpans = ignoreSpans?.length
+    ? spans.filter(span => !shouldIgnoreSpan(spanToJSON(span), ignoreSpans))
+    : spans;
   const droppedSpans = spans.length - filteredSpans.length;
 
   if (droppedSpans) {

packages/core/src/types-hoist/options.ts

@@ -10,10 +10,31 @@ import type { StackLineParser, StackParser } from './stacktrace';
 import type { TracePropagationTargets } from './tracing';
 import type { BaseTransportOptions, Transport } from './transport';
 
-interface IgnoreSpanFilter {
-  name?: string | RegExp;
-  op?: string | RegExp;
-}
+/**
+ * A filter object for ignoring spans.
+ * At least one of the properties (`op` or `name`) must be set.
+ */
+type IgnoreSpanFilter =
+  | {
+      /**
+       * Spans with a name matching this pattern will be ignored.
+       */
+      name: string | RegExp;
+      /**
+       * Spans with an op matching this pattern will be ignored.
+       */
+      op?: string | RegExp;
+    }
+  | {
+      /**
+       * Spans with a name matching this pattern will be ignored.
+       */
+      name?: string | RegExp;
+      /**
+       * Spans with an op matching this pattern will be ignored.
+       */
+      op: string | RegExp;
+    };
 
 export interface ClientOptions<TO extends BaseTransportOptions = BaseTransportOptions> {
   /**
@@ -216,6 +237,9 @@ export interface ClientOptions<TO extends BaseTransportOptions = BaseTransportOp
   /**
    * A list of span names or patterns to ignore.
    *
+   * If you specify a pattern {@link IgnoreSpanFilter}, at least one
+   * of the properties (`op` or `name`) must be set.
+   *
    * @default []
    */
   ignoreSpans?: (string | RegExp | IgnoreSpanFilter)[];

packages/core/src/utils/should-ignore-span.ts

@@ -1,38 +1,37 @@
 import type { ClientOptions } from '../types-hoist/options';
 import type { SpanJSON } from '../types-hoist/span';
-import { isMatchingPattern, stringMatchesSomePattern } from './string';
+import { isMatchingPattern } from './string';
 
 /**
  * Check if a span should be ignored based on the ignoreSpans configuration.
  */
 export function shouldIgnoreSpan(
   span: Pick<SpanJSON, 'description' | 'op'>,
-  ignoreSpans: ClientOptions['ignoreSpans'],
+  ignoreSpans: Required<ClientOptions>['ignoreSpans'],
 ): boolean {
-  if (!ignoreSpans?.length) {
+  if (!ignoreSpans?.length || !span.description) {
     return false;
   }
 
-  if (!span.description) {
-    return false;
-  }
-
-  // First we check the simple string/regex patterns - if the name matches any of them, we ignore the span
-  const simplePatterns = ignoreSpans.filter(isStringOrRegExp);
-  if (simplePatterns.length && stringMatchesSomePattern(span.description, simplePatterns)) {
-    return true;
-  }
-
-  // Then we check the more complex patterns, where both parts must match
   for (const pattern of ignoreSpans) {
-    // Have already checked for simple patterns, so we can skip these
-    if (isStringOrRegExp(pattern) || (!pattern.name && !pattern.op)) {
+    if (isStringOrRegExp(pattern)) {
+      if (isMatchingPattern(span.description, pattern)) {
+        return true;
+      }
+      continue;
+    }
+
+    if (!pattern.name && !pattern.op) {
       continue;
     }
 
     const nameMatches = pattern.name ? isMatchingPattern(span.description, pattern.name) : true;
     const opMatches = pattern.op ? span.op && isMatchingPattern(span.op, pattern.op) : true;
 
+    // This check here is only correct because we can guarantee that we ran `isMatchingPattern`
+    // for at least one of `nameMatches` and `opMatches`. So in contrary to how this looks,
+    // not both op and name actually have to match. This is the most efficient way to check
+    // for all combinations of name and op patterns.
     if (nameMatches && opMatches) {
       return true;
     }

packages/core/test/lib/utils/should-ignore-span.test.ts

@@ -5,7 +5,7 @@ import { reparentChildSpans, shouldIgnoreSpan } from '../../../src/utils/should-
 describe('shouldIgnoreSpan', () => {
   it('should not ignore spans with empty ignoreSpans', () => {
     const span = { description: 'test', op: 'test' };
-    const ignoreSpans = [] as ClientOptions['ignoreSpans'];
+    const ignoreSpans = [] as Required<ClientOptions>['ignoreSpans'];
     expect(shouldIgnoreSpan(span, ignoreSpans)).toBe(false);
   });