@sentry/elysia 10.46.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Functional Software, Inc. dba Sentry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,38 @@
+<p align="center">
+  <a href="https://sentry.io/?utm_source=github&utm_medium=logo" target="_blank">
+    <img src="https://sentry-brand.storage.googleapis.com/sentry-wordmark-dark-280x84.png" alt="Sentry" width="280" height="84">
+  </a>
+</p>
+
+> NOTICE: This package is in alpha state and may be subject to breaking changes.
+
+# Official Sentry SDK for Elysia
+
+[![npm version](https://img.shields.io/npm/v/@sentry/elysia.svg)](https://www.npmjs.com/package/@sentry/elysia)
+[![npm dm](https://img.shields.io/npm/dm/@sentry/elysia.svg)](https://www.npmjs.com/package/@sentry/elysia)
+[![npm dt](https://img.shields.io/npm/dt/@sentry/elysia.svg)](https://www.npmjs.com/package/@sentry/elysia)
+
+> **Alpha**: This SDK is in alpha stage and may have breaking changes in future releases.
+
+## Usage
+
+```javascript
+import * as Sentry from '@sentry/elysia';
+import { Elysia } from 'elysia';
+
+Sentry.init({
+  dsn: '__DSN__',
+  tracesSampleRate: 1.0,
+});
+
+const app = Sentry.withElysia(new Elysia())
+  .get('/', () => 'Hello World')
+  .listen(3000);
+```
+
+## Links
+
+<!-- - [Official SDK Docs](https://docs.sentry.io/platforms/javascript/guides/elysia/) -->
+
+- [Sentry.io](https://sentry.io/?utm_source=github&utm_medium=npm_elysia)
+- [Sentry Discord Server](https://discord.gg/Ww9hbqr)

package/build/cjs/index.js

@@ -0,0 +1,170 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const bun = require('@sentry/bun');
+const core = require('@sentry/core');
+const withElysia = require('./withElysia.js');
+const sdk = require('./sdk.js');
+
+
+
+exports.NodeClient = bun.NodeClient;
+exports.OpenFeatureIntegrationHook = bun.OpenFeatureIntegrationHook;
+exports.SDK_VERSION = bun.SDK_VERSION;
+exports.SEMANTIC_ATTRIBUTE_SENTRY_OP = bun.SEMANTIC_ATTRIBUTE_SENTRY_OP;
+exports.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN = bun.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN;
+exports.SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE = bun.SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE;
+exports.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE = bun.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE;
+exports.Scope = bun.Scope;
+exports.addBreadcrumb = bun.addBreadcrumb;
+exports.addEventProcessor = bun.addEventProcessor;
+exports.addIntegration = bun.addIntegration;
+exports.amqplibIntegration = bun.amqplibIntegration;
+exports.anrIntegration = bun.anrIntegration;
+exports.anthropicAIIntegration = bun.anthropicAIIntegration;
+exports.buildLaunchDarklyFlagUsedHandler = bun.buildLaunchDarklyFlagUsedHandler;
+exports.bunServerIntegration = bun.bunServerIntegration;
+exports.captureCheckIn = bun.captureCheckIn;
+exports.captureEvent = bun.captureEvent;
+exports.captureException = bun.captureException;
+exports.captureFeedback = bun.captureFeedback;
+exports.captureMessage = bun.captureMessage;
+exports.captureSession = bun.captureSession;
+exports.close = bun.close;
+exports.connectIntegration = bun.connectIntegration;
+exports.consoleIntegration = bun.consoleIntegration;
+exports.consoleLoggingIntegration = bun.consoleLoggingIntegration;
+exports.contextLinesIntegration = bun.contextLinesIntegration;
+exports.continueTrace = bun.continueTrace;
+exports.createConsolaReporter = bun.createConsolaReporter;
+exports.createGetModuleFromFilename = bun.createGetModuleFromFilename;
+exports.createLangChainCallbackHandler = bun.createLangChainCallbackHandler;
+exports.createSentryWinstonTransport = bun.createSentryWinstonTransport;
+exports.createTransport = bun.createTransport;
+exports.cron = bun.cron;
+exports.dataloaderIntegration = bun.dataloaderIntegration;
+exports.defaultStackParser = bun.defaultStackParser;
+exports.disableAnrDetectionForCallback = bun.disableAnrDetectionForCallback;
+exports.endSession = bun.endSession;
+exports.eventFiltersIntegration = bun.eventFiltersIntegration;
+exports.expressErrorHandler = bun.expressErrorHandler;
+exports.expressIntegration = bun.expressIntegration;
+exports.fastifyIntegration = bun.fastifyIntegration;
+exports.featureFlagsIntegration = bun.featureFlagsIntegration;
+exports.firebaseIntegration = bun.firebaseIntegration;
+exports.flush = bun.flush;
+exports.fsIntegration = bun.fsIntegration;
+exports.functionToStringIntegration = bun.functionToStringIntegration;
+exports.generateInstrumentOnce = bun.generateInstrumentOnce;
+exports.genericPoolIntegration = bun.genericPoolIntegration;
+exports.getActiveSpan = bun.getActiveSpan;
+exports.getAutoPerformanceIntegrations = bun.getAutoPerformanceIntegrations;
+exports.getClient = bun.getClient;
+exports.getCurrentScope = bun.getCurrentScope;
+exports.getGlobalScope = bun.getGlobalScope;
+exports.getIsolationScope = bun.getIsolationScope;
+exports.getRootSpan = bun.getRootSpan;
+exports.getSentryRelease = bun.getSentryRelease;
+exports.getSpanDescendants = bun.getSpanDescendants;
+exports.getSpanStatusFromHttpCode = bun.getSpanStatusFromHttpCode;
+exports.getTraceData = bun.getTraceData;
+exports.getTraceMetaTags = bun.getTraceMetaTags;
+exports.googleGenAIIntegration = bun.googleGenAIIntegration;
+exports.graphqlIntegration = bun.graphqlIntegration;
+exports.growthbookIntegration = bun.growthbookIntegration;
+exports.hapiIntegration = bun.hapiIntegration;
+exports.honoIntegration = bun.honoIntegration;
+exports.httpHeadersToSpanAttributes = bun.httpHeadersToSpanAttributes;
+exports.httpIntegration = bun.httpIntegration;
+exports.httpServerIntegration = bun.httpServerIntegration;
+exports.httpServerSpansIntegration = bun.httpServerSpansIntegration;
+exports.inboundFiltersIntegration = bun.inboundFiltersIntegration;
+exports.initOpenTelemetry = bun.initOpenTelemetry;
+exports.instrumentAnthropicAiClient = bun.instrumentAnthropicAiClient;
+exports.instrumentGoogleGenAIClient = bun.instrumentGoogleGenAIClient;
+exports.instrumentLangGraph = bun.instrumentLangGraph;
+exports.instrumentOpenAiClient = bun.instrumentOpenAiClient;
+exports.instrumentStateGraphCompile = bun.instrumentStateGraphCompile;
+exports.instrumentSupabaseClient = bun.instrumentSupabaseClient;
+exports.isEnabled = bun.isEnabled;
+exports.isInitialized = bun.isInitialized;
+exports.kafkaIntegration = bun.kafkaIntegration;
+exports.knexIntegration = bun.knexIntegration;
+exports.koaIntegration = bun.koaIntegration;
+exports.langChainIntegration = bun.langChainIntegration;
+exports.langGraphIntegration = bun.langGraphIntegration;
+exports.lastEventId = bun.lastEventId;
+exports.launchDarklyIntegration = bun.launchDarklyIntegration;
+exports.linkedErrorsIntegration = bun.linkedErrorsIntegration;
+exports.localVariablesIntegration = bun.localVariablesIntegration;
+exports.logger = bun.logger;
+exports.lruMemoizerIntegration = bun.lruMemoizerIntegration;
+exports.makeFetchTransport = bun.makeFetchTransport;
+exports.makeNodeTransport = bun.makeNodeTransport;
+exports.metrics = bun.metrics;
+exports.modulesIntegration = bun.modulesIntegration;
+exports.mongoIntegration = bun.mongoIntegration;
+exports.mongooseIntegration = bun.mongooseIntegration;
+exports.mysql2Integration = bun.mysql2Integration;
+exports.mysqlIntegration = bun.mysqlIntegration;
+exports.nativeNodeFetchIntegration = bun.nativeNodeFetchIntegration;
+exports.nodeContextIntegration = bun.nodeContextIntegration;
+exports.onUncaughtExceptionIntegration = bun.onUncaughtExceptionIntegration;
+exports.onUnhandledRejectionIntegration = bun.onUnhandledRejectionIntegration;
+exports.openAIIntegration = bun.openAIIntegration;
+exports.openFeatureIntegration = bun.openFeatureIntegration;
+exports.parameterize = bun.parameterize;
+exports.postgresIntegration = bun.postgresIntegration;
+exports.postgresJsIntegration = bun.postgresJsIntegration;
+exports.prismaIntegration = bun.prismaIntegration;
+exports.processSessionIntegration = bun.processSessionIntegration;
+exports.profiler = bun.profiler;
+exports.redisIntegration = bun.redisIntegration;
+exports.requestDataIntegration = bun.requestDataIntegration;
+exports.setContext = bun.setContext;
+exports.setConversationId = bun.setConversationId;
+exports.setCurrentClient = bun.setCurrentClient;
+exports.setExtra = bun.setExtra;
+exports.setExtras = bun.setExtras;
+exports.setHttpStatus = bun.setHttpStatus;
+exports.setMeasurement = bun.setMeasurement;
+exports.setTag = bun.setTag;
+exports.setTags = bun.setTags;
+exports.setUser = bun.setUser;
+exports.setupConnectErrorHandler = bun.setupConnectErrorHandler;
+exports.setupExpressErrorHandler = bun.setupExpressErrorHandler;
+exports.setupFastifyErrorHandler = bun.setupFastifyErrorHandler;
+exports.setupHapiErrorHandler = bun.setupHapiErrorHandler;
+exports.setupHonoErrorHandler = bun.setupHonoErrorHandler;
+exports.setupKoaErrorHandler = bun.setupKoaErrorHandler;
+exports.spanToBaggageHeader = bun.spanToBaggageHeader;
+exports.spanToJSON = bun.spanToJSON;
+exports.spanToTraceHeader = bun.spanToTraceHeader;
+exports.spotlightIntegration = bun.spotlightIntegration;
+exports.startInactiveSpan = bun.startInactiveSpan;
+exports.startNewTrace = bun.startNewTrace;
+exports.startSession = bun.startSession;
+exports.startSpan = bun.startSpan;
+exports.startSpanManual = bun.startSpanManual;
+exports.statsigIntegration = bun.statsigIntegration;
+exports.supabaseIntegration = bun.supabaseIntegration;
+exports.suppressTracing = bun.suppressTracing;
+exports.tediousIntegration = bun.tediousIntegration;
+exports.trpcMiddleware = bun.trpcMiddleware;
+exports.unleashIntegration = bun.unleashIntegration;
+exports.updateSpanName = bun.updateSpanName;
+exports.vercelAIIntegration = bun.vercelAIIntegration;
+exports.winterCGHeadersToDict = bun.winterCGHeadersToDict;
+exports.withActiveSpan = bun.withActiveSpan;
+exports.withIsolationScope = bun.withIsolationScope;
+exports.withMonitor = bun.withMonitor;
+exports.withScope = bun.withScope;
+exports.wrapMcpServerWithSentry = bun.wrapMcpServerWithSentry;
+exports.zodErrorsIntegration = bun.zodErrorsIntegration;
+exports.captureConsoleIntegration = core.captureConsoleIntegration;
+exports.dedupeIntegration = core.dedupeIntegration;
+exports.extraErrorDataIntegration = core.extraErrorDataIntegration;
+exports.rewriteFramesIntegration = core.rewriteFramesIntegration;
+exports.withElysia = withElysia.withElysia;
+exports.getDefaultIntegrations = sdk.getDefaultIntegrations;
+exports.init = sdk.init;
+//# sourceMappingURL=index.js.map

package/build/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/cjs/sdk.js

@@ -0,0 +1,59 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const os = require('node:os');
+const bun = require('@sentry/bun');
+const core = require('@sentry/core');
+
+/** Get the default integrations for the Elysia SDK. */
+function getDefaultIntegrations(_options) {
+  // Filter out bunServerIntegration
+  // Elysia already produces an HTTP server span, so we don't need Bun's competing root span.
+  return bun.getDefaultIntegrations(_options).filter(i => i.name !== bun.bunServerIntegration().name);
+}
+
+/**
+ * Get the runtime name and version.
+ */
+function getRuntime() {
+  if (typeof Bun !== 'undefined') {
+    return { name: 'bun', version: Bun.version };
+  }
+
+  return { name: 'node', version: process.version };
+}
+
+/**
+ * Initializes the Sentry Elysia SDK.
+ *
+ * @example
+ * ```javascript
+ * import * as Sentry from '@sentry/elysia';
+ *
+ * Sentry.init({
+ *   dsn: '__DSN__',
+ *   tracesSampleRate: 1.0,
+ * });
+ * ```
+ */
+function init(userOptions = {}) {
+  const options = {
+    ...userOptions,
+    platform: 'javascript',
+    runtime: getRuntime(),
+    serverName: userOptions.serverName || global.process.env.SENTRY_NAME || os.hostname(),
+  };
+
+  core.applySdkMetadata(userOptions, 'elysia', ['elysia', options.runtime.name]);
+
+  options.transport = options.transport || bun.makeFetchTransport;
+
+  if (options.defaultIntegrations === undefined) {
+    options.defaultIntegrations = getDefaultIntegrations(options);
+  }
+
+  return bun.init(options);
+}
+
+exports.getDefaultIntegrations = getDefaultIntegrations;
+exports.init = init;
+//# sourceMappingURL=sdk.js.map

package/build/cjs/sdk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.js","sources":["../../src/sdk.ts"],"sourcesContent":["import * as os from 'node:os';\nimport {\n  bunServerIntegration,\n  getDefaultIntegrations as getBunDefaultIntegrations,\n  makeFetchTransport,\n} from '@sentry/bun';\nimport type { Integration, Options } from '@sentry/core';\nimport { applySdkMetadata } from '@sentry/core';\nimport { init as initNode, type NodeClient } from '@sentry/bun';\nimport type { ElysiaOptions } from './types';\n\n/** Get the default integrations for the Elysia SDK. */\nexport function getDefaultIntegrations(_options: Options): Integration[] {\n  // Filter out bunServerIntegration\n  // Elysia already produces an HTTP server span, so we don't need Bun's competing root span.\n  return getBunDefaultIntegrations(_options).filter(i => i.name !== bunServerIntegration().name);\n}\n\n/**\n * Get the runtime name and version.\n */\nfunction getRuntime(): { name: string; version: string } {\n  if (typeof Bun !== 'undefined') {\n    return { name: 'bun', version: Bun.version };\n  }\n\n  return { name: 'node', version: process.version };\n}\n\n/**\n * Initializes the Sentry Elysia SDK.\n *\n * @example\n * ```javascript\n * import * as Sentry from '@sentry/elysia';\n *\n * Sentry.init({\n *   dsn: '__DSN__',\n *   tracesSampleRate: 1.0,\n * });\n * ```\n */\nexport function init(userOptions: ElysiaOptions = {}): NodeClient | undefined {\n  const options = {\n    ...userOptions,\n    platform: 'javascript',\n    runtime: getRuntime(),\n    serverName: userOptions.serverName || global.process.env.SENTRY_NAME || os.hostname(),\n  };\n\n  applySdkMetadata(userOptions, 'elysia', ['elysia', options.runtime.name]);\n\n  options.transport = options.transport || makeFetchTransport;\n\n  if (options.defaultIntegrations === undefined) {\n    options.defaultIntegrations = getDefaultIntegrations(options);\n  }\n\n  return initNode(options);\n}\n"],"names":["getBunDefaultIntegrations","bunServerIntegration","applySdkMetadata","makeFetchTransport","initNode"],"mappings":";;;;;;AAWA;AACO,SAAS,sBAAsB,CAAC,QAAQ,EAA0B;AACzE;AACA;AACA,EAAE,OAAOA,0BAAyB,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAA,IAAK,CAAC,CAAC,SAASC,wBAAoB,EAAE,CAAC,IAAI,CAAC;AAChG;;AAEA;AACA;AACA;AACA,SAAS,UAAU,GAAsC;AACzD,EAAE,IAAI,OAAO,GAAA,KAAQ,WAAW,EAAE;AAClC,IAAI,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,OAAA,EAAS;AAChD,EAAE;;AAEF,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,OAAA,EAAS;AACnD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,IAAI,CAAC,WAAW,GAAkB,EAAE,EAA0B;AAC9E,EAAE,MAAM,UAAU;AAClB,IAAI,GAAG,WAAW;AAClB,IAAI,QAAQ,EAAE,YAAY;AAC1B,IAAI,OAAO,EAAE,UAAU,EAAE;AACzB,IAAI,UAAU,EAAE,WAAW,CAAC,UAAA,IAAc,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,WAAA,IAAe,EAAE,CAAC,QAAQ,EAAE;AACzF,GAAG;;AAEH,EAAEC,qBAAgB,CAAC,WAAW,EAAE,QAAQ,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;;AAE3E,EAAE,OAAO,CAAC,SAAA,GAAY,OAAO,CAAC,SAAA,IAAaC,sBAAkB;;AAE7D,EAAE,IAAI,OAAO,CAAC,mBAAA,KAAwB,SAAS,EAAE;AACjD,IAAI,OAAO,CAAC,mBAAA,GAAsB,sBAAsB,CAAC,OAAO,CAAC;AACjE,EAAE;;AAEF,EAAE,OAAOC,QAAQ,CAAC,OAAO,CAAC;AAC1B;;;;;"}

package/build/cjs/withElysia.js

@@ -0,0 +1,299 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+
+const ELYSIA_ORIGIN = 'auto.http.elysia';
+
+/**
+ * Map Elysia lifecycle phase names to Sentry span ops.
+ */
+const ELYSIA_LIFECYCLE_OP_MAP = {
+  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 isBun() {
+  return typeof Bun !== 'undefined';
+}
+
+/**
+ * Per-request storage for the root span reference.
+ * .wrap() captures the root span and .trace() reads it.
+ * This is necessary because Elysia's .trace() callbacks may run in a different
+ * async context where getActiveSpan() returns undefined.
+ */
+const rootSpanForRequest = new WeakMap();
+
+const instrumentedApps = new WeakSet();
+
+/**
+ * Updates the root span and isolation scope with the parameterized route name.
+ */
+function updateRouteTransactionName(request, method, route) {
+  const transactionName = `${method} ${route}`;
+
+  // Try the stored root span first (reliable across async contexts),
+  // then fall back to getActiveSpan() for cases where async context is preserved.
+  const rootSpan = rootSpanForRequest.get(request);
+  if (rootSpan) {
+    core.updateSpanName(rootSpan, transactionName);
+    rootSpan.setAttribute(core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, 'route');
+  } else {
+    const activeSpan = core.getActiveSpan();
+    if (activeSpan) {
+      const root = core.getRootSpan(activeSpan);
+      core.updateSpanName(root, transactionName);
+      root.setAttribute(core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, 'route');
+    }
+  }
+
+  core.getIsolationScope().setTransactionName(transactionName);
+}
+
+function defaultShouldHandleError(context) {
+  const status = context.set.status;
+  if (status === undefined) {
+    return true;
+  }
+  const statusCode = parseInt(String(status), 10);
+  if (Number.isNaN(statusCode)) {
+    return true;
+  }
+  // Capture server errors (5xx) and unusual status codes (<= 299 in an error handler).
+  // 3xx and 4xx are not captured by default (client errors / redirects).
+  return statusCode >= 500 || statusCode <= 299;
+}
+
+/**
+ * Instruments a single Elysia lifecycle phase by creating a Sentry span for it,
+ * and child spans for each individual handler within the phase.
+ *
+ * @param rootSpan - The root server span to parent lifecycle spans under.
+ *   Must be passed explicitly because Elysia's .trace() listener callbacks run
+ *   in a different async context where getActiveSpan() returns undefined.
+ */
+function instrumentLifecyclePhase(phaseName, listener, rootSpan) {
+  const op = ELYSIA_LIFECYCLE_OP_MAP[phaseName];
+  if (!op) {
+    return;
+  }
+
+  void listener(process => {
+    const phaseSpan = core.startInactiveSpan({
+      name: phaseName,
+      parentSpan: rootSpan,
+      attributes: {
+        [core.SEMANTIC_ATTRIBUTE_SENTRY_OP]: op,
+        [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ELYSIA_ORIGIN,
+      },
+    });
+
+    // Create child spans for individual handlers within this phase.
+    // Named functions get their name, arrow functions get 'anonymous'.
+    if (process.total > 0) {
+      void process.onEvent(child => {
+        const handlerName = child.name || 'anonymous';
+        const childSpan = core.startInactiveSpan({
+          name: handlerName,
+          parentSpan: phaseSpan,
+          attributes: {
+            [core.SEMANTIC_ATTRIBUTE_SENTRY_OP]: op,
+            [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ELYSIA_ORIGIN,
+          },
+        });
+
+        void child.onStop(() => {
+          childSpan.end();
+        });
+      });
+    }
+
+    void process.onStop(() => {
+      phaseSpan.end();
+    });
+  });
+}
+
+/**
+ * Integrate Sentry with an Elysia app for error handling, request context,
+ * and tracing. Returns the app instance for chaining.
+ *
+ * Should be called at the **start** of the chain before defining routes.
+ *
+ * @param app The Elysia instance
+ * @param options Configuration options
+ * @returns The same Elysia instance for chaining
+ *
+ * @example
+ * ```javascript
+ * import * as Sentry from '@sentry/elysia';
+ * import { Elysia } from 'elysia';
+ *
+ * Sentry.withElysia(new Elysia())
+ *   .get('/', () => 'Hello World')
+ *   .listen(3000);
+ * ```
+ */
+function withElysia(app, options = {}) {
+  if (instrumentedApps.has(app)) {
+    return app;
+  }
+  instrumentedApps.add(app);
+
+  // Use .wrap() to capture or create the root span for each request.
+  // This is necessary because Elysia's .trace() callbacks run in a different
+  // async context where getActiveSpan() returns undefined. By storing the root
+  // span in a WeakMap keyed by the Request object, we can retrieve it in .trace().
+  // HigherOrderFunction type is not exported from elysia's main entry point,
+  // so we type the callback parameters directly.
+  app.wrap((fn, request) => {
+    if (isBun()) {
+      // On Bun there is no HTTP instrumentation, so we create a root span ourselves.
+      // Scope setup must happen inside the returned function so that it's active
+      // when Elysia calls the handler (not during .wrap() registration).
+      return (...args) => {
+        return core.withIsolationScope(() => {
+          return core.continueTrace(
+            {
+              sentryTrace: request.headers.get('sentry-trace') || '',
+              baggage: request.headers.get('baggage'),
+            },
+            () => {
+              return core.startSpanManual(
+                {
+                  op: 'http.server',
+                  name: `${request.method} ${new URL(request.url).pathname}`,
+                  attributes: {
+                    [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ELYSIA_ORIGIN,
+                    [core.SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',
+                  },
+                },
+                rootSpan => {
+                  rootSpanForRequest.set(request, rootSpan);
+                  try {
+                    const result = fn(...args);
+                    if (result instanceof Promise) {
+                      return result.then(
+                        res => {
+                          rootSpanForRequest.delete(request);
+                          rootSpan.end();
+                          return res;
+                        },
+                        err => {
+                          rootSpanForRequest.delete(request);
+                          rootSpan.end();
+                          throw err;
+                        },
+                      );
+                    }
+                    rootSpanForRequest.delete(request);
+                    rootSpan.end();
+                    return result;
+                  } catch (err) {
+                    rootSpanForRequest.delete(request);
+                    rootSpan.end();
+                    throw err;
+                  }
+                },
+              );
+            },
+          );
+        });
+      };
+    }
+
+    // On Node.js, the HTTP instrumentation already creates a root span.
+    // We just capture its reference so .trace() can use it.
+    const activeSpan = core.getActiveSpan();
+    if (activeSpan) {
+      rootSpanForRequest.set(request, core.getRootSpan(activeSpan));
+    }
+    return fn;
+  });
+
+  // Use .trace() ONLY for span creation. The trace API is observational —
+  // callbacks fire after phases complete, so they can't reliably mutate
+  // response headers or capture errors. All SDK logic stays in real hooks.
+  const traceHandler = lifecycle => {
+    const rootSpan = rootSpanForRequest.get(lifecycle.context.request);
+
+    const phases = [
+      ['Request', lifecycle.onRequest],
+      ['Parse', lifecycle.onParse],
+      ['Transform', lifecycle.onTransform],
+      ['BeforeHandle', lifecycle.onBeforeHandle],
+      ['Handle', lifecycle.onHandle],
+      ['AfterHandle', lifecycle.onAfterHandle],
+      ['MapResponse', lifecycle.onMapResponse],
+      ['AfterResponse', lifecycle.onAfterResponse],
+      ['Error', lifecycle.onError],
+    ];
+
+    for (const [phaseName, listener] of phases) {
+      if (listener) {
+        instrumentLifecyclePhase(phaseName, listener, rootSpan);
+      }
+    }
+  };
+
+  app.trace({ as: 'global' }, traceHandler);
+
+  // SDK logic uses real lifecycle hooks — these show up as handler spans
+  // in the trace (named sentryOnRequest etc.), but that's the correct
+  // tradeoff: the trace API can't reliably mutate state or capture errors.
+
+  app.onRequest(function sentryOnRequest(context) {
+    core.getIsolationScope().setSDKProcessingMetadata({
+      normalizedRequest: core.winterCGRequestToRequestData(context.request),
+    });
+  });
+
+  app.onAfterHandle({ as: 'global' }, function sentryOnAfterHandle(context) {
+    if (context.route) {
+      updateRouteTransactionName(context.request, context.request.method, context.route);
+    }
+
+    const traceData = core.getTraceData();
+    if (traceData['sentry-trace']) {
+      context.set.headers['sentry-trace'] = traceData['sentry-trace'];
+    }
+    if (traceData.baggage) {
+      context.set.headers['baggage'] = traceData.baggage;
+    }
+  });
+
+  app.onError({ as: 'global' }, function sentryOnError(context) {
+    if (context.route) {
+      updateRouteTransactionName(context.request, context.request.method, context.route);
+    }
+
+    // Set error status on root span
+    const rootSpan = rootSpanForRequest.get(context.request);
+    if (rootSpan) {
+      const statusCode = parseInt(String(context.set.status), 10);
+      core.setHttpStatus(rootSpan, Number.isNaN(statusCode) ? 500 : statusCode);
+    }
+
+    const shouldHandleError = options?.shouldHandleError || defaultShouldHandleError;
+    if (shouldHandleError(context)) {
+      core.captureException(context.error, {
+        mechanism: {
+          type: 'auto.http.elysia.on_error',
+          handled: false,
+        },
+      });
+    }
+  });
+
+  return app;
+}
+
+exports.withElysia = withElysia;
+//# sourceMappingURL=withElysia.js.map

package/build/cjs/withElysia.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withElysia.js","sources":["../../src/withElysia.ts"],"sourcesContent":["import type { Span } from '@sentry/core';\nimport {\n  captureException,\n  continueTrace,\n  getActiveSpan,\n  getIsolationScope,\n  getRootSpan,\n  getTraceData,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,\n  setHttpStatus,\n  startInactiveSpan,\n  startSpanManual,\n  updateSpanName,\n  winterCGRequestToRequestData,\n  withIsolationScope,\n} from '@sentry/core';\nimport type { Elysia, ErrorContext, TraceHandler, TraceListener } from 'elysia';\n\ninterface ElysiaHandlerOptions {\n  shouldHandleError?: (context: ErrorContext) => boolean;\n}\n\nconst ELYSIA_ORIGIN = 'auto.http.elysia';\n\n/**\n * Map Elysia lifecycle phase names to Sentry span ops.\n */\nconst ELYSIA_LIFECYCLE_OP_MAP: Record<string, string> = {\n  Request: 'middleware.elysia',\n  Parse: 'middleware.elysia',\n  Transform: 'middleware.elysia',\n  BeforeHandle: 'middleware.elysia',\n  Handle: 'request_handler.elysia',\n  AfterHandle: 'middleware.elysia',\n  MapResponse: 'middleware.elysia',\n  AfterResponse: 'middleware.elysia',\n  Error: 'middleware.elysia',\n};\n\nfunction isBun(): boolean {\n  return typeof Bun !== 'undefined';\n}\n\n/**\n * Per-request storage for the root span reference.\n * .wrap() captures the root span and .trace() reads it.\n * This is necessary because Elysia's .trace() callbacks may run in a different\n * async context where getActiveSpan() returns undefined.\n */\nconst rootSpanForRequest = new WeakMap<Request, Span>();\n\nconst instrumentedApps = new WeakSet<Elysia>();\n\n/**\n * Updates the root span and isolation scope with the parameterized route name.\n */\nfunction updateRouteTransactionName(request: Request, method: string, route: string): void {\n  const transactionName = `${method} ${route}`;\n\n  // Try the stored root span first (reliable across async contexts),\n  // then fall back to getActiveSpan() for cases where async context is preserved.\n  const rootSpan = rootSpanForRequest.get(request);\n  if (rootSpan) {\n    updateSpanName(rootSpan, transactionName);\n    rootSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, 'route');\n  } else {\n    const activeSpan = getActiveSpan();\n    if (activeSpan) {\n      const root = getRootSpan(activeSpan);\n      updateSpanName(root, transactionName);\n      root.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, 'route');\n    }\n  }\n\n  getIsolationScope().setTransactionName(transactionName);\n}\n\nfunction defaultShouldHandleError(context: ErrorContext): boolean {\n  const status = context.set.status;\n  if (status === undefined) {\n    return true;\n  }\n  const statusCode = parseInt(String(status), 10);\n  if (Number.isNaN(statusCode)) {\n    return true;\n  }\n  // Capture server errors (5xx) and unusual status codes (<= 299 in an error handler).\n  // 3xx and 4xx are not captured by default (client errors / redirects).\n  return statusCode >= 500 || statusCode <= 299;\n}\n\n/**\n * Instruments a single Elysia lifecycle phase by creating a Sentry span for it,\n * and child spans for each individual handler within the phase.\n *\n * @param rootSpan - The root server span to parent lifecycle spans under.\n *   Must be passed explicitly because Elysia's .trace() listener callbacks run\n *   in a different async context where getActiveSpan() returns undefined.\n */\nfunction instrumentLifecyclePhase(phaseName: string, listener: TraceListener, rootSpan: Span | undefined): void {\n  const op = ELYSIA_LIFECYCLE_OP_MAP[phaseName];\n  if (!op) {\n    return;\n  }\n\n  void listener(process => {\n    const phaseSpan = startInactiveSpan({\n      name: phaseName,\n      parentSpan: rootSpan,\n      attributes: {\n        [SEMANTIC_ATTRIBUTE_SENTRY_OP]: op,\n        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ELYSIA_ORIGIN,\n      },\n    });\n\n    // Create child spans for individual handlers within this phase.\n    // Named functions get their name, arrow functions get 'anonymous'.\n    if (process.total > 0) {\n      void process.onEvent(child => {\n        const handlerName = child.name || 'anonymous';\n        const childSpan = startInactiveSpan({\n          name: handlerName,\n          parentSpan: phaseSpan,\n          attributes: {\n            [SEMANTIC_ATTRIBUTE_SENTRY_OP]: op,\n            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ELYSIA_ORIGIN,\n          },\n        });\n\n        void child.onStop(() => {\n          childSpan.end();\n        });\n      });\n    }\n\n    void process.onStop(() => {\n      phaseSpan.end();\n    });\n  });\n}\n\n/**\n * Integrate Sentry with an Elysia app for error handling, request context,\n * and tracing. Returns the app instance for chaining.\n *\n * Should be called at the **start** of the chain before defining routes.\n *\n * @param app The Elysia instance\n * @param options Configuration options\n * @returns The same Elysia instance for chaining\n *\n * @example\n * ```javascript\n * import * as Sentry from '@sentry/elysia';\n * import { Elysia } from 'elysia';\n *\n * Sentry.withElysia(new Elysia())\n *   .get('/', () => 'Hello World')\n *   .listen(3000);\n * ```\n */\nexport function withElysia<T extends Elysia>(app: T, options: ElysiaHandlerOptions = {}): T {\n  if (instrumentedApps.has(app)) {\n    return app;\n  }\n  instrumentedApps.add(app);\n\n  // Use .wrap() to capture or create the root span for each request.\n  // This is necessary because Elysia's .trace() callbacks run in a different\n  // async context where getActiveSpan() returns undefined. By storing the root\n  // span in a WeakMap keyed by the Request object, we can retrieve it in .trace().\n  // HigherOrderFunction type is not exported from elysia's main entry point,\n  // so we type the callback parameters directly.\n  app.wrap((fn: (...args: unknown[]) => unknown, request: Request) => {\n    if (isBun()) {\n      // On Bun there is no HTTP instrumentation, so we create a root span ourselves.\n      // Scope setup must happen inside the returned function so that it's active\n      // when Elysia calls the handler (not during .wrap() registration).\n      return (...args: unknown[]) => {\n        return withIsolationScope(() => {\n          return continueTrace(\n            {\n              sentryTrace: request.headers.get('sentry-trace') || '',\n              baggage: request.headers.get('baggage'),\n            },\n            () => {\n              return startSpanManual(\n                {\n                  op: 'http.server',\n                  name: `${request.method} ${new URL(request.url).pathname}`,\n                  attributes: {\n                    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ELYSIA_ORIGIN,\n                    [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',\n                  },\n                },\n                rootSpan => {\n                  rootSpanForRequest.set(request, rootSpan);\n                  try {\n                    const result = fn(...args);\n                    if (result instanceof Promise) {\n                      return result.then(\n                        res => {\n                          rootSpanForRequest.delete(request);\n                          rootSpan.end();\n                          return res;\n                        },\n                        err => {\n                          rootSpanForRequest.delete(request);\n                          rootSpan.end();\n                          throw err;\n                        },\n                      );\n                    }\n                    rootSpanForRequest.delete(request);\n                    rootSpan.end();\n                    return result;\n                  } catch (err) {\n                    rootSpanForRequest.delete(request);\n                    rootSpan.end();\n                    throw err;\n                  }\n                },\n              );\n            },\n          );\n        });\n      };\n    }\n\n    // On Node.js, the HTTP instrumentation already creates a root span.\n    // We just capture its reference so .trace() can use it.\n    const activeSpan = getActiveSpan();\n    if (activeSpan) {\n      rootSpanForRequest.set(request, getRootSpan(activeSpan));\n    }\n    return fn;\n  });\n\n  // Use .trace() ONLY for span creation. The trace API is observational —\n  // callbacks fire after phases complete, so they can't reliably mutate\n  // response headers or capture errors. All SDK logic stays in real hooks.\n  const traceHandler: TraceHandler = lifecycle => {\n    const rootSpan = rootSpanForRequest.get(lifecycle.context.request);\n\n    const phases: [string, TraceListener][] = [\n      ['Request', lifecycle.onRequest],\n      ['Parse', lifecycle.onParse],\n      ['Transform', lifecycle.onTransform],\n      ['BeforeHandle', lifecycle.onBeforeHandle],\n      ['Handle', lifecycle.onHandle],\n      ['AfterHandle', lifecycle.onAfterHandle],\n      ['MapResponse', lifecycle.onMapResponse],\n      ['AfterResponse', lifecycle.onAfterResponse],\n      ['Error', lifecycle.onError],\n    ];\n\n    for (const [phaseName, listener] of phases) {\n      if (listener) {\n        instrumentLifecyclePhase(phaseName, listener, rootSpan);\n      }\n    }\n  };\n\n  app.trace({ as: 'global' }, traceHandler);\n\n  // SDK logic uses real lifecycle hooks — these show up as handler spans\n  // in the trace (named sentryOnRequest etc.), but that's the correct\n  // tradeoff: the trace API can't reliably mutate state or capture errors.\n\n  app.onRequest(function sentryOnRequest(context) {\n    getIsolationScope().setSDKProcessingMetadata({\n      normalizedRequest: winterCGRequestToRequestData(context.request),\n    });\n  });\n\n  app.onAfterHandle({ as: 'global' }, function sentryOnAfterHandle(context) {\n    if (context.route) {\n      updateRouteTransactionName(context.request, context.request.method, context.route);\n    }\n\n    const traceData = getTraceData();\n    if (traceData['sentry-trace']) {\n      context.set.headers['sentry-trace'] = traceData['sentry-trace'];\n    }\n    if (traceData.baggage) {\n      context.set.headers['baggage'] = traceData.baggage;\n    }\n  });\n\n  app.onError({ as: 'global' }, function sentryOnError(context) {\n    if (context.route) {\n      updateRouteTransactionName(context.request, context.request.method, context.route);\n    }\n\n    // Set error status on root span\n    const rootSpan = rootSpanForRequest.get(context.request);\n    if (rootSpan) {\n      const statusCode = parseInt(String(context.set.status), 10);\n      setHttpStatus(rootSpan, Number.isNaN(statusCode) ? 500 : statusCode);\n    }\n\n    const shouldHandleError = options?.shouldHandleError || defaultShouldHandleError;\n    if (shouldHandleError(context)) {\n      captureException(context.error, {\n        mechanism: {\n          type: 'auto.http.elysia.on_error',\n          handled: false,\n        },\n      });\n    }\n  });\n\n  return app;\n}\n"],"names":["updateSpanName","SEMANTIC_ATTRIBUTE_SENTRY_SOURCE","getActiveSpan","getRootSpan","getIsolationScope","startInactiveSpan","SEMANTIC_ATTRIBUTE_SENTRY_OP","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN","withIsolationScope","continueTrace","startSpanManual","winterCGRequestToRequestData","getTraceData","setHttpStatus","captureException"],"mappings":"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"}

package/build/esm/index.js

@@ -0,0 +1,5 @@
+export { NodeClient, OpenFeatureIntegrationHook, SDK_VERSION, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, Scope, addBreadcrumb, addEventProcessor, addIntegration, amqplibIntegration, anrIntegration, anthropicAIIntegration, buildLaunchDarklyFlagUsedHandler, bunServerIntegration, captureCheckIn, captureEvent, captureException, captureFeedback, captureMessage, captureSession, close, connectIntegration, consoleIntegration, consoleLoggingIntegration, contextLinesIntegration, continueTrace, createConsolaReporter, createGetModuleFromFilename, createLangChainCallbackHandler, createSentryWinstonTransport, createTransport, cron, dataloaderIntegration, defaultStackParser, disableAnrDetectionForCallback, endSession, eventFiltersIntegration, expressErrorHandler, expressIntegration, fastifyIntegration, featureFlagsIntegration, firebaseIntegration, flush, fsIntegration, functionToStringIntegration, generateInstrumentOnce, genericPoolIntegration, getActiveSpan, getAutoPerformanceIntegrations, getClient, getCurrentScope, getGlobalScope, getIsolationScope, getRootSpan, getSentryRelease, getSpanDescendants, getSpanStatusFromHttpCode, getTraceData, getTraceMetaTags, googleGenAIIntegration, graphqlIntegration, growthbookIntegration, hapiIntegration, honoIntegration, httpHeadersToSpanAttributes, httpIntegration, httpServerIntegration, httpServerSpansIntegration, inboundFiltersIntegration, initOpenTelemetry, instrumentAnthropicAiClient, instrumentGoogleGenAIClient, instrumentLangGraph, instrumentOpenAiClient, instrumentStateGraphCompile, instrumentSupabaseClient, isEnabled, isInitialized, kafkaIntegration, knexIntegration, koaIntegration, langChainIntegration, langGraphIntegration, lastEventId, launchDarklyIntegration, linkedErrorsIntegration, localVariablesIntegration, logger, lruMemoizerIntegration, makeFetchTransport, makeNodeTransport, metrics, modulesIntegration, mongoIntegration, mongooseIntegration, mysql2Integration, mysqlIntegration, nativeNodeFetchIntegration, nodeContextIntegration, onUncaughtExceptionIntegration, onUnhandledRejectionIntegration, openAIIntegration, openFeatureIntegration, parameterize, postgresIntegration, postgresJsIntegration, prismaIntegration, processSessionIntegration, profiler, redisIntegration, requestDataIntegration, setContext, setConversationId, setCurrentClient, setExtra, setExtras, setHttpStatus, setMeasurement, setTag, setTags, setUser, setupConnectErrorHandler, setupExpressErrorHandler, setupFastifyErrorHandler, setupHapiErrorHandler, setupHonoErrorHandler, setupKoaErrorHandler, spanToBaggageHeader, spanToJSON, spanToTraceHeader, spotlightIntegration, startInactiveSpan, startNewTrace, startSession, startSpan, startSpanManual, statsigIntegration, supabaseIntegration, suppressTracing, tediousIntegration, trpcMiddleware, unleashIntegration, updateSpanName, vercelAIIntegration, winterCGHeadersToDict, withActiveSpan, withIsolationScope, withMonitor, withScope, wrapMcpServerWithSentry, zodErrorsIntegration } from '@sentry/bun';
+export { captureConsoleIntegration, dedupeIntegration, extraErrorDataIntegration, rewriteFramesIntegration } from '@sentry/core';
+export { withElysia } from './withElysia.js';
+export { getDefaultIntegrations, init } from './sdk.js';
+//# sourceMappingURL=index.js.map

package/build/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/build/esm/package.json

@@ -0,0 +1 @@
+{"type":"module","version":"10.46.0","sideEffects":false}