@depup/sentry__server-utils 10.67.0-depup.0

package/build/esm/integrations/tracing-channel/graphql/spans.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spans.js","sources":["../../../../../src/integrations/tracing-channel/graphql/spans.ts"],"sourcesContent":["/*\n * Span builders for the orchestrion graphql channels (v14–16). They emit the same spans as the native\n * `diagnostics_channel` subscriber (`../../../graphql/graphql-dc-subscriber.ts`, graphql >= 17) by\n * reusing its `utils` and conventions — only the data source differs: here the payloads are the raw\n * arguments of the injected `parse`/`validate`/`execute` calls rather than graphql's native events.\n */\n\nimport { GRAPHQL_DOCUMENT, GRAPHQL_OPERATION_NAME, GRAPHQL_OPERATION_TYPE } from '@sentry/conventions/attributes';\nimport { WEB_SERVER_GRAPHQL_SPAN_OP } from '@sentry/conventions/op';\nimport type { Span } from '@sentry/core';\nimport {\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  SPAN_STATUS_ERROR,\n  startInactiveSpan,\n} from '@sentry/core';\nimport type { GraphqlDocumentNode } from '../../../graphql/utils';\nimport {\n  collectGraphqlDocument,\n  getOperationSpanName,\n  hasResultErrors,\n  renameRootSpanWithOperation,\n} from '../../../graphql/utils';\nimport { GRAPHQL_DATA_SYMBOL, ORIGIN, SPAN_NAME_EXECUTE, SPAN_NAME_PARSE, SPAN_NAME_VALIDATE } from './constants';\nimport { getOperation, wrapFields, wrapFieldResolver } from './resolvers';\nimport type {\n  DocumentNode,\n  GraphQLFieldResolver,\n  GraphQLSchema,\n  GraphqlResolvedConfig,\n  Maybe,\n  ObjectWithGraphQLData,\n} from './types';\n\nconst BASE_ATTRIBUTES = {\n  [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN,\n  [SEMANTIC_ATTRIBUTE_SENTRY_OP]: WEB_SERVER_GRAPHQL_SPAN_OP,\n} as const;\n\nexport function startParseSpan(): Span {\n  return startInactiveSpan({ name: SPAN_NAME_PARSE, attributes: { ...BASE_ATTRIBUTES } });\n}\n\n/** `documentAST` is the 2nd argument to `validate(schema, documentAST, …)`. */\nexport function startValidateSpan(documentAST: unknown): Span {\n  return startInactiveSpan({\n    name: SPAN_NAME_VALIDATE,\n    attributes: { ...BASE_ATTRIBUTES, [GRAPHQL_DOCUMENT]: collectGraphqlDocument(documentAST as GraphqlDocumentNode) },\n  });\n}\n\n/** `result` is validation's return value: a (possibly empty) array of errors. */\nexport function finalizeValidateSpan(span: Span, result: unknown): void {\n  if (Array.isArray(result) && result.length > 0) {\n    span.setStatus({ code: SPAN_STATUS_ERROR, message: 'invalid_argument' });\n  }\n}\n\n/** Positional slots of a `graphql.execute(schema, document, …)` call (v14/v15 legacy signature). */\nconst enum ExecuteArg {\n  SCHEMA = 0,\n  DOCUMENT = 1,\n  CONTEXT_VALUE = 3,\n  OPERATION_NAME = 5,\n  FIELD_RESOLVER = 6,\n}\n\ninterface NormalizedExecuteArgs {\n  schema?: GraphQLSchema;\n  document?: DocumentNode;\n  contextValue: ObjectWithGraphQLData;\n  operationName?: Maybe<string>;\n  fieldResolver?: Maybe<GraphQLFieldResolver>;\n  /** Writes `contextValue`/`fieldResolver` mutations back to the live channel `arguments`. */\n  writeBack: (contextValue: ObjectWithGraphQLData, fieldResolver: Maybe<GraphQLFieldResolver>) => void;\n}\n\n/**\n * `execute` accepts either a single `ExecutionArgs` object (modern callers, always in v16) or\n * positional args (v14/v15). Both are normalized here; `writeBack` puts mutations onto the correct\n * slot so they reach the real call.\n */\nfunction normalizeExecuteArgs(argsArray: unknown[]): NormalizedExecuteArgs {\n  if (argsArray.length >= 2) {\n    return {\n      schema: argsArray[ExecuteArg.SCHEMA] as GraphQLSchema | undefined,\n      document: argsArray[ExecuteArg.DOCUMENT] as DocumentNode | undefined,\n      contextValue: (argsArray[ExecuteArg.CONTEXT_VALUE] ?? {}) as ObjectWithGraphQLData,\n      operationName: argsArray[ExecuteArg.OPERATION_NAME] as Maybe<string>,\n      fieldResolver: argsArray[ExecuteArg.FIELD_RESOLVER] as Maybe<GraphQLFieldResolver>,\n      writeBack: (contextValue, fieldResolver) => {\n        argsArray[ExecuteArg.CONTEXT_VALUE] = contextValue;\n        argsArray[ExecuteArg.FIELD_RESOLVER] = fieldResolver;\n      },\n    };\n  }\n\n  const obj = (argsArray[0] ?? {}) as {\n    schema?: GraphQLSchema;\n    document?: DocumentNode;\n    contextValue?: unknown;\n    operationName?: Maybe<string>;\n    fieldResolver?: Maybe<GraphQLFieldResolver>;\n  };\n  return {\n    schema: obj.schema,\n    document: obj.document,\n    contextValue: (obj.contextValue ?? {}) as ObjectWithGraphQLData,\n    operationName: obj.operationName,\n    fieldResolver: obj.fieldResolver,\n    writeBack: (contextValue, fieldResolver) => {\n      obj.contextValue = contextValue;\n      obj.fieldResolver = fieldResolver;\n    },\n  };\n}\n\n/**\n * Opens the execute span and, unless resolver spans are disabled, swaps the schema's field resolvers\n * (and the default field resolver) for span-creating proxies — mutating the live `arguments` in place\n * so the wrapped `execute` call runs with them. Always returns a span; the caller guards against\n * throws (see `safe` in `index.ts`).\n */\nexport function startExecuteSpan(\n  argsArray: unknown[],\n  self: unknown,\n  config: GraphqlResolvedConfig,\n  getConfig: () => GraphqlResolvedConfig,\n): Span {\n  const args = normalizeExecuteArgs(argsArray);\n  const { schema, document } = args;\n  let { contextValue, fieldResolver } = args;\n\n  // Skip resolver wrapping when disabled or when a parent execute already set up this context\n  // (nested execute reusing the same contextValue).\n  const alreadyInstrumented = !!contextValue[GRAPHQL_DATA_SYMBOL];\n  if (!config.ignoreResolveSpans && !alreadyInstrumented) {\n    const isUsingDefaultResolver = fieldResolver == null;\n    const defaultFieldResolver = (self as { defaultFieldResolver?: GraphQLFieldResolver } | undefined)\n      ?.defaultFieldResolver;\n    const fieldResolverForExecute = fieldResolver ?? defaultFieldResolver;\n    if (fieldResolverForExecute) {\n      fieldResolver = wrapFieldResolver(getConfig, fieldResolverForExecute, isUsingDefaultResolver);\n    }\n\n    if (schema) {\n      wrapFields(schema.getQueryType(), getConfig);\n      wrapFields(schema.getMutationType(), getConfig);\n    }\n  }\n\n  // v14–16 channels carry only the raw args, so derive the operation from the document (native v17\n  // provides `operationType`/`operationName` on the event directly).\n  const operation = getOperation(document as DocumentNode, args.operationName);\n  const operationType = operation?.operation;\n  const operationName = operation?.name?.value ?? args.operationName ?? undefined;\n\n  const span = startInactiveSpan({\n    name: getOperationSpanName(operationType, operationName || undefined, SPAN_NAME_EXECUTE),\n    attributes: {\n      ...BASE_ATTRIBUTES,\n      [GRAPHQL_OPERATION_TYPE]: operationType,\n      [GRAPHQL_OPERATION_NAME]: operationName || undefined,\n      [GRAPHQL_DOCUMENT]: collectGraphqlDocument(document as GraphqlDocumentNode | undefined),\n    },\n  });\n\n  if (config.useOperationNameForRootSpan && operationType) {\n    renameRootSpanWithOperation(span, operationType, operationName || undefined);\n  }\n\n  // The resolver proxies read the execute span (and their own bookkeeping) off this symbol.\n  contextValue[GRAPHQL_DATA_SYMBOL] = { source: document, span, fields: {} };\n  args.writeBack(contextValue, fieldResolver);\n\n  return span;\n}\n\n/** `result` is the settled `ExecutionResult`; GraphQL errors surface on `result.errors`, not a throw. */\nexport function finalizeExecuteSpan(span: Span, result: unknown): void {\n  if (hasResultErrors(result)) {\n    span.setStatus({ code: SPAN_STATUS_ERROR, message: 'internal_error' });\n  }\n}\n"],"names":[],"mappings":"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"}

package/build/esm/integrations/tracing-channel/hapi-types.js

@@ -0,0 +1,25 @@
+const LIFECYCLE_EXT_POINTS = [
+  "onPreAuth",
+  "onCredentials",
+  "onPostAuth",
+  "onPreHandler",
+  "onPostHandler",
+  "onPreResponse",
+  "onRequest"
+];
+const handlerPatched = /* @__PURE__ */ Symbol("hapi-handler-patched");
+const HapiLayerType = {
+  ROUTER: "router",
+  PLUGIN: "plugin",
+  EXT: "server.ext"
+};
+const HapiLifecycleMethodNames = new Set(LIFECYCLE_EXT_POINTS);
+var AttributeNames = /* @__PURE__ */ ((AttributeNames2) => {
+  AttributeNames2["HAPI_TYPE"] = "hapi.type";
+  AttributeNames2["PLUGIN_NAME"] = "hapi.plugin.name";
+  AttributeNames2["EXT_TYPE"] = "server.ext.type";
+  return AttributeNames2;
+})(AttributeNames || {});
+
+export { AttributeNames, HapiLayerType, HapiLifecycleMethodNames, handlerPatched };
+//# sourceMappingURL=hapi-types.js.map

package/build/esm/integrations/tracing-channel/hapi-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hapi-types.js","sources":["../../../../src/integrations/tracing-channel/hapi-types.ts"],"sourcesContent":["/*\n * Structural type definitions and constants ported from the vendored\n * `@opentelemetry/instrumentation-hapi` types, with all `@hapi/*` and\n * `@opentelemetry/*` dependencies removed. Only the shapes actually accessed by\n * the orchestrion hapi subscriber are kept.\n */\n\n// Single source of truth for the request lifecycle extension points, so the\n// `ServerRequestExtType` union and the runtime `HapiLifecycleMethodNames` set\n// below can't drift apart.\nconst LIFECYCLE_EXT_POINTS = [\n  'onPreAuth',\n  'onCredentials',\n  'onPostAuth',\n  'onPreHandler',\n  'onPostHandler',\n  'onPreResponse',\n  'onRequest',\n] as const;\n\nexport type ServerRequestExtType = (typeof LIFECYCLE_EXT_POINTS)[number];\n\nexport type LifecycleMethod = (request: unknown, h: unknown, err?: Error) => unknown;\n\nexport interface ServerRouteOptions {\n  handler?: LifecycleMethod | unknown;\n  [key: string]: unknown;\n}\n\nexport interface ServerRoute {\n  path: string;\n  method: string;\n  handler?: LifecycleMethod | unknown;\n  options?: ((server: unknown) => ServerRouteOptions) | ServerRouteOptions;\n  [key: string]: unknown;\n}\n\nexport interface ServerExtEventsObject {\n  type: string;\n  [key: string]: unknown;\n}\n\nexport interface ServerExtEventsRequestObject {\n  type: ServerRequestExtType;\n  method: LifecycleMethod;\n  [key: string]: unknown;\n}\n\nexport interface ServerExtOptions {\n  [key: string]: unknown;\n}\n\n/**\n * This symbol is used to mark a Hapi route handler or server extension handler as\n * already patched, since it's possible to use these handlers multiple times\n * i.e. when allowing multiple versions of one plugin, or when registering a plugin\n * multiple times on different servers.\n */\nexport const handlerPatched: unique symbol = Symbol('hapi-handler-patched');\n\nexport type PatchableServerRoute = ServerRoute & {\n  [handlerPatched]?: boolean;\n};\n\nexport type PatchableExtMethod = LifecycleMethod & {\n  [handlerPatched]?: boolean;\n};\n\nexport type ServerExtDirectInput = [ServerRequestExtType, LifecycleMethod, (ServerExtOptions | undefined)?];\n\nexport const HapiLayerType = {\n  ROUTER: 'router',\n  PLUGIN: 'plugin',\n  EXT: 'server.ext',\n} as const;\n\nexport const HapiLifecycleMethodNames = new Set<string>(LIFECYCLE_EXT_POINTS);\n\nexport enum AttributeNames {\n  HAPI_TYPE = 'hapi.type',\n  PLUGIN_NAME = 'hapi.plugin.name',\n  EXT_TYPE = 'server.ext.type',\n}\n"],"names":["AttributeNames"],"mappings":"AAUA,MAAM,oBAAA,GAAuB;AAAA,EAC3B,WAAA;AAAA,EACA,eAAA;AAAA,EACA,YAAA;AAAA,EACA,cAAA;AAAA,EACA,eAAA;AAAA,EACA,eAAA;AAAA,EACA;AACF,CAAA;AAwCO,MAAM,cAAA,0BAAuC,sBAAsB;AAYnE,MAAM,aAAA,GAAgB;AAAA,EAC3B,MAAA,EAAQ,QAAA;AAAA,EACR,MAAA,EAAQ,QAAA;AAAA,EACR,GAAA,EAAK;AACP;AAEO,MAAM,wBAAA,GAA2B,IAAI,GAAA,CAAY,oBAAoB;AAErE,IAAK,cAAA,qBAAAA,eAAAA,KAAL;AACL,EAAAA,gBAAA,WAAA,CAAA,GAAY,WAAA;AACZ,EAAAA,gBAAA,aAAA,CAAA,GAAc,kBAAA;AACd,EAAAA,gBAAA,UAAA,CAAA,GAAW,iBAAA;AAHD,EAAA,OAAAA,eAAAA;AAAA,CAAA,EAAA,cAAA,IAAA,EAAA;;;;"}

package/build/esm/integrations/tracing-channel/hapi-utils.js

@@ -0,0 +1,172 @@
+import { getActiveSpan, getRootSpan, spanToJSON, SEMANTIC_ATTRIBUTE_SENTRY_OP, startSpan, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
+import { HTTP_ROUTE, HTTP_METHOD } from '@sentry/conventions/attributes';
+import { handlerPatched, HapiLifecycleMethodNames, HapiLayerType, AttributeNames } from './hapi-types.js';
+
+function setHttpServerSpanRouteAttribute(route) {
+  const activeSpan = getActiveSpan();
+  if (!activeSpan) {
+    return;
+  }
+  const rootSpan = getRootSpan(activeSpan);
+  if (!rootSpan) {
+    return;
+  }
+  if (spanToJSON(rootSpan).data[SEMANTIC_ATTRIBUTE_SENTRY_OP] !== "http.server") {
+    return;
+  }
+  rootSpan.setAttribute(HTTP_ROUTE, route);
+}
+const isLifecycleExtType = (variableToCheck) => {
+  return typeof variableToCheck === "string" && HapiLifecycleMethodNames.has(variableToCheck);
+};
+const isLifecycleExtEventObj = (variableToCheck) => {
+  const event = variableToCheck?.type;
+  return event !== void 0 && isLifecycleExtType(event);
+};
+const isDirectExtInput = (variableToCheck) => {
+  return Array.isArray(variableToCheck) && variableToCheck.length <= 3 && isLifecycleExtType(variableToCheck[0]) && typeof variableToCheck[1] === "function";
+};
+const isPatchableExtMethod = (variableToCheck) => {
+  return !Array.isArray(variableToCheck);
+};
+const getRouteMetadata = (route, pluginName) => {
+  const attributes = {
+    [HTTP_ROUTE]: route.path,
+    // eslint-disable-next-line typescript/no-deprecated -- TODO(v11): Replace deprecated attributes
+    [HTTP_METHOD]: route.method
+  };
+  let name;
+  if (pluginName) {
+    attributes[AttributeNames.HAPI_TYPE] = HapiLayerType.PLUGIN;
+    attributes[AttributeNames.PLUGIN_NAME] = pluginName;
+    name = `${pluginName}: route - ${route.path}`;
+  } else {
+    attributes[AttributeNames.HAPI_TYPE] = HapiLayerType.ROUTER;
+    name = `route - ${route.path}`;
+  }
+  return { attributes, name };
+};
+const getExtMetadata = (extPoint, pluginName, methodName) => {
+  let baseName = `ext - ${extPoint}`;
+  if (methodName && methodName !== "method") {
+    baseName = `ext - ${extPoint} - ${methodName}`;
+  }
+  if (pluginName) {
+    return {
+      attributes: {
+        [AttributeNames.EXT_TYPE]: extPoint,
+        [AttributeNames.HAPI_TYPE]: HapiLayerType.EXT,
+        [AttributeNames.PLUGIN_NAME]: pluginName
+      },
+      name: `${pluginName}: ${baseName}`
+    };
+  }
+  return {
+    attributes: {
+      [AttributeNames.EXT_TYPE]: extPoint,
+      [AttributeNames.HAPI_TYPE]: HapiLayerType.EXT
+    },
+    name: baseName
+  };
+};
+function startMetadataSpan(metadata, original) {
+  return startSpan(
+    {
+      name: metadata.name,
+      op: `${metadata.attributes[AttributeNames.HAPI_TYPE]}.hapi`,
+      attributes: {
+        ...metadata.attributes,
+        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: "auto.http.orchestrion.hapi"
+      }
+    },
+    original
+  );
+}
+function wrapRouteHandler(route, pluginName) {
+  if (route[handlerPatched] === true) return route;
+  route[handlerPatched] = true;
+  const wrapHandler = (oldHandler) => {
+    return function(...params) {
+      if (!getActiveSpan()) {
+        return oldHandler.call(this, ...params);
+      }
+      setHttpServerSpanRouteAttribute(route.path);
+      const metadata = getRouteMetadata(route, pluginName);
+      return startMetadataSpan(metadata, () => oldHandler.call(this, ...params));
+    };
+  };
+  if (typeof route.handler === "function") {
+    route.handler = wrapHandler(route.handler);
+  } else if (typeof route.options === "function") {
+    const oldOptions = route.options;
+    route.options = function(server) {
+      const options = oldOptions(server);
+      if (typeof options.handler === "function") {
+        options.handler = wrapHandler(options.handler);
+      }
+      return options;
+    };
+  } else if (typeof route.options?.handler === "function") {
+    route.options.handler = wrapHandler(route.options.handler);
+  }
+  return route;
+}
+function wrapExtMethods(method, extPoint, pluginName) {
+  if (Array.isArray(method)) {
+    for (let i = 0; i < method.length; i++) {
+      method[i] = wrapExtMethods(method[i], extPoint);
+    }
+    return method;
+  } else if (isPatchableExtMethod(method)) {
+    if (method[handlerPatched] === true) return method;
+    method[handlerPatched] = true;
+    const newHandler = function(...params) {
+      if (!getActiveSpan()) {
+        return method.apply(this, params);
+      }
+      const metadata = getExtMetadata(extPoint, pluginName, method.name);
+      return startMetadataSpan(metadata, () => method.apply(void 0, params));
+    };
+    newHandler[handlerPatched] = true;
+    return newHandler;
+  }
+  return method;
+}
+function wrapRouteArguments(args, pluginName) {
+  const route = args[0];
+  if (Array.isArray(route)) {
+    for (let i = 0; i < route.length; i++) {
+      route[i] = wrapRouteHandler(route[i], pluginName);
+    }
+  } else {
+    args[0] = wrapRouteHandler(route, pluginName);
+  }
+}
+function wrapExtArguments(args, pluginName) {
+  if (Array.isArray(args[0])) {
+    const eventsList = args[0];
+    for (let i = 0; i < eventsList.length; i++) {
+      const eventObj = eventsList[i];
+      if (isLifecycleExtType(eventObj.type)) {
+        const lifecycleEventObj = eventObj;
+        const handler = wrapExtMethods(lifecycleEventObj.method, eventObj.type, pluginName);
+        lifecycleEventObj.method = handler;
+        eventsList[i] = lifecycleEventObj;
+      }
+    }
+    return;
+  } else if (isDirectExtInput(args)) {
+    const extInput = args;
+    const method = extInput[1];
+    const handler = wrapExtMethods(method, extInput[0], pluginName);
+    args[1] = handler;
+    return;
+  } else if (isLifecycleExtEventObj(args[0])) {
+    const lifecycleEventObj = args[0];
+    const handler = wrapExtMethods(lifecycleEventObj.method, lifecycleEventObj.type, pluginName);
+    lifecycleEventObj.method = handler;
+  }
+}
+
+export { getExtMetadata, getRouteMetadata, wrapExtArguments, wrapRouteArguments };
+//# sourceMappingURL=hapi-utils.js.map

package/build/esm/integrations/tracing-channel/hapi-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hapi-utils.js","sources":["../../../../src/integrations/tracing-channel/hapi-utils.ts"],"sourcesContent":["/*\n * OTel-free, `@hapi/*`-free port of the span-building helpers and handler/ext\n * wrap logic from the vendored `@opentelemetry/instrumentation-hapi`\n * (upstream @opentelemetry/instrumentation-hapi@0.64.0). Span output (names,\n * ops, origins, attributes) is kept byte-identical to that instrumentation;\n * span creation goes through the `@sentry/core` API and the OTel active-span\n * guard is replaced with `getActiveSpan()`.\n */\n\nimport {\n  getActiveSpan,\n  getRootSpan,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  spanToJSON,\n  startSpan,\n} from '@sentry/core';\nimport type {\n  LifecycleMethod,\n  PatchableExtMethod,\n  PatchableServerRoute,\n  ServerExtDirectInput,\n  ServerExtEventsObject,\n  ServerExtEventsRequestObject,\n  ServerRequestExtType,\n  ServerRoute,\n  ServerRouteOptions,\n} from './hapi-types';\n// eslint-disable-next-line typescript/no-deprecated -- TODO(v11): Replace deprecated attributes\nimport { HTTP_METHOD, HTTP_ROUTE } from '@sentry/conventions/attributes';\nimport { AttributeNames, handlerPatched, HapiLayerType, HapiLifecycleMethodNames } from './hapi-types';\n\ntype SpanAttributes = Record<string, string | undefined>;\n\ninterface SpanMetadata {\n  attributes: SpanAttributes;\n  name: string;\n}\n\n/**\n * Set the `http.route` attribute on the root HTTP server span for the current trace.\n *\n * No-op when there is no active span, no root span, or the root span is not an\n * `http.server` span — so framework instrumentations can call this unconditionally\n * without risking attribute pollution on non-HTTP root spans.\n */\nfunction setHttpServerSpanRouteAttribute(route: string): void {\n  const activeSpan = getActiveSpan();\n  if (!activeSpan) {\n    return;\n  }\n  const rootSpan = getRootSpan(activeSpan);\n  if (!rootSpan) {\n    return;\n  }\n  if (spanToJSON(rootSpan).data[SEMANTIC_ATTRIBUTE_SENTRY_OP] !== 'http.server') {\n    return;\n  }\n  rootSpan.setAttribute(HTTP_ROUTE, route);\n}\n\nconst isLifecycleExtType = (variableToCheck: unknown): variableToCheck is ServerRequestExtType => {\n  return typeof variableToCheck === 'string' && HapiLifecycleMethodNames.has(variableToCheck);\n};\n\nconst isLifecycleExtEventObj = (variableToCheck: unknown): variableToCheck is ServerExtEventsRequestObject => {\n  const event = (variableToCheck as ServerExtEventsRequestObject)?.type;\n  return event !== undefined && isLifecycleExtType(event);\n};\n\nconst isDirectExtInput = (variableToCheck: unknown): variableToCheck is ServerExtDirectInput => {\n  return (\n    Array.isArray(variableToCheck) &&\n    variableToCheck.length <= 3 &&\n    isLifecycleExtType(variableToCheck[0]) &&\n    typeof variableToCheck[1] === 'function'\n  );\n};\n\nconst isPatchableExtMethod = (\n  variableToCheck: PatchableExtMethod | PatchableExtMethod[],\n): variableToCheck is PatchableExtMethod => {\n  return !Array.isArray(variableToCheck);\n};\n\n/** Build the span name and attributes for a Hapi route. */\nexport const getRouteMetadata = (route: ServerRoute, pluginName?: string): SpanMetadata => {\n  const attributes: SpanAttributes = {\n    [HTTP_ROUTE]: route.path,\n    // eslint-disable-next-line typescript/no-deprecated -- TODO(v11): Replace deprecated attributes\n    [HTTP_METHOD]: route.method,\n  };\n\n  let name;\n  if (pluginName) {\n    attributes[AttributeNames.HAPI_TYPE] = HapiLayerType.PLUGIN;\n    attributes[AttributeNames.PLUGIN_NAME] = pluginName;\n    name = `${pluginName}: route - ${route.path}`;\n  } else {\n    attributes[AttributeNames.HAPI_TYPE] = HapiLayerType.ROUTER;\n    name = `route - ${route.path}`;\n  }\n\n  return { attributes, name };\n};\n\n/** Build the span name and attributes for a Hapi server extension. */\nexport const getExtMetadata = (\n  extPoint: ServerRequestExtType,\n  pluginName?: string,\n  methodName?: string,\n): SpanMetadata => {\n  let baseName = `ext - ${extPoint}`;\n  if (methodName && methodName !== 'method') {\n    // `method` is the default name for the extension in the ServerExtEventsObject format.\n    baseName = `ext - ${extPoint} - ${methodName}`;\n  }\n  if (pluginName) {\n    return {\n      attributes: {\n        [AttributeNames.EXT_TYPE]: extPoint,\n        [AttributeNames.HAPI_TYPE]: HapiLayerType.EXT,\n        [AttributeNames.PLUGIN_NAME]: pluginName,\n      },\n      name: `${pluginName}: ${baseName}`,\n    };\n  }\n  return {\n    attributes: {\n      [AttributeNames.EXT_TYPE]: extPoint,\n      [AttributeNames.HAPI_TYPE]: HapiLayerType.EXT,\n    },\n    name: baseName,\n  };\n};\n\nfunction startMetadataSpan(metadata: SpanMetadata, original: () => unknown): unknown {\n  return startSpan(\n    {\n      name: metadata.name,\n      op: `${metadata.attributes[AttributeNames.HAPI_TYPE]}.hapi`,\n      attributes: {\n        ...metadata.attributes,\n        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.orchestrion.hapi',\n      },\n    },\n    original,\n  );\n}\n\n/**\n * Patches each individual route handler method in order to create the span. It\n * does not create spans when there is no parent span.\n */\nfunction wrapRouteHandler(route: PatchableServerRoute, pluginName?: string): PatchableServerRoute {\n  if (route[handlerPatched] === true) return route;\n  route[handlerPatched] = true;\n\n  const wrapHandler: (oldHandler: LifecycleMethod) => LifecycleMethod = oldHandler => {\n    return function (this: unknown, ...params: Parameters<LifecycleMethod>) {\n      if (!getActiveSpan()) {\n        return oldHandler.call(this, ...params);\n      }\n      setHttpServerSpanRouteAttribute(route.path);\n      const metadata = getRouteMetadata(route, pluginName);\n      return startMetadataSpan(metadata, () => oldHandler.call(this, ...params));\n    };\n  };\n\n  if (typeof route.handler === 'function') {\n    route.handler = wrapHandler(route.handler as LifecycleMethod);\n  } else if (typeof route.options === 'function') {\n    const oldOptions = route.options;\n    route.options = function (server: unknown): ServerRouteOptions {\n      const options = oldOptions(server);\n      if (typeof options.handler === 'function') {\n        options.handler = wrapHandler(options.handler as LifecycleMethod);\n      }\n      return options;\n    };\n  } else if (typeof route.options?.handler === 'function') {\n    route.options.handler = wrapHandler(route.options.handler as LifecycleMethod);\n  }\n  return route;\n}\n\n/**\n * Wraps request extension methods to add instrumentation to each new extension\n * handler. It does not create spans when there is no parent span.\n */\nfunction wrapExtMethods<T extends PatchableExtMethod | PatchableExtMethod[]>(\n  method: T,\n  extPoint: ServerRequestExtType,\n  pluginName?: string,\n): T {\n  if (Array.isArray(method)) {\n    for (let i = 0; i < method.length; i++) {\n      method[i] = wrapExtMethods(method[i]!, extPoint);\n    }\n    return method;\n  } else if (isPatchableExtMethod(method)) {\n    if (method[handlerPatched] === true) return method;\n    method[handlerPatched] = true;\n\n    const newHandler: PatchableExtMethod = function (this: unknown, ...params: Parameters<LifecycleMethod>) {\n      if (!getActiveSpan()) {\n        return method.apply(this, params);\n      }\n      const metadata = getExtMetadata(extPoint, pluginName, method.name);\n      return startMetadataSpan(metadata, () => method.apply(undefined, params));\n    };\n    // Mark the wrapper too (not just the original)\n    newHandler[handlerPatched] = true;\n    return newHandler as T;\n  }\n  return method;\n}\n\n/**\n * Wrap the route handler(s) in the live `server.route` arguments array, mutating\n * `args[0]` in place. `args[0]` is either a single route options object or an\n * array of them. Idempotent via the `handlerPatched` marker.\n */\nexport function wrapRouteArguments(args: unknown[], pluginName?: string): void {\n  const route = args[0] as PatchableServerRoute | PatchableServerRoute[];\n  if (Array.isArray(route)) {\n    for (let i = 0; i < route.length; i++) {\n      route[i] = wrapRouteHandler(route[i]!, pluginName);\n    }\n  } else {\n    args[0] = wrapRouteHandler(route, pluginName);\n  }\n}\n\n/**\n * Wrap the extension method(s) in the live `server.ext` arguments array,\n * mutating `args` in place. Handles the three accepted input shapes:\n * `(eventsArray)`, `(lifecycleEventObject)`, and `(extTypeString, method, options)`.\n * Idempotent via the `handlerPatched` marker.\n */\nexport function wrapExtArguments(args: unknown[], pluginName?: string): void {\n  if (Array.isArray(args[0])) {\n    const eventsList = args[0] as ServerExtEventsObject[] | ServerExtEventsRequestObject[];\n    for (let i = 0; i < eventsList.length; i++) {\n      const eventObj = eventsList[i]!;\n      if (isLifecycleExtType(eventObj.type)) {\n        const lifecycleEventObj = eventObj as ServerExtEventsRequestObject;\n        const handler = wrapExtMethods(lifecycleEventObj.method, eventObj.type, pluginName);\n        lifecycleEventObj.method = handler;\n        eventsList[i] = lifecycleEventObj;\n      }\n    }\n    return;\n  } else if (isDirectExtInput(args)) {\n    const extInput: ServerExtDirectInput = args;\n    const method: PatchableExtMethod = extInput[1];\n    const handler = wrapExtMethods(method, extInput[0], pluginName);\n    args[1] = handler;\n    return;\n  } else if (isLifecycleExtEventObj(args[0])) {\n    const lifecycleEventObj = args[0];\n    const handler = wrapExtMethods(lifecycleEventObj.method, lifecycleEventObj.type, pluginName);\n    lifecycleEventObj.method = handler;\n  }\n}\n"],"names":[],"mappings":";;;;AA8CA,SAAS,gCAAgC,KAAA,EAAqB;AAC5D,EAAA,MAAM,aAAa,aAAA,EAAc;AACjC,EAAA,IAAI,CAAC,UAAA,EAAY;AACf,IAAA;AAAA,EACF;AACA,EAAA,MAAM,QAAA,GAAW,YAAY,UAAU,CAAA;AACvC,EAAA,IAAI,CAAC,QAAA,EAAU;AACb,IAAA;AAAA,EACF;AACA,EAAA,IAAI,WAAW,QAAQ,CAAA,CAAE,IAAA,CAAK,4BAA4B,MAAM,aAAA,EAAe;AAC7E,IAAA;AAAA,EACF;AACA,EAAA,QAAA,CAAS,YAAA,CAAa,YAAY,KAAK,CAAA;AACzC;AAEA,MAAM,kBAAA,GAAqB,CAAC,eAAA,KAAsE;AAChG,EAAA,OAAO,OAAO,eAAA,KAAoB,QAAA,IAAY,wBAAA,CAAyB,IAAI,eAAe,CAAA;AAC5F,CAAA;AAEA,MAAM,sBAAA,GAAyB,CAAC,eAAA,KAA8E;AAC5G,EAAA,MAAM,QAAS,eAAA,EAAkD,IAAA;AACjE,EAAA,OAAO,KAAA,KAAU,MAAA,IAAa,kBAAA,CAAmB,KAAK,CAAA;AACxD,CAAA;AAEA,MAAM,gBAAA,GAAmB,CAAC,eAAA,KAAsE;AAC9F,EAAA,OACE,KAAA,CAAM,OAAA,CAAQ,eAAe,CAAA,IAC7B,gBAAgB,MAAA,IAAU,CAAA,IAC1B,kBAAA,CAAmB,eAAA,CAAgB,CAAC,CAAC,CAAA,IACrC,OAAO,eAAA,CAAgB,CAAC,CAAA,KAAM,UAAA;AAElC,CAAA;AAEA,MAAM,oBAAA,GAAuB,CAC3B,eAAA,KAC0C;AAC1C,EAAA,OAAO,CAAC,KAAA,CAAM,OAAA,CAAQ,eAAe,CAAA;AACvC,CAAA;AAGO,MAAM,gBAAA,GAAmB,CAAC,KAAA,EAAoB,UAAA,KAAsC;AACzF,EAAA,MAAM,UAAA,GAA6B;AAAA,IACjC,CAAC,UAAU,GAAG,KAAA,CAAM,IAAA;AAAA;AAAA,IAEpB,CAAC,WAAW,GAAG,KAAA,CAAM;AAAA,GACvB;AAEA,EAAA,IAAI,IAAA;AACJ,EAAA,IAAI,UAAA,EAAY;AACd,IAAA,UAAA,CAAW,cAAA,CAAe,SAAS,CAAA,GAAI,aAAA,CAAc,MAAA;AACrD,IAAA,UAAA,CAAW,cAAA,CAAe,WAAW,CAAA,GAAI,UAAA;AACzC,IAAA,IAAA,GAAO,CAAA,EAAG,UAAU,CAAA,UAAA,EAAa,KAAA,CAAM,IAAI,CAAA,CAAA;AAAA,EAC7C,CAAA,MAAO;AACL,IAAA,UAAA,CAAW,cAAA,CAAe,SAAS,CAAA,GAAI,aAAA,CAAc,MAAA;AACrD,IAAA,IAAA,GAAO,CAAA,QAAA,EAAW,MAAM,IAAI,CAAA,CAAA;AAAA,EAC9B;AAEA,EAAA,OAAO,EAAE,YAAY,IAAA,EAAK;AAC5B;AAGO,MAAM,cAAA,GAAiB,CAC5B,QAAA,EACA,UAAA,EACA,UAAA,KACiB;AACjB,EAAA,IAAI,QAAA,GAAW,SAAS,QAAQ,CAAA,CAAA;AAChC,EAAA,IAAI,UAAA,IAAc,eAAe,QAAA,EAAU;AAEzC,IAAA,QAAA,GAAW,CAAA,MAAA,EAAS,QAAQ,CAAA,GAAA,EAAM,UAAU,CAAA,CAAA;AAAA,EAC9C;AACA,EAAA,IAAI,UAAA,EAAY;AACd,IAAA,OAAO;AAAA,MACL,UAAA,EAAY;AAAA,QACV,CAAC,cAAA,CAAe,QAAQ,GAAG,QAAA;AAAA,QAC3B,CAAC,cAAA,CAAe,SAAS,GAAG,aAAA,CAAc,GAAA;AAAA,QAC1C,CAAC,cAAA,CAAe,WAAW,GAAG;AAAA,OAChC;AAAA,MACA,IAAA,EAAM,CAAA,EAAG,UAAU,CAAA,EAAA,EAAK,QAAQ,CAAA;AAAA,KAClC;AAAA,EACF;AACA,EAAA,OAAO;AAAA,IACL,UAAA,EAAY;AAAA,MACV,CAAC,cAAA,CAAe,QAAQ,GAAG,QAAA;AAAA,MAC3B,CAAC,cAAA,CAAe,SAAS,GAAG,aAAA,CAAc;AAAA,KAC5C;AAAA,IACA,IAAA,EAAM;AAAA,GACR;AACF;AAEA,SAAS,iBAAA,CAAkB,UAAwB,QAAA,EAAkC;AACnF,EAAA,OAAO,SAAA;AAAA,IACL;AAAA,MACE,MAAM,QAAA,CAAS,IAAA;AAAA,MACf,IAAI,CAAA,EAAG,QAAA,CAAS,UAAA,CAAW,cAAA,CAAe,SAAS,CAAC,CAAA,KAAA,CAAA;AAAA,MACpD,UAAA,EAAY;AAAA,QACV,GAAG,QAAA,CAAS,UAAA;AAAA,QACZ,CAAC,gCAAgC,GAAG;AAAA;AACtC,KACF;AAAA,IACA;AAAA,GACF;AACF;AAMA,SAAS,gBAAA,CAAiB,OAA6B,UAAA,EAA2C;AAChG,EAAA,IAAI,KAAA,CAAM,cAAc,CAAA,KAAM,IAAA,EAAM,OAAO,KAAA;AAC3C,EAAA,KAAA,CAAM,cAAc,CAAA,GAAI,IAAA;AAExB,EAAA,MAAM,cAAgE,CAAA,UAAA,KAAc;AAClF,IAAA,OAAO,YAA4B,MAAA,EAAqC;AACtE,MAAA,IAAI,CAAC,eAAc,EAAG;AACpB,QAAA,OAAO,UAAA,CAAW,IAAA,CAAK,IAAA,EAAM,GAAG,MAAM,CAAA;AAAA,MACxC;AACA,MAAA,+BAAA,CAAgC,MAAM,IAAI,CAAA;AAC1C,MAAA,MAAM,QAAA,GAAW,gBAAA,CAAiB,KAAA,EAAO,UAAU,CAAA;AACnD,MAAA,OAAO,iBAAA,CAAkB,UAAU,MAAM,UAAA,CAAW,KAAK,IAAA,EAAM,GAAG,MAAM,CAAC,CAAA;AAAA,IAC3E,CAAA;AAAA,EACF,CAAA;AAEA,EAAA,IAAI,OAAO,KAAA,CAAM,OAAA,KAAY,UAAA,EAAY;AACvC,IAAA,KAAA,CAAM,OAAA,GAAU,WAAA,CAAY,KAAA,CAAM,OAA0B,CAAA;AAAA,EAC9D,CAAA,MAAA,IAAW,OAAO,KAAA,CAAM,OAAA,KAAY,UAAA,EAAY;AAC9C,IAAA,MAAM,aAAa,KAAA,CAAM,OAAA;AACzB,IAAA,KAAA,CAAM,OAAA,GAAU,SAAU,MAAA,EAAqC;AAC7D,MAAA,MAAM,OAAA,GAAU,WAAW,MAAM,CAAA;AACjC,MAAA,IAAI,OAAO,OAAA,CAAQ,OAAA,KAAY,UAAA,EAAY;AACzC,QAAA,OAAA,CAAQ,OAAA,GAAU,WAAA,CAAY,OAAA,CAAQ,OAA0B,CAAA;AAAA,MAClE;AACA,MAAA,OAAO,OAAA;AAAA,IACT,CAAA;AAAA,EACF,CAAA,MAAA,IAAW,OAAO,KAAA,CAAM,OAAA,EAAS,YAAY,UAAA,EAAY;AACvD,IAAA,KAAA,CAAM,OAAA,CAAQ,OAAA,GAAU,WAAA,CAAY,KAAA,CAAM,QAAQ,OAA0B,CAAA;AAAA,EAC9E;AACA,EAAA,OAAO,KAAA;AACT;AAMA,SAAS,cAAA,CACP,MAAA,EACA,QAAA,EACA,UAAA,EACG;AACH,EAAA,IAAI,KAAA,CAAM,OAAA,CAAQ,MAAM,CAAA,EAAG;AACzB,IAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,MAAA,CAAO,QAAQ,CAAA,EAAA,EAAK;AACtC,MAAA,MAAA,CAAO,CAAC,CAAA,GAAI,cAAA,CAAe,MAAA,CAAO,CAAC,GAAI,QAAQ,CAAA;AAAA,IACjD;AACA,IAAA,OAAO,MAAA;AAAA,EACT,CAAA,MAAA,IAAW,oBAAA,CAAqB,MAAM,CAAA,EAAG;AACvC,IAAA,IAAI,MAAA,CAAO,cAAc,CAAA,KAAM,IAAA,EAAM,OAAO,MAAA;AAC5C,IAAA,MAAA,CAAO,cAAc,CAAA,GAAI,IAAA;AAEzB,IAAA,MAAM,UAAA,GAAiC,YAA4B,MAAA,EAAqC;AACtG,MAAA,IAAI,CAAC,eAAc,EAAG;AACpB,QAAA,OAAO,MAAA,CAAO,KAAA,CAAM,IAAA,EAAM,MAAM,CAAA;AAAA,MAClC;AACA,MAAA,MAAM,QAAA,GAAW,cAAA,CAAe,QAAA,EAAU,UAAA,EAAY,OAAO,IAAI,CAAA;AACjE,MAAA,OAAO,kBAAkB,QAAA,EAAU,MAAM,OAAO,KAAA,CAAM,MAAA,EAAW,MAAM,CAAC,CAAA;AAAA,IAC1E,CAAA;AAEA,IAAA,UAAA,CAAW,cAAc,CAAA,GAAI,IAAA;AAC7B,IAAA,OAAO,UAAA;AAAA,EACT;AACA,EAAA,OAAO,MAAA;AACT;AAOO,SAAS,kBAAA,CAAmB,MAAiB,UAAA,EAA2B;AAC7E,EAAA,MAAM,KAAA,GAAQ,KAAK,CAAC,CAAA;AACpB,EAAA,IAAI,KAAA,CAAM,OAAA,CAAQ,KAAK,CAAA,EAAG;AACxB,IAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,KAAA,CAAM,QAAQ,CAAA,EAAA,EAAK;AACrC,MAAA,KAAA,CAAM,CAAC,CAAA,GAAI,gBAAA,CAAiB,KAAA,CAAM,CAAC,GAAI,UAAU,CAAA;AAAA,IACnD;AAAA,EACF,CAAA,MAAO;AACL,IAAA,IAAA,CAAK,CAAC,CAAA,GAAI,gBAAA,CAAiB,KAAA,EAAO,UAAU,CAAA;AAAA,EAC9C;AACF;AAQO,SAAS,gBAAA,CAAiB,MAAiB,UAAA,EAA2B;AAC3E,EAAA,IAAI,KAAA,CAAM,OAAA,CAAQ,IAAA,CAAK,CAAC,CAAC,CAAA,EAAG;AAC1B,IAAA,MAAM,UAAA,GAAa,KAAK,CAAC,CAAA;AACzB,IAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,UAAA,CAAW,QAAQ,CAAA,EAAA,EAAK;AAC1C,MAAA,MAAM,QAAA,GAAW,WAAW,CAAC,CAAA;AAC7B,MAAA,IAAI,kBAAA,CAAmB,QAAA,CAAS,IAAI,CAAA,EAAG;AACrC,QAAA,MAAM,iBAAA,GAAoB,QAAA;AAC1B,QAAA,MAAM,UAAU,cAAA,CAAe,iBAAA,CAAkB,MAAA,EAAQ,QAAA,CAAS,MAAM,UAAU,CAAA;AAClF,QAAA,iBAAA,CAAkB,MAAA,GAAS,OAAA;AAC3B,QAAA,UAAA,CAAW,CAAC,CAAA,GAAI,iBAAA;AAAA,MAClB;AAAA,IACF;AACA,IAAA;AAAA,EACF,CAAA,MAAA,IAAW,gBAAA,CAAiB,IAAI,CAAA,EAAG;AACjC,IAAA,MAAM,QAAA,GAAiC,IAAA;AACvC,IAAA,MAAM,MAAA,GAA6B,SAAS,CAAC,CAAA;AAC7C,IAAA,MAAM,UAAU,cAAA,CAAe,MAAA,EAAQ,QAAA,CAAS,CAAC,GAAG,UAAU,CAAA;AAC9D,IAAA,IAAA,CAAK,CAAC,CAAA,GAAI,OAAA;AACV,IAAA;AAAA,EACF,CAAA,MAAA,IAAW,sBAAA,CAAuB,IAAA,CAAK,CAAC,CAAC,CAAA,EAAG;AAC1C,IAAA,MAAM,iBAAA,GAAoB,KAAK,CAAC,CAAA;AAChC,IAAA,MAAM,UAAU,cAAA,CAAe,iBAAA,CAAkB,MAAA,EAAQ,iBAAA,CAAkB,MAAM,UAAU,CAAA;AAC3F,IAAA,iBAAA,CAAkB,MAAA,GAAS,OAAA;AAAA,EAC7B;AACF;;;;"}

package/build/esm/integrations/tracing-channel/hapi.js

@@ -0,0 +1,50 @@
+import * as diagnosticsChannel from 'node:diagnostics_channel';
+import { defineIntegration, debug } from '@sentry/core';
+import { DEBUG_BUILD } from '../../debug-build.js';
+import { CHANNELS } from '../../orchestrion/channels.js';
+import { wrapRouteArguments, wrapExtArguments } from './hapi-utils.js';
+
+const INTEGRATION_NAME = "Hapi";
+const _hapiChannelIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      if (!diagnosticsChannel.tracingChannel) {
+        return;
+      }
+      DEBUG_BUILD && debug.log(`[orchestrion:hapi] subscribing to channels "${CHANNELS.HAPI_ROUTE}" / "${CHANNELS.HAPI_EXT}"`);
+      diagnosticsChannel.tracingChannel(CHANNELS.HAPI_ROUTE).subscribe({
+        start(rawCtx) {
+          const ctx = rawCtx;
+          wrapRouteArguments(ctx.arguments, ctx.self?.realm?.plugin);
+        },
+        end() {
+        },
+        asyncStart() {
+        },
+        asyncEnd() {
+        },
+        error() {
+        }
+      });
+      diagnosticsChannel.tracingChannel(CHANNELS.HAPI_EXT).subscribe({
+        start(rawCtx) {
+          const ctx = rawCtx;
+          wrapExtArguments(ctx.arguments, ctx.self?.realm?.plugin);
+        },
+        end() {
+        },
+        asyncStart() {
+        },
+        asyncEnd() {
+        },
+        error() {
+        }
+      });
+    }
+  };
+});
+const hapiChannelIntegration = defineIntegration(_hapiChannelIntegration);
+
+export { hapiChannelIntegration };
+//# sourceMappingURL=hapi.js.map

