@depup/sentry__node 10.44.0-depup.0

package/build/esm/integrations/tracing/index.js

@@ -0,0 +1,107 @@
+import { instrumentSentryHttp, instrumentOtelHttp } from '../http.js';
+import { instrumentAmqplib, amqplibIntegration } from './amqplib.js';
+import { instrumentAnthropicAi, anthropicAIIntegration } from './anthropic-ai/index.js';
+import { instrumentConnect, connectIntegration } from './connect.js';
+import { instrumentExpress, expressIntegration } from './express.js';
+import { instrumentFastify, instrumentFastifyV3, fastifyIntegration } from './fastify/index.js';
+import { instrumentFirebase, firebaseIntegration } from './firebase/firebase.js';
+import { instrumentGenericPool, genericPoolIntegration } from './genericPool.js';
+import { instrumentGoogleGenAI, googleGenAIIntegration } from './google-genai/index.js';
+import { instrumentGraphql, graphqlIntegration } from './graphql.js';
+import { instrumentHapi, hapiIntegration } from './hapi/index.js';
+import { instrumentHono, honoIntegration } from './hono/index.js';
+import { instrumentKafka, kafkaIntegration } from './kafka.js';
+import { instrumentKoa, koaIntegration } from './koa.js';
+import { instrumentLangChain, langChainIntegration } from './langchain/index.js';
+import { instrumentLangGraph, langGraphIntegration } from './langgraph/index.js';
+import { instrumentLruMemoizer, lruMemoizerIntegration } from './lrumemoizer.js';
+import { instrumentMongo, mongoIntegration } from './mongo.js';
+import { instrumentMongoose, mongooseIntegration } from './mongoose.js';
+import { instrumentMysql, mysqlIntegration } from './mysql.js';
+import { instrumentMysql2, mysql2Integration } from './mysql2.js';
+import { instrumentOpenAi, openAIIntegration } from './openai/index.js';
+import { instrumentPostgres, postgresIntegration } from './postgres.js';
+import { instrumentPostgresJs, postgresJsIntegration } from './postgresjs.js';
+import { prismaIntegration } from './prisma.js';
+import { instrumentRedis, redisIntegration } from './redis.js';
+import { instrumentTedious, tediousIntegration } from './tedious.js';
+import { instrumentVercelAi, vercelAIIntegration } from './vercelai/index.js';
+
+/**
+ * With OTEL, all performance integrations will be added, as OTEL only initializes them when the patched package is actually required.
+ */
+function getAutoPerformanceIntegrations() {
+  return [
+    expressIntegration(),
+    fastifyIntegration(),
+    graphqlIntegration(),
+    honoIntegration(),
+    mongoIntegration(),
+    mongooseIntegration(),
+    mysqlIntegration(),
+    mysql2Integration(),
+    redisIntegration(),
+    postgresIntegration(),
+    prismaIntegration(),
+    hapiIntegration(),
+    koaIntegration(),
+    connectIntegration(),
+    tediousIntegration(),
+    genericPoolIntegration(),
+    kafkaIntegration(),
+    amqplibIntegration(),
+    lruMemoizerIntegration(),
+    // AI providers
+    // LangChain must come first to disable AI provider integrations before they instrument
+    langChainIntegration(),
+    langGraphIntegration(),
+    vercelAIIntegration(),
+    openAIIntegration(),
+    anthropicAIIntegration(),
+    googleGenAIIntegration(),
+    postgresJsIntegration(),
+    firebaseIntegration(),
+  ];
+}
+
+/**
+ * Get a list of methods to instrument OTEL, when preload instrumentation.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getOpenTelemetryInstrumentationToPreload() {
+  return [
+    instrumentSentryHttp,
+    instrumentOtelHttp,
+    instrumentExpress,
+    instrumentConnect,
+    instrumentFastify,
+    instrumentFastifyV3,
+    instrumentHapi,
+    instrumentHono,
+    instrumentKafka,
+    instrumentKoa,
+    instrumentLruMemoizer,
+    instrumentMongo,
+    instrumentMongoose,
+    instrumentMysql,
+    instrumentMysql2,
+    instrumentPostgres,
+    instrumentHapi,
+    instrumentGraphql,
+    instrumentRedis,
+    instrumentTedious,
+    instrumentGenericPool,
+    instrumentAmqplib,
+    instrumentLangChain,
+    instrumentVercelAi,
+    instrumentOpenAi,
+    instrumentPostgresJs,
+    instrumentFirebase,
+    instrumentAnthropicAi,
+    instrumentGoogleGenAI,
+    instrumentLangGraph,
+  ];
+}
+
+export { getAutoPerformanceIntegrations, getOpenTelemetryInstrumentationToPreload };
+//# sourceMappingURL=index.js.map

package/build/esm/integrations/tracing/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../src/integrations/tracing/index.ts"],"sourcesContent":["import type { Integration } from '@sentry/core';\nimport { instrumentOtelHttp, instrumentSentryHttp } from '../http';\nimport { amqplibIntegration, instrumentAmqplib } from './amqplib';\nimport { anthropicAIIntegration, instrumentAnthropicAi } from './anthropic-ai';\nimport { connectIntegration, instrumentConnect } from './connect';\nimport { expressIntegration, instrumentExpress } from './express';\nimport { fastifyIntegration, instrumentFastify, instrumentFastifyV3 } from './fastify';\nimport { firebaseIntegration, instrumentFirebase } from './firebase';\nimport { genericPoolIntegration, instrumentGenericPool } from './genericPool';\nimport { googleGenAIIntegration, instrumentGoogleGenAI } from './google-genai';\nimport { graphqlIntegration, instrumentGraphql } from './graphql';\nimport { hapiIntegration, instrumentHapi } from './hapi';\nimport { honoIntegration, instrumentHono } from './hono';\nimport { instrumentKafka, kafkaIntegration } from './kafka';\nimport { instrumentKoa, koaIntegration } from './koa';\nimport { instrumentLangChain, langChainIntegration } from './langchain';\nimport { instrumentLangGraph, langGraphIntegration } from './langgraph';\nimport { instrumentLruMemoizer, lruMemoizerIntegration } from './lrumemoizer';\nimport { instrumentMongo, mongoIntegration } from './mongo';\nimport { instrumentMongoose, mongooseIntegration } from './mongoose';\nimport { instrumentMysql, mysqlIntegration } from './mysql';\nimport { instrumentMysql2, mysql2Integration } from './mysql2';\nimport { instrumentOpenAi, openAIIntegration } from './openai';\nimport { instrumentPostgres, postgresIntegration } from './postgres';\nimport { instrumentPostgresJs, postgresJsIntegration } from './postgresjs';\nimport { prismaIntegration } from './prisma';\nimport { instrumentRedis, redisIntegration } from './redis';\nimport { instrumentTedious, tediousIntegration } from './tedious';\nimport { instrumentVercelAi, vercelAIIntegration } from './vercelai';\n\n/**\n * With OTEL, all performance integrations will be added, as OTEL only initializes them when the patched package is actually required.\n */\nexport function getAutoPerformanceIntegrations(): Integration[] {\n  return [\n    expressIntegration(),\n    fastifyIntegration(),\n    graphqlIntegration(),\n    honoIntegration(),\n    mongoIntegration(),\n    mongooseIntegration(),\n    mysqlIntegration(),\n    mysql2Integration(),\n    redisIntegration(),\n    postgresIntegration(),\n    prismaIntegration(),\n    hapiIntegration(),\n    koaIntegration(),\n    connectIntegration(),\n    tediousIntegration(),\n    genericPoolIntegration(),\n    kafkaIntegration(),\n    amqplibIntegration(),\n    lruMemoizerIntegration(),\n    // AI providers\n    // LangChain must come first to disable AI provider integrations before they instrument\n    langChainIntegration(),\n    langGraphIntegration(),\n    vercelAIIntegration(),\n    openAIIntegration(),\n    anthropicAIIntegration(),\n    googleGenAIIntegration(),\n    postgresJsIntegration(),\n    firebaseIntegration(),\n  ];\n}\n\n/**\n * Get a list of methods to instrument OTEL, when preload instrumentation.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function getOpenTelemetryInstrumentationToPreload(): (((options?: any) => void) & { id: string })[] {\n  return [\n    instrumentSentryHttp,\n    instrumentOtelHttp,\n    instrumentExpress,\n    instrumentConnect,\n    instrumentFastify,\n    instrumentFastifyV3,\n    instrumentHapi,\n    instrumentHono,\n    instrumentKafka,\n    instrumentKoa,\n    instrumentLruMemoizer,\n    instrumentMongo,\n    instrumentMongoose,\n    instrumentMysql,\n    instrumentMysql2,\n    instrumentPostgres,\n    instrumentHapi,\n    instrumentGraphql,\n    instrumentRedis,\n    instrumentTedious,\n    instrumentGenericPool,\n    instrumentAmqplib,\n    instrumentLangChain,\n    instrumentVercelAi,\n    instrumentOpenAi,\n    instrumentPostgresJs,\n    instrumentFirebase,\n    instrumentAnthropicAi,\n    instrumentGoogleGenAI,\n    instrumentLangGraph,\n  ];\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA;AACA;AACA;AACO,SAAS,8BAA8B,GAAkB;AAChE,EAAE,OAAO;AACT,IAAI,kBAAkB,EAAE;AACxB,IAAI,kBAAkB,EAAE;AACxB,IAAI,kBAAkB,EAAE;AACxB,IAAI,eAAe,EAAE;AACrB,IAAI,gBAAgB,EAAE;AACtB,IAAI,mBAAmB,EAAE;AACzB,IAAI,gBAAgB,EAAE;AACtB,IAAI,iBAAiB,EAAE;AACvB,IAAI,gBAAgB,EAAE;AACtB,IAAI,mBAAmB,EAAE;AACzB,IAAI,iBAAiB,EAAE;AACvB,IAAI,eAAe,EAAE;AACrB,IAAI,cAAc,EAAE;AACpB,IAAI,kBAAkB,EAAE;AACxB,IAAI,kBAAkB,EAAE;AACxB,IAAI,sBAAsB,EAAE;AAC5B,IAAI,gBAAgB,EAAE;AACtB,IAAI,kBAAkB,EAAE;AACxB,IAAI,sBAAsB,EAAE;AAC5B;AACA;AACA,IAAI,oBAAoB,EAAE;AAC1B,IAAI,oBAAoB,EAAE;AAC1B,IAAI,mBAAmB,EAAE;AACzB,IAAI,iBAAiB,EAAE;AACvB,IAAI,sBAAsB,EAAE;AAC5B,IAAI,sBAAsB,EAAE;AAC5B,IAAI,qBAAqB,EAAE;AAC3B,IAAI,mBAAmB,EAAE;AACzB,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACO,SAAS,wCAAwC,GAAmD;AAC3G,EAAE,OAAO;AACT,IAAI,oBAAoB;AACxB,IAAI,kBAAkB;AACtB,IAAI,iBAAiB;AACrB,IAAI,iBAAiB;AACrB,IAAI,iBAAiB;AACrB,IAAI,mBAAmB;AACvB,IAAI,cAAc;AAClB,IAAI,cAAc;AAClB,IAAI,eAAe;AACnB,IAAI,aAAa;AACjB,IAAI,qBAAqB;AACzB,IAAI,eAAe;AACnB,IAAI,kBAAkB;AACtB,IAAI,eAAe;AACnB,IAAI,gBAAgB;AACpB,IAAI,kBAAkB;AACtB,IAAI,cAAc;AAClB,IAAI,iBAAiB;AACrB,IAAI,eAAe;AACnB,IAAI,iBAAiB;AACrB,IAAI,qBAAqB;AACzB,IAAI,iBAAiB;AACrB,IAAI,mBAAmB;AACvB,IAAI,kBAAkB;AACtB,IAAI,gBAAgB;AACpB,IAAI,oBAAoB;AACxB,IAAI,kBAAkB;AACtB,IAAI,qBAAqB;AACzB,IAAI,qBAAqB;AACzB,IAAI,mBAAmB;AACvB,GAAG;AACH;;;;"}

package/build/esm/integrations/tracing/kafka.js

@@ -0,0 +1,45 @@
+import { KafkaJsInstrumentation } from '@opentelemetry/instrumentation-kafkajs';
+import { defineIntegration } from '@sentry/core';
+import { generateInstrumentOnce, addOriginToSpan } from '@sentry/node-core';
+
+const INTEGRATION_NAME = 'Kafka';
+
+const instrumentKafka = generateInstrumentOnce(
+  INTEGRATION_NAME,
+  () =>
+    new KafkaJsInstrumentation({
+      consumerHook(span) {
+        addOriginToSpan(span, 'auto.kafkajs.otel.consumer');
+      },
+      producerHook(span) {
+        addOriginToSpan(span, 'auto.kafkajs.otel.producer');
+      },
+    }),
+);
+
+const _kafkaIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      instrumentKafka();
+    },
+  };
+}) ;
+
+/**
+ * Adds Sentry tracing instrumentation for the [kafkajs](https://www.npmjs.com/package/kafkajs) library.
+ *
+ * For more information, see the [`kafkaIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/kafka/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.kafkaIntegration()],
+ * });
+ */
+const kafkaIntegration = defineIntegration(_kafkaIntegration);
+
+export { instrumentKafka, kafkaIntegration };
+//# sourceMappingURL=kafka.js.map

