fix(elysia): scope empty span filtering to Elysia spans only and add e2e test

Move span enrichment and filtering into clientHooks.ts. Filter empty
<unknown> spans only when they are children of Elysia lifecycle spans,
avoiding accidental removal of spans from other integrations. Removes
the global emptySpanIds Set entirely — no memory leak possible.

Add e2e test verifying no <unknown> spans appear in transactions.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: logaretm

dev-packages/e2e-tests/test-applications/bun-elysia/tests/transactions.test.ts

@@ -138,6 +138,27 @@ test('Creates lifecycle spans for Elysia hooks', async ({ baseURL, request }) =>
   );
 });
 
+test('Filters out empty anonymous Elysia spans but keeps all other spans', async ({ baseURL, request }) => {
+  const transactionEventPromise = waitForTransaction('bun-elysia', transactionEvent => {
+    return (
+      transactionEvent?.contexts?.trace?.op === 'http.server' && transactionEvent?.transaction === 'GET /test-success'
+    );
+  });
+
+  await request.get(`${baseURL}/test-success`);
+
+  const transactionEvent = await transactionEventPromise;
+  const spans = transactionEvent.spans || [];
+
+  // Elysia produces empty anonymous spans for arrow function handlers that show up as <unknown>.
+  // These should be filtered out by our beforeSendEvent hook.
+  const unknownSpans = spans.filter(span => span.description === '<unknown>');
+  expect(unknownSpans).toHaveLength(0);
+
+  // But named Elysia lifecycle spans should still be present
+  expect(spans.filter(span => span.origin === 'auto.http.otel.elysia').length).toBeGreaterThan(0);
+});
+
 test('Creates lifecycle spans for route-specific middleware', async ({ baseURL, request }) => {
   const transactionEventPromise = waitForTransaction('bun-elysia', transactionEvent => {
     return (

packages/elysia/src/clientHooks.ts

@@ -0,0 +1,63 @@
+import type { Client, Event, Span } from '@sentry/core';
+import { SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, spanToJSON } from '@sentry/core';
+
+const ELYSIA_ORIGIN = 'auto.http.otel.elysia';
+
+const ELYSIA_LIFECYCLE_OP_MAP: Record<string, string> = {
+  Request: 'middleware.elysia',
+  Parse: 'middleware.elysia',
+  Transform: 'middleware.elysia',
+  BeforeHandle: 'middleware.elysia',
+  Handle: 'request_handler.elysia',
+  AfterHandle: 'middleware.elysia',
+  MapResponse: 'middleware.elysia',
+  AfterResponse: 'middleware.elysia',
+  Error: 'middleware.elysia',
+};
+
+/**
+ * Enrich Elysia lifecycle spans with semantic op and origin,
+ * and filter out empty anonymous child spans that Elysia produces.
+ */
+export function setupClientHooks(client: Client): void {
+  // Enrich Elysia lifecycle spans with semantic op and origin.
+  // We mutate the attributes directly because the span has already ended
+  // and `setAttribute()` is a no-op on ended OTel spans.
+  client.on('spanEnd', (span: Span) => {
+    const spanData = spanToJSON(span);
+    const op = ELYSIA_LIFECYCLE_OP_MAP[spanData.description || ''];
+    if (op && spanData.data) {
+      const attrs = spanData.data;
+      attrs[SEMANTIC_ATTRIBUTE_SENTRY_OP] = op;
+      attrs[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] = ELYSIA_ORIGIN;
+    }
+  });
+
+  // Filter out empty child spans that Elysia produces for each function handler.
+  // Users usually use arrow functions so they show up as <unknown>.
+  // We identify Elysia spans by checking if their parent is an Elysia lifecycle span
+  // (one we enriched with our origin), so we don't accidentally drop spans from other integrations.
+  client.on('beforeSendEvent', (event: Event) => {
+    if (event.type === 'transaction' && event.spans) {
+      const elysiaSpanIds = new Set<string>();
+      for (const span of event.spans) {
+        if (span.origin === ELYSIA_ORIGIN) {
+          elysiaSpanIds.add(span.span_id);
+        }
+      }
+
+      if (elysiaSpanIds.size > 0) {
+        event.spans = event.spans.filter(span => {
+          if (
+            (!span.description || span.description === '<unknown>') &&
+            span.parent_span_id &&
+            elysiaSpanIds.has(span.parent_span_id)
+          ) {
+            return false;
+          }
+          return true;
+        });
+      }
+    }
+  });
+}

packages/elysia/src/withElysia.ts

@@ -4,35 +4,17 @@ import {
   getClient,
   getIsolationScope,
   getTraceData,
-  SEMANTIC_ATTRIBUTE_SENTRY_OP,
-  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
-  spanToJSON,
   winterCGRequestToRequestData,
 } from '@sentry/core';
 import type { Elysia, ErrorContext } from 'elysia';
+import { setupClientHooks } from './clientHooks';
 
 interface ElysiaHandlerOptions {
   shouldHandleError: (context: ErrorContext) => boolean;
 }
 
-const ELYSIA_ORIGIN = 'auto.http.otel.elysia';
-
 let isClientHooksSetup = false;
 const instrumentedApps = new WeakSet<Elysia>();
-const emptySpanIds = new Set<string>();
-const MAX_EMPTY_SPAN_IDS = 1000;
-
-const ELYSIA_LIFECYCLE_OP_MAP: Record<string, string> = {
-  Request: 'middleware.elysia',
-  Parse: 'middleware.elysia',
-  Transform: 'middleware.elysia',
-  BeforeHandle: 'middleware.elysia',
-  Handle: 'request_handler.elysia',
-  AfterHandle: 'middleware.elysia',
-  MapResponse: 'middleware.elysia',
-  AfterResponse: 'middleware.elysia',
-  Error: 'middleware.elysia',
-};
 
 function defaultShouldHandleError(context: ErrorContext): boolean {
   const status = context.set.status;
@@ -82,48 +64,7 @@ export function withElysia<T extends Elysia>(app: T, options?: Partial<ElysiaHan
     const client = getClient();
     if (client) {
       isClientHooksSetup = true;
-
-      // Enrich Elysia lifecycle spans with semantic op and origin,
-      // and mark empty spans that Elysia produces as children of lifecycle spans.
-      client.on('spanEnd', span => {
-        const spanData = spanToJSON(span);
-
-        // Elysia produces empty spans for each function handler.
-        // Users usually use arrow functions so they show up as <unknown>.
-        // We track their IDs here so we can drop them in beforeSendEvent.
-        // Named functions will still show up with their name.
-        if (!spanData.description && (!spanData.data || Object.keys(spanData.data).length === 0)) {
-          if (emptySpanIds.size >= MAX_EMPTY_SPAN_IDS) {
-            emptySpanIds.clear();
-          }
-          emptySpanIds.add(spanData.span_id);
-          return;
-        }
-
-        // Enrich Elysia lifecycle spans with semantic op and origin.
-        // We mutate the attributes directly because the span has already ended
-        // and `setAttribute()` is a no-op on ended OTel spans.
-        const op = ELYSIA_LIFECYCLE_OP_MAP[spanData.description || ''];
-        if (op && spanData.data) {
-          const attrs = spanData.data;
-          attrs[SEMANTIC_ATTRIBUTE_SENTRY_OP] = op;
-          attrs[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] = ELYSIA_ORIGIN;
-        }
-      });
-
-      // Filter out the empty spans we marked above before sending the transaction,
-      // and delete matched IDs individually to avoid clearing IDs from concurrent transactions.
-      client.on('beforeSendEvent', event => {
-        if (event.type === 'transaction' && event.spans) {
-          event.spans = event.spans.filter(span => {
-            if (!emptySpanIds.has(span.span_id)) {
-              return true;
-            }
-            emptySpanIds.delete(span.span_id);
-            return false;
-          });
-        }
-      });
+      setupClientHooks(client);
     }
   }