package/build/esm/integrations/tracing-channel/hapi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hapi.js","sources":["../../../../src/integrations/tracing-channel/hapi.ts"],"sourcesContent":["import * as diagnosticsChannel from 'node:diagnostics_channel';\nimport type { IntegrationFn } from '@sentry/core';\nimport { debug, defineIntegration } from '@sentry/core';\nimport { DEBUG_BUILD } from '../../debug-build';\nimport { CHANNELS } from '../../orchestrion/channels';\nimport { wrapExtArguments, wrapRouteArguments } from './hapi-utils';\n\n// NOTE: same name as the OTel integration by design — when enabled, the OTel\n// 'Hapi' integration is omitted from the default set.\nconst INTEGRATION_NAME = 'Hapi' as const;\n\n/**\n * The shape orchestrion's transform attaches to the `@hapi/hapi` route/ext\n * tracing-channel `context` objects.\n *\n * `arguments` is the *live* args array passed to `server.route` / `server.ext`;\n * we mutate it in place to swap handlers for span-creating proxies. `self` is\n * the hapi server instance: the root server has `self.realm.plugin === undefined`,\n * while a plugin's clone server exposes the registering plugin's name there.\n */\ninterface HapiChannelContext {\n  arguments: unknown[];\n  self?: { realm?: { plugin?: string } };\n}\n\nconst _hapiChannelIntegration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      if (!diagnosticsChannel.tracingChannel) {\n        return;\n      }\n\n      DEBUG_BUILD &&\n        debug.log(`[orchestrion:hapi] subscribing to channels \"${CHANNELS.HAPI_ROUTE}\" / \"${CHANNELS.HAPI_EXT}\"`);\n\n      // `subscribe` requires all five lifecycle hooks. We only act on `start`,\n      // which orchestrion fires synchronously with the live args array — that's\n      // the moment we mutate the handlers in place.\n      diagnosticsChannel.tracingChannel(CHANNELS.HAPI_ROUTE).subscribe({\n        start(rawCtx) {\n          const ctx = rawCtx as HapiChannelContext;\n          wrapRouteArguments(ctx.arguments, ctx.self?.realm?.plugin);\n        },\n        end() {},\n        asyncStart() {},\n        asyncEnd() {},\n        error() {},\n      });\n\n      diagnosticsChannel.tracingChannel(CHANNELS.HAPI_EXT).subscribe({\n        start(rawCtx) {\n          const ctx = rawCtx as HapiChannelContext;\n          wrapExtArguments(ctx.arguments, ctx.self?.realm?.plugin);\n        },\n        end() {},\n        asyncStart() {},\n        asyncEnd() {},\n        error() {},\n      });\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * EXPERIMENTAL — orchestrion-driven hapi integration. Subscribes to the\n * `orchestrion:@hapi/hapi:route` / `:ext` channels injected into `@hapi/hapi`'s\n * `lib/server.js`. Requires the orchestrion runtime hook or bundler plugin.\n */\nexport const hapiChannelIntegration = defineIntegration(_hapiChannelIntegration);\n"],"names":[],"mappings":";;;;;;AASA,MAAM,gBAAA,GAAmB,MAAA;AAgBzB,MAAM,2BAA2B,MAAM;AACrC,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,SAAA,GAAY;AACV,MAAA,IAAI,CAAC,mBAAmB,cAAA,EAAgB;AACtC,QAAA;AAAA,MACF;AAEA,MAAA,WAAA,IACE,KAAA,CAAM,IAAI,CAAA,4CAAA,EAA+C,QAAA,CAAS,UAAU,CAAA,KAAA,EAAQ,QAAA,CAAS,QAAQ,CAAA,CAAA,CAAG,CAAA;AAK1G,MAAA,kBAAA,CAAmB,cAAA,CAAe,QAAA,CAAS,UAAU,CAAA,CAAE,SAAA,CAAU;AAAA,QAC/D,MAAM,MAAA,EAAQ;AACZ,UAAA,MAAM,GAAA,GAAM,MAAA;AACZ,UAAA,kBAAA,CAAmB,GAAA,CAAI,SAAA,EAAW,GAAA,CAAI,IAAA,EAAM,OAAO,MAAM,CAAA;AAAA,QAC3D,CAAA;AAAA,QACA,GAAA,GAAM;AAAA,QAAC,CAAA;AAAA,QACP,UAAA,GAAa;AAAA,QAAC,CAAA;AAAA,QACd,QAAA,GAAW;AAAA,QAAC,CAAA;AAAA,QACZ,KAAA,GAAQ;AAAA,QAAC;AAAA,OACV,CAAA;AAED,MAAA,kBAAA,CAAmB,cAAA,CAAe,QAAA,CAAS,QAAQ,CAAA,CAAE,SAAA,CAAU;AAAA,QAC7D,MAAM,MAAA,EAAQ;AACZ,UAAA,MAAM,GAAA,GAAM,MAAA;AACZ,UAAA,gBAAA,CAAiB,GAAA,CAAI,SAAA,EAAW,GAAA,CAAI,IAAA,EAAM,OAAO,MAAM,CAAA;AAAA,QACzD,CAAA;AAAA,QACA,GAAA,GAAM;AAAA,QAAC,CAAA;AAAA,QACP,UAAA,GAAa;AAAA,QAAC,CAAA;AAAA,QACd,QAAA,GAAW;AAAA,QAAC,CAAA;AAAA,QACZ,KAAA,GAAQ;AAAA,QAAC;AAAA,OACV,CAAA;AAAA,IACH;AAAA,GACF;AACF,CAAA,CAAA;AAOO,MAAM,sBAAA,GAAyB,kBAAkB,uBAAuB;;;;"}