package/build/esm/integrations/tracing/kafka.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kafka.js","sources":["../../../../src/integrations/tracing/kafka.ts"],"sourcesContent":["import { KafkaJsInstrumentation } from '@opentelemetry/instrumentation-kafkajs';\nimport type { IntegrationFn } from '@sentry/core';\nimport { defineIntegration } from '@sentry/core';\nimport { addOriginToSpan, generateInstrumentOnce } from '@sentry/node-core';\n\nconst INTEGRATION_NAME = 'Kafka';\n\nexport const instrumentKafka = generateInstrumentOnce(\n  INTEGRATION_NAME,\n  () =>\n    new KafkaJsInstrumentation({\n      consumerHook(span) {\n        addOriginToSpan(span, 'auto.kafkajs.otel.consumer');\n      },\n      producerHook(span) {\n        addOriginToSpan(span, 'auto.kafkajs.otel.producer');\n      },\n    }),\n);\n\nconst _kafkaIntegration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      instrumentKafka();\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for the [kafkajs](https://www.npmjs.com/package/kafkajs) library.\n *\n * For more information, see the [`kafkaIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/kafka/).\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *  integrations: [Sentry.kafkaIntegration()],\n * });\n */\nexport const kafkaIntegration = defineIntegration(_kafkaIntegration);\n"],"names":[],"mappings":";;;;AAKA,MAAM,gBAAA,GAAmB,OAAO;;AAEzB,MAAM,eAAA,GAAkB,sBAAsB;AACrD,EAAE,gBAAgB;AAClB,EAAE;AACF,IAAI,IAAI,sBAAsB,CAAC;AAC/B,MAAM,YAAY,CAAC,IAAI,EAAE;AACzB,QAAQ,eAAe,CAAC,IAAI,EAAE,4BAA4B,CAAC;AAC3D,MAAM,CAAC;AACP,MAAM,YAAY,CAAC,IAAI,EAAE;AACzB,QAAQ,eAAe,CAAC,IAAI,EAAE,4BAA4B,CAAC;AAC3D,MAAM,CAAC;AACP,KAAK,CAAC;AACN;;AAEA,MAAM,iBAAA,IAAqB,MAAM;AACjC,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,gBAAgB;AAC1B,IAAI,SAAS,GAAG;AAChB,MAAM,eAAe,EAAE;AACvB,IAAI,CAAC;AACL,GAAG;AACH,CAAC,CAAA;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACa,gBAAA,GAAmB,iBAAiB,CAAC,iBAAiB;;;;"}

package/build/esm/integrations/tracing/knex.js

@@ -0,0 +1,54 @@
+import { KnexInstrumentation } from '@opentelemetry/instrumentation-knex';
+import { defineIntegration, spanToJSON, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
+import { generateInstrumentOnce, instrumentWhenWrapped } from '@sentry/node-core';
+
+const INTEGRATION_NAME = 'Knex';
+
+const instrumentKnex = generateInstrumentOnce(
+  INTEGRATION_NAME,
+  () => new KnexInstrumentation({ requireParentSpan: true }),
+);
+
+const _knexIntegration = (() => {
+  let instrumentationWrappedCallback;
+
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      const instrumentation = instrumentKnex();
+      instrumentationWrappedCallback = instrumentWhenWrapped(instrumentation);
+    },
+
+    setup(client) {
+      instrumentationWrappedCallback?.(() =>
+        client.on('spanStart', span => {
+          const { data } = spanToJSON(span);
+          // knex.version is always set in the span data
+          // https://github.com/open-telemetry/opentelemetry-js-contrib/blob/0309caeafc44ac9cb13a3345b790b01b76d0497d/plugins/node/opentelemetry-instrumentation-knex/src/instrumentation.ts#L138
+          if ('knex.version' in data) {
+            span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, 'auto.db.otel.knex');
+          }
+        }),
+      );
+    },
+  };
+}) ;
+
+/**
+ * Knex integration
+ *
+ * Capture tracing data for [Knex](https://knexjs.org/).
+ *
+ * @example
+ * ```javascript
+ * import * as Sentry from '@sentry/node';
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.knexIntegration()],
+ * });
+ * ```
+ */
+const knexIntegration = defineIntegration(_knexIntegration);
+
+export { instrumentKnex, knexIntegration };
+//# sourceMappingURL=knex.js.map

