@depup/sentry__server-utils 10.75.2-depup.0 → 11.1.0-depup.0

package/build/cjs/index.js

@@ -1,34 +1,138 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const index$1 = require('./graphql/index.js');
-const index$3 = require('./mongoose/index.js');
-const mongodbSpan = require('./mongodb/mongodb-span.js');
-const index$4 = require('./mysql2/index.js');
-const index$2 = require('./prisma/index.js');
-const index$5 = require('./redis/index.js');
-const redisStatementSerializer = require('./redis/redis-statement-serializer.js');
+const setHttpServerSpanRouteAttribute = require('./utils/setHttpServerSpanRouteAttribute.js');
+const asyncContext = require('./async-context.js');
+const opentelemetry = require('./opentelemetry.js');
+const index$f = require('./ai/openai/index.js');
+const index$b = require('./ai/anthropic-ai/index.js');
+const index$d = require('./ai/google-genai/index.js');
+const index$e = require('./ai/mistral/index.js');
+const index$g = require('./ai/typesafe/index.js');
+const index$h = require('./ai/workers-ai/index.js');
+const index$3 = require('./ai/langchain/index.js');
+const index$c = require('./ai/langgraph/index.js');
+const index = require('./ai/mastra/index.js');
+const index$2 = require('./ai/flue/index.js');
+const sql = require('./utils/sql.js');
+const postgresjs = require('./integrations/postgresjs.js');
+const detect = require('./orchestrion/detect.js');
+const koaErrorHandler = require('./integrations/koa/koa-error-handler.js');
+const hapiErrorHandler = require('./integrations/hapi/hapi-error-handler.js');
 const tracingChannel = require('./tracing-channel.js');
-const index$6 = require('./vercel-ai/index.js');
-const index = require('./integrations/tracing-channel/fastify/index.js');
-const mongooseLegacySpan = require('./mongoose/mongoose-legacy-span.js');
+const moduleInjected = require('./utils/moduleInjected.js');
+const diagnosticsChannel = require('./utils/diagnosticsChannel.js');
+const eve = require('./eve.js');
+const index$8 = require('./orchestrion/config/index.js');
+const index$5 = require('./integrations/fastify/index.js');
+const index$n = require('./integrations/prisma/index.js');
+const amqplib = require('./integrations/amqplib.js');
+const anthropic = require('./integrations/anthropic.js');
+const index$1 = require('./integrations/aws-sdk/index.js');
+const dataloader = require('./integrations/dataloader.js');
+const genericPool = require('./integrations/generic-pool.js');
+const googleGenai = require('./integrations/google-genai.js');
+const index$9 = require('./integrations/graphql/index.js');
+const index$a = require('./integrations/hapi/index.js');
+const index$j = require('./integrations/koa/index.js');
+const index$o = require('./integrations/redis/index.js');
+const index$i = require('./integrations/kafkajs/index.js');
+const knex = require('./integrations/knex.js');
+const langchain = require('./integrations/langchain.js');
+const langgraph = require('./integrations/langgraph.js');
+const flue = require('./integrations/flue.js');
+const mastra = require('./integrations/mastra.js');
+const mcpServer = require('./integrations/mcp-server.js');
+const lruMemoizer = require('./integrations/lru-memoizer.js');
+const index$k = require('./integrations/mongodb/index.js');
+const index$l = require('./integrations/mongoose/index.js');
+const mistral = require('./integrations/mistral.js');
+const groq = require('./integrations/groq.js');
+const togetherAi = require('./integrations/together-ai.js');
+const typesafe = require('./integrations/typesafe.js');
+const mysql = require('./integrations/mysql.js');
+const index$m = require('./integrations/mysql2/index.js');
+const openai = require('./integrations/openai.js');
+const postgres = require('./integrations/postgres.js');
+const postgresJs = require('./integrations/postgres-js.js');
+const tedious = require('./integrations/tedious.js');
+const index$p = require('./integrations/vercel-ai/index.js');
+const index$4 = require('./integrations/express/index.js');
+const errorHandler = require('./integrations/express/error-handler.js');
+const index$6 = require('./integrations/firebase/index.js');
+const index$7 = require('./integrations/index.js');
+const embeddings = require('./ai/langchain/embeddings.js');
 
+const attachHapiErrorHandler = hapiErrorHandler.attachHapiErrorHandler;
 