package/build/esm/integrations/tracing-channel/ioredis.js

@@ -0,0 +1,96 @@
+import * as diagnosticsChannel from 'node:diagnostics_channel';
+import { DB_STATEMENT, NET_PEER_PORT, NET_PEER_NAME, DB_SYSTEM } from '@sentry/conventions/attributes';
+import { defineIntegration, debug, waitForTracingChannelBinding, startInactiveSpan, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '@sentry/core';
+import { DEBUG_BUILD } from '../../debug-build.js';
+import { CHANNELS } from '../../orchestrion/channels.js';
+import { defaultDbStatementSerializer } from '../../redis/redis-statement-serializer.js';
+import { bindTracingChannelToSpan } from '../../tracing-channel.js';
+
+const INTEGRATION_NAME = "IORedis";
+const ORIGIN = "auto.db.orchestrion.redis";
+const ATTR_DB_CONNECTION_STRING = "db.connection_string";
+function getConnectionOptions(self) {
+  return { host: self?.options?.host, port: self?.options?.port };
+}
+function connectionAttributes(host, port) {
+  return {
+    [DB_SYSTEM]: "redis",
+    [ATTR_DB_CONNECTION_STRING]: `redis://${host}:${port}`,
+    [NET_PEER_NAME]: host,
+    [NET_PEER_PORT]: port,
+    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN
+  };
+}
+const tracedCommands = /* @__PURE__ */ new WeakSet();
+function startIORedisCommandSpan(data) {
+  const command = data.arguments?.[0];
+  if (!command || typeof command !== "object") {
+    return void 0;
+  }
+  if (tracedCommands.has(command)) {
+    return void 0;
+  }
+  tracedCommands.add(command);
+  const { host, port } = getConnectionOptions(data.self);
+  const statement = defaultDbStatementSerializer(command.name, command.args ?? []);
+  return startInactiveSpan({
+    name: statement,
+    op: "db",
+    attributes: { ...connectionAttributes(host, port), [DB_STATEMENT]: statement }
+  });
+}
+const _ioredisChannelIntegration = ((options = {}) => {
+  const responseHook = options.responseHook;
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      if (!diagnosticsChannel.tracingChannel) {
+        return;
+      }
+      DEBUG_BUILD && debug.log(`[orchestrion:ioredis] subscribing to "${CHANNELS.IOREDIS_COMMAND}"/"${CHANNELS.IOREDIS_CONNECT}"`);
+      const commandChannel = diagnosticsChannel.tracingChannel(
+        CHANNELS.IOREDIS_COMMAND
+      );
+      const connectChannel = diagnosticsChannel.tracingChannel(
+        CHANNELS.IOREDIS_CONNECT
+      );
+      waitForTracingChannelBinding(() => {
+        bindTracingChannelToSpan(commandChannel, startIORedisCommandSpan, {
+          // ioredis' `requireParentSpan` default: only create a span under an active span.
+          requiresParentSpan: true,
+          beforeSpanEnd(span, data) {
+            if ("error" in data || !responseHook) {
+              return;
+            }
+            const command = data.arguments?.[0];
+            if (command) {
+              runResponseHook(responseHook, span, command, data.result);
+            }
+          }
+        });
+        bindTracingChannelToSpan(
+          connectChannel,
+          (data) => {
+            const { host, port } = getConnectionOptions(data.self);
+            return startInactiveSpan({
+              name: "connect",
+              op: "db",
+              attributes: { ...connectionAttributes(host, port), [DB_STATEMENT]: "connect" }
+            });
+          },
+          { requiresParentSpan: true }
+        );
+      });
+    }
+  };
+});
+function runResponseHook(hook, span, command, result) {
+  try {
+    hook(span, command.name, command.args, result);
+  } catch {
+  }
+}
+const ioredisChannelIntegration = defineIntegration(_ioredisChannelIntegration);
+
+export { ioredisChannelIntegration, startIORedisCommandSpan };
+//# sourceMappingURL=ioredis.js.map