package/build/esm/integrations/tracing/knex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"knex.js","sources":["../../../../src/integrations/tracing/knex.ts"],"sourcesContent":["import { KnexInstrumentation } from '@opentelemetry/instrumentation-knex';\nimport type { IntegrationFn } from '@sentry/core';\nimport { defineIntegration, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, spanToJSON } from '@sentry/core';\nimport { generateInstrumentOnce, instrumentWhenWrapped } from '@sentry/node-core';\n\nconst INTEGRATION_NAME = 'Knex';\n\nexport const instrumentKnex = generateInstrumentOnce(\n  INTEGRATION_NAME,\n  () => new KnexInstrumentation({ requireParentSpan: true }),\n);\n\nconst _knexIntegration = (() => {\n  let instrumentationWrappedCallback: undefined | ((callback: () => void) => void);\n\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      const instrumentation = instrumentKnex();\n      instrumentationWrappedCallback = instrumentWhenWrapped(instrumentation);\n    },\n\n    setup(client) {\n      instrumentationWrappedCallback?.(() =>\n        client.on('spanStart', span => {\n          const { data } = spanToJSON(span);\n          // knex.version is always set in the span data\n          // https://github.com/open-telemetry/opentelemetry-js-contrib/blob/0309caeafc44ac9cb13a3345b790b01b76d0497d/plugins/node/opentelemetry-instrumentation-knex/src/instrumentation.ts#L138\n          if ('knex.version' in data) {\n            span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, 'auto.db.otel.knex');\n          }\n        }),\n      );\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Knex integration\n *\n * Capture tracing data for [Knex](https://knexjs.org/).\n *\n * @example\n * ```javascript\n * import * as Sentry from '@sentry/node';\n *\n * Sentry.init({\n *  integrations: [Sentry.knexIntegration()],\n * });\n * ```\n */\nexport const knexIntegration = defineIntegration(_knexIntegration);\n"],"names":[],"mappings":";;;;AAKA,MAAM,gBAAA,GAAmB,MAAM;;AAExB,MAAM,cAAA,GAAiB,sBAAsB;AACpD,EAAE,gBAAgB;AAClB,EAAE,MAAM,IAAI,mBAAmB,CAAC,EAAE,iBAAiB,EAAE,IAAA,EAAM,CAAC;AAC5D;;AAEA,MAAM,gBAAA,IAAoB,MAAM;AAChC,EAAE,IAAI,8BAA8B;;AAEpC,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,gBAAgB;AAC1B,IAAI,SAAS,GAAG;AAChB,MAAM,MAAM,eAAA,GAAkB,cAAc,EAAE;AAC9C,MAAM,8BAAA,GAAiC,qBAAqB,CAAC,eAAe,CAAC;AAC7E,IAAI,CAAC;;AAEL,IAAI,KAAK,CAAC,MAAM,EAAE;AAClB,MAAM,8BAA8B,GAAG;AACvC,QAAQ,MAAM,CAAC,EAAE,CAAC,WAAW,EAAE,QAAQ;AACvC,UAAU,MAAM,EAAE,IAAA,EAAK,GAAI,UAAU,CAAC,IAAI,CAAC;AAC3C;AACA;AACA,UAAU,IAAI,cAAA,IAAkB,IAAI,EAAE;AACtC,YAAY,IAAI,CAAC,YAAY,CAAC,gCAAgC,EAAE,mBAAmB,CAAC;AACpF,UAAU;AACV,QAAQ,CAAC,CAAC;AACV,OAAO;AACP,IAAI,CAAC;AACL,GAAG;AACH,CAAC,CAAA;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACa,eAAA,GAAkB,iBAAiB,CAAC,gBAAgB;;;;"}