-
-exports.graphqlIntegration = index$1.graphqlIntegration;
-exports.mongooseIntegration = index$3.mongooseIntegration;
-exports.getV3CommandOperation = mongodbSpan.getV3CommandOperation;
-exports.getV3SpanAttributes = mongodbSpan.getV3SpanAttributes;
-exports.getV4SpanAttributes = mongodbSpan.getV4SpanAttributes;
-exports.startMongoSpan = mongodbSpan.startMongoSpan;
-exports.mysql2Integration = index$4.mysql2Integration;
-exports.instrumentPrisma = index$2.instrumentPrisma;
-exports.prismaIntegration = index$2.prismaIntegration;
-exports.redisIntegration = index$5.redisIntegration;
-exports.defaultDbStatementSerializer = redisStatementSerializer.defaultDbStatementSerializer;
+exports.setHttpServerSpanRouteAttribute = setHttpServerSpanRouteAttribute.setHttpServerSpanRouteAttribute;
+exports.setAsyncLocalStorageAsyncContextStrategy = asyncContext.setAsyncLocalStorageAsyncContextStrategy;
+exports.getOtlpTracesEndpoint = opentelemetry.getOtlpTracesEndpoint;
+exports.openTelemetryIntegration = opentelemetry.openTelemetryIntegration;
+exports.instrumentOpenAiClient = index$f.instrumentOpenAiClient;
+exports.instrumentAnthropicAiClient = index$b.instrumentAnthropicAiClient;
+exports.instrumentGoogleGenAIClient = index$d.instrumentGoogleGenAIClient;
+exports.instrumentMistralAiClient = index$e.instrumentMistralAiClient;
+exports.instrumentTypeSafeClient = index$g.instrumentTypeSafeClient;
+exports.instrumentWorkersAiClient = index$h.instrumentWorkersAiClient;
+exports.createLangChainCallbackHandler = index$3.createLangChainCallbackHandler;
+exports.instrumentCreateReactAgent = index$c.instrumentCreateReactAgent;
+exports.instrumentStateGraph = index$c.instrumentStateGraph;
+exports.instrumentStateGraphCompile = index$c.instrumentStateGraphCompile;
+exports.SentryMastraExporter = index.SentryMastraExporter;
+exports.createFlueInstrumentation = index$2.createFlueInstrumentation;
+exports.getSqlQuerySummary = sql.getSqlQuerySummary;
+exports.sanitizeSqlQuery = sql.sanitizeSqlQuery;
+exports.sanitizeSqlQueryWithSummary = sql.sanitizeSqlQueryWithSummary;
+exports.instrumentPostgresJsSql = postgresjs.instrumentPostgresJsSql;
+exports.detectOrchestrionSetup = detect.detectOrchestrionSetup;
+exports.attachKoaErrorHandler = koaErrorHandler.attachKoaErrorHandler;
 exports.bindTracingChannelToSpan = tracingChannel.bindTracingChannelToSpan;
-exports.vercelAiIntegration = index$6.vercelAiIntegration;
-exports.fastifyIntegration = index.fastifyIntegration;
-exports.handleFastifyError = index.handleFastifyError;
-exports.instrumentFastify = index.instrumentFastify;
-exports.startMongooseLegacySpan = mongooseLegacySpan.startMongooseLegacySpan;
+exports.orchestrionModuleInjected = moduleInjected.orchestrionModuleInjected;
+exports.diagnosticsTracingChannel = diagnosticsChannel.tracingChannel;
+exports.subscribeDiagnosticsChannel = diagnosticsChannel.subscribe;
+exports.eveConversationHook = eve.eveConversationHook;
+exports.eveIntegration = eve.eveIntegration;
+exports.getInstrumentedModuleNames = index$8.getInstrumentedModuleNames;
+exports.fastifyIntegration = index$5.fastifyIntegration;
+exports.setupFastifyErrorHandler = index$5.setupFastifyErrorHandler;
+exports.prismaIntegration = index$n.prismaIntegration;
+exports.amqplibIntegration = amqplib.amqplibIntegration;
+exports.anthropicAIIntegration = anthropic.anthropicAIIntegration;
+exports.awsIntegration = index$1.awsIntegration;
+exports.dataloaderIntegration = dataloader.dataloaderIntegration;
+exports.genericPoolIntegration = genericPool.genericPoolIntegration;
+exports.googleGenAIIntegration = googleGenai.googleGenAIIntegration;
+exports.graphqlIntegration = index$9.graphqlIntegration;
+exports.hapiIntegration = index$a.hapiIntegration;
+exports.koaIntegration = index$j.koaIntegration;
+exports.redisIntegration = index$o.redisIntegration;
+exports.kafkaIntegration = index$i.kafkaIntegration;
+exports.knexIntegration = knex.knexIntegration;
+exports.langChainIntegration = langchain.langChainIntegration;
+exports.langGraphIntegration = langgraph.langGraphIntegration;
+exports.flueIntegration = flue.flueIntegration;
+exports.mastraIntegration = mastra.mastraIntegration;
+exports.mcpServerIntegration = mcpServer.mcpServerIntegration;
+exports.lruMemoizerIntegration = lruMemoizer.lruMemoizerIntegration;
+exports.mongoIntegration = index$k.mongoIntegration;
+exports.mongooseIntegration = index$l.mongooseIntegration;
+exports.mistralAIIntegration = mistral.mistralAIIntegration;
+exports.groqIntegration = groq.groqIntegration;
+exports.togetherAIIntegration = togetherAi.togetherAIIntegration;
+exports.typesafeIntegration = typesafe.typesafeIntegration;
+exports.mysqlIntegration = mysql.mysqlIntegration;
+exports.mysql2Integration = index$m.mysql2Integration;
+exports.openAIIntegration = openai.openAIIntegration;
+exports.postgresIntegration = postgres.postgresIntegration;
+exports.postgresJsIntegration = postgresJs.postgresJsIntegration;
+exports.tediousIntegration = tedious.tediousIntegration;
+exports.vercelAIIntegration = index$p.vercelAIIntegration;
+exports.expressIntegration = index$4.expressIntegration;
+exports.expressErrorHandler = errorHandler.expressErrorHandler;
+exports.setupExpressErrorHandler = errorHandler.setupExpressErrorHandler;
+exports.firebaseIntegration = index$6.firebaseIntegration;
+exports.getErrorIntegrations = index$7.getErrorIntegrations;
+exports.getTracingIntegrations = index$7.getTracingIntegrations;
+exports.instrumentLangChainEmbeddings = embeddings.instrumentLangChainEmbeddings;
+exports.attachHapiErrorHandler = attachHapiErrorHandler;
 //# sourceMappingURL=index.js.map