package/build/esm/integrations/tracing-channel/ioredis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ioredis.js","sources":["../../../../src/integrations/tracing-channel/ioredis.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-deprecated -- we intentionally emit the OLD db/net semconv\n   to match `@opentelemetry/instrumentation-ioredis` (and Sentry's `inferDbSpanData`, which keys off\n   `db.statement`). TODO(v11): switch to the non-deprecated `db.system.name`/`db.query.text`/\n   `server.address`/`server.port` conventions and drop this disable. */\nimport * as diagnosticsChannel from 'node:diagnostics_channel';\nimport { DB_STATEMENT, DB_SYSTEM, NET_PEER_NAME, NET_PEER_PORT } from '@sentry/conventions/attributes';\nimport type { IntegrationFn, Span } from '@sentry/core';\nimport {\n  debug,\n  defineIntegration,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  startInactiveSpan,\n  waitForTracingChannelBinding,\n} from '@sentry/core';\nimport { DEBUG_BUILD } from '../../debug-build';\nimport { CHANNELS } from '../../orchestrion/channels';\nimport { defaultDbStatementSerializer } from '../../redis/redis-statement-serializer';\nimport { bindTracingChannelToSpan } from '../../tracing-channel';\n\n// Distinct from the OTel `Redis` integration, which is composite (node-redis +\n// ioredis + the >=5.11.0 diagnostics_channel subscriber) and stays in the set;\n// only its ioredis monkey-patch is gated off in the node SDK when this is active.\nconst INTEGRATION_NAME = 'IORedis' as const;\n\nconst ORIGIN = 'auto.db.orchestrion.redis';\n\n// todo(v11): Let's drop this as this is already covered with host and port\nconst ATTR_DB_CONNECTION_STRING = 'db.connection_string';\n\n/** Mirrors `@opentelemetry/instrumentation-ioredis`' response hook. Not called for failed commands. */\nexport type IORedisResponseHook = (span: Span, command: string, args: Array<string | Buffer>, result: unknown) => void;\n\nexport interface IORedisChannelIntegrationOptions {\n  responseHook?: IORedisResponseHook;\n}\n\n/** Structural type for the command object ioredis passes to `sendCommand`. */\ninterface RedisCommand {\n  name: string;\n  args: Array<string | Buffer>;\n}\n\ninterface RedisClientLike {\n  options?: { host?: string; port?: number };\n}\n\ninterface IORedisCommandContext {\n  arguments?: unknown[];\n  self?: RedisClientLike;\n  result?: unknown;\n  error?: unknown;\n}\n\ntype IORedisConnectContext = Omit<IORedisCommandContext, 'arguments'>;\n\nfunction getConnectionOptions(self: RedisClientLike | undefined): { host?: string; port?: number } {\n  return { host: self?.options?.host, port: self?.options?.port };\n}\n\nfunction connectionAttributes(host: string | undefined, port: number | undefined): Record<string, unknown> {\n  return {\n    [DB_SYSTEM]: 'redis',\n    [ATTR_DB_CONNECTION_STRING]: `redis://${host}:${port}`,\n    [NET_PEER_NAME]: host,\n    [NET_PEER_PORT]: port,\n    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: ORIGIN,\n  };\n}\n\n// ioredis re-enters `sendCommand` with the same command object when it drains\n// the offline queue on connect which leads to duplicate spans.\n// Track commands we've already traced so each logical command produces one span.\nconst tracedCommands = new WeakSet<object>();\n\n/**\n * Builds the db span for an `orchestrion:ioredis:command` payload, or returns `undefined` to skip\n * it: for a non-command payload, or the offline-queue re-send of an already-traced command.\n *\n * Exported for unit testing.\n */\nexport function startIORedisCommandSpan(data: IORedisCommandContext): Span | undefined {\n  const command = data.arguments?.[0] as RedisCommand | undefined;\n  if (!command || typeof command !== 'object') {\n    return undefined;\n  }\n  // guard against duplicate spans\n  if (tracedCommands.has(command)) {\n    return undefined;\n  }\n  tracedCommands.add(command);\n  const { host, port } = getConnectionOptions(data.self);\n  const statement = defaultDbStatementSerializer(command.name, command.args ?? []);\n  return startInactiveSpan({\n    name: statement,\n    op: 'db',\n    attributes: { ...connectionAttributes(host, port), [DB_STATEMENT]: statement },\n  });\n}\n\nconst _ioredisChannelIntegration = ((options: IORedisChannelIntegrationOptions = {}) => {\n  const responseHook = options.responseHook;\n\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      // `tracingChannel` is unavailable before Node 18.19.\n      if (!diagnosticsChannel.tracingChannel) {\n        return;\n      }\n\n      DEBUG_BUILD &&\n        debug.log(`[orchestrion:ioredis] subscribing to \"${CHANNELS.IOREDIS_COMMAND}\"/\"${CHANNELS.IOREDIS_CONNECT}\"`);\n\n      const commandChannel = diagnosticsChannel.tracingChannel<IORedisCommandContext, IORedisCommandContext>(\n        CHANNELS.IOREDIS_COMMAND,\n      );\n      const connectChannel = diagnosticsChannel.tracingChannel<IORedisConnectContext, IORedisConnectContext>(\n        CHANNELS.IOREDIS_CONNECT,\n      );\n\n      // `bindTracingChannelToSpan` uses `bindStore`, which needs the async-context\n      // binding that `initOpenTelemetry()` registers after integration `setupOnce` —\n      // defer until it's available (matches the native redis diagnostics-channel subscriber).\n      waitForTracingChannelBinding(() => {\n        bindTracingChannelToSpan(commandChannel, startIORedisCommandSpan, {\n          // ioredis' `requireParentSpan` default: only create a span under an active span.\n          requiresParentSpan: true,\n          beforeSpanEnd(span, data) {\n            if ('error' in data || !responseHook) {\n              return;\n            }\n            const command = data.arguments?.[0] as RedisCommand | undefined;\n            if (command) {\n              runResponseHook(responseHook, span, command, data.result);\n            }\n          },\n        });\n\n        bindTracingChannelToSpan(\n          connectChannel,\n          data => {\n            const { host, port } = getConnectionOptions(data.self);\n            return startInactiveSpan({\n              name: 'connect',\n              op: 'db',\n              attributes: { ...connectionAttributes(host, port), [DB_STATEMENT]: 'connect' },\n            });\n          },\n          { requiresParentSpan: true },\n        );\n      });\n    },\n  };\n}) satisfies IntegrationFn;\n\nfunction runResponseHook(hook: IORedisResponseHook, span: Span, command: RedisCommand, result: unknown): void {\n  try {\n    hook(span, command.name, command.args, result);\n  } catch {\n    // never let a user-provided response hook break instrumentation\n  }\n}\n\n/**\n * EXPERIMENTAL — orchestrion-driven ioredis integration. Subscribes to\n * `orchestrion:ioredis:command` / `:connect` (injected into ioredis' `<5.11.0`\n * `sendCommand`/`connect`) and creates db spans matching\n * `@opentelemetry/instrumentation-ioredis`. Requires the orchestrion runtime hook\n * or bundler plugin.\n */\nexport const ioredisChannelIntegration = defineIntegration(_ioredisChannelIntegration);\n"],"names":[],"mappings":"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"}

package/build/esm/integrations/tracing-channel/kafkajs/consumer.js

@@ -0,0 +1,67 @@
+import { MESSAGING_BATCH_MESSAGE_COUNT } from '@sentry/conventions/attributes';
+import { continueTrace, withActiveSpan, startNewTrace } from '@sentry/core';
+import { ATTR_MESSAGING_DESTINATION_PARTITION_ID, MESSAGING_OPERATION_TYPE_VALUE_PROCESS, MESSAGING_OPERATION_TYPE_VALUE_RECEIVE } from './semconv.js';
+import { getHeaderAsString, startConsumerSpan, endSpansOnPromise, getLinksFromHeaders } from './spans.js';
+
+const consumerCallbackWrapped = /* @__PURE__ */ Symbol("sentry-kafkajs-consumer-callback-wrapped");
+function isWrappedConsumerCallback(fn) {
+  return typeof fn === "function" && fn[consumerCallbackWrapped] === true;
+}
+function wrapEachMessage(original) {
+  const wrapped = function eachMessage(payload) {
+    const sentryTrace = getHeaderAsString(payload.message.headers, "sentry-trace");
+    const baggage = getHeaderAsString(payload.message.headers, "baggage");
+    return continueTrace({ sentryTrace, baggage }, () => {
+      const span = startConsumerSpan({
+        topic: payload.topic,
+        message: payload.message,
+        operationType: MESSAGING_OPERATION_TYPE_VALUE_PROCESS,
+        attributes: {
+          [ATTR_MESSAGING_DESTINATION_PARTITION_ID]: String(payload.partition)
+        }
+      });
+      const promise = withActiveSpan(span, () => original.call(this, payload));
+      return endSpansOnPromise([span], promise);
+    });
+  };
+  wrapped[consumerCallbackWrapped] = true;
+  return wrapped;
+}
+function wrapEachBatch(original) {
+  const wrapped = function eachBatch(payload) {
+    const receivingSpan = startNewTrace(
+      () => startConsumerSpan({
+        topic: payload.batch.topic,
+        message: void 0,
+        operationType: MESSAGING_OPERATION_TYPE_VALUE_RECEIVE,
+        attributes: {
+          [MESSAGING_BATCH_MESSAGE_COUNT]: payload.batch.messages.length,
+          [ATTR_MESSAGING_DESTINATION_PARTITION_ID]: String(payload.batch.partition)
+        }
+      })
+    );
+    return withActiveSpan(receivingSpan, () => {
+      const spans = [receivingSpan];
+      payload.batch.messages.forEach((message) => {
+        spans.push(
+          startConsumerSpan({
+            topic: payload.batch.topic,
+            message,
+            operationType: MESSAGING_OPERATION_TYPE_VALUE_PROCESS,
+            links: getLinksFromHeaders(message.headers),
+            attributes: {
+              [ATTR_MESSAGING_DESTINATION_PARTITION_ID]: String(payload.batch.partition)
+            }
+          })
+        );
+      });
+      const promise = original.call(this, payload);
+      return endSpansOnPromise(spans, promise);
+    });
+  };
+  wrapped[consumerCallbackWrapped] = true;
+  return wrapped;
+}
+
+export { isWrappedConsumerCallback, wrapEachBatch, wrapEachMessage };
+//# sourceMappingURL=consumer.js.map

package/build/esm/integrations/tracing-channel/kafkajs/consumer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumer.js","sources":["../../../../../src/integrations/tracing-channel/kafkajs/consumer.ts"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors, Aspecto\n * SPDX-License-Identifier: Apache-2.0\n *\n * NOTICE from the Sentry authors:\n * - Vendored from: https://github.com/open-telemetry/opentelemetry-js-contrib/tree/15ef7506553f631ea4181391e0c5725a56f0d082/packages/instrumentation-kafkajs\n * - Upstream version: @opentelemetry/instrumentation-kafkajs@0.27.0\n * - Span-creating wrappers for the consumer callbacks (`_getConsumerEachMessagePatch`/\n *   `_getConsumerEachBatchPatch`), migrated to the `@sentry/core` span API. The `run` channel's `start`\n *   subscriber swaps the user's `eachMessage`/`eachBatch` for these before the original runs.\n */\n\nimport { MESSAGING_BATCH_MESSAGE_COUNT } from '@sentry/conventions/attributes';\nimport type { Span } from '@sentry/core';\nimport { continueTrace, startNewTrace, withActiveSpan } from '@sentry/core';\nimport {\n  ATTR_MESSAGING_DESTINATION_PARTITION_ID,\n  MESSAGING_OPERATION_TYPE_VALUE_PROCESS,\n  MESSAGING_OPERATION_TYPE_VALUE_RECEIVE,\n} from './semconv';\nimport { endSpansOnPromise, getHeaderAsString, getLinksFromHeaders, startConsumerSpan } from './spans';\nimport type { EachBatchHandler, EachMessageHandler, KafkaMessage } from './types';\n\n// Marks a callback we've already wrapped. A user can reuse one config object across multiple\n// `consumer.run(config)` calls (e.g. a second consumer); without this guard the second `start` would\n// wrap the wrapper and emit duplicate spans per message.\nconst consumerCallbackWrapped: unique symbol = Symbol('sentry-kafkajs-consumer-callback-wrapped');\n\ntype MaybeWrapped = { [consumerCallbackWrapped]?: true };\n\n/** Whether `fn` is a callback this module already wrapped, so callers skip re-wrapping it. */\nexport function isWrappedConsumerCallback(fn: unknown): boolean {\n  return typeof fn === 'function' && (fn as MaybeWrapped)[consumerCallbackWrapped] === true;\n}\n\n/** Wraps `eachMessage` so each processed message becomes a consumer span parented to the message's producer. */\nexport function wrapEachMessage(original: EachMessageHandler): EachMessageHandler {\n  const wrapped: EachMessageHandler & MaybeWrapped = function eachMessage(this: unknown, payload) {\n    const sentryTrace = getHeaderAsString(payload.message.headers, 'sentry-trace');\n    const baggage = getHeaderAsString(payload.message.headers, 'baggage');\n\n    // Continue the producer's trace so the consumer span is parented to the message's producer.\n    return continueTrace({ sentryTrace, baggage }, () => {\n      const span = startConsumerSpan({\n        topic: payload.topic,\n        message: payload.message,\n        operationType: MESSAGING_OPERATION_TYPE_VALUE_PROCESS,\n        attributes: {\n          [ATTR_MESSAGING_DESTINATION_PARTITION_ID]: String(payload.partition),\n        },\n      });\n\n      const promise = withActiveSpan(span, () => original.call(this, payload));\n      return endSpansOnPromise([span], promise);\n    });\n  };\n  wrapped[consumerCallbackWrapped] = true;\n  return wrapped;\n}\n\n/** Wraps `eachBatch` so the batch pull becomes a fresh-root receiving span with a process span per message. */\nexport function wrapEachBatch(original: EachBatchHandler): EachBatchHandler {\n  const wrapped: EachBatchHandler & MaybeWrapped = function eachBatch(this: unknown, payload) {\n    // A batch pull aggregates messages from many producers, so the receiving span is a fresh root\n    // trace and each processed message links back to its own producer span. Mirrors the OTel messaging\n    // semantic conventions for a topic with multiple consumers.\n    const receivingSpan = startNewTrace(() =>\n      startConsumerSpan({\n        topic: payload.batch.topic,\n        message: undefined,\n        operationType: MESSAGING_OPERATION_TYPE_VALUE_RECEIVE,\n        attributes: {\n          [MESSAGING_BATCH_MESSAGE_COUNT]: payload.batch.messages.length,\n          [ATTR_MESSAGING_DESTINATION_PARTITION_ID]: String(payload.batch.partition),\n        },\n      }),\n    );\n\n    return withActiveSpan(receivingSpan, () => {\n      const spans: Span[] = [receivingSpan];\n      payload.batch.messages.forEach((message: KafkaMessage) => {\n        spans.push(\n          startConsumerSpan({\n            topic: payload.batch.topic,\n            message,\n            operationType: MESSAGING_OPERATION_TYPE_VALUE_PROCESS,\n            links: getLinksFromHeaders(message.headers),\n            attributes: {\n              [ATTR_MESSAGING_DESTINATION_PARTITION_ID]: String(payload.batch.partition),\n            },\n          }),\n        );\n      });\n      const promise = original.call(this, payload);\n      return endSpansOnPromise(spans, promise);\n    });\n  };\n  wrapped[consumerCallbackWrapped] = true;\n  return wrapped;\n}\n"],"names":[],"mappings":";;;;;AA0BA,MAAM,uBAAA,0BAAgD,0CAA0C,CAAA;AAKzF,SAAS,0BAA0B,EAAA,EAAsB;AAC9D,EAAA,OAAO,OAAO,EAAA,KAAO,UAAA,IAAe,EAAA,CAAoB,uBAAuB,CAAA,KAAM,IAAA;AACvF;AAGO,SAAS,gBAAgB,QAAA,EAAkD;AAChF,EAAA,MAAM,OAAA,GAA6C,SAAS,WAAA,CAA2B,OAAA,EAAS;AAC9F,IAAA,MAAM,WAAA,GAAc,iBAAA,CAAkB,OAAA,CAAQ,OAAA,CAAQ,SAAS,cAAc,CAAA;AAC7E,IAAA,MAAM,OAAA,GAAU,iBAAA,CAAkB,OAAA,CAAQ,OAAA,CAAQ,SAAS,SAAS,CAAA;AAGpE,IAAA,OAAO,aAAA,CAAc,EAAE,WAAA,EAAa,OAAA,IAAW,MAAM;AACnD,MAAA,MAAM,OAAO,iBAAA,CAAkB;AAAA,QAC7B,OAAO,OAAA,CAAQ,KAAA;AAAA,QACf,SAAS,OAAA,CAAQ,OAAA;AAAA,QACjB,aAAA,EAAe,sCAAA;AAAA,QACf,UAAA,EAAY;AAAA,UACV,CAAC,uCAAuC,GAAG,MAAA,CAAO,QAAQ,SAAS;AAAA;AACrE,OACD,CAAA;AAED,MAAA,MAAM,OAAA,GAAU,eAAe,IAAA,EAAM,MAAM,SAAS,IAAA,CAAK,IAAA,EAAM,OAAO,CAAC,CAAA;AACvE,MAAA,OAAO,iBAAA,CAAkB,CAAC,IAAI,CAAA,EAAG,OAAO,CAAA;AAAA,IAC1C,CAAC,CAAA;AAAA,EACH,CAAA;AACA,EAAA,OAAA,CAAQ,uBAAuB,CAAA,GAAI,IAAA;AACnC,EAAA,OAAO,OAAA;AACT;AAGO,SAAS,cAAc,QAAA,EAA8C;AAC1E,EAAA,MAAM,OAAA,GAA2C,SAAS,SAAA,CAAyB,OAAA,EAAS;AAI1F,IAAA,MAAM,aAAA,GAAgB,aAAA;AAAA,MAAc,MAClC,iBAAA,CAAkB;AAAA,QAChB,KAAA,EAAO,QAAQ,KAAA,CAAM,KAAA;AAAA,QACrB,OAAA,EAAS,MAAA;AAAA,QACT,aAAA,EAAe,sCAAA;AAAA,QACf,UAAA,EAAY;AAAA,UACV,CAAC,6BAA6B,GAAG,OAAA,CAAQ,MAAM,QAAA,CAAS,MAAA;AAAA,UACxD,CAAC,uCAAuC,GAAG,MAAA,CAAO,OAAA,CAAQ,MAAM,SAAS;AAAA;AAC3E,OACD;AAAA,KACH;AAEA,IAAA,OAAO,cAAA,CAAe,eAAe,MAAM;AACzC,MAAA,MAAM,KAAA,GAAgB,CAAC,aAAa,CAAA;AACpC,MAAA,OAAA,CAAQ,KAAA,CAAM,QAAA,CAAS,OAAA,CAAQ,CAAC,OAAA,KAA0B;AACxD,QAAA,KAAA,CAAM,IAAA;AAAA,UACJ,iBAAA,CAAkB;AAAA,YAChB,KAAA,EAAO,QAAQ,KAAA,CAAM,KAAA;AAAA,YACrB,OAAA;AAAA,YACA,aAAA,EAAe,sCAAA;AAAA,YACf,KAAA,EAAO,mBAAA,CAAoB,OAAA,CAAQ,OAAO,CAAA;AAAA,YAC1C,UAAA,EAAY;AAAA,cACV,CAAC,uCAAuC,GAAG,MAAA,CAAO,OAAA,CAAQ,MAAM,SAAS;AAAA;AAC3E,WACD;AAAA,SACH;AAAA,MACF,CAAC,CAAA;AACD,MAAA,MAAM,OAAA,GAAU,QAAA,CAAS,IAAA,CAAK,IAAA,EAAM,OAAO,CAAA;AAC3C,MAAA,OAAO,iBAAA,CAAkB,OAAO,OAAO,CAAA;AAAA,IACzC,CAAC,CAAA;AAAA,EACH,CAAA;AACA,EAAA,OAAA,CAAQ,uBAAuB,CAAA,GAAI,IAAA;AACnC,EAAA,OAAO,OAAA;AACT;;;;"}

