@depup/sentry__node 10.44.0-depup.0

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

@@ -0,0 +1,43 @@
+import { MySQL2Instrumentation } from '@opentelemetry/instrumentation-mysql2';
+import { defineIntegration } from '@sentry/core';
+import { generateInstrumentOnce, addOriginToSpan } from '@sentry/node-core';
+
+const INTEGRATION_NAME = 'Mysql2';
+
+const instrumentMysql2 = generateInstrumentOnce(
+  INTEGRATION_NAME,
+  () =>
+    new MySQL2Instrumentation({
+      responseHook(span) {
+        addOriginToSpan(span, 'auto.db.otel.mysql2');
+      },
+    }),
+);
+
+const _mysql2Integration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      instrumentMysql2();
+    },
+  };
+}) ;
+
+/**
+ * Adds Sentry tracing instrumentation for the [mysql2](https://www.npmjs.com/package/mysql2) library.
+ *
+ * For more information, see the [`mysql2Integration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/mysql2/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.mysqlIntegration()],
+ * });
+ * ```
+ */
+const mysql2Integration = defineIntegration(_mysql2Integration);
+
+export { instrumentMysql2, mysql2Integration };
+//# sourceMappingURL=mysql2.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mysql2.js","sources":["../../../../src/integrations/tracing/mysql2.ts"],"sourcesContent":["import { MySQL2Instrumentation } from '@opentelemetry/instrumentation-mysql2';\nimport type { IntegrationFn } from '@sentry/core';\nimport { defineIntegration } from '@sentry/core';\nimport { addOriginToSpan, generateInstrumentOnce } from '@sentry/node-core';\n\nconst INTEGRATION_NAME = 'Mysql2';\n\nexport const instrumentMysql2 = generateInstrumentOnce(\n  INTEGRATION_NAME,\n  () =>\n    new MySQL2Instrumentation({\n      responseHook(span) {\n        addOriginToSpan(span, 'auto.db.otel.mysql2');\n      },\n    }),\n);\n\nconst _mysql2Integration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      instrumentMysql2();\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for the [mysql2](https://www.npmjs.com/package/mysql2) library.\n *\n * For more information, see the [`mysql2Integration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/mysql2/).\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *  integrations: [Sentry.mysqlIntegration()],\n * });\n * ```\n */\nexport const mysql2Integration = defineIntegration(_mysql2Integration);\n"],"names":[],"mappings":";;;;AAKA,MAAM,gBAAA,GAAmB,QAAQ;;AAE1B,MAAM,gBAAA,GAAmB,sBAAsB;AACtD,EAAE,gBAAgB;AAClB,EAAE;AACF,IAAI,IAAI,qBAAqB,CAAC;AAC9B,MAAM,YAAY,CAAC,IAAI,EAAE;AACzB,QAAQ,eAAe,CAAC,IAAI,EAAE,qBAAqB,CAAC;AACpD,MAAM,CAAC;AACP,KAAK,CAAC;AACN;;AAEA,MAAM,kBAAA,IAAsB,MAAM;AAClC,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,gBAAgB;AAC1B,IAAI,SAAS,GAAG;AAChB,MAAM,gBAAgB,EAAE;AACxB,IAAI,CAAC;AACL,GAAG;AACH,CAAC,CAAA;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACa,iBAAA,GAAoB,iBAAiB,CAAC,kBAAkB;;;;"}

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