package/build/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":["../../src/index.ts"],"sourcesContent":["export * from './exports';\n\n// Exports using diagnostics channels\nexport { detectOrchestrionSetup } from './orchestrion/detect';\n// oxlint-disable-next-line typescript/no-deprecated -- re-exported so the deprecated `setupKoaErrorHandler` can delegate\nexport { attachKoaErrorHandler } from './integrations/koa/koa-error-handler';\nimport { attachHapiErrorHandler as _attachHapiErrorHandler } from './integrations/hapi/hapi-error-handler';\nexport { bindTracingChannelToSpan } from './tracing-channel';\nexport type { TracingChannelPayloadWithSpan } from './tracing-channel';\nexport type { InstrumentationConfig } from './orchestrion/apmTypes';\n// Runtime target of the bundler-injected module snippet. The snippet imports it\n// from this entry alongside the module's subscriber factory (see\n// `orchestrion/bundler/moduleInjectedTransform.ts`); it is a plain runtime\n// helper with no orchestrion build-time dependency.\nexport { orchestrionModuleInjected } from './utils/moduleInjected';\nexport {\n  subscribe as subscribeDiagnosticsChannel,\n  tracingChannel as diagnosticsTracingChannel,\n} from './utils/diagnosticsChannel';\nexport { eveConversationHook, eveIntegration } from './eve';\nexport { getInstrumentedModuleNames } from './orchestrion/config';\nexport {\n  fastifyIntegration,\n  // oxlint-disable-next-line typescript/no-deprecated\n  setupFastifyErrorHandler,\n} from './integrations/fastify';\n\n/**\n * @deprecated This is a temporary export to avoid breaking changes. It will be removed in the next major version.\n */\nexport const attachHapiErrorHandler = _attachHapiErrorHandler;\n\n// Integrations\nexport { prismaIntegration } from './integrations/prisma';\nexport { amqplibIntegration } from './integrations/amqplib';\nexport { anthropicAIIntegration } from './integrations/anthropic';\nexport { awsIntegration } from './integrations/aws-sdk';\nexport { dataloaderIntegration } from './integrations/dataloader';\nexport { genericPoolIntegration } from './integrations/generic-pool';\nexport { googleGenAIIntegration } from './integrations/google-genai';\nexport { graphqlIntegration } from './integrations/graphql';\nexport { hapiIntegration } from './integrations/hapi';\nexport { koaIntegration } from './integrations/koa';\nexport { redisIntegration } from './integrations/redis';\nexport { kafkaIntegration } from './integrations/kafkajs';\nexport { knexIntegration } from './integrations/knex';\nexport { langChainIntegration } from './integrations/langchain';\nexport { langGraphIntegration } from './integrations/langgraph';\nexport { createFlueInstrumentation } from './ai/flue';\nexport { flueIntegration } from './integrations/flue';\nexport type { FlueOptions } from './ai/flue';\nexport { mastraIntegration } from './integrations/mastra';\nexport { mcpServerIntegration } from './integrations/mcp-server';\nexport { SentryMastraExporter } from './ai/mastra';\nexport { lruMemoizerIntegration } from './integrations/lru-memoizer';\nexport { mongoIntegration } from './integrations/mongodb';\nexport { mongooseIntegration } from './integrations/mongoose';\nexport { mistralAIIntegration } from './integrations/mistral';\nexport { groqIntegration } from './integrations/groq';\nexport { togetherAIIntegration } from './integrations/together-ai';\nexport { typesafeIntegration } from './integrations/typesafe';\nexport { mysqlIntegration } from './integrations/mysql';\nexport { mysql2Integration } from './integrations/mysql2';\nexport { openAIIntegration } from './integrations/openai';\nexport { postgresIntegration } from './integrations/postgres';\nexport { postgresJsIntegration } from './integrations/postgres-js';\nexport { tediousIntegration } from './integrations/tedious';\nexport { vercelAIIntegration } from './integrations/vercel-ai';\nexport { expressIntegration } from './integrations/express';\nexport type { ExpressIntegrationOptions } from './integrations/express/types';\n/* oxlint-disable typescript/no-deprecated -- deprecated Express error-handler exports, kept until the next major */\nexport { expressErrorHandler, setupExpressErrorHandler } from './integrations/express/error-handler';\n/* oxlint-enable typescript/no-deprecated */\nexport { firebaseIntegration } from './integrations/firebase';\n\nexport { getTracingIntegrations, getErrorIntegrations } from './integrations';\n"],"names":["_attachHapiErrorHandler"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BO,CAAA,CAAA,CAAA,CAAA,CAAA,CAAM,sBAAA,CAAA,CAAA,CAAyBA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA,CAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/cjs/index.no-diagnostic-channels.js