package/build/esm/integrations/tracing/koa.js

@@ -0,0 +1,134 @@
+import { KoaInstrumentation } from '@opentelemetry/instrumentation-koa';
+import { ATTR_HTTP_ROUTE } from '@opentelemetry/semantic-conventions';
+import { spanToJSON, SEMANTIC_ATTRIBUTE_SENTRY_OP, getIsolationScope, getDefaultIsolationScope, debug, defineIntegration, captureException } from '@sentry/core';
+import { generateInstrumentOnce, addOriginToSpan, ensureIsWrapped } from '@sentry/node-core';
+import { DEBUG_BUILD } from '../../debug-build.js';
+
+const INTEGRATION_NAME = 'Koa';
+
+const instrumentKoa = generateInstrumentOnce(
+  INTEGRATION_NAME,
+  KoaInstrumentation,
+  (options = {}) => {
+    return {
+      ignoreLayersType: options.ignoreLayersType ,
+      requestHook(span, info) {
+        addOriginToSpan(span, 'auto.http.otel.koa');
+
+        const attributes = spanToJSON(span).data;
+
+        // this is one of: middleware, router
+        const type = attributes['koa.type'];
+        if (type) {
+          span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, `${type}.koa`);
+        }
+
+        // Also update the name
+        const name = attributes['koa.name'];
+        if (typeof name === 'string') {
+          // Somehow, name is sometimes `''` for middleware spans
+          // See: https://github.com/open-telemetry/opentelemetry-js-contrib/issues/2220
+          span.updateName(name || '< unknown >');
+        }
+
+        if (getIsolationScope() === getDefaultIsolationScope()) {
+          DEBUG_BUILD && debug.warn('Isolation scope is default isolation scope - skipping setting transactionName');
+          return;
+        }
+        const route = attributes[ATTR_HTTP_ROUTE];
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        const method = info.context?.request?.method?.toUpperCase() || 'GET';
+        if (route) {
+          getIsolationScope().setTransactionName(`${method} ${route}`);
+        }
+      },
+    } ;
+  },
+);
+
+const _koaIntegration = ((options = {}) => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      instrumentKoa(options);
+    },
+  };
+}) ;
+
+/**
+ * Adds Sentry tracing instrumentation for [Koa](https://koajs.com/).
+ *
+ * If you also want to capture errors, you need to call `setupKoaErrorHandler(app)` after you set up your Koa server.
+ *
+ * For more information, see the [koa documentation](https://docs.sentry.io/platforms/javascript/guides/koa/).
+ *
+ * @param {KoaOptions} options Configuration options for the Koa integration.
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.koaIntegration()],
+ * })
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // To ignore middleware spans
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *   integrations: [
+ *     Sentry.koaIntegration({
+ *       ignoreLayersType: ['middleware']
+ *     })
+ *   ],
+ * })
+ * ```
+ */
+const koaIntegration = defineIntegration(_koaIntegration);
+
+/**
+ * Add an Koa error handler to capture errors to Sentry.
+ *
+ * The error handler must be before any other middleware and after all controllers.
+ *
+ * @param app The Express instances
+ * @param options {ExpressHandlerOptions} Configuration options for the handler
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ * const Koa = require("koa");
+ *
+ * const app = new Koa();
+ *
+ * Sentry.setupKoaErrorHandler(app);
+ *
+ * // Add your routes, etc.
+ *
+ * app.listen(3000);
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const setupKoaErrorHandler = (app) => {
+  app.use(async (ctx, next) => {
+    try {
+      await next();
+    } catch (error) {
+      captureException(error, {
+        mechanism: {
+          handled: false,
+          type: 'auto.middleware.koa',
+        },
+      });
+      throw error;
+    }
+  });
+
+  ensureIsWrapped(app.use, 'koa');
+};
+
+export { instrumentKoa, koaIntegration, setupKoaErrorHandler };
+//# sourceMappingURL=koa.js.map

package/build/esm/integrations/tracing/koa.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"koa.js","sources":["../../../../src/integrations/tracing/koa.ts"],"sourcesContent":["import type { KoaInstrumentationConfig, KoaLayerType } from '@opentelemetry/instrumentation-koa';\nimport { KoaInstrumentation } from '@opentelemetry/instrumentation-koa';\nimport { ATTR_HTTP_ROUTE } from '@opentelemetry/semantic-conventions';\nimport type { IntegrationFn } from '@sentry/core';\nimport {\n  captureException,\n  debug,\n  defineIntegration,\n  getDefaultIsolationScope,\n  getIsolationScope,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  spanToJSON,\n} from '@sentry/core';\nimport { addOriginToSpan, ensureIsWrapped, generateInstrumentOnce } from '@sentry/node-core';\nimport { DEBUG_BUILD } from '../../debug-build';\n\ninterface KoaOptions {\n  /**\n   * Ignore layers of specified types\n   */\n  ignoreLayersType?: Array<'middleware' | 'router'>;\n}\n\nconst INTEGRATION_NAME = 'Koa';\n\nexport const instrumentKoa = generateInstrumentOnce(\n  INTEGRATION_NAME,\n  KoaInstrumentation,\n  (options: KoaOptions = {}) => {\n    return {\n      ignoreLayersType: options.ignoreLayersType as KoaLayerType[],\n      requestHook(span, info) {\n        addOriginToSpan(span, 'auto.http.otel.koa');\n\n        const attributes = spanToJSON(span).data;\n\n        // this is one of: middleware, router\n        const type = attributes['koa.type'];\n        if (type) {\n          span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, `${type}.koa`);\n        }\n\n        // Also update the name\n        const name = attributes['koa.name'];\n        if (typeof name === 'string') {\n          // Somehow, name is sometimes `''` for middleware spans\n          // See: https://github.com/open-telemetry/opentelemetry-js-contrib/issues/2220\n          span.updateName(name || '< unknown >');\n        }\n\n        if (getIsolationScope() === getDefaultIsolationScope()) {\n          DEBUG_BUILD && debug.warn('Isolation scope is default isolation scope - skipping setting transactionName');\n          return;\n        }\n        const route = attributes[ATTR_HTTP_ROUTE];\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        const method = info.context?.request?.method?.toUpperCase() || 'GET';\n        if (route) {\n          getIsolationScope().setTransactionName(`${method} ${route}`);\n        }\n      },\n    } satisfies KoaInstrumentationConfig;\n  },\n);\n\nconst _koaIntegration = ((options: KoaOptions = {}) => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      instrumentKoa(options);\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for [Koa](https://koajs.com/).\n *\n * If you also want to capture errors, you need to call `setupKoaErrorHandler(app)` after you set up your Koa server.\n *\n * For more information, see the [koa documentation](https://docs.sentry.io/platforms/javascript/guides/koa/).\n *\n * @param {KoaOptions} options Configuration options for the Koa integration.\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *   integrations: [Sentry.koaIntegration()],\n * })\n * ```\n *\n * @example\n * ```javascript\n * // To ignore middleware spans\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *   integrations: [\n *     Sentry.koaIntegration({\n *       ignoreLayersType: ['middleware']\n *     })\n *   ],\n * })\n * ```\n */\nexport const koaIntegration = defineIntegration(_koaIntegration);\n\n/**\n * Add an Koa error handler to capture errors to Sentry.\n *\n * The error handler must be before any other middleware and after all controllers.\n *\n * @param app The Express instances\n * @param options {ExpressHandlerOptions} Configuration options for the handler\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n * const Koa = require(\"koa\");\n *\n * const app = new Koa();\n *\n * Sentry.setupKoaErrorHandler(app);\n *\n * // Add your routes, etc.\n *\n * app.listen(3000);\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const setupKoaErrorHandler = (app: { use: (arg0: (ctx: any, next: any) => Promise<void>) => void }): void => {\n  app.use(async (ctx, next) => {\n    try {\n      await next();\n    } catch (error) {\n      captureException(error, {\n        mechanism: {\n          handled: false,\n          type: 'auto.middleware.koa',\n        },\n      });\n      throw error;\n    }\n  });\n\n  ensureIsWrapped(app.use, 'koa');\n};\n"],"names":[],"mappings":";;;;;;AAuBA,MAAM,gBAAA,GAAmB,KAAK;;AAEvB,MAAM,aAAA,GAAgB,sBAAsB;AACnD,EAAE,gBAAgB;AAClB,EAAE,kBAAkB;AACpB,EAAE,CAAC,OAAO,GAAe,EAAE,KAAK;AAChC,IAAI,OAAO;AACX,MAAM,gBAAgB,EAAE,OAAO,CAAC,gBAAA;AAChC,MAAM,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE;AAC9B,QAAQ,eAAe,CAAC,IAAI,EAAE,oBAAoB,CAAC;;AAEnD,QAAQ,MAAM,aAAa,UAAU,CAAC,IAAI,CAAC,CAAC,IAAI;;AAEhD;AACA,QAAQ,MAAM,IAAA,GAAO,UAAU,CAAC,UAAU,CAAC;AAC3C,QAAQ,IAAI,IAAI,EAAE;AAClB,UAAU,IAAI,CAAC,YAAY,CAAC,4BAA4B,EAAE,CAAC,EAAA,IAAA,CAAA,IAAA,CAAA,CAAA;AACA,QAAA;;AAEA;AACA,QAAA,MAAA,IAAA,GAAA,UAAA,CAAA,UAAA,CAAA;AACA,QAAA,IAAA,OAAA,IAAA,KAAA,QAAA,EAAA;AACA;AACA;AACA,UAAA,IAAA,CAAA,UAAA,CAAA,IAAA,IAAA,aAAA,CAAA;AACA,QAAA;;AAEA,QAAA,IAAA,iBAAA,EAAA,KAAA,wBAAA,EAAA,EAAA;AACA,UAAA,WAAA,IAAA,KAAA,CAAA,IAAA,CAAA,+EAAA,CAAA;AACA,UAAA;AACA,QAAA;AACA,QAAA,MAAA,KAAA,GAAA,UAAA,CAAA,eAAA,CAAA;AACA;AACA,QAAA,MAAA,MAAA,GAAA,IAAA,CAAA,OAAA,EAAA,OAAA,EAAA,MAAA,EAAA,WAAA,EAAA,IAAA,KAAA;AACA,QAAA,IAAA,KAAA,EAAA;AACA,UAAA,iBAAA,EAAA,CAAA,kBAAA,CAAA,CAAA,EAAA,MAAA,CAAA,CAAA,EAAA,KAAA,CAAA,CAAA,CAAA;AACA,QAAA;AACA,MAAA,CAAA;AACA,KAAA;AACA,EAAA,CAAA;AACA;;AAEA,MAAA,eAAA,IAAA,CAAA,OAAA,GAAA,EAAA,KAAA;AACA,EAAA,OAAA;AACA,IAAA,IAAA,EAAA,gBAAA;AACA,IAAA,SAAA,GAAA;AACA,MAAA,aAAA,CAAA,OAAA,CAAA;AACA,IAAA,CAAA;AACA,GAAA;AACA,CAAA,CAAA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAA,cAAA,GAAA,iBAAA,CAAA,eAAA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAA,oBAAA,GAAA,CAAA,GAAA,KAAA;AACA,EAAA,GAAA,CAAA,GAAA,CAAA,OAAA,GAAA,EAAA,IAAA,KAAA;AACA,IAAA,IAAA;AACA,MAAA,MAAA,IAAA,EAAA;AACA,IAAA,CAAA,CAAA,OAAA,KAAA,EAAA;AACA,MAAA,gBAAA,CAAA,KAAA,EAAA;AACA,QAAA,SAAA,EAAA;AACA,UAAA,OAAA,EAAA,KAAA;AACA,UAAA,IAAA,EAAA,qBAAA;AACA,SAAA;AACA,OAAA,CAAA;AACA,MAAA,MAAA,KAAA;AACA,IAAA;AACA,EAAA,CAAA,CAAA;;AAEA,EAAA,eAAA,CAAA,GAAA,CAAA,GAAA,EAAA,KAAA,CAAA;AACA;;;;"}

package/build/esm/integrations/tracing/langchain/index.js

@@ -0,0 +1,113 @@
+import { LANGCHAIN_INTEGRATION_NAME, defineIntegration } from '@sentry/core';
+import { generateInstrumentOnce } from '@sentry/node-core';
+import { SentryLangChainInstrumentation } from './instrumentation.js';
+
+const instrumentLangChain = generateInstrumentOnce(
+  LANGCHAIN_INTEGRATION_NAME,
+  options => new SentryLangChainInstrumentation(options),
+);
+
+const _langChainIntegration = ((options = {}) => {
+  return {
+    name: LANGCHAIN_INTEGRATION_NAME,
+    setupOnce() {
+      instrumentLangChain(options);
+    },
+  };
+}) ;
+
+/**
+ * Adds Sentry tracing instrumentation for LangChain.
+ *
+ * This integration is enabled by default.
+ *
+ * When configured, this integration automatically instruments LangChain runnable instances
+ * to capture telemetry data by injecting Sentry callback handlers into all LangChain calls.
+ *
+ * **Important:** This integration automatically skips wrapping the OpenAI, Anthropic, and Google GenAI
+ * providers to prevent duplicate spans when using LangChain with these AI providers.
+ * LangChain handles the instrumentation for all underlying AI providers.
+ *
+ * @example
+ * ```javascript
+ * import * as Sentry from '@sentry/node';
+ * import { ChatOpenAI } from '@langchain/openai';
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.langChainIntegration()],
+ *   sendDefaultPii: true, // Enable to record inputs/outputs
+ * });
+ *
+ * // LangChain calls are automatically instrumented
+ * const model = new ChatOpenAI();
+ * await model.invoke("What is the capital of France?");
+ * ```
+ *
+ * ## Manual Callback Handler
+ *
+ * You can also manually add the Sentry callback handler alongside other callbacks:
+ *
+ * @example
+ * ```javascript
+ * import * as Sentry from '@sentry/node';
+ * import { ChatOpenAI } from '@langchain/openai';
+ *
+ * const sentryHandler = Sentry.createLangChainCallbackHandler({
+ *   recordInputs: true,
+ *   recordOutputs: true
+ * });
+ *
+ * const model = new ChatOpenAI();
+ * await model.invoke(
+ *   "What is the capital of France?",
+ *   { callbacks: [sentryHandler, myOtherCallback] }
+ * );
+ * ```
+ *
+ * ## Options
+ *
+ * - `recordInputs`: Whether to record input messages/prompts (default: respects `sendDefaultPii` client option)
+ * - `recordOutputs`: Whether to record response text (default: respects `sendDefaultPii` client option)
+ *
+ * ### Default Behavior
+ *
+ * By default, the integration will:
+ * - Record inputs and outputs ONLY if `sendDefaultPii` is set to `true` in your Sentry client options
+ * - Otherwise, inputs and outputs are NOT recorded unless explicitly enabled
+ *
+ * @example
+ * ```javascript
+ * // Record inputs and outputs when sendDefaultPii is false
+ * Sentry.init({
+ *   integrations: [
+ *     Sentry.langChainIntegration({
+ *       recordInputs: true,
+ *       recordOutputs: true
+ *     })
+ *   ],
+ * });
+ *
+ * // Never record inputs/outputs regardless of sendDefaultPii
+ * Sentry.init({
+ *   sendDefaultPii: true,
+ *   integrations: [
+ *     Sentry.langChainIntegration({
+ *       recordInputs: false,
+ *       recordOutputs: false
+ *     })
+ *   ],
+ * });
+ * ```
+ *
+ * ## Supported Events
+ *
+ * The integration captures the following LangChain lifecycle events:
+ * - LLM/Chat Model: start, end, error
+ * - Chain: start, end, error
+ * - Tool: start, end, error
+ *
+ */
+const langChainIntegration = defineIntegration(_langChainIntegration);
+
+export { instrumentLangChain, langChainIntegration };
+//# sourceMappingURL=index.js.map

package/build/esm/integrations/tracing/langchain/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../src/integrations/tracing/langchain/index.ts"],"sourcesContent":["import type { IntegrationFn, LangChainOptions } from '@sentry/core';\nimport { defineIntegration, LANGCHAIN_INTEGRATION_NAME } from '@sentry/core';\nimport { generateInstrumentOnce } from '@sentry/node-core';\nimport { SentryLangChainInstrumentation } from './instrumentation';\n\nexport const instrumentLangChain = generateInstrumentOnce<LangChainOptions>(\n  LANGCHAIN_INTEGRATION_NAME,\n  options => new SentryLangChainInstrumentation(options),\n);\n\nconst _langChainIntegration = ((options: LangChainOptions = {}) => {\n  return {\n    name: LANGCHAIN_INTEGRATION_NAME,\n    setupOnce() {\n      instrumentLangChain(options);\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for LangChain.\n *\n * This integration is enabled by default.\n *\n * When configured, this integration automatically instruments LangChain runnable instances\n * to capture telemetry data by injecting Sentry callback handlers into all LangChain calls.\n *\n * **Important:** This integration automatically skips wrapping the OpenAI, Anthropic, and Google GenAI\n * providers to prevent duplicate spans when using LangChain with these AI providers.\n * LangChain handles the instrumentation for all underlying AI providers.\n *\n * @example\n * ```javascript\n * import * as Sentry from '@sentry/node';\n * import { ChatOpenAI } from '@langchain/openai';\n *\n * Sentry.init({\n *   integrations: [Sentry.langChainIntegration()],\n *   sendDefaultPii: true, // Enable to record inputs/outputs\n * });\n *\n * // LangChain calls are automatically instrumented\n * const model = new ChatOpenAI();\n * await model.invoke(\"What is the capital of France?\");\n * ```\n *\n * ## Manual Callback Handler\n *\n * You can also manually add the Sentry callback handler alongside other callbacks:\n *\n * @example\n * ```javascript\n * import * as Sentry from '@sentry/node';\n * import { ChatOpenAI } from '@langchain/openai';\n *\n * const sentryHandler = Sentry.createLangChainCallbackHandler({\n *   recordInputs: true,\n *   recordOutputs: true\n * });\n *\n * const model = new ChatOpenAI();\n * await model.invoke(\n *   \"What is the capital of France?\",\n *   { callbacks: [sentryHandler, myOtherCallback] }\n * );\n * ```\n *\n * ## Options\n *\n * - `recordInputs`: Whether to record input messages/prompts (default: respects `sendDefaultPii` client option)\n * - `recordOutputs`: Whether to record response text (default: respects `sendDefaultPii` client option)\n *\n * ### Default Behavior\n *\n * By default, the integration will:\n * - Record inputs and outputs ONLY if `sendDefaultPii` is set to `true` in your Sentry client options\n * - Otherwise, inputs and outputs are NOT recorded unless explicitly enabled\n *\n * @example\n * ```javascript\n * // Record inputs and outputs when sendDefaultPii is false\n * Sentry.init({\n *   integrations: [\n *     Sentry.langChainIntegration({\n *       recordInputs: true,\n *       recordOutputs: true\n *     })\n *   ],\n * });\n *\n * // Never record inputs/outputs regardless of sendDefaultPii\n * Sentry.init({\n *   sendDefaultPii: true,\n *   integrations: [\n *     Sentry.langChainIntegration({\n *       recordInputs: false,\n *       recordOutputs: false\n *     })\n *   ],\n * });\n * ```\n *\n * ## Supported Events\n *\n * The integration captures the following LangChain lifecycle events:\n * - LLM/Chat Model: start, end, error\n * - Chain: start, end, error\n * - Tool: start, end, error\n *\n */\nexport const langChainIntegration = defineIntegration(_langChainIntegration);\n"],"names":[],"mappings":";;;;AAKO,MAAM,mBAAA,GAAsB,sBAAsB;AACzD,EAAE,0BAA0B;AAC5B,EAAE,WAAW,IAAI,8BAA8B,CAAC,OAAO,CAAC;AACxD;;AAEA,MAAM,qBAAA,IAAyB,CAAC,OAAO,GAAqB,EAAE,KAAK;AACnE,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,0BAA0B;AACpC,IAAI,SAAS,GAAG;AAChB,MAAM,mBAAmB,CAAC,OAAO,CAAC;AAClC,IAAI,CAAC;AACL,GAAG;AACH,CAAC,CAAA;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACa,oBAAA,GAAuB,iBAAiB,CAAC,qBAAqB;;;;"}