package/build/esm/integrations/tracing-channel/kafkajs/index.js

@@ -0,0 +1,68 @@
+import * as diagnosticsChannel from 'node:diagnostics_channel';
+import { defineIntegration, debug } from '@sentry/core';
+import { DEBUG_BUILD } from '../../../debug-build.js';
+import { CHANNELS } from '../../../orchestrion/channels.js';
+import { isWrappedConsumerCallback, wrapEachMessage, wrapEachBatch } from './consumer.js';
+import { applyErrorToSpans, startProducerSpan } from './spans.js';
+
+const INTEGRATION_NAME = "Kafka";
+function subscribeToProducer() {
+  const channel = diagnosticsChannel.tracingChannel(CHANNELS.KAFKAJS_SEND_BATCH);
+  const subscribers = {
+    start(ctx) {
+      const spans = [];
+      (ctx.arguments[0]?.topicMessages ?? []).forEach((topicMessage) => {
+        topicMessage.messages.forEach((message) => {
+          spans.push(startProducerSpan(topicMessage.topic, message));
+        });
+      });
+      ctx._sentrySpans = spans;
+    },
+    error(ctx) {
+      if (ctx._sentrySpans) {
+        applyErrorToSpans(ctx._sentrySpans, ctx.error);
+      }
+    },
+    asyncEnd(ctx) {
+      ctx._sentrySpans?.forEach((span) => span.end());
+    }
+  };
+  channel.subscribe(subscribers);
+}
+function subscribeToConsumer() {
+  const channel = diagnosticsChannel.tracingChannel(CHANNELS.KAFKAJS_CONSUMER_RUN);
+  const subscribers = {
+    start(ctx) {
+      const config = ctx.arguments[0];
+      if (!config || typeof config !== "object") {
+        return;
+      }
+      if (typeof config.eachMessage === "function" && !isWrappedConsumerCallback(config.eachMessage)) {
+        config.eachMessage = wrapEachMessage(config.eachMessage);
+      }
+      if (typeof config.eachBatch === "function" && !isWrappedConsumerCallback(config.eachBatch)) {
+        config.eachBatch = wrapEachBatch(config.eachBatch);
+      }
+    }
+  };
+  channel.subscribe(subscribers);
+}
+const _kafkajsChannelIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      if (!diagnosticsChannel.tracingChannel) {
+        return;
+      }
+      DEBUG_BUILD && debug.log(
+        `[orchestrion:kafkajs] subscribing to channels "${CHANNELS.KAFKAJS_SEND_BATCH}", "${CHANNELS.KAFKAJS_CONSUMER_RUN}"`
+      );
+      subscribeToProducer();
+      subscribeToConsumer();
+    }
+  };
+});
+const kafkajsChannelIntegration = defineIntegration(_kafkajsChannelIntegration);
+
+export { kafkajsChannelIntegration };
+//# sourceMappingURL=index.js.map

package/build/esm/integrations/tracing-channel/kafkajs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../src/integrations/tracing-channel/kafkajs/index.ts"],"sourcesContent":["import * as diagnosticsChannel from 'node:diagnostics_channel';\nimport type { TracingChannelSubscribers } from 'node:diagnostics_channel';\nimport type { IntegrationFn, Span } from '@sentry/core';\nimport { debug, defineIntegration } from '@sentry/core';\nimport { DEBUG_BUILD } from '../../../debug-build';\nimport { CHANNELS } from '../../../orchestrion/channels';\nimport { isWrappedConsumerCallback, wrapEachBatch, wrapEachMessage } from './consumer';\nimport { applyErrorToSpans, startProducerSpan } from './spans';\nimport type { ConsumerRunConfig, ProducerBatch } from './types';\n\n// NOTE: this uses the same name as the OTel `Kafka` integration by design. When enabled, the OTel\n// integration is omitted from the default set (see `experimentalUseDiagnosticsChannelInjection`).\nconst INTEGRATION_NAME = 'Kafka' as const;\n\n/** The tracing-channel context the transform attaches around `messageProducer.js`'s `sendBatch`. */\ninterface SendBatchChannelContext {\n  // `arguments[0]` is the `{ topicMessages }` batch (kafkajs normalizes `send` into `sendBatch`).\n  arguments: [ProducerBatch?, ...unknown[]];\n  error?: unknown;\n  // The producer spans opened at `start`, ended on `asyncEnd` (and marked errored on `error`).\n  _sentrySpans?: Span[];\n}\n\n/** The tracing-channel context the transform attaches around `consumer/index.js`'s `run`. */\ninterface ConsumerRunChannelContext {\n  // `arguments[0]` is the `run(config)` config whose `eachMessage`/`eachBatch` we swap in place.\n  arguments: [ConsumerRunConfig?, ...unknown[]];\n}\n\nfunction subscribeToProducer(): void {\n  const channel = diagnosticsChannel.tracingChannel<SendBatchChannelContext>(CHANNELS.KAFKAJS_SEND_BATCH);\n  // Node types `subscribe` as requiring every lifecycle handler; runtime accepts a partial set, so we\n  // pass only the ones we use (matching `bindTracingChannelToSpan`'s handling in `tracing-channel.ts`).\n  const subscribers: Partial<TracingChannelSubscribers<SendBatchChannelContext>> = {\n    start(ctx) {\n      const spans: Span[] = [];\n      // `startProducerSpan` mutates each message's headers; doing it at `start` means the mutation\n      // reaches the real call, propagating the producer's trace to consumers.\n      (ctx.arguments[0]?.topicMessages ?? []).forEach(topicMessage => {\n        topicMessage.messages.forEach(message => {\n          spans.push(startProducerSpan(topicMessage.topic, message));\n        });\n      });\n      ctx._sentrySpans = spans;\n    },\n    error(ctx) {\n      if (ctx._sentrySpans) {\n        applyErrorToSpans(ctx._sentrySpans, ctx.error);\n      }\n    },\n    asyncEnd(ctx) {\n      // `asyncEnd` fires on both success and failure; `error` (above) has already set the status.\n      ctx._sentrySpans?.forEach(span => span.end());\n    },\n  };\n  channel.subscribe(subscribers as TracingChannelSubscribers<SendBatchChannelContext>);\n}\n\nfunction subscribeToConsumer(): void {\n  const channel = diagnosticsChannel.tracingChannel<ConsumerRunChannelContext>(CHANNELS.KAFKAJS_CONSUMER_RUN);\n  const subscribers: Partial<TracingChannelSubscribers<ConsumerRunChannelContext>> = {\n    start(ctx) {\n      const config = ctx.arguments[0];\n      if (!config || typeof config !== 'object') {\n        return;\n      }\n      // Swap the user callbacks for span-creating wrappers before `run` destructures its config. The\n      // `isWrappedConsumerCallback` guard keeps this idempotent: a config object reused across another\n      // `run` (or a second consumer) must not have its wrapper wrapped again, which would double spans.\n      if (typeof config.eachMessage === 'function' && !isWrappedConsumerCallback(config.eachMessage)) {\n        config.eachMessage = wrapEachMessage(config.eachMessage);\n      }\n      if (typeof config.eachBatch === 'function' && !isWrappedConsumerCallback(config.eachBatch)) {\n        config.eachBatch = wrapEachBatch(config.eachBatch);\n      }\n    },\n  };\n  channel.subscribe(subscribers as TracingChannelSubscribers<ConsumerRunChannelContext>);\n}\n\nconst _kafkajsChannelIntegration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      if (!diagnosticsChannel.tracingChannel) {\n        return;\n      }\n\n      DEBUG_BUILD &&\n        debug.log(\n          `[orchestrion:kafkajs] subscribing to channels \"${CHANNELS.KAFKAJS_SEND_BATCH}\", \"${CHANNELS.KAFKAJS_CONSUMER_RUN}\"`,\n        );\n\n      subscribeToProducer();\n      subscribeToConsumer();\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * EXPERIMENTAL — orchestrion-driven kafkajs integration.\n *\n * Subscribes to the `orchestrion:kafkajs:*` diagnostics_channels that the orchestrion code transform\n * injects into `kafkajs`'s `producer/messageProducer.js` (`sendBatch`) and `consumer/index.js` (`run`).\n * Requires the orchestrion runtime hook or bundler plugin to be active — wire that up via\n * `experimentalUseDiagnosticsChannelInjection`.\n *\n * Known limitation vs. the OTel integration it replaces: the wrapping producer-`transaction` span is\n * not emitted (the transformer can't replace `transaction()`'s return value to patch commit/abort).\n * Transactional `send`/`sendBatch` calls still produce producer spans, since they route through the\n * same instrumented `sendBatch`.\n */\nexport const kafkajsChannelIntegration = defineIntegration(_kafkajsChannelIntegration);\n"],"names":[],"mappings":";;;;;;;AAYA,MAAM,gBAAA,GAAmB,OAAA;AAiBzB,SAAS,mBAAA,GAA4B;AACnC,EAAA,MAAM,OAAA,GAAU,kBAAA,CAAmB,cAAA,CAAwC,QAAA,CAAS,kBAAkB,CAAA;AAGtG,EAAA,MAAM,WAAA,GAA2E;AAAA,IAC/E,MAAM,GAAA,EAAK;AACT,MAAA,MAAM,QAAgB,EAAC;AAGvB,MAAA,CAAC,GAAA,CAAI,UAAU,CAAC,CAAA,EAAG,iBAAiB,EAAC,EAAG,QAAQ,CAAA,YAAA,KAAgB;AAC9D,QAAA,YAAA,CAAa,QAAA,CAAS,QAAQ,CAAA,OAAA,KAAW;AACvC,UAAA,KAAA,CAAM,IAAA,CAAK,iBAAA,CAAkB,YAAA,CAAa,KAAA,EAAO,OAAO,CAAC,CAAA;AAAA,QAC3D,CAAC,CAAA;AAAA,MACH,CAAC,CAAA;AACD,MAAA,GAAA,CAAI,YAAA,GAAe,KAAA;AAAA,IACrB,CAAA;AAAA,IACA,MAAM,GAAA,EAAK;AACT,MAAA,IAAI,IAAI,YAAA,EAAc;AACpB,QAAA,iBAAA,CAAkB,GAAA,CAAI,YAAA,EAAc,GAAA,CAAI,KAAK,CAAA;AAAA,MAC/C;AAAA,IACF,CAAA;AAAA,IACA,SAAS,GAAA,EAAK;AAEZ,MAAA,GAAA,CAAI,YAAA,EAAc,OAAA,CAAQ,CAAA,IAAA,KAAQ,IAAA,CAAK,KAAK,CAAA;AAAA,IAC9C;AAAA,GACF;AACA,EAAA,OAAA,CAAQ,UAAU,WAAiE,CAAA;AACrF;AAEA,SAAS,mBAAA,GAA4B;AACnC,EAAA,MAAM,OAAA,GAAU,kBAAA,CAAmB,cAAA,CAA0C,QAAA,CAAS,oBAAoB,CAAA;AAC1G,EAAA,MAAM,WAAA,GAA6E;AAAA,IACjF,MAAM,GAAA,EAAK;AACT,MAAA,MAAM,MAAA,GAAS,GAAA,CAAI,SAAA,CAAU,CAAC,CAAA;AAC9B,MAAA,IAAI,CAAC,MAAA,IAAU,OAAO,MAAA,KAAW,QAAA,EAAU;AACzC,QAAA;AAAA,MACF;AAIA,MAAA,IAAI,OAAO,OAAO,WAAA,KAAgB,UAAA,IAAc,CAAC,yBAAA,CAA0B,MAAA,CAAO,WAAW,CAAA,EAAG;AAC9F,QAAA,MAAA,CAAO,WAAA,GAAc,eAAA,CAAgB,MAAA,CAAO,WAAW,CAAA;AAAA,MACzD;AACA,MAAA,IAAI,OAAO,OAAO,SAAA,KAAc,UAAA,IAAc,CAAC,yBAAA,CAA0B,MAAA,CAAO,SAAS,CAAA,EAAG;AAC1F,QAAA,MAAA,CAAO,SAAA,GAAY,aAAA,CAAc,MAAA,CAAO,SAAS,CAAA;AAAA,MACnD;AAAA,IACF;AAAA,GACF;AACA,EAAA,OAAA,CAAQ,UAAU,WAAmE,CAAA;AACvF;AAEA,MAAM,8BAA8B,MAAM;AACxC,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,SAAA,GAAY;AACV,MAAA,IAAI,CAAC,mBAAmB,cAAA,EAAgB;AACtC,QAAA;AAAA,MACF;AAEA,MAAA,WAAA,IACE,KAAA,CAAM,GAAA;AAAA,QACJ,CAAA,+CAAA,EAAkD,QAAA,CAAS,kBAAkB,CAAA,IAAA,EAAO,SAAS,oBAAoB,CAAA,CAAA;AAAA,OACnH;AAEF,MAAA,mBAAA,EAAoB;AACpB,MAAA,mBAAA,EAAoB;AAAA,IACtB;AAAA,GACF;AACF,CAAA,CAAA;AAeO,MAAM,yBAAA,GAA4B,kBAAkB,0BAA0B;;;;"}

package/build/esm/integrations/tracing-channel/kafkajs/semconv.js

@@ -0,0 +1,12 @@
+const ATTR_MESSAGING_DESTINATION_PARTITION_ID = "messaging.destination.partition.id";
+const ATTR_MESSAGING_KAFKA_MESSAGE_KEY = "messaging.kafka.message.key";
+const ATTR_MESSAGING_KAFKA_MESSAGE_TOMBSTONE = "messaging.kafka.message.tombstone";
+const ATTR_MESSAGING_KAFKA_OFFSET = "messaging.kafka.offset";
+const MESSAGING_OPERATION_TYPE_VALUE_PROCESS = "process";
+const MESSAGING_OPERATION_TYPE_VALUE_RECEIVE = "receive";
+const MESSAGING_OPERATION_TYPE_VALUE_SEND = "send";
+const MESSAGING_SYSTEM_VALUE_KAFKA = "kafka";
+const ERROR_TYPE_VALUE_OTHER = "_OTHER";
+
+export { ATTR_MESSAGING_DESTINATION_PARTITION_ID, ATTR_MESSAGING_KAFKA_MESSAGE_KEY, ATTR_MESSAGING_KAFKA_MESSAGE_TOMBSTONE, ATTR_MESSAGING_KAFKA_OFFSET, ERROR_TYPE_VALUE_OTHER, MESSAGING_OPERATION_TYPE_VALUE_PROCESS, MESSAGING_OPERATION_TYPE_VALUE_RECEIVE, MESSAGING_OPERATION_TYPE_VALUE_SEND, MESSAGING_SYSTEM_VALUE_KAFKA };
+//# sourceMappingURL=semconv.js.map