@@ -0,0 +1,43 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const setHttpServerSpanRouteAttribute = require('./utils/setHttpServerSpanRouteAttribute.js');
+const asyncContext = require('./async-context.js');
+const opentelemetry = require('./opentelemetry.js');
+const index$7 = require('./ai/openai/index.js');
+const index$3 = require('./ai/anthropic-ai/index.js');
+const index$5 = require('./ai/google-genai/index.js');
+const index$6 = require('./ai/mistral/index.js');
+const index$8 = require('./ai/typesafe/index.js');
+const index$9 = require('./ai/workers-ai/index.js');
+const index$2 = require('./ai/langchain/index.js');
+const index$4 = require('./ai/langgraph/index.js');
+const index = require('./ai/mastra/index.js');
+const index$1 = require('./ai/flue/index.js');
+const sql = require('./utils/sql.js');
+const postgresjs = require('./integrations/postgresjs.js');
+const embeddings = require('./ai/langchain/embeddings.js');
+
+
+
+exports.setHttpServerSpanRouteAttribute = setHttpServerSpanRouteAttribute.setHttpServerSpanRouteAttribute;
+exports.setAsyncLocalStorageAsyncContextStrategy = asyncContext.setAsyncLocalStorageAsyncContextStrategy;
+exports.getOtlpTracesEndpoint = opentelemetry.getOtlpTracesEndpoint;
+exports.openTelemetryIntegration = opentelemetry.openTelemetryIntegration;
+exports.instrumentOpenAiClient = index$7.instrumentOpenAiClient;
+exports.instrumentAnthropicAiClient = index$3.instrumentAnthropicAiClient;
+exports.instrumentGoogleGenAIClient = index$5.instrumentGoogleGenAIClient;
+exports.instrumentMistralAiClient = index$6.instrumentMistralAiClient;
+exports.instrumentTypeSafeClient = index$8.instrumentTypeSafeClient;
+exports.instrumentWorkersAiClient = index$9.instrumentWorkersAiClient;
+exports.createLangChainCallbackHandler = index$2.createLangChainCallbackHandler;
+exports.instrumentCreateReactAgent = index$4.instrumentCreateReactAgent;
+exports.instrumentStateGraph = index$4.instrumentStateGraph;
+exports.instrumentStateGraphCompile = index$4.instrumentStateGraphCompile;
+exports.SentryMastraExporter = index.SentryMastraExporter;
+exports.createFlueInstrumentation = index$1.createFlueInstrumentation;
+exports.getSqlQuerySummary = sql.getSqlQuerySummary;
+exports.sanitizeSqlQuery = sql.sanitizeSqlQuery;
+exports.sanitizeSqlQueryWithSummary = sql.sanitizeSqlQueryWithSummary;
+exports.instrumentPostgresJsSql = postgresjs.instrumentPostgresJsSql;
+exports.instrumentLangChainEmbeddings = embeddings.instrumentLangChainEmbeddings;
+//# sourceMappingURL=index.no-diagnostic-channels.js.map

package/build/cjs/index.no-diagnostic-channels.js.map

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

package/build/cjs/integrations/amqplib.js

@@ -0,0 +1,389 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const diagnosticsChannel = require('../utils/diagnosticsChannel.js');
+const core = require('@sentry/core');
+const attributes = require('@sentry/conventions/attributes');
+const op = require('@sentry/conventions/op');
+const amqplib = require('../orchestrion/config/amqplib.js');
+const instrumentation = require('../orchestrion/instrumentation.js');
+const channels = require('../orchestrion/channels.js');
+const tracingChannel = require('../tracing-channel.js');
+
+const INTEGRATION_NAME = "Amqplib";
+const PUBLISHER_ORIGIN = "auto.amqplib.publisher";
+const CONSUMER_ORIGIN = "auto.amqplib.consumer";
+const ATTR_MESSAGING_RABBITMQ_DESTINATION_ROUTING_KEY = "messaging.rabbitmq.destination.routing_key";
+const ATTR_MESSAGING_CONVERSATION_ID = "messaging.message.conversation_id";
+const MESSAGING_OPERATION_VALUE_PROCESS = "process";
+const MESSAGING_OPERATION_VALUE_SEND = "send";
+const CONSUME_TIMEOUT_MS = 1e3 * 60;
+const END_OP = {
+  Ack: "ack",
+  AckAll: "ackAll",
+  Reject: "reject",
+  Nack: "nack",
+  NackAll: "nackAll",
+  ChannelClosed: "channel closed",
+  ChannelError: "channel error",
+  InstrumentationTimeout: "instrumentation timeout"
+};
+const MESSAGE_STORED_SPAN = /* @__PURE__ */ Symbol("sentry.amqplib.message.stored-span");
+const CHANNEL_SPANS_NOT_ENDED = /* @__PURE__ */ Symbol("sentry.amqplib.channel.spans-not-ended");
+const CHANNEL_CONSUME_TIMEOUT_TIMER = /* @__PURE__ */ Symbol("sentry.amqplib.channel.consume-timeout-timer");
+const CHANNEL_CONSUMER_INFO = /* @__PURE__ */ Symbol("sentry.amqplib.channel.consumer-info");
+const CHANNEL_IS_CONFIRM_PUBLISHING = /* @__PURE__ */ Symbol("sentry.amqplib.channel.is-confirm-publishing");
+const CONNECTION_ATTRIBUTES = /* @__PURE__ */ Symbol("sentry.amqplib.connection.attributes");
+const NOOP = () => {
+};
+const _amqplibIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setup(client) {
+      instrumentation.invokeOrchestrionInstrumentation(client, amqplib.amqplibModuleNames, instrumentAmqplib, []);
+    }
+  };
+});
+function instrumentAmqplib() {
+  subscribeConnect();
+  subscribePublish();
+  subscribeConfirmPublish();
+  subscribeConsume();
+  subscribeDispatch();
+  subscribeSettle();
+}
+function subscribePublish() {
+  tracingChannel.bindTracingChannelToSpan(diagnosticsChannel.tracingChannel(channels.CHANNELS.AMQPLIB_PUBLISH), (data) => {
+    if (data.self?.[CHANNEL_IS_CONFIRM_PUBLISHING]) {
+      return void 0;
+    }
+    return startPublishSpan(data);
+  });
+}
+function subscribeConfirmPublish() {
+  const channel = diagnosticsChannel.tracingChannel(channels.CHANNELS.AMQPLIB_CONFIRM_PUBLISH);
+  tracingChannel.bindTracingChannelToSpan(channel, (data) => {
+    if (data.self) {
+      data.self[CHANNEL_IS_CONFIRM_PUBLISHING] = true;
+    }
+    return startPublishSpan(data);
+  });
+  channel.end.subscribe((message) => {
+    const self = message.self;
+    if (self) {
+      self[CHANNEL_IS_CONFIRM_PUBLISHING] = false;
+    }
+  });
+}
+function subscribeConsume() {
+  const channel = diagnosticsChannel.tracingChannel(channels.CHANNELS.AMQPLIB_CONSUME);
+  channel.start.subscribe(NOOP);
+  channel.asyncEnd.subscribe((message) => {
+    const data = message;
+    const consumerChannel = data.self;
+    const result = data.result;
+    const consumerTag = result?.consumerTag;
+    if (!consumerChannel || !consumerTag) {
+      return;
+    }
+    ensureChannelState(consumerChannel);
+    const queueArg = data.arguments[0];
+    const queue = typeof queueArg === "string" ? queueArg : "<unknown>";
+    const options = data.arguments[2];
+    consumerChannel[CHANNEL_CONSUMER_INFO]?.set(consumerTag, { noAck: !!options?.noAck, queue });
+  });
+}
+function subscribeDispatch() {
+  tracingChannel.bindTracingChannelToSpan(
+    diagnosticsChannel.tracingChannel(channels.CHANNELS.AMQPLIB_DISPATCH),
+    (data) => {
+      const channel = data.self;
+      const fields = data.arguments[0];
+      const msg = data.arguments[1];
+      if (!channel || !msg) {
+        return void 0;
+      }
+      ensureChannelState(channel);
+      const info = fields?.consumerTag ? channel[CHANNEL_CONSUMER_INFO]?.get(fields.consumerTag) : void 0;
+      const queue = info?.queue ?? msg.fields?.routingKey;
+      const noAck = info?.noAck ?? false;
+      const headers = msg.properties?.headers;
+      const sentryTrace = getHeaderAsString(headers, "sentry-trace");
+      const baggage = getHeaderAsString(headers, "baggage");
+      const span = core.continueTrace({ sentryTrace, baggage }, () => startConsumeSpan(queue, msg, channel));
+      if (!noAck) {
+        channel[CHANNEL_SPANS_NOT_ENDED]?.push({ msg, timeOfConsume: core.timestampInSeconds() });
+        msg[MESSAGE_STORED_SPAN] = span;
+      }
+      data._sentryNoAck = noAck;
+      return span;
+    },
+    {
+      // Manual-ack consumers: the span outlives the dispatch call and is ended by ack/nack/reject
+      // (or timeout/close), so take ownership and don't let the helper end it here. noAck consumers
+      // have no settle call, so let the helper end the span when dispatch returns.
+      deferSpanEnd({ data }) {
+        return !data._sentryNoAck;
+      }
+    }
+  );
+}
+function subscribeSettle() {
+  diagnosticsChannel.tracingChannel(channels.CHANNELS.AMQPLIB_ACK).start.subscribe((message) => handleAck(message, false, END_OP.Ack));
+  diagnosticsChannel.tracingChannel(channels.CHANNELS.AMQPLIB_NACK).start.subscribe((message) => handleAck(message, true, END_OP.Nack));
+  diagnosticsChannel.tracingChannel(channels.CHANNELS.AMQPLIB_REJECT).start.subscribe((message) => handleAck(message, true, END_OP.Reject));
+  diagnosticsChannel.tracingChannel(channels.CHANNELS.AMQPLIB_ACK_ALL).start.subscribe((message) => {
+    const data = message;
+    if (data.self) {
+      endAllSpansOnChannel(data.self, false, END_OP.AckAll, void 0);
+    }
+  });
+  diagnosticsChannel.tracingChannel(channels.CHANNELS.AMQPLIB_NACK_ALL).start.subscribe((message) => {
+    const data = message;
+    if (data.self) {
+      endAllSpansOnChannel(data.self, true, END_OP.NackAll, data.arguments[0]);
+    }
+  });
+}
+function subscribeConnect() {
+  const channel = diagnosticsChannel.tracingChannel(channels.CHANNELS.AMQPLIB_CONNECT);
+  channel.start.subscribe(NOOP);
+  channel.asyncEnd.subscribe((message) => {
+    const data = message;
+    const conn = data.result;
+    if (!conn || typeof conn !== "object") {
+      return;
+    }
+    conn[CONNECTION_ATTRIBUTES] = {
+      ...getConnectionAttributesFromUrl(data.arguments?.[0]),
+      ...getConnectionAttributesFromServer(conn)
+    };
+  });
+}
+function handleAck(data, isRejected, endOperation) {
+  const channel = data.self;
+  if (!channel) {
+    return;
+  }
+  const message = data.arguments[0];
+  if (!message) {
+    return;
+  }
+  const allUpToOrRequeue = data.arguments[1];
+  const requeue = data.arguments[2];
+  const requeueResolved = endOperation === END_OP.Reject ? allUpToOrRequeue : requeue;
+  const spansNotEnded = channel[CHANNEL_SPANS_NOT_ENDED] ?? [];
+  const msgIndex = spansNotEnded.findIndex((msgDetails) => msgDetails.msg === message);
+  if (msgIndex < 0) {
+    endConsumerSpan(message, isRejected, endOperation, requeueResolved);
+  } else if (endOperation !== END_OP.Reject && allUpToOrRequeue) {
+    for (let i = 0; i <= msgIndex; i++) {
+      endConsumerSpan(spansNotEnded[i].msg, isRejected, endOperation, requeueResolved);
+    }
+    spansNotEnded.splice(0, msgIndex + 1);
+  } else {
+    endConsumerSpan(message, isRejected, endOperation, requeueResolved);
+    spansNotEnded.splice(msgIndex, 1);
+  }
+}
+function ensureChannelState(channel) {
+  if (Object.prototype.hasOwnProperty.call(channel, CHANNEL_SPANS_NOT_ENDED)) {
+    return;
+  }
+  channel[CHANNEL_SPANS_NOT_ENDED] = [];
+  channel[CHANNEL_CONSUMER_INFO] = /* @__PURE__ */ new Map();
+  const timer = setInterval(() => checkConsumeTimeoutOnChannel(channel), CONSUME_TIMEOUT_MS);
+  timer.unref?.();
+  channel[CHANNEL_CONSUME_TIMEOUT_TIMER] = timer;
+  if (typeof channel.on === "function") {
+    channel.on("close", () => {
+      endAllSpansOnChannel(channel, true, END_OP.ChannelClosed, void 0);
+      clearConsumeTimeoutTimer(channel);
+    });
+    channel.on("error", () => {
+      endAllSpansOnChannel(channel, true, END_OP.ChannelError, void 0);
+      clearConsumeTimeoutTimer(channel);
+    });
+  }
+}
+function clearConsumeTimeoutTimer(channel) {
+  const activeTimer = channel[CHANNEL_CONSUME_TIMEOUT_TIMER];
+  if (activeTimer) {
+    clearInterval(activeTimer);
+    channel[CHANNEL_CONSUME_TIMEOUT_TIMER] = void 0;
+  }
+}
+function checkConsumeTimeoutOnChannel(channel) {
+  const currentTime = core.timestampInSeconds();
+  const spansNotEnded = channel[CHANNEL_SPANS_NOT_ENDED] ?? [];
+  let i;
+  for (i = 0; i < spansNotEnded.length; i++) {
+    const currMessage = spansNotEnded[i];
+    const timeFromConsumeMs = (currentTime - currMessage.timeOfConsume) * 1e3;
+    if (timeFromConsumeMs < CONSUME_TIMEOUT_MS) {
+      break;
+    }
+    endConsumerSpan(currMessage.msg, null, END_OP.InstrumentationTimeout, true);
+  }
+  spansNotEnded.splice(0, i);
+}
+function endAllSpansOnChannel(channel, isRejected, operation, requeue) {
+  const spansNotEnded = channel[CHANNEL_SPANS_NOT_ENDED] ?? [];
+  spansNotEnded.forEach((msgDetails) => {
+    endConsumerSpan(msgDetails.msg, isRejected, operation, requeue);
+  });
+  channel[CHANNEL_SPANS_NOT_ENDED] = [];
+}
+function endConsumerSpan(message, isRejected, operation, requeue) {
+  const storedSpan = message[MESSAGE_STORED_SPAN];
+  if (!storedSpan) {
+    return;
+  }
+  if (isRejected !== false) {
+    storedSpan.setStatus({
+      code: core.SPAN_STATUS_ERROR,
+      message: operation !== END_OP.ChannelClosed && operation !== END_OP.ChannelError ? `${operation} called on message${requeue === true ? " with requeue" : requeue === false ? " without requeue" : ""}` : operation
+    });
+  }
+  storedSpan.end();
+  message[MESSAGE_STORED_SPAN] = void 0;
+}
+function startPublishSpan(data) {
+  const exchangeArg = data.arguments[0];
+  const routingKeyArg = data.arguments[1];
+  const exchange = typeof exchangeArg === "string" ? exchangeArg : "";
+  const routingKey = typeof routingKeyArg === "string" ? routingKeyArg : "";
+  let options = data.arguments[3];
+  const client = core.getClient();
+  const destination = resolveDestination(exchange, routingKey);
+  const streamedName = destination ? `${MESSAGING_OPERATION_VALUE_SEND} ${destination}` : MESSAGING_OPERATION_VALUE_SEND;
+  const span = core.startInactiveSpan({
+    name: client && core.hasSpanStreamingEnabled(client) ? streamedName : `publish ${normalizeExchange(exchange)}`,
+    attributes: {
+      [attributes.SENTRY_OP]: op.QUEUE_PUBLISH,
+      [attributes.SENTRY_KIND]: "producer",
+      ...getStoredConnectionAttributes(data.self),
+      [attributes.MESSAGING_DESTINATION_NAME]: destination,
+      [ATTR_MESSAGING_RABBITMQ_DESTINATION_ROUTING_KEY]: routingKey,
+      [attributes.MESSAGING_OPERATION_NAME]: MESSAGING_OPERATION_VALUE_SEND,
+      [attributes.MESSAGING_OPERATION_TYPE]: MESSAGING_OPERATION_VALUE_SEND,
+      [attributes.MESSAGING_MESSAGE_ID]: options?.messageId,
+      [ATTR_MESSAGING_CONVERSATION_ID]: options?.correlationId,
+      [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: PUBLISHER_ORIGIN
+    }
+  });
+  if (!options || typeof options !== "object") {
+    options = {};
+    data.arguments[3] = options;
+  }
+  const headers = options.headers && typeof options.headers === "object" ? options.headers : options.headers = {};
+  const traceData = core.getTraceData({ span });
+  if (traceData["sentry-trace"]) {
+    headers["sentry-trace"] = traceData["sentry-trace"];
+  }
+  if (traceData.baggage) {
+    headers["baggage"] = traceData.baggage;
+  }
+  return span;
+}
+function startConsumeSpan(queue, msg, channel) {
+  const client = core.getClient();
+  const destination = resolveDestination(msg.fields?.exchange, msg.fields?.routingKey);
+  const streamedName = destination ? `${MESSAGING_OPERATION_VALUE_PROCESS} ${destination}` : MESSAGING_OPERATION_VALUE_PROCESS;
+  return core.startInactiveSpan({
+    name: client && core.hasSpanStreamingEnabled(client) ? streamedName : queue ? `${queue} ${MESSAGING_OPERATION_VALUE_PROCESS}` : MESSAGING_OPERATION_VALUE_PROCESS,
+    attributes: {
+      [attributes.SENTRY_OP]: op.QUEUE_PROCESS,
+      [attributes.SENTRY_KIND]: "consumer",
+      [attributes.SENTRY_SEGMENT_NAME_SOURCE]: "component",
+      ...getStoredConnectionAttributes(channel),
+      [attributes.MESSAGING_DESTINATION_NAME]: destination,
+      [ATTR_MESSAGING_RABBITMQ_DESTINATION_ROUTING_KEY]: msg.fields?.routingKey,
+      [attributes.MESSAGING_OPERATION_NAME]: MESSAGING_OPERATION_VALUE_PROCESS,
+      [attributes.MESSAGING_OPERATION_TYPE]: MESSAGING_OPERATION_VALUE_PROCESS,
+      [attributes.MESSAGING_MESSAGE_ID]: msg.properties?.messageId,
+      [ATTR_MESSAGING_CONVERSATION_ID]: msg.properties?.correlationId,
+      [core.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: CONSUMER_ORIGIN
+    }
+  });
+}
+function getStoredConnectionAttributes(channel) {
+  const connection = channel?.connection;
+  const stored = connection?.[CONNECTION_ATTRIBUTES];
+  if (stored) {
+    return stored;
+  }
+  const product = connection?.serverProperties?.product ?? connection?.connection?.serverProperties?.product;
+  if (typeof product === "string" && product) {
+    return { [attributes.MESSAGING_SYSTEM]: product.toLowerCase() };
+  }
+  return {};
+}
+function getConnectionAttributesFromServer(conn) {
+  const product = conn.serverProperties?.product ?? conn.connection?.serverProperties?.product;
+  if (typeof product === "string" && product) {
+    return { [attributes.MESSAGING_SYSTEM]: product.toLowerCase() };
+  }
+  return {};
+}
+function getConnectionAttributesFromUrl(url) {
+  const attributes$1 = {
+    // The only protocol supported by the instrumented library.
+    [attributes.NETWORK_PROTOCOL_VERSION]: "0.9.1"
+  };
+  const resolvedUrl = url || "amqp://localhost";
+  if (typeof resolvedUrl === "object") {
+    const connectOptions = resolvedUrl;
+    const protocol = getProtocol(connectOptions.protocol);
+    const hostname = getHostname(connectOptions.hostname);
+    const port = getPort(connectOptions.port, protocol);
+    attributes$1[attributes.NETWORK_PROTOCOL_NAME] = protocol;
+    attributes$1[attributes.SERVER_ADDRESS] = hostname;
+    attributes$1[attributes.SERVER_PORT] = port;
+  } else if (typeof resolvedUrl === "string") {
+    const censoredUrl = censorPassword(resolvedUrl);
+    attributes$1[attributes.URL_FULL] = censoredUrl;
+    try {
+      const urlParts = new URL(censoredUrl);
+      const protocol = getProtocol(urlParts.protocol);
+      const hostname = getHostname(urlParts.hostname);
+      const port = getPort(urlParts.port ? parseInt(urlParts.port, 10) : void 0, protocol);
+      attributes$1[attributes.NETWORK_PROTOCOL_NAME] = protocol;
+      attributes$1[attributes.SERVER_ADDRESS] = hostname;
+      attributes$1[attributes.SERVER_PORT] = port;
+    } catch {
+    }
+  }
+  return attributes$1;
+}
+function resolveDestination(exchange, routingKey) {
+  return exchange || routingKey || void 0;
+}
+function normalizeExchange(exchangeName) {
+  return exchangeName !== "" ? exchangeName : "<default>";
+}
+function censorPassword(url) {
+  return url.replace(/:[^:@/]*@/, ":***@");
+}
+function getPort(portFromUrl, resolvedProtocol) {
+  return portFromUrl || (resolvedProtocol === "AMQP" ? 5672 : 5671);
+}
+function getProtocol(protocolFromUrl) {
+  const resolvedProtocol = protocolFromUrl || "amqp";
+  const noEndingColon = resolvedProtocol.endsWith(":") ? resolvedProtocol.substring(0, resolvedProtocol.length - 1) : resolvedProtocol;
+  return noEndingColon.toUpperCase();
+}
+function getHostname(hostnameFromUrl) {
+  return hostnameFromUrl || "localhost";
+}
+function getHeaderAsString(headers, key) {
+  const value = headers?.[key];
+  if (value == null) {
+    return void 0;
+  }
+  return Array.isArray(value) ? String(value[0]) : String(value);
+}
+const amqplibIntegration = core.defineIntegration(_amqplibIntegration);
+
+exports.amqplibIntegration = amqplibIntegration;
+exports.resolveDestination = resolveDestination;
+//# sourceMappingURL=amqplib.js.map