@@ -0,0 +1,75 @@
+import { OPENAI_INTEGRATION_NAME, defineIntegration } from '@sentry/core';
+import { generateInstrumentOnce } from '@sentry/node-core';
+import { SentryOpenAiInstrumentation } from './instrumentation.js';
+
+const instrumentOpenAi = generateInstrumentOnce(
+  OPENAI_INTEGRATION_NAME,
+  options => new SentryOpenAiInstrumentation(options),
+);
+
+const _openAiIntegration = ((options = {}) => {
+  return {
+    name: OPENAI_INTEGRATION_NAME,
+    setupOnce() {
+      instrumentOpenAi(options);
+    },
+  };
+}) ;
+
+/**
+ * Adds Sentry tracing instrumentation for the OpenAI SDK.
+ *
+ * This integration is enabled by default.
+ *
+ * When configured, this integration automatically instruments OpenAI SDK client instances
+ * to capture telemetry data following OpenTelemetry Semantic Conventions for Generative AI.
+ *
+ * @example
+ * ```javascript
+ * import * as Sentry from '@sentry/node';
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.openAIIntegration()],
+ * });
+ * ```
+ *
+ * ## Options
+ *
+ * - `recordInputs`: Whether to record prompt messages (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.openAIIntegration({
+ *       recordInputs: true,
+ *       recordOutputs: true
+ *     })
+ *   ],
+ * });
+ *
+ * // Never record inputs/outputs regardless of sendDefaultPii
+ * Sentry.init({
+ *   sendDefaultPii: true,
+ *   integrations: [
+ *     Sentry.openAIIntegration({
+ *       recordInputs: false,
+ *       recordOutputs: false
+ *     })
+ *   ],
+ * });
+ * ```
+ *
+ */
+const openAIIntegration = defineIntegration(_openAiIntegration);
+
+export { instrumentOpenAi, openAIIntegration };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../src/integrations/tracing/openai/index.ts"],"sourcesContent":["import type { IntegrationFn, OpenAiOptions } from '@sentry/core';\nimport { defineIntegration, OPENAI_INTEGRATION_NAME } from '@sentry/core';\nimport { generateInstrumentOnce } from '@sentry/node-core';\nimport { SentryOpenAiInstrumentation } from './instrumentation';\n\nexport const instrumentOpenAi = generateInstrumentOnce<OpenAiOptions>(\n  OPENAI_INTEGRATION_NAME,\n  options => new SentryOpenAiInstrumentation(options),\n);\n\nconst _openAiIntegration = ((options: OpenAiOptions = {}) => {\n  return {\n    name: OPENAI_INTEGRATION_NAME,\n    setupOnce() {\n      instrumentOpenAi(options);\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for the OpenAI SDK.\n *\n * This integration is enabled by default.\n *\n * When configured, this integration automatically instruments OpenAI SDK client instances\n * to capture telemetry data following OpenTelemetry Semantic Conventions for Generative AI.\n *\n * @example\n * ```javascript\n * import * as Sentry from '@sentry/node';\n *\n * Sentry.init({\n *   integrations: [Sentry.openAIIntegration()],\n * });\n * ```\n *\n * ## Options\n *\n * - `recordInputs`: Whether to record prompt messages (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.openAIIntegration({\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.openAIIntegration({\n *       recordInputs: false,\n *       recordOutputs: false\n *     })\n *   ],\n * });\n * ```\n *\n */\nexport const openAIIntegration = defineIntegration(_openAiIntegration);\n"],"names":[],"mappings":";;;;AAKO,MAAM,gBAAA,GAAmB,sBAAsB;AACtD,EAAE,uBAAuB;AACzB,EAAE,WAAW,IAAI,2BAA2B,CAAC,OAAO,CAAC;AACrD;;AAEA,MAAM,kBAAA,IAAsB,CAAC,OAAO,GAAkB,EAAE,KAAK;AAC7D,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,uBAAuB;AACjC,IAAI,SAAS,GAAG;AAChB,MAAM,gBAAgB,CAAC,OAAO,CAAC;AAC/B,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;MACa,iBAAA,GAAoB,iBAAiB,CAAC,kBAAkB;;;;"}

package/build/esm/integrations/tracing/openai/instrumentation.js

@@ -0,0 +1,102 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { SDK_VERSION, _INTERNAL_shouldSkipAiProviderWrapping, OPENAI_INTEGRATION_NAME, instrumentOpenAiClient } from '@sentry/core';
+
+const supportedVersions = ['>=4.0.0 <7'];
+
+/**
+ * Sentry OpenAI instrumentation using OpenTelemetry.
+ */
+class SentryOpenAiInstrumentation extends InstrumentationBase {
+   constructor(config = {}) {
+    super('@sentry/instrumentation-openai', SDK_VERSION, config);
+  }
+
+  /**
+   * Initializes the instrumentation by defining the modules to be patched.
+   */
+   init() {
+    const module = new InstrumentationNodeModuleDefinition('openai', supportedVersions, this._patch.bind(this));
+    return module;
+  }
+
+  /**
+   * Core patch logic applying instrumentation to the OpenAI and AzureOpenAI client constructors.
+   */
+   _patch(exports$1) {
+    let result = exports$1;
+    result = this._patchClient(result, 'OpenAI');
+    result = this._patchClient(result, 'AzureOpenAI');
+    return result;
+  }
+
+  /**
+   * Patch logic applying instrumentation to the specified client constructor.
+   */
+   _patchClient(exports$1, exportKey) {
+    const Original = exports$1[exportKey];
+    if (!Original) {
+      return exports$1;
+    }
+
+    const config = this.getConfig();
+
+    const WrappedOpenAI = function ( ...args) {
+      // Check if wrapping should be skipped (e.g., when LangChain is handling instrumentation)
+      if (_INTERNAL_shouldSkipAiProviderWrapping(OPENAI_INTEGRATION_NAME)) {
+        return Reflect.construct(Original, args) ;
+      }
+
+      const instance = Reflect.construct(Original, args);
+
+      return instrumentOpenAiClient(instance , config);
+    } ;
+
+    // Preserve static and prototype chains
+    Object.setPrototypeOf(WrappedOpenAI, Original);
+    Object.setPrototypeOf(WrappedOpenAI.prototype, Original.prototype);
+
+    for (const key of Object.getOwnPropertyNames(Original)) {
+      if (!['length', 'name', 'prototype'].includes(key)) {
+        const descriptor = Object.getOwnPropertyDescriptor(Original, key);
+        if (descriptor) {
+          Object.defineProperty(WrappedOpenAI, key, descriptor);
+        }
+      }
+    }
+
+    // Constructor replacement - handle read-only properties
+    // The OpenAI property might have only a getter, so use defineProperty
+    try {
+      exports$1[exportKey] = WrappedOpenAI;
+    } catch {
+      // If direct assignment fails, override the property descriptor
+      Object.defineProperty(exports$1, exportKey, {
+        value: WrappedOpenAI,
+        writable: true,
+        configurable: true,
+        enumerable: true,
+      });
+    }
+
+    // Wrap the default export if it points to the original constructor
+    // Constructor replacement - handle read-only properties
+    // The OpenAI property might have only a getter, so use defineProperty
+    if (exports$1.default === Original) {
+      try {
+        exports$1.default = WrappedOpenAI;
+      } catch {
+        // If direct assignment fails, override the property descriptor
+        Object.defineProperty(exports$1, 'default', {
+          value: WrappedOpenAI,
+          writable: true,
+          configurable: true,
+          enumerable: true,
+        });
+      }
+    }
+    return exports$1;
+  }
+}
+
+export { SentryOpenAiInstrumentation };
+//# sourceMappingURL=instrumentation.js.map

package/build/esm/integrations/tracing/openai/instrumentation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.js","sources":["../../../../../src/integrations/tracing/openai/instrumentation.ts"],"sourcesContent":["import {\n  InstrumentationBase,\n  type InstrumentationConfig,\n  type InstrumentationModuleDefinition,\n  InstrumentationNodeModuleDefinition,\n} from '@opentelemetry/instrumentation';\nimport type { Integration, OpenAiClient, OpenAiOptions } from '@sentry/core';\nimport {\n  _INTERNAL_shouldSkipAiProviderWrapping,\n  instrumentOpenAiClient,\n  OPENAI_INTEGRATION_NAME,\n  SDK_VERSION,\n} from '@sentry/core';\n\nconst supportedVersions = ['>=4.0.0 <7'];\n\nexport interface OpenAiIntegration extends Integration {\n  options: OpenAiOptions;\n}\n\ntype OpenAiInstrumentationOptions = InstrumentationConfig & OpenAiOptions;\n\n/**\n * Represents the patched shape of the OpenAI module export.\n */\ninterface PatchedModuleExports {\n  [key: string]: unknown;\n  OpenAI: abstract new (...args: unknown[]) => OpenAiClient;\n  AzureOpenAI?: abstract new (...args: unknown[]) => OpenAiClient;\n}\n\n/**\n * Sentry OpenAI instrumentation using OpenTelemetry.\n */\nexport class SentryOpenAiInstrumentation extends InstrumentationBase<OpenAiInstrumentationOptions> {\n  public constructor(config: OpenAiInstrumentationOptions = {}) {\n    super('@sentry/instrumentation-openai', SDK_VERSION, config);\n  }\n\n  /**\n   * Initializes the instrumentation by defining the modules to be patched.\n   */\n  public init(): InstrumentationModuleDefinition {\n    const module = new InstrumentationNodeModuleDefinition('openai', supportedVersions, this._patch.bind(this));\n    return module;\n  }\n\n  /**\n   * Core patch logic applying instrumentation to the OpenAI and AzureOpenAI client constructors.\n   */\n  private _patch(exports: PatchedModuleExports): PatchedModuleExports | void {\n    let result = exports;\n    result = this._patchClient(result, 'OpenAI');\n    result = this._patchClient(result, 'AzureOpenAI');\n    return result;\n  }\n\n  /**\n   * Patch logic applying instrumentation to the specified client constructor.\n   */\n  private _patchClient(exports: PatchedModuleExports, exportKey: 'OpenAI' | 'AzureOpenAI'): PatchedModuleExports {\n    const Original = exports[exportKey];\n    if (!Original) {\n      return exports;\n    }\n\n    const config = this.getConfig();\n\n    const WrappedOpenAI = function (this: unknown, ...args: unknown[]) {\n      // Check if wrapping should be skipped (e.g., when LangChain is handling instrumentation)\n      if (_INTERNAL_shouldSkipAiProviderWrapping(OPENAI_INTEGRATION_NAME)) {\n        return Reflect.construct(Original, args) as OpenAiClient;\n      }\n\n      const instance = Reflect.construct(Original, args);\n\n      return instrumentOpenAiClient(instance as OpenAiClient, config);\n    } as unknown as abstract new (...args: unknown[]) => OpenAiClient;\n\n    // Preserve static and prototype chains\n    Object.setPrototypeOf(WrappedOpenAI, Original);\n    Object.setPrototypeOf(WrappedOpenAI.prototype, Original.prototype);\n\n    for (const key of Object.getOwnPropertyNames(Original)) {\n      if (!['length', 'name', 'prototype'].includes(key)) {\n        const descriptor = Object.getOwnPropertyDescriptor(Original, key);\n        if (descriptor) {\n          Object.defineProperty(WrappedOpenAI, key, descriptor);\n        }\n      }\n    }\n\n    // Constructor replacement - handle read-only properties\n    // The OpenAI property might have only a getter, so use defineProperty\n    try {\n      exports[exportKey] = WrappedOpenAI;\n    } catch {\n      // If direct assignment fails, override the property descriptor\n      Object.defineProperty(exports, exportKey, {\n        value: WrappedOpenAI,\n        writable: true,\n        configurable: true,\n        enumerable: true,\n      });\n    }\n\n    // Wrap the default export if it points to the original constructor\n    // Constructor replacement - handle read-only properties\n    // The OpenAI property might have only a getter, so use defineProperty\n    if (exports.default === Original) {\n      try {\n        exports.default = WrappedOpenAI;\n      } catch {\n        // If direct assignment fails, override the property descriptor\n        Object.defineProperty(exports, 'default', {\n          value: WrappedOpenAI,\n          writable: true,\n          configurable: true,\n          enumerable: true,\n        });\n      }\n    }\n    return exports;\n  }\n}\n"],"names":["exports"],"mappings":"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"}

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

@@ -0,0 +1,45 @@
+import { PgInstrumentation } from '@opentelemetry/instrumentation-pg';
+import { defineIntegration } from '@sentry/core';
+import { generateInstrumentOnce, addOriginToSpan } from '@sentry/node-core';
+
+const INTEGRATION_NAME = 'Postgres';
+
+const instrumentPostgres = generateInstrumentOnce(
+  INTEGRATION_NAME,
+  PgInstrumentation,
+  (options) => ({
+    requireParentSpan: true,
+    requestHook(span) {
+      addOriginToSpan(span, 'auto.db.otel.postgres');
+    },
+    ignoreConnectSpans: options?.ignoreConnectSpans ?? false,
+  }),
+);
+
+const _postgresIntegration = ((options) => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      instrumentPostgres(options);
+    },
+  };
+}) ;
+
+/**
+ * Adds Sentry tracing instrumentation for the [pg](https://www.npmjs.com/package/pg) library.
+ *
+ * For more information, see the [`postgresIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/postgres/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.postgresIntegration()],
+ * });
+ * ```
+ */
+const postgresIntegration = defineIntegration(_postgresIntegration);
+
+export { instrumentPostgres, postgresIntegration };
+//# sourceMappingURL=postgres.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.js","sources":["../../../../src/integrations/tracing/postgres.ts"],"sourcesContent":["import { PgInstrumentation } from '@opentelemetry/instrumentation-pg';\nimport type { IntegrationFn } from '@sentry/core';\nimport { defineIntegration } from '@sentry/core';\nimport { addOriginToSpan, generateInstrumentOnce } from '@sentry/node-core';\n\ninterface PostgresIntegrationOptions {\n  ignoreConnectSpans?: boolean;\n}\n\nconst INTEGRATION_NAME = 'Postgres';\n\nexport const instrumentPostgres = generateInstrumentOnce(\n  INTEGRATION_NAME,\n  PgInstrumentation,\n  (options?: PostgresIntegrationOptions) => ({\n    requireParentSpan: true,\n    requestHook(span) {\n      addOriginToSpan(span, 'auto.db.otel.postgres');\n    },\n    ignoreConnectSpans: options?.ignoreConnectSpans ?? false,\n  }),\n);\n\nconst _postgresIntegration = ((options?: PostgresIntegrationOptions) => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      instrumentPostgres(options);\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for the [pg](https://www.npmjs.com/package/pg) library.\n *\n * For more information, see the [`postgresIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/postgres/).\n *\n * @example\n * ```javascript\n * const Sentry = require('@sentry/node');\n *\n * Sentry.init({\n *  integrations: [Sentry.postgresIntegration()],\n * });\n * ```\n */\nexport const postgresIntegration = defineIntegration(_postgresIntegration);\n"],"names":[],"mappings":";;;;AASA,MAAM,gBAAA,GAAmB,UAAU;;AAE5B,MAAM,kBAAA,GAAqB,sBAAsB;AACxD,EAAE,gBAAgB;AAClB,EAAE,iBAAiB;AACnB,EAAE,CAAC,OAAO,MAAmC;AAC7C,IAAI,iBAAiB,EAAE,IAAI;AAC3B,IAAI,WAAW,CAAC,IAAI,EAAE;AACtB,MAAM,eAAe,CAAC,IAAI,EAAE,uBAAuB,CAAC;AACpD,IAAI,CAAC;AACL,IAAI,kBAAkB,EAAE,OAAO,EAAE,kBAAA,IAAsB,KAAK;AAC5D,GAAG,CAAC;AACJ;;AAEA,MAAM,wBAAwB,CAAC,OAAO,KAAkC;AACxE,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,gBAAgB;AAC1B,IAAI,SAAS,GAAG;AAChB,MAAM,kBAAkB,CAAC,OAAO,CAAC;AACjC,IAAI,CAAC;AACL,GAAG;AACH,CAAC,CAAA;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;MACa,mBAAA,GAAsB,iBAAiB,CAAC,oBAAoB;;;;"}

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

@@ -0,0 +1,374 @@
+import { trace, context } from '@opentelemetry/api';
+import { InstrumentationBase, InstrumentationNodeModuleDefinition, InstrumentationNodeModuleFile, safeExecuteInTheMiddle } from '@opentelemetry/instrumentation';
+import { ATTR_DB_OPERATION_NAME, ATTR_DB_QUERY_TEXT, ATTR_DB_SYSTEM_NAME, ATTR_DB_RESPONSE_STATUS_CODE, ATTR_ERROR_TYPE } from '@opentelemetry/semantic-conventions';
+import { SDK_VERSION, debug, replaceExports, startSpanManual, SPAN_STATUS_ERROR, defineIntegration, instrumentPostgresJsSql } from '@sentry/core';
+import { generateInstrumentOnce, addOriginToSpan } from '@sentry/node-core';
+import { DEBUG_BUILD } from '../../debug-build.js';
+
+// Instrumentation for https://github.com/porsager/postgres
+
+
+const INTEGRATION_NAME = 'PostgresJs';
+const SUPPORTED_VERSIONS = ['>=3.0.0 <4'];
+const SQL_OPERATION_REGEX = /^(SELECT|INSERT|UPDATE|DELETE|CREATE|DROP|ALTER)/i;
+
+// Marker to track if a query was created from an instrumented sql instance
+// This prevents double-spanning when both wrapper and prototype patches are active
+const QUERY_FROM_INSTRUMENTED_SQL = Symbol.for('sentry.query.from.instrumented.sql');
+
+const instrumentPostgresJs = generateInstrumentOnce(
+  INTEGRATION_NAME,
+  (options) =>
+    new PostgresJsInstrumentation({
+      requireParentSpan: options?.requireParentSpan ?? true,
+      requestHook: options?.requestHook,
+    }),
+);
+
+/**
+ * Instrumentation for the [postgres](https://www.npmjs.com/package/postgres) library.
+ * This instrumentation captures postgresjs queries and their attributes.
+ *
+ * Uses internal Sentry patching patterns to support both CommonJS and ESM environments.
+ */
+class PostgresJsInstrumentation extends InstrumentationBase {
+   constructor(config) {
+    super('sentry-postgres-js', SDK_VERSION, config);
+  }
+
+  /**
+   * Initializes the instrumentation by patching the postgres module.
+   * Uses two complementary approaches:
+   * 1. Main function wrapper: instruments sql instances created AFTER instrumentation is set up (CJS + ESM)
+   * 2. Query.prototype patch: fallback for sql instances created BEFORE instrumentation (CJS only)
+   */
+   init() {
+    const module = new InstrumentationNodeModuleDefinition(
+      'postgres',
+      SUPPORTED_VERSIONS,
+      exports$1 => {
+        try {
+          return this._patchPostgres(exports$1);
+        } catch (e) {
+          DEBUG_BUILD && debug.error('Failed to patch postgres module:', e);
+          return exports$1;
+        }
+      },
+      exports$1 => exports$1,
+    );
+
+    // Add fallback Query.prototype patching for pre-existing sql instances (CJS only)
+    // This catches queries from sql instances created before Sentry was initialized
+    ['src', 'cf/src', 'cjs/src'].forEach(path => {
+      module.files.push(
+        new InstrumentationNodeModuleFile(
+          `postgres/${path}/query.js`,
+          SUPPORTED_VERSIONS,
+          this._patchQueryPrototype.bind(this),
+          this._unpatchQueryPrototype.bind(this),
+        ),
+      );
+    });
+
+    return module;
+  }
+
+  /**
+   * Patches the postgres module by wrapping the main export function.
+   * This intercepts the creation of sql instances and instruments them.
+   */
+   _patchPostgres(exports$1) {
+    // In CJS: exports is the function itself
+    // In ESM: exports.default is the function
+    const isFunction = typeof exports$1 === 'function';
+    const Original = isFunction ? exports$1 : exports$1.default;
+
+    if (typeof Original !== 'function') {
+      DEBUG_BUILD && debug.warn('postgres module does not export a function. Skipping instrumentation.');
+      return exports$1;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this;
+
+    const WrappedPostgres = function ( ...args) {
+      const sql = Reflect.construct(Original , args);
+
+      // Validate that construction succeeded and returned a valid function object
+      if (!sql || typeof sql !== 'function') {
+        DEBUG_BUILD && debug.warn('postgres() did not return a valid instance');
+        return sql;
+      }
+
+      // Delegate to the portable instrumentation from @sentry/core
+      const config = self.getConfig();
+      return instrumentPostgresJsSql(sql, {
+        requireParentSpan: config.requireParentSpan,
+        requestHook: config.requestHook,
+      });
+    };
+
+    Object.setPrototypeOf(WrappedPostgres, Original);
+    Object.setPrototypeOf(WrappedPostgres.prototype, (Original ).prototype);
+
+    for (const key of Object.getOwnPropertyNames(Original)) {
+      if (!['length', 'name', 'prototype'].includes(key)) {
+        const descriptor = Object.getOwnPropertyDescriptor(Original, key);
+        if (descriptor) {
+          Object.defineProperty(WrappedPostgres, key, descriptor);
+        }
+      }
+    }
+
+    // For CJS: the exports object IS the function, so return the wrapped function
+    // For ESM: replace the default export
+    if (isFunction) {
+      return WrappedPostgres ;
+    } else {
+      replaceExports(exports$1, 'default', WrappedPostgres);
+      return exports$1;
+    }
+  }
+
+  /**
+   * Determines whether a span should be created based on the current context.
+   * If `requireParentSpan` is set to true in the configuration, a span will
+   * only be created if there is a parent span available.
+   */
+   _shouldCreateSpans() {
+    const config = this.getConfig();
+    const hasParentSpan = trace.getSpan(context.active()) !== undefined;
+    return hasParentSpan || !config.requireParentSpan;
+  }
+
+  /**
+   * Extracts DB operation name from SQL query and sets it on the span.
+   */
+   _setOperationName(span, sanitizedQuery, command) {
+    if (command) {
+      span.setAttribute(ATTR_DB_OPERATION_NAME, command);
+      return;
+    }
+    // Fallback: extract operation from the SQL query
+    const operationMatch = sanitizedQuery?.match(SQL_OPERATION_REGEX);
+    if (operationMatch?.[1]) {
+      span.setAttribute(ATTR_DB_OPERATION_NAME, operationMatch[1].toUpperCase());
+    }
+  }
+
+  /**
+   * Reconstructs the full SQL query from template strings with PostgreSQL placeholders.
+   *
+   * For sql`SELECT * FROM users WHERE id = ${123} AND name = ${'foo'}`:
+   *   strings = ["SELECT * FROM users WHERE id = ", " AND name = ", ""]
+   *   returns: "SELECT * FROM users WHERE id = $1 AND name = $2"
+   */
+   _reconstructQuery(strings) {
+    if (!strings?.length) {
+      return undefined;
+    }
+    if (strings.length === 1) {
+      return strings[0] || undefined;
+    }
+    // Join template parts with PostgreSQL placeholders ($1, $2, etc.)
+    return strings.reduce((acc, str, i) => (i === 0 ? str : `${acc}$${i}${str}`), '');
+  }
+
+  /**
+   * Sanitize SQL query as per the OTEL semantic conventions
+   * https://opentelemetry.io/docs/specs/semconv/database/database-spans/#sanitization-of-dbquerytext
+   *
+   * PostgreSQL $n placeholders are preserved per OTEL spec - they're parameterized queries,
+   * not sensitive literals. Only actual values (strings, numbers, booleans) are sanitized.
+   */
+   _sanitizeSqlQuery(sqlQuery) {
+    if (!sqlQuery) {
+      return 'Unknown SQL Query';
+    }
+
+    return (
+      sqlQuery
+        // Remove comments first (they may contain newlines and extra spaces)
+        .replace(/--.*$/gm, '') // Single line comments (multiline mode)
+        .replace(/\/\*[\s\S]*?\*\//g, '') // Multi-line comments
+        .replace(/;\s*$/, '') // Remove trailing semicolons
+        // Collapse whitespace to a single space (after removing comments)
+        .replace(/\s+/g, ' ')
+        .trim() // Remove extra spaces and trim
+        // Sanitize hex/binary literals before string literals
+        .replace(/\bX'[0-9A-Fa-f]*'/gi, '?') // Hex string literals
+        .replace(/\bB'[01]*'/gi, '?') // Binary string literals
+        // Sanitize string literals (handles escaped quotes)
+        .replace(/'(?:[^']|'')*'/g, '?')
+        // Sanitize hex numbers
+        .replace(/\b0x[0-9A-Fa-f]+/gi, '?')
+        // Sanitize boolean literals
+        .replace(/\b(?:TRUE|FALSE)\b/gi, '?')
+        // Sanitize numeric literals (preserve $n placeholders via negative lookbehind)
+        .replace(/-?\b\d+\.?\d*[eE][+-]?\d+\b/g, '?') // Scientific notation
+        .replace(/-?\b\d+\.\d+\b/g, '?') // Decimals
+        .replace(/-?\.\d+\b/g, '?') // Decimals starting with dot
+        .replace(/(?<!\$)-?\b\d+\b/g, '?') // Integers (NOT $n placeholders)
+        // Collapse IN clauses for cardinality (both ? and $n variants)
+        .replace(/\bIN\b\s*\(\s*\?(?:\s*,\s*\?)*\s*\)/gi, 'IN (?)')
+        .replace(/\bIN\b\s*\(\s*\$\d+(?:\s*,\s*\$\d+)*\s*\)/gi, 'IN ($?)')
+    );
+  }
+
+  /**
+   * Fallback patch for Query.prototype.handle to instrument queries from pre-existing sql instances.
+   * This catches queries from sql instances created BEFORE Sentry was initialized (CJS only).
+   *
+   * Note: Queries from pre-existing instances won't have connection context (database, host, port)
+   * because the sql instance wasn't created through our instrumented wrapper.
+   */
+   _patchQueryPrototype(moduleExports
+
+) {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this;
+    const originalHandle = moduleExports.Query.prototype.handle;
+
+    moduleExports.Query.prototype.handle = async function (
+
+      ...args
+    ) {
+      // Skip if this query came from an instrumented sql instance (already handled by wrapper)
+      if ((this )[QUERY_FROM_INSTRUMENTED_SQL]) {
+        return originalHandle.apply(this, args);
+      }
+
+      // Skip if we shouldn't create spans
+      if (!self._shouldCreateSpans()) {
+        return originalHandle.apply(this, args);
+      }
+
+      const fullQuery = self._reconstructQuery(this.strings);
+      const sanitizedSqlQuery = self._sanitizeSqlQuery(fullQuery);
+
+      return startSpanManual(
+        {
+          name: sanitizedSqlQuery || 'postgresjs.query',
+          op: 'db',
+        },
+        (span) => {
+          addOriginToSpan(span, 'auto.db.postgresjs');
+
+          span.setAttributes({
+            [ATTR_DB_SYSTEM_NAME]: 'postgres',
+            [ATTR_DB_QUERY_TEXT]: sanitizedSqlQuery,
+          });
+
+          // Note: No connection context available for pre-existing instances
+          // because the sql instance wasn't created through our instrumented wrapper
+
+          const config = self.getConfig();
+          const { requestHook } = config;
+          if (requestHook) {
+            safeExecuteInTheMiddle(
+              () => requestHook(span, sanitizedSqlQuery, undefined),
+              e => {
+                if (e) {
+                  span.setAttribute('sentry.hook.error', 'requestHook failed');
+                  DEBUG_BUILD && debug.error(`Error in requestHook for ${INTEGRATION_NAME} integration:`, e);
+                }
+              },
+              true,
+            );
+          }
+
+          // Wrap resolve to end span on success
+          const originalResolve = this.resolve;
+          this.resolve = new Proxy(originalResolve , {
+            apply: (resolveTarget, resolveThisArg, resolveArgs) => {
+              try {
+                self._setOperationName(span, sanitizedSqlQuery, resolveArgs?.[0]?.command);
+                span.end();
+              } catch (e) {
+                DEBUG_BUILD && debug.error('Error ending span in resolve callback:', e);
+              }
+              return Reflect.apply(resolveTarget, resolveThisArg, resolveArgs);
+            },
+          });
+
+          // Wrap reject to end span on error
+          const originalReject = this.reject;
+          this.reject = new Proxy(originalReject , {
+            apply: (rejectTarget, rejectThisArg, rejectArgs) => {
+              try {
+                span.setStatus({
+                  code: SPAN_STATUS_ERROR,
+                  message: rejectArgs?.[0]?.message || 'unknown_error',
+                });
+                span.setAttribute(ATTR_DB_RESPONSE_STATUS_CODE, rejectArgs?.[0]?.code || 'unknown');
+                span.setAttribute(ATTR_ERROR_TYPE, rejectArgs?.[0]?.name || 'unknown');
+                self._setOperationName(span, sanitizedSqlQuery);
+                span.end();
+              } catch (e) {
+                DEBUG_BUILD && debug.error('Error ending span in reject callback:', e);
+              }
+              return Reflect.apply(rejectTarget, rejectThisArg, rejectArgs);
+            },
+          });
+
+          try {
+            return originalHandle.apply(this, args);
+          } catch (e) {
+            span.setStatus({
+              code: SPAN_STATUS_ERROR,
+              message: e instanceof Error ? e.message : 'unknown_error',
+            });
+            span.end();
+            throw e;
+          }
+        },
+      );
+    };
+
+    // Store original for unpatch - must be set on the NEW patched function
+    moduleExports.Query.prototype.handle.__sentry_original__ = originalHandle;
+
+    return moduleExports;
+  }
+
+  /**
+   * Restores the original Query.prototype.handle method.
+   */
+   _unpatchQueryPrototype(moduleExports
+
+) {
+    if (moduleExports.Query.prototype.handle.__sentry_original__) {
+      moduleExports.Query.prototype.handle = moduleExports.Query.prototype.handle.__sentry_original__;
+    }
+    return moduleExports;
+  }
+}
+
+const _postgresJsIntegration = ((options) => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      instrumentPostgresJs(options);
+    },
+  };
+}) ;
+
+/**
+ * Adds Sentry tracing instrumentation for the [postgres](https://www.npmjs.com/package/postgres) library.
+ *
+ * For more information, see the [`postgresIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/postgres/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.postgresJsIntegration()],
+ * });
+ * ```
+ */
+
+const postgresJsIntegration = defineIntegration(_postgresJsIntegration);
+
+export { PostgresJsInstrumentation, instrumentPostgresJs, postgresJsIntegration };
+//# sourceMappingURL=postgresjs.js.map