@sentry/node 10.53.0 → 10.54.0

package/build/cjs/integrations/tracing/tedious/vendored/semconv.js

@@ -0,0 +1,20 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const ATTR_DB_NAME = "db.name";
+const ATTR_DB_SQL_TABLE = "db.sql.table";
+const ATTR_DB_STATEMENT = "db.statement";
+const ATTR_DB_SYSTEM = "db.system";
+const ATTR_DB_USER = "db.user";
+const ATTR_NET_PEER_NAME = "net.peer.name";
+const ATTR_NET_PEER_PORT = "net.peer.port";
+const DB_SYSTEM_VALUE_MSSQL = "mssql";
+
+exports.ATTR_DB_NAME = ATTR_DB_NAME;
+exports.ATTR_DB_SQL_TABLE = ATTR_DB_SQL_TABLE;
+exports.ATTR_DB_STATEMENT = ATTR_DB_STATEMENT;
+exports.ATTR_DB_SYSTEM = ATTR_DB_SYSTEM;
+exports.ATTR_DB_USER = ATTR_DB_USER;
+exports.ATTR_NET_PEER_NAME = ATTR_NET_PEER_NAME;
+exports.ATTR_NET_PEER_PORT = ATTR_NET_PEER_PORT;
+exports.DB_SYSTEM_VALUE_MSSQL = DB_SYSTEM_VALUE_MSSQL;
+//# sourceMappingURL=semconv.js.map

package/build/cjs/integrations/tracing/tedious/vendored/semconv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"semconv.js","sources":["../../../../../../src/integrations/tracing/tedious/vendored/semconv.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n * NOTICE from the Sentry authors:\n * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-tedious\n * - Upstream version: @opentelemetry/instrumentation-tedious@0.37.0\n */\n/* eslint-disable */\n\n/*\n * This file contains a copy of unstable semantic convention definitions\n * used by this package.\n * @see https://github.com/open-telemetry/opentelemetry-js/tree/main/semantic-conventions#unstable-semconv\n */\n\n/**\n * Deprecated, use `db.namespace` instead.\n *\n * @example customers\n * @example main\n *\n * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.\n *\n * @deprecated Replaced by `db.namespace`.\n */\nexport const ATTR_DB_NAME = 'db.name' as const;\n\n/**\n * Deprecated, use `db.collection.name` instead.\n *\n * @example \"mytable\"\n *\n * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.\n *\n * @deprecated Replaced by `db.collection.name`, but only if not extracting the value from `db.query.text`.\n */\nexport const ATTR_DB_SQL_TABLE = 'db.sql.table' as const;\n\n/**\n * The database statement being executed.\n *\n * @example SELECT * FROM wuser_table\n * @example SET mykey \"WuValue\"\n *\n * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.\n *\n * @deprecated Replaced by `db.query.text`.\n */\nexport const ATTR_DB_STATEMENT = 'db.statement' as const;\n\n/**\n * Deprecated, use `db.system.name` instead.\n *\n * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.\n *\n * @deprecated Replaced by `db.system.name`.\n */\nexport const ATTR_DB_SYSTEM = 'db.system' as const;\n\n/**\n * Deprecated, no replacement at this time.\n *\n * @example readonly_user\n * @example reporting_user\n *\n * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.\n *\n * @deprecated Removed, no replacement at this time.\n */\nexport const ATTR_DB_USER = 'db.user' as const;\n\n/**\n * Deprecated, use `server.address` on client spans and `client.address` on server spans.\n *\n * @example example.com\n *\n * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.\n *\n * @deprecated Replaced by `server.address` on client spans and `client.address` on server spans.\n */\nexport const ATTR_NET_PEER_NAME = 'net.peer.name' as const;\n\n/**\n * Deprecated, use `server.port` on client spans and `client.port` on server spans.\n *\n * @example 8080\n *\n * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.\n *\n * @deprecated Replaced by `server.port` on client spans and `client.port` on server spans.\n */\nexport const ATTR_NET_PEER_PORT = 'net.peer.port' as const;\n\n/**\n * Enum value \"mssql\" for attribute {@link ATTR_DB_SYSTEM}.\n *\n * Microsoft SQL Server\n *\n * @experimental This enum value is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.\n */\nexport const DB_SYSTEM_VALUE_MSSQL = 'mssql' as const;\n"],"names":[],"mappings":";;AAqCO,MAAM,YAAA,GAAe;AAWrB,MAAM,iBAAA,GAAoB;AAY1B,MAAM,iBAAA,GAAoB;AAS1B,MAAM,cAAA,GAAiB;AAYvB,MAAM,YAAA,GAAe;AAWrB,MAAM,kBAAA,GAAqB;AAW3B,MAAM,kBAAA,GAAqB;AAS3B,MAAM,qBAAA,GAAwB;;;;;;;;;;;"}

package/build/cjs/integrations/tracing/tedious/vendored/utils.js

@@ -0,0 +1,29 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+function getSpanName(operation, db, sql, bulkLoadTable) {
+  if (operation === "execBulkLoad" && bulkLoadTable && db) {
+    return `${operation} ${bulkLoadTable} ${db}`;
+  }
+  if (operation === "callProcedure") {
+    if (db) {
+      return `${operation} ${sql} ${db}`;
+    }
+    return `${operation} ${sql}`;
+  }
+  if (db) {
+    return `${operation} ${db}`;
+  }
+  return `${operation}`;
+}
+const once = (fn) => {
+  let called = false;
+  return (...args) => {
+    if (called) return;
+    called = true;
+    return fn(...args);
+  };
+};
+
+exports.getSpanName = getSpanName;
+exports.once = once;
+//# sourceMappingURL=utils.js.map

package/build/cjs/integrations/tracing/tedious/vendored/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../../../../../src/integrations/tracing/tedious/vendored/utils.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n * NOTICE from the Sentry authors:\n * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-tedious\n * - Upstream version: @opentelemetry/instrumentation-tedious@0.37.0\n */\n/* eslint-disable */\n\n/**\n * The span name SHOULD be set to a low cardinality value\n * representing the statement executed on the database.\n *\n * @returns Operation executed on Tedious Connection. Does not map to SQL statement in any way.\n */\nexport function getSpanName(\n  operation: string,\n  db: string | undefined,\n  sql: string | undefined,\n  bulkLoadTable: string | undefined,\n): string {\n  if (operation === 'execBulkLoad' && bulkLoadTable && db) {\n    return `${operation} ${bulkLoadTable} ${db}`;\n  }\n  if (operation === 'callProcedure') {\n    // `sql` refers to procedure name with `callProcedure`\n    if (db) {\n      return `${operation} ${sql} ${db}`;\n    }\n    return `${operation} ${sql}`;\n  }\n  // do not use `sql` in general case because of high-cardinality\n  if (db) {\n    return `${operation} ${db}`;\n  }\n  return `${operation}`;\n}\n\nexport const once = (fn: Function) => {\n  let called = false;\n  return (...args: unknown[]) => {\n    if (called) return;\n    called = true;\n    return fn(...args);\n  };\n};\n"],"names":[],"mappings":";;AA2BO,SAAS,WAAA,CACd,SAAA,EACA,EAAA,EACA,GAAA,EACA,aAAA,EACQ;AACR,EAAA,IAAI,SAAA,KAAc,cAAA,IAAkB,aAAA,IAAiB,EAAA,EAAI;AACvD,IAAA,OAAO,CAAA,EAAG,SAAS,CAAA,CAAA,EAAI,aAAa,IAAI,EAAE,CAAA,CAAA;AAAA,EAC5C;AACA,EAAA,IAAI,cAAc,eAAA,EAAiB;AAEjC,IAAA,IAAI,EAAA,EAAI;AACN,MAAA,OAAO,CAAA,EAAG,SAAS,CAAA,CAAA,EAAI,GAAG,IAAI,EAAE,CAAA,CAAA;AAAA,IAClC;AACA,IAAA,OAAO,CAAA,EAAG,SAAS,CAAA,CAAA,EAAI,GAAG,CAAA,CAAA;AAAA,EAC5B;AAEA,EAAA,IAAI,EAAA,EAAI;AACN,IAAA,OAAO,CAAA,EAAG,SAAS,CAAA,CAAA,EAAI,EAAE,CAAA,CAAA;AAAA,EAC3B;AACA,EAAA,OAAO,GAAG,SAAS,CAAA,CAAA;AACrB;AAEO,MAAM,IAAA,GAAO,CAAC,EAAA,KAAiB;AACpC,EAAA,IAAI,MAAA,GAAS,KAAA;AACb,EAAA,OAAO,IAAI,IAAA,KAAoB;AAC7B,IAAA,IAAI,MAAA,EAAQ;AACZ,IAAA,MAAA,GAAS,IAAA;AACT,IAAA,OAAO,EAAA,CAAG,GAAG,IAAI,CAAA;AAAA,EACnB,CAAA;AACF;;;;;"}

package/build/cjs/integrations/tracing/utils/sql-common.js

@@ -0,0 +1,43 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const api = require('@opentelemetry/api');
+const core = require('@opentelemetry/core');
+
+function hasValidSqlComment(query) {
+  const indexOpeningDashDashComment = query.indexOf("--");
+  if (indexOpeningDashDashComment >= 0) {
+    return true;
+  }
+  const indexOpeningSlashComment = query.indexOf("/*");
+  if (indexOpeningSlashComment < 0) {
+    return false;
+  }
+  const indexClosingSlashComment = query.indexOf("*/");
+  return indexOpeningDashDashComment < indexClosingSlashComment;
+}
+function fixedEncodeURIComponent(str) {
+  return encodeURIComponent(str).replace(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function addSqlCommenterComment(span, query) {
+  if (typeof query !== "string" || query.length === 0) {
+    return query;
+  }
+  if (hasValidSqlComment(query)) {
+    return query;
+  }
+  const propagator = new core.W3CTraceContextPropagator();
+  const headers = {};
+  propagator.inject(api.trace.setSpan(api.ROOT_CONTEXT, span), headers, api.defaultTextMapSetter);
+  const sortedKeys = Object.keys(headers).sort();
+  if (sortedKeys.length === 0) {
+    return query;
+  }
+  const commentString = sortedKeys.map((key) => {
+    const encodedValue = fixedEncodeURIComponent(headers[key]);
+    return `${key}='${encodedValue}'`;
+  }).join(",");
+  return `${query} /*${commentString}*/`;
+}
+
+exports.addSqlCommenterComment = addSqlCommenterComment;
+//# sourceMappingURL=sql-common.js.map

package/build/cjs/integrations/tracing/utils/sql-common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-common.js","sources":["../../../../../src/integrations/tracing/utils/sql-common.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n * NOTICE from the Sentry authors:\n * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/5a5918fd4f9f16b14c9ef4d3de08ab98c20e5b46/packages/sql-common\n * - Upstream version: @opentelemetry/sql-common@0.41.2\n */\n\n/* eslint-disable */\n\nimport { trace, Span, ROOT_CONTEXT, defaultTextMapSetter } from '@opentelemetry/api';\nimport { W3CTraceContextPropagator } from '@opentelemetry/core';\n\n// NOTE: This function currently is returning false-positives\n// in cases where comment characters appear in string literals\n// (\"SELECT '-- not a comment';\" would return true, although has no comment)\nfunction hasValidSqlComment(query: string): boolean {\n  const indexOpeningDashDashComment = query.indexOf('--');\n  if (indexOpeningDashDashComment >= 0) {\n    return true;\n  }\n\n  const indexOpeningSlashComment = query.indexOf('/*');\n  if (indexOpeningSlashComment < 0) {\n    return false;\n  }\n\n  const indexClosingSlashComment = query.indexOf('*/');\n  return indexOpeningDashDashComment < indexClosingSlashComment;\n}\n\n// sqlcommenter specification (https://google.github.io/sqlcommenter/spec/#value-serialization)\n// expects us to URL encode based on the RFC 3986 spec (https://en.wikipedia.org/wiki/Percent-encoding),\n// but encodeURIComponent does not handle some characters correctly (! ' ( ) *),\n// which means we need special handling for this\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent\nfunction fixedEncodeURIComponent(str: string) {\n  return encodeURIComponent(str).replace(/[!'()*]/g, c => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);\n}\n\nexport function addSqlCommenterComment(span: Span, query: string): string {\n  if (typeof query !== 'string' || query.length === 0) {\n    return query;\n  }\n\n  // As per sqlcommenter spec we shall not add a comment if there already is a comment\n  // in the query\n  if (hasValidSqlComment(query)) {\n    return query;\n  }\n\n  const propagator = new W3CTraceContextPropagator();\n  const headers: { [key: string]: string } = {};\n  propagator.inject(trace.setSpan(ROOT_CONTEXT, span), headers, defaultTextMapSetter);\n\n  // sqlcommenter spec requires keys in the comment to be sorted lexicographically\n  const sortedKeys = Object.keys(headers).sort();\n\n  if (sortedKeys.length === 0) {\n    return query;\n  }\n\n  const commentString = sortedKeys\n    .map(key => {\n      const encodedValue = fixedEncodeURIComponent(headers[key]!);\n      return `${key}='${encodedValue}'`;\n    })\n    .join(',');\n\n  return `${query} /*${commentString}*/`;\n}\n"],"names":["W3CTraceContextPropagator","trace","ROOT_CONTEXT","defaultTextMapSetter"],"mappings":";;;;;AA4BA,SAAS,mBAAmB,KAAA,EAAwB;AAClD,EAAA,MAAM,2BAAA,GAA8B,KAAA,CAAM,OAAA,CAAQ,IAAI,CAAA;AACtD,EAAA,IAAI,+BAA+B,CAAA,EAAG;AACpC,IAAA,OAAO,IAAA;AAAA,EACT;AAEA,EAAA,MAAM,wBAAA,GAA2B,KAAA,CAAM,OAAA,CAAQ,IAAI,CAAA;AACnD,EAAA,IAAI,2BAA2B,CAAA,EAAG;AAChC,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,MAAM,wBAAA,GAA2B,KAAA,CAAM,OAAA,CAAQ,IAAI,CAAA;AACnD,EAAA,OAAO,2BAAA,GAA8B,wBAAA;AACvC;AAOA,SAAS,wBAAwB,GAAA,EAAa;AAC5C,EAAA,OAAO,mBAAmB,GAAG,CAAA,CAAE,OAAA,CAAQ,UAAA,EAAY,OAAK,CAAA,CAAA,EAAI,CAAA,CAAE,UAAA,CAAW,CAAC,EAAE,QAAA,CAAS,EAAE,CAAA,CAAE,WAAA,EAAa,CAAA,CAAE,CAAA;AAC1G;AAEO,SAAS,sBAAA,CAAuB,MAAY,KAAA,EAAuB;AACxE,EAAA,IAAI,OAAO,KAAA,KAAU,QAAA,IAAY,KAAA,CAAM,WAAW,CAAA,EAAG;AACnD,IAAA,OAAO,KAAA;AAAA,EACT;AAIA,EAAA,IAAI,kBAAA,CAAmB,KAAK,CAAA,EAAG;AAC7B,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,MAAM,UAAA,GAAa,IAAIA,8BAAA,EAA0B;AACjD,EAAA,MAAM,UAAqC,EAAC;AAC5C,EAAA,UAAA,CAAW,OAAOC,SAAA,CAAM,OAAA,CAAQC,kBAAc,IAAI,CAAA,EAAG,SAASC,wBAAoB,CAAA;AAGlF,EAAA,MAAM,UAAA,GAAa,MAAA,CAAO,IAAA,CAAK,OAAO,EAAE,IAAA,EAAK;AAE7C,EAAA,IAAI,UAAA,CAAW,WAAW,CAAA,EAAG;AAC3B,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,MAAM,aAAA,GAAgB,UAAA,CACnB,GAAA,CAAI,CAAA,GAAA,KAAO;AACV,IAAA,MAAM,YAAA,GAAe,uBAAA,CAAwB,OAAA,CAAQ,GAAG,CAAE,CAAA;AAC1D,IAAA,OAAO,CAAA,EAAG,GAAG,CAAA,EAAA,EAAK,YAAY,CAAA,CAAA,CAAA;AAAA,EAChC,CAAC,CAAA,CACA,IAAA,CAAK,GAAG,CAAA;AAEX,EAAA,OAAO,CAAA,EAAG,KAAK,CAAA,GAAA,EAAM,aAAa,CAAA,EAAA,CAAA;AACpC;;;;"}

package/build/cjs/integrations/tracing/vercelai/constants.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const INTEGRATION_NAME = 'VercelAI';
+const INTEGRATION_NAME = "VercelAI";
 
 exports.INTEGRATION_NAME = INTEGRATION_NAME;
 //# sourceMappingURL=constants.js.map

package/build/cjs/integrations/tracing/vercelai/index.js

@@ -6,19 +6,12 @@ const constants = require('./constants.js');
 const instrumentation = require('./instrumentation.js');
 
 const instrumentVercelAi = nodeCore.generateInstrumentOnce(constants.INTEGRATION_NAME, () => new instrumentation.SentryVercelAiInstrumentation({}));
-
-/**
- * Determines if the integration should be forced based on environment and package availability.
- * Returns true if the 'ai' package is available.
- */
 function shouldForceIntegration(client) {
-  const modules = client.getIntegrationByName('Modules');
+  const modules = client.getIntegrationByName("Modules");
   return !!modules?.getModules?.()?.ai;
 }
-
 const _vercelAIIntegration = ((options = {}) => {
   let instrumentation;
-
   return {
     name: constants.INTEGRATION_NAME,
     options,
@@ -26,55 +19,15 @@ const _vercelAIIntegration = ((options = {}) => {
       instrumentation = instrumentVercelAi();
     },
     afterAllSetup(client) {
-      // Auto-detect if we should force the integration when running with 'ai' package available
-      // Note that this can only be detected if the 'Modules' integration is available, and running in CJS mode
       const shouldForce = options.force ?? shouldForceIntegration(client);
-
       if (shouldForce) {
         core.addVercelAiProcessors(client);
       } else {
         instrumentation?.callWhenPatched(() => core.addVercelAiProcessors(client));
       }
-    },
+    }
   };
-}) ;
-
-/**
- * Adds Sentry tracing instrumentation for the [ai](https://www.npmjs.com/package/ai) library.
- * This integration is not enabled by default, you need to manually add it.
- *
- * For more information, see the [`ai` documentation](https://sdk.vercel.ai/docs/ai-sdk-core/telemetry).
- *
- * @example
- * ```javascript
- * const Sentry = require('@sentry/node');
- *
- * Sentry.init({
- *  integrations: [Sentry.vercelAIIntegration()],
- * });
- * ```
- *
- * This integration adds tracing support to all `ai` function calls.
- * You need to opt-in to collecting spans for a specific call,
- * you can do so by setting `experimental_telemetry.isEnabled` to `true` in the first argument of the function call.
- *
- * ```javascript
- * const result = await generateText({
- *   model: openai('gpt-4-turbo'),
- *   experimental_telemetry: { isEnabled: true },
- * });
- * ```
- *
- * If you want to collect inputs and outputs for a specific call, you must specifically opt-in to each
- * function call by setting `experimental_telemetry.recordInputs` and `experimental_telemetry.recordOutputs`
- * to `true`.
- *
- * ```javascript
- * const result = await generateText({
- *  model: openai('gpt-4-turbo'),
- *  experimental_telemetry: { isEnabled: true, recordInputs: true, recordOutputs: true },
- * });
- */
+});
 const vercelAIIntegration = core.defineIntegration(_vercelAIIntegration);
 
 exports.instrumentVercelAi = instrumentVercelAi;

package/build/cjs/integrations/tracing/vercelai/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../../../src/integrations/tracing/vercelai/index.ts"],"sourcesContent":["import type { Client, IntegrationFn } from '@sentry/core';\nimport { addVercelAiProcessors, defineIntegration } from '@sentry/core';\nimport { generateInstrumentOnce, type modulesIntegration } from '@sentry/node-core';\nimport { INTEGRATION_NAME } from './constants';\nimport { SentryVercelAiInstrumentation } from './instrumentation';\nimport type { VercelAiOptions } from './types';\n\nexport const instrumentVercelAi = generateInstrumentOnce(INTEGRATION_NAME, () => new SentryVercelAiInstrumentation({}));\n\n/**\n * Determines if the integration should be forced based on environment and package availability.\n * Returns true if the 'ai' package is available.\n */\nfunction shouldForceIntegration(client: Client): boolean {\n  const modules = client.getIntegrationByName<ReturnType<typeof modulesIntegration>>('Modules');\n  return !!modules?.getModules?.()?.ai;\n}\n\nconst _vercelAIIntegration = ((options: VercelAiOptions = {}) => {\n  let instrumentation: undefined | SentryVercelAiInstrumentation;\n\n  return {\n    name: INTEGRATION_NAME,\n    options,\n    setupOnce() {\n      instrumentation = instrumentVercelAi();\n    },\n    afterAllSetup(client) {\n      // Auto-detect if we should force the integration when running with 'ai' package available\n      // Note that this can only be detected if the 'Modules' integration is available, and running in CJS mode\n      const shouldForce = options.force ?? shouldForceIntegration(client);\n\n      if (shouldForce) {\n        addVercelAiProcessors(client);\n      } else {\n        instrumentation?.callWhenPatched(() => addVercelAiProcessors(client));\n      }\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for the [ai](https://www.npmjs.com/package/ai) library.\n * This integration is not enabled by default, you need to manually add it.\n *\n * For more information, see the [`ai` documentation](https://sdk.vercel.ai/docs/ai-sdk-core/telemetry).\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *  integrations: [Sentry.vercelAIIntegration()],\n * });\n * ```\n *\n * This integration adds tracing support to all `ai` function calls.\n * You need to opt-in to collecting spans for a specific call,\n * you can do so by setting `experimental_telemetry.isEnabled` to `true` in the first argument of the function call.\n *\n * ```javascript\n * const result = await generateText({\n *   model: openai('gpt-4-turbo'),\n *   experimental_telemetry: { isEnabled: true },\n * });\n * ```\n *\n * If you want to collect inputs and outputs for a specific call, you must specifically opt-in to each\n * function call by setting `experimental_telemetry.recordInputs` and `experimental_telemetry.recordOutputs`\n * to `true`.\n *\n * ```javascript\n * const result = await generateText({\n *  model: openai('gpt-4-turbo'),\n *  experimental_telemetry: { isEnabled: true, recordInputs: true, recordOutputs: true },\n * });\n */\nexport const vercelAIIntegration = defineIntegration(_vercelAIIntegration);\n"],"names":["generateInstrumentOnce","INTEGRATION_NAME","SentryVercelAiInstrumentation","addVercelAiProcessors","defineIntegration"],"mappings":";;;;;;;MAOa,kBAAA,GAAqBA,+BAAsB,CAACC,0BAAgB,EAAE,MAAM,IAAIC,6CAA6B,CAAC,EAAE,CAAC;;AAEtH;AACA;AACA;AACA;AACA,SAAS,sBAAsB,CAAC,MAAM,EAAmB;AACzD,EAAE,MAAM,UAAU,MAAM,CAAC,oBAAoB,CAAwC,SAAS,CAAC;AAC/F,EAAE,OAAO,CAAC,CAAC,OAAO,EAAE,UAAU,IAAI,EAAE,EAAE;AACtC;;AAEA,MAAM,oBAAA,IAAwB,CAAC,OAAO,GAAoB,EAAE,KAAK;AACjE,EAAE,IAAI,eAAe;;AAErB,EAAE,OAAO;AACT,IAAI,IAAI,EAAED,0BAAgB;AAC1B,IAAI,OAAO;AACX,IAAI,SAAS,GAAG;AAChB,MAAM,eAAA,GAAkB,kBAAkB,EAAE;AAC5C,IAAI,CAAC;AACL,IAAI,aAAa,CAAC,MAAM,EAAE;AAC1B;AACA;AACA,MAAM,MAAM,WAAA,GAAc,OAAO,CAAC,SAAS,sBAAsB,CAAC,MAAM,CAAC;;AAEzE,MAAM,IAAI,WAAW,EAAE;AACvB,QAAQE,0BAAqB,CAAC,MAAM,CAAC;AACrC,MAAM,OAAO;AACb,QAAQ,eAAe,EAAE,eAAe,CAAC,MAAMA,0BAAqB,CAAC,MAAM,CAAC,CAAC;AAC7E,MAAM;AACN,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;MACa,mBAAA,GAAsBC,sBAAiB,CAAC,oBAAoB;;;;;"}
+{"version":3,"file":"index.js","sources":["../../../../../src/integrations/tracing/vercelai/index.ts"],"sourcesContent":["import type { Client, IntegrationFn } from '@sentry/core';\nimport { addVercelAiProcessors, defineIntegration } from '@sentry/core';\nimport { generateInstrumentOnce, type modulesIntegration } from '@sentry/node-core';\nimport { INTEGRATION_NAME } from './constants';\nimport { SentryVercelAiInstrumentation } from './instrumentation';\nimport type { VercelAiOptions } from './types';\n\nexport const instrumentVercelAi = generateInstrumentOnce(INTEGRATION_NAME, () => new SentryVercelAiInstrumentation({}));\n\n/**\n * Determines if the integration should be forced based on environment and package availability.\n * Returns true if the 'ai' package is available.\n */\nfunction shouldForceIntegration(client: Client): boolean {\n  const modules = client.getIntegrationByName<ReturnType<typeof modulesIntegration>>('Modules');\n  return !!modules?.getModules?.()?.ai;\n}\n\nconst _vercelAIIntegration = ((options: VercelAiOptions = {}) => {\n  let instrumentation: undefined | SentryVercelAiInstrumentation;\n\n  return {\n    name: INTEGRATION_NAME,\n    options,\n    setupOnce() {\n      instrumentation = instrumentVercelAi();\n    },\n    afterAllSetup(client) {\n      // Auto-detect if we should force the integration when running with 'ai' package available\n      // Note that this can only be detected if the 'Modules' integration is available, and running in CJS mode\n      const shouldForce = options.force ?? shouldForceIntegration(client);\n\n      if (shouldForce) {\n        addVercelAiProcessors(client);\n      } else {\n        instrumentation?.callWhenPatched(() => addVercelAiProcessors(client));\n      }\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for the [ai](https://www.npmjs.com/package/ai) library.\n * This integration is not enabled by default, you need to manually add it.\n *\n * For more information, see the [`ai` documentation](https://sdk.vercel.ai/docs/ai-sdk-core/telemetry).\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *  integrations: [Sentry.vercelAIIntegration()],\n * });\n * ```\n *\n * This integration adds tracing support to all `ai` function calls.\n * You need to opt-in to collecting spans for a specific call,\n * you can do so by setting `experimental_telemetry.isEnabled` to `true` in the first argument of the function call.\n *\n * ```javascript\n * const result = await generateText({\n *   model: openai('gpt-4-turbo'),\n *   experimental_telemetry: { isEnabled: true },\n * });\n * ```\n *\n * If you want to collect inputs and outputs for a specific call, you must specifically opt-in to each\n * function call by setting `experimental_telemetry.recordInputs` and `experimental_telemetry.recordOutputs`\n * to `true`.\n *\n * ```javascript\n * const result = await generateText({\n *  model: openai('gpt-4-turbo'),\n *  experimental_telemetry: { isEnabled: true, recordInputs: true, recordOutputs: true },\n * });\n */\nexport const vercelAIIntegration = defineIntegration(_vercelAIIntegration);\n"],"names":["generateInstrumentOnce","INTEGRATION_NAME","SentryVercelAiInstrumentation","addVercelAiProcessors","defineIntegration"],"mappings":";;;;;;;AAOO,MAAM,kBAAA,GAAqBA,gCAAuBC,0BAAA,EAAkB,MAAM,IAAIC,6CAAA,CAA8B,EAAE,CAAC;AAMtH,SAAS,uBAAuB,MAAA,EAAyB;AACvD,EAAA,MAAM,OAAA,GAAU,MAAA,CAAO,oBAAA,CAA4D,SAAS,CAAA;AAC5F,EAAA,OAAO,CAAC,CAAC,OAAA,EAAS,UAAA,IAAa,EAAG,EAAA;AACpC;AAEA,MAAM,oBAAA,IAAwB,CAAC,OAAA,GAA2B,EAAC,KAAM;AAC/D,EAAA,IAAI,eAAA;AAEJ,EAAA,OAAO;AAAA,IACL,IAAA,EAAMD,0BAAA;AAAA,IACN,OAAA;AAAA,IACA,SAAA,GAAY;AACV,MAAA,eAAA,GAAkB,kBAAA,EAAmB;AAAA,IACvC,CAAA;AAAA,IACA,cAAc,MAAA,EAAQ;AAGpB,MAAA,MAAM,WAAA,GAAc,OAAA,CAAQ,KAAA,IAAS,sBAAA,CAAuB,MAAM,CAAA;AAElE,MAAA,IAAI,WAAA,EAAa;AACf,QAAAE,0BAAA,CAAsB,MAAM,CAAA;AAAA,MAC9B,CAAA,MAAO;AACL,QAAA,eAAA,EAAiB,eAAA,CAAgB,MAAMA,0BAAA,CAAsB,MAAM,CAAC,CAAA;AAAA,MACtE;AAAA,IACF;AAAA,GACF;AACF,CAAA,CAAA;AAsCO,MAAM,mBAAA,GAAsBC,uBAAkB,oBAAoB;;;;;"}

package/build/cjs/integrations/tracing/vercelai/instrumentation.js

@@ -4,264 +4,165 @@ const instrumentation = require('@opentelemetry/instrumentation');
 const core = require('@sentry/core');
 const constants = require('./constants.js');
 
-const SUPPORTED_VERSIONS = ['>=3.0.0 <7'];
-
-// List of patched methods
-// From: https://sdk.vercel.ai/docs/ai-sdk-core/telemetry#collected-data
+const SUPPORTED_VERSIONS = [">=3.0.0 <7"];
 const INSTRUMENTED_METHODS = [
-  'generateText',
-  'streamText',
-  'generateObject',
-  'streamObject',
-  'embed',
-  'embedMany',
-  'rerank',
-] ;
-
+  "generateText",
+  "streamText",
+  "generateObject",
+  "streamObject",
+  "embed",
+  "embedMany",
+  "rerank"
+];
 function isToolError(obj) {
-  if (typeof obj !== 'object' || obj === null) {
+  if (typeof obj !== "object" || obj === null) {
     return false;
   }
-
-  const candidate = obj ;
-  return (
-    'type' in candidate &&
-    'error' in candidate &&
-    'toolName' in candidate &&
-    'toolCallId' in candidate &&
-    candidate.type === 'tool-error' &&
-    candidate.error instanceof Error
-  );
+  const candidate = obj;
+  return "type" in candidate && "error" in candidate && "toolName" in candidate && "toolCallId" in candidate && candidate.type === "tool-error" && candidate.error instanceof Error;
 }
-
-/**
- * Process tool call results: capture tool errors and clean up span context mappings.
- *
- * Error checking runs first (needs span context for linking), then cleanup removes all entries.
- * Tool errors are not rejected in Vercel AI V5 — they appear as metadata in the result content.
- */
 function processToolCallResults(result) {
-  if (typeof result !== 'object' || result === null || !('content' in result)) {
+  if (typeof result !== "object" || result === null || !("content" in result)) {
     return;
   }
-
-  const resultObj = result ;
+  const resultObj = result;
   if (!Array.isArray(resultObj.content)) {
     return;
   }
-
   captureToolErrors(resultObj.content);
   cleanupToolCallSpanContexts(resultObj.content);
 }
-
 function captureToolErrors(content) {
   for (const item of content) {
     if (!isToolError(item)) {
       continue;
     }
-
-    // Try to get the span context associated with this tool call ID
     const spanContext = core._INTERNAL_getSpanContextForToolCallId(item.toolCallId);
-
     if (spanContext) {
-      // We have the span context, so link the error using span and trace IDs
-      core.withScope(scope => {
-        scope.setContext('trace', {
+      core.withScope((scope) => {
+        scope.setContext("trace", {
           trace_id: spanContext.traceId,
-          span_id: spanContext.spanId,
+          span_id: spanContext.spanId
         });
-
-        scope.setTag('vercel.ai.tool.name', item.toolName);
-        scope.setTag('vercel.ai.tool.callId', item.toolCallId);
-        scope.setLevel('error');
-
+        scope.setTag("vercel.ai.tool.name", item.toolName);
+        scope.setTag("vercel.ai.tool.callId", item.toolCallId);
+        scope.setLevel("error");
         core.captureException(item.error, {
           mechanism: {
-            type: 'auto.vercelai.otel',
-            handled: false,
-          },
+            type: "auto.vercelai.otel",
+            handled: false
+          }
         });
       });
     } else {
-      // Fallback: capture without span linking
-      core.withScope(scope => {
-        scope.setTag('vercel.ai.tool.name', item.toolName);
-        scope.setTag('vercel.ai.tool.callId', item.toolCallId);
-        scope.setLevel('error');
-
+      core.withScope((scope) => {
+        scope.setTag("vercel.ai.tool.name", item.toolName);
+        scope.setTag("vercel.ai.tool.callId", item.toolCallId);
+        scope.setLevel("error");
         core.captureException(item.error, {
           mechanism: {
-            type: 'auto.vercelai.otel',
-            handled: false,
-          },
+            type: "auto.vercelai.otel",
+            handled: false
+          }
         });
       });
     }
   }
 }
-
-/**
- * Remove span context entries for all completed tool calls in the content array.
- */
 function cleanupToolCallSpanContexts(content) {
   for (const item of content) {
-    if (
-      typeof item === 'object' &&
-      item !== null &&
-      'toolCallId' in item &&
-      typeof (item ).toolCallId === 'string'
-    ) {
-      core._INTERNAL_cleanupToolCallSpanContext((item ).toolCallId );
+    if (typeof item === "object" && item !== null && "toolCallId" in item && typeof item.toolCallId === "string") {
+      core._INTERNAL_cleanupToolCallSpanContext(item.toolCallId);
     }
   }
 }
-
-/**
- * Determines whether to record inputs and outputs for Vercel AI telemetry based on the configuration hierarchy.
- *
- * The order of precedence is:
- * 1. The vercel ai integration options
- * 2. The experimental_telemetry options in the vercel ai method calls
- * 3. When telemetry is explicitly enabled (isEnabled: true), default to recording
- * 4. Otherwise, use the sendDefaultPii option from client options
- */
-function determineRecordingSettings(
-  integrationRecordingOptions,
-  methodTelemetryOptions,
-  telemetryExplicitlyEnabled,
-  defaultRecordingEnabled,
-) {
-  const recordInputs =
-    integrationRecordingOptions?.recordInputs !== undefined
-      ? integrationRecordingOptions.recordInputs
-      : methodTelemetryOptions.recordInputs !== undefined
-        ? methodTelemetryOptions.recordInputs
-        : telemetryExplicitlyEnabled === true
-          ? true // When telemetry is explicitly enabled, default to recording inputs
-          : defaultRecordingEnabled;
-
-  const recordOutputs =
-    integrationRecordingOptions?.recordOutputs !== undefined
-      ? integrationRecordingOptions.recordOutputs
-      : methodTelemetryOptions.recordOutputs !== undefined
-        ? methodTelemetryOptions.recordOutputs
-        : telemetryExplicitlyEnabled === true
-          ? true // When telemetry is explicitly enabled, default to recording inputs
-          : defaultRecordingEnabled;
-
+function determineRecordingSettings(integrationRecordingOptions, methodTelemetryOptions, telemetryExplicitlyEnabled, defaultRecordingEnabled) {
+  const recordInputs = integrationRecordingOptions?.recordInputs !== void 0 ? integrationRecordingOptions.recordInputs : methodTelemetryOptions.recordInputs !== void 0 ? methodTelemetryOptions.recordInputs : telemetryExplicitlyEnabled === true ? true : defaultRecordingEnabled;
+  const recordOutputs = integrationRecordingOptions?.recordOutputs !== void 0 ? integrationRecordingOptions.recordOutputs : methodTelemetryOptions.recordOutputs !== void 0 ? methodTelemetryOptions.recordOutputs : telemetryExplicitlyEnabled === true ? true : defaultRecordingEnabled;
   return { recordInputs, recordOutputs };
 }
-
-/**
- * This detects is added by the Sentry Vercel AI Integration to detect if the integration should
- * be enabled.
- *
- * It also patches the `ai` module to enable Vercel AI telemetry automatically for all methods.
- */
 class SentryVercelAiInstrumentation extends instrumentation.InstrumentationBase {
-   __init() {this._isPatched = false;}
-   __init2() {this._callbacks = [];}
-
-   constructor(config = {}) {
-    super('@sentry/instrumentation-vercel-ai', core.SDK_VERSION, config);SentryVercelAiInstrumentation.prototype.__init.call(this);SentryVercelAiInstrumentation.prototype.__init2.call(this);  }
-
+  constructor(config = {}) {
+    super("@sentry/instrumentation-vercel-ai", core.SDK_VERSION, config);
+    this._isPatched = false;
+    this._callbacks = [];
+  }
   /**
    * Initializes the instrumentation by defining the modules to be patched.
    */
-   init() {
-    const module = new instrumentation.InstrumentationNodeModuleDefinition('ai', SUPPORTED_VERSIONS, this._patch.bind(this));
+  init() {
+    const module = new instrumentation.InstrumentationNodeModuleDefinition("ai", SUPPORTED_VERSIONS, this._patch.bind(this));
     return module;
   }
-
   /**
    * Call the provided callback when the module is patched.
    * If it has already been patched, the callback will be called immediately.
    */
-   callWhenPatched(callback) {
+  callWhenPatched(callback) {
     if (this._isPatched) {
       callback();
     } else {
       this._callbacks.push(callback);
     }
   }
-
   /**
    * Patches module exports to enable Vercel AI telemetry.
    */
-   _patch(moduleExports) {
+  _patch(moduleExports) {
     this._isPatched = true;
-
-    this._callbacks.forEach(callback => callback());
+    this._callbacks.forEach((callback) => callback());
     this._callbacks = [];
-
     const generatePatch = (originalMethod) => {
       return new Proxy(originalMethod, {
         apply: (target, thisArg, args) => {
           const existingExperimentalTelemetry = args[0].experimental_telemetry || {};
           const isEnabled = existingExperimentalTelemetry.isEnabled;
-
           const client = core.getClient();
           const integration = client?.getIntegrationByName(constants.INTEGRATION_NAME);
           const integrationOptions = integration?.options;
           const shouldRecordInputsAndOutputs = integration ? Boolean(client?.getOptions().sendDefaultPii) : false;
-
           const { recordInputs, recordOutputs } = determineRecordingSettings(
             integrationOptions,
             existingExperimentalTelemetry,
             isEnabled,
-            shouldRecordInputsAndOutputs,
+            shouldRecordInputsAndOutputs
           );
-
           args[0].experimental_telemetry = {
             ...existingExperimentalTelemetry,
-            isEnabled: isEnabled !== undefined ? isEnabled : true,
+            isEnabled: isEnabled !== void 0 ? isEnabled : true,
             recordInputs,
-            recordOutputs,
+            recordOutputs
           };
-
           return core.handleCallbackErrors(
             () => Reflect.apply(target, thisArg, args),
-            error => {
-              // This error bubbles up to unhandledrejection handler (if not handled before),
-              // where we do not know the active span anymore
-              // So to circumvent this, we set the active span on the error object
-              // which is picked up by the unhandledrejection handler
-              if (error && typeof error === 'object') {
-                core.addNonEnumerableProperty(error, '_sentry_active_span', core.getActiveSpan());
+            (error) => {
+              if (error && typeof error === "object") {
+                core.addNonEnumerableProperty(error, "_sentry_active_span", core.getActiveSpan());
               }
             },
-            () => {},
-            result => {
-              processToolCallResults(result);
+            () => {
             },
+            (result) => {
+              processToolCallResults(result);
+            }
           );
-        },
+        }
       });
     };
-
-    // Is this an ESM module?
-    // https://tc39.es/ecma262/#sec-module-namespace-objects
-    if (Object.prototype.toString.call(moduleExports) === '[object Module]') {
-      // In ESM we take the usual route and just replace the exports we want to instrument
+    if (Object.prototype.toString.call(moduleExports) === "[object Module]") {
       for (const method of INSTRUMENTED_METHODS) {
-        // Skip methods that don't exist in this version of the AI SDK (e.g., rerank was added in v6)
         if (moduleExports[method] != null) {
           moduleExports[method] = generatePatch(moduleExports[method]);
         }
       }
-
       return moduleExports;
     } else {
-      // In CJS we can't replace the exports in the original module because they
-      // don't have setters, so we create a new object with the same properties
       const patchedModuleExports = INSTRUMENTED_METHODS.reduce((acc, curr) => {
-        // Skip methods that don't exist in this version of the AI SDK (e.g., rerank was added in v6)
         if (moduleExports[curr] != null) {
           acc[curr] = generatePatch(moduleExports[curr]);
         }
         return acc;
-      }, {} );
-
+      }, {});
       return { ...moduleExports, ...patchedModuleExports };
     }
   }