@depup/sentry__server-utils 10.67.0-depup.0

package/build/cjs/orchestrion/config/postgres.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.js","sources":["../../../../src/orchestrion/config/postgres.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\n// postgres.js (`postgres` npm package, v3.x). Named after the npm package;\n// `postgres` doesn't collide with `pg.ts` (that file instruments `pg`/`pg-pool`).\n//\n// The ESM build lives under `src/*`, the CJS build under `cjs/src/*` (the\n// `cf/*` workerd build has no channel subscribers, see the integration).\n// Both builds share the same class/function shapes, so a single `flatMap`\n// over the two dirs emits one entry per (dir, target).\nconst postgresJsInstrumentationConfig = (dir: string): InstrumentationConfig[] => [\n  // `Query.prototype.handle` (`class Query extends Promise`) is the single\n  // funnel every query passes through (`then`/`catch`/`finally`/`.execute()`/\n  // `.forEach()`/cursor all call it), guarded by `this.executed`. `Async`\n  // because `handle` is `async`.\n  {\n    channelName: 'handle',\n    module: { name: 'postgres', versionRange: '>=3.0.0 <4', filePath: `${dir}/query.js` },\n    functionQuery: { className: 'Query', methodName: 'handle', kind: 'Async' },\n  },\n  // `function Connection(options, ...)` (default export of `connection.js`)\n  // returns the connection object; used to build the endpoint registry that\n  // resolves `server.address`/`server.port`/`db.namespace`.\n  {\n    channelName: 'connection',\n    module: { name: 'postgres', versionRange: '>=3.0.0 <4', filePath: `${dir}/connection.js` },\n    functionQuery: { functionName: 'Connection', kind: 'Sync' },\n  },\n  // The nested `function execute(q)` inside `Connection`; the per-connection\n  // hook that attaches connection attributes to the query's span.\n  {\n    channelName: 'execute',\n    module: { name: 'postgres', versionRange: '>=3.0.0 <4', filePath: `${dir}/connection.js` },\n    functionQuery: { functionName: 'execute', kind: 'Sync' },\n  },\n  // The connection object's `connect(query)` method. Matched by `methodName`\n  // (an object-literal method): `functionName` would hit the unrelated\n  // socket-level `async function connect()` in the same file. `self` is the\n  // connection object and `arguments[0]` the query, so the first query that\n  // opens a connection (dispatched via a bare `execute` with no `self`) still\n  // gets connection attributes in multi-endpoint apps.\n  {\n    channelName: 'connect',\n    module: { name: 'postgres', versionRange: '>=3.0.0 <4', filePath: `${dir}/connection.js` },\n    functionQuery: { methodName: 'connect', kind: 'Sync' },\n  },\n];\n\nexport const postgresJsConfig = ['src', 'cjs/src'].flatMap(postgresJsInstrumentationConfig);\n\nexport const postgresJsChannels = {\n  POSTGRESJS_HANDLE: 'orchestrion:postgres:handle',\n  POSTGRESJS_CONNECTION: 'orchestrion:postgres:connection',\n  POSTGRESJS_EXECUTE: 'orchestrion:postgres:execute',\n  POSTGRESJS_CONNECT: 'orchestrion:postgres:connect',\n} as const;\n"],"names":[],"mappings":";;AASA,MAAM,+BAAA,GAAkC,CAAC,GAAA,KAAyC;AAAA;AAAA;AAAA;AAAA;AAAA,EAKhF;AAAA,IACE,WAAA,EAAa,QAAA;AAAA,IACb,MAAA,EAAQ,EAAE,IAAA,EAAM,UAAA,EAAY,cAAc,YAAA,EAAc,QAAA,EAAU,CAAA,EAAG,GAAG,CAAA,SAAA,CAAA,EAAY;AAAA,IACpF,eAAe,EAAE,SAAA,EAAW,SAAS,UAAA,EAAY,QAAA,EAAU,MAAM,OAAA;AAAQ,GAC3E;AAAA;AAAA;AAAA;AAAA,EAIA;AAAA,IACE,WAAA,EAAa,YAAA;AAAA,IACb,MAAA,EAAQ,EAAE,IAAA,EAAM,UAAA,EAAY,cAAc,YAAA,EAAc,QAAA,EAAU,CAAA,EAAG,GAAG,CAAA,cAAA,CAAA,EAAiB;AAAA,IACzF,aAAA,EAAe,EAAE,YAAA,EAAc,YAAA,EAAc,MAAM,MAAA;AAAO,GAC5D;AAAA;AAAA;AAAA,EAGA;AAAA,IACE,WAAA,EAAa,SAAA;AAAA,IACb,MAAA,EAAQ,EAAE,IAAA,EAAM,UAAA,EAAY,cAAc,YAAA,EAAc,QAAA,EAAU,CAAA,EAAG,GAAG,CAAA,cAAA,CAAA,EAAiB;AAAA,IACzF,aAAA,EAAe,EAAE,YAAA,EAAc,SAAA,EAAW,MAAM,MAAA;AAAO,GACzD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA;AAAA,IACE,WAAA,EAAa,SAAA;AAAA,IACb,MAAA,EAAQ,EAAE,IAAA,EAAM,UAAA,EAAY,cAAc,YAAA,EAAc,QAAA,EAAU,CAAA,EAAG,GAAG,CAAA,cAAA,CAAA,EAAiB;AAAA,IACzF,aAAA,EAAe,EAAE,UAAA,EAAY,SAAA,EAAW,MAAM,MAAA;AAAO;AAEzD,CAAA;AAEO,MAAM,mBAAmB,CAAC,KAAA,EAAO,SAAS,CAAA,CAAE,QAAQ,+BAA+B;AAEnF,MAAM,kBAAA,GAAqB;AAAA,EAChC,iBAAA,EAAmB,6BAAA;AAAA,EACnB,qBAAA,EAAuB,iCAAA;AAAA,EACvB,kBAAA,EAAoB,8BAAA;AAAA,EACpB,kBAAA,EAAoB;AACtB;;;;;"}

package/build/cjs/orchestrion/config/prisma.js

@@ -0,0 +1,8 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const prismaConfig = [];
+const prismaChannels = {};
+
+exports.prismaChannels = prismaChannels;
+exports.prismaConfig = prismaConfig;
+//# sourceMappingURL=prisma.js.map

package/build/cjs/orchestrion/config/prisma.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma.js","sources":["../../../../src/orchestrion/config/prisma.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\n// TODO: Stub for the `prisma` orchestrion integration (ports `@prisma/instrumentation`).\nexport const prismaConfig: InstrumentationConfig[] = [];\n\nexport const prismaChannels = {} as const;\n"],"names":[],"mappings":";;AAGO,MAAM,eAAwC;AAE9C,MAAM,iBAAiB;;;;;"}

package/build/cjs/orchestrion/config/react-router.js

@@ -0,0 +1,8 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const reactRouterConfig = [];
+const reactRouterChannels = {};
+
+exports.reactRouterChannels = reactRouterChannels;
+exports.reactRouterConfig = reactRouterConfig;
+//# sourceMappingURL=react-router.js.map

package/build/cjs/orchestrion/config/react-router.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-router.js","sources":["../../../../src/orchestrion/config/react-router.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\n// TODO: Stub for the `react-router` orchestrion integration (ports `ReactRouterInstrumentation`).\nexport const reactRouterConfig: InstrumentationConfig[] = [];\n\nexport const reactRouterChannels = {} as const;\n"],"names":[],"mappings":";;AAGO,MAAM,oBAA6C;AAEnD,MAAM,sBAAsB;;;;;"}

package/build/cjs/orchestrion/config/redis.js

@@ -0,0 +1,76 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const redisConfig = [
+  // redis `>=2.6.0 <4` (standalone `redis`). `internal_send_command` is an
+  // anonymous prototype assignment (`expressionName`); it settles via the nested
+  // `command_obj.callback`, so `kind: 'Sync'` and the subscriber wraps that callback.
+  {
+    channelName: "command",
+    module: { name: "redis", versionRange: ">=2.6.0 <4", filePath: "index.js" },
+    functionQuery: { expressionName: "internal_send_command", kind: "Sync" }
+  },
+  // node-redis v4 (`@redis/client` v1). The real chokepoint (private `#sendCommand`)
+  // isn't matchable, so wrap both public entry points: `commandsExecutor` (friendly
+  // commands) and `sendCommand` (direct calls). They never overlap, so no double span.
+  {
+    channelName: "executor",
+    module: { name: "@redis/client", versionRange: "^1.0.0", filePath: "dist/lib/client/index.js" },
+    functionQuery: { className: "RedisClient", methodName: "commandsExecutor", kind: "Async" }
+  },
+  {
+    channelName: "command",
+    module: { name: "@redis/client", versionRange: "^1.0.0", filePath: "dist/lib/client/index.js" },
+    functionQuery: { className: "RedisClient", methodName: "sendCommand", kind: "Async" }
+  },
+  {
+    channelName: "connect",
+    module: { name: "@redis/client", versionRange: "^1.0.0", filePath: "dist/lib/client/index.js" },
+    functionQuery: { className: "RedisClient", methodName: "connect", kind: "Async" }
+  },
+  // node-redis `>=5.0.0 <5.12.0` (`@redis/client` v5; >=5.12.0 has its own
+  // `node-redis:*` diagnostics_channel, see `redis-dc-subscriber.ts`). Friendly
+  // commands route through the public `sendCommand`, so it covers them all — no
+  // `executor` entry (would double-count).
+  {
+    channelName: "command",
+    module: { name: "@redis/client", versionRange: ">=5.0.0 <5.12.0", filePath: "dist/lib/client/index.js" },
+    functionQuery: { className: "RedisClient", methodName: "sendCommand", kind: "Async" }
+  },
+  {
+    channelName: "connect",
+    module: { name: "@redis/client", versionRange: ">=5.0.0 <5.12.0", filePath: "dist/lib/client/index.js" },
+    functionQuery: { className: "RedisClient", methodName: "connect", kind: "Async" }
+  },
+  // Batch (multi/pipeline) — one span per `exec`. Batched commands bypass `sendCommand`,
+  // so they go through the client's batch executors, which receive the queued commands
+  // array (→ batch size). v5 splits MULTI/PIPELINE into two methods; v4's single
+  // `multiExecutor` is MULTI when a `chainId` arg is present, PIPELINE otherwise.
+  {
+    channelName: "multi",
+    module: { name: "@redis/client", versionRange: ">=5.0.0 <5.12.0", filePath: "dist/lib/client/index.js" },
+    functionQuery: { className: "RedisClient", methodName: "_executeMulti", kind: "Async" }
+  },
+  {
+    channelName: "pipeline",
+    module: { name: "@redis/client", versionRange: ">=5.0.0 <5.12.0", filePath: "dist/lib/client/index.js" },
+    functionQuery: { className: "RedisClient", methodName: "_executePipeline", kind: "Async" }
+  },
+  {
+    channelName: "batch",
+    module: { name: "@redis/client", versionRange: "^1.0.0", filePath: "dist/lib/client/index.js" },
+    functionQuery: { className: "RedisClient", methodName: "multiExecutor", kind: "Async" }
+  }
+];
+const redisChannels = {
+  REDIS_COMMAND: "orchestrion:redis:command",
+  NODE_REDIS_COMMAND: "orchestrion:@redis/client:command",
+  NODE_REDIS_EXECUTOR: "orchestrion:@redis/client:executor",
+  NODE_REDIS_CONNECT: "orchestrion:@redis/client:connect",
+  NODE_REDIS_MULTI: "orchestrion:@redis/client:multi",
+  NODE_REDIS_PIPELINE: "orchestrion:@redis/client:pipeline",
+  NODE_REDIS_BATCH: "orchestrion:@redis/client:batch"
+};
+
+exports.redisChannels = redisChannels;
+exports.redisConfig = redisConfig;
+//# sourceMappingURL=redis.js.map

package/build/cjs/orchestrion/config/redis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.js","sources":["../../../../src/orchestrion/config/redis.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\nexport const redisConfig = [\n  // redis `>=2.6.0 <4` (standalone `redis`). `internal_send_command` is an\n  // anonymous prototype assignment (`expressionName`); it settles via the nested\n  // `command_obj.callback`, so `kind: 'Sync'` and the subscriber wraps that callback.\n  {\n    channelName: 'command',\n    module: { name: 'redis', versionRange: '>=2.6.0 <4', filePath: 'index.js' },\n    functionQuery: { expressionName: 'internal_send_command', kind: 'Sync' },\n  },\n  // node-redis v4 (`@redis/client` v1). The real chokepoint (private `#sendCommand`)\n  // isn't matchable, so wrap both public entry points: `commandsExecutor` (friendly\n  // commands) and `sendCommand` (direct calls). They never overlap, so no double span.\n  {\n    channelName: 'executor',\n    module: { name: '@redis/client', versionRange: '^1.0.0', filePath: 'dist/lib/client/index.js' },\n    functionQuery: { className: 'RedisClient', methodName: 'commandsExecutor', kind: 'Async' },\n  },\n  {\n    channelName: 'command',\n    module: { name: '@redis/client', versionRange: '^1.0.0', filePath: 'dist/lib/client/index.js' },\n    functionQuery: { className: 'RedisClient', methodName: 'sendCommand', kind: 'Async' },\n  },\n  {\n    channelName: 'connect',\n    module: { name: '@redis/client', versionRange: '^1.0.0', filePath: 'dist/lib/client/index.js' },\n    functionQuery: { className: 'RedisClient', methodName: 'connect', kind: 'Async' },\n  },\n  // node-redis `>=5.0.0 <5.12.0` (`@redis/client` v5; >=5.12.0 has its own\n  // `node-redis:*` diagnostics_channel, see `redis-dc-subscriber.ts`). Friendly\n  // commands route through the public `sendCommand`, so it covers them all — no\n  // `executor` entry (would double-count).\n  {\n    channelName: 'command',\n    module: { name: '@redis/client', versionRange: '>=5.0.0 <5.12.0', filePath: 'dist/lib/client/index.js' },\n    functionQuery: { className: 'RedisClient', methodName: 'sendCommand', kind: 'Async' },\n  },\n  {\n    channelName: 'connect',\n    module: { name: '@redis/client', versionRange: '>=5.0.0 <5.12.0', filePath: 'dist/lib/client/index.js' },\n    functionQuery: { className: 'RedisClient', methodName: 'connect', kind: 'Async' },\n  },\n  // Batch (multi/pipeline) — one span per `exec`. Batched commands bypass `sendCommand`,\n  // so they go through the client's batch executors, which receive the queued commands\n  // array (→ batch size). v5 splits MULTI/PIPELINE into two methods; v4's single\n  // `multiExecutor` is MULTI when a `chainId` arg is present, PIPELINE otherwise.\n  {\n    channelName: 'multi',\n    module: { name: '@redis/client', versionRange: '>=5.0.0 <5.12.0', filePath: 'dist/lib/client/index.js' },\n    functionQuery: { className: 'RedisClient', methodName: '_executeMulti', kind: 'Async' },\n  },\n  {\n    channelName: 'pipeline',\n    module: { name: '@redis/client', versionRange: '>=5.0.0 <5.12.0', filePath: 'dist/lib/client/index.js' },\n    functionQuery: { className: 'RedisClient', methodName: '_executePipeline', kind: 'Async' },\n  },\n  {\n    channelName: 'batch',\n    module: { name: '@redis/client', versionRange: '^1.0.0', filePath: 'dist/lib/client/index.js' },\n    functionQuery: { className: 'RedisClient', methodName: 'multiExecutor', kind: 'Async' },\n  },\n] satisfies InstrumentationConfig[];\n\nexport const redisChannels = {\n  REDIS_COMMAND: 'orchestrion:redis:command',\n  NODE_REDIS_COMMAND: 'orchestrion:@redis/client:command',\n  NODE_REDIS_EXECUTOR: 'orchestrion:@redis/client:executor',\n  NODE_REDIS_CONNECT: 'orchestrion:@redis/client:connect',\n  NODE_REDIS_MULTI: 'orchestrion:@redis/client:multi',\n  NODE_REDIS_PIPELINE: 'orchestrion:@redis/client:pipeline',\n  NODE_REDIS_BATCH: 'orchestrion:@redis/client:batch',\n} as const;\n"],"names":[],"mappings":";;AAEO,MAAM,WAAA,GAAc;AAAA;AAAA;AAAA;AAAA,EAIzB;AAAA,IACE,WAAA,EAAa,SAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,SAAS,YAAA,EAAc,YAAA,EAAc,UAAU,UAAA,EAAW;AAAA,IAC1E,aAAA,EAAe,EAAE,cAAA,EAAgB,uBAAA,EAAyB,MAAM,MAAA;AAAO,GACzE;AAAA;AAAA;AAAA;AAAA,EAIA;AAAA,IACE,WAAA,EAAa,UAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,iBAAiB,YAAA,EAAc,QAAA,EAAU,UAAU,0BAAA,EAA2B;AAAA,IAC9F,eAAe,EAAE,SAAA,EAAW,eAAe,UAAA,EAAY,kBAAA,EAAoB,MAAM,OAAA;AAAQ,GAC3F;AAAA,EACA;AAAA,IACE,WAAA,EAAa,SAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,iBAAiB,YAAA,EAAc,QAAA,EAAU,UAAU,0BAAA,EAA2B;AAAA,IAC9F,eAAe,EAAE,SAAA,EAAW,eAAe,UAAA,EAAY,aAAA,EAAe,MAAM,OAAA;AAAQ,GACtF;AAAA,EACA;AAAA,IACE,WAAA,EAAa,SAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,iBAAiB,YAAA,EAAc,QAAA,EAAU,UAAU,0BAAA,EAA2B;AAAA,IAC9F,eAAe,EAAE,SAAA,EAAW,eAAe,UAAA,EAAY,SAAA,EAAW,MAAM,OAAA;AAAQ,GAClF;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA,IACE,WAAA,EAAa,SAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,iBAAiB,YAAA,EAAc,iBAAA,EAAmB,UAAU,0BAAA,EAA2B;AAAA,IACvG,eAAe,EAAE,SAAA,EAAW,eAAe,UAAA,EAAY,aAAA,EAAe,MAAM,OAAA;AAAQ,GACtF;AAAA,EACA;AAAA,IACE,WAAA,EAAa,SAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,iBAAiB,YAAA,EAAc,iBAAA,EAAmB,UAAU,0BAAA,EAA2B;AAAA,IACvG,eAAe,EAAE,SAAA,EAAW,eAAe,UAAA,EAAY,SAAA,EAAW,MAAM,OAAA;AAAQ,GAClF;AAAA;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA,IACE,WAAA,EAAa,OAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,iBAAiB,YAAA,EAAc,iBAAA,EAAmB,UAAU,0BAAA,EAA2B;AAAA,IACvG,eAAe,EAAE,SAAA,EAAW,eAAe,UAAA,EAAY,eAAA,EAAiB,MAAM,OAAA;AAAQ,GACxF;AAAA,EACA;AAAA,IACE,WAAA,EAAa,UAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,iBAAiB,YAAA,EAAc,iBAAA,EAAmB,UAAU,0BAAA,EAA2B;AAAA,IACvG,eAAe,EAAE,SAAA,EAAW,eAAe,UAAA,EAAY,kBAAA,EAAoB,MAAM,OAAA;AAAQ,GAC3F;AAAA,EACA;AAAA,IACE,WAAA,EAAa,OAAA;AAAA,IACb,QAAQ,EAAE,IAAA,EAAM,iBAAiB,YAAA,EAAc,QAAA,EAAU,UAAU,0BAAA,EAA2B;AAAA,IAC9F,eAAe,EAAE,SAAA,EAAW,eAAe,UAAA,EAAY,eAAA,EAAiB,MAAM,OAAA;AAAQ;AAE1F;AAEO,MAAM,aAAA,GAAgB;AAAA,EAC3B,aAAA,EAAe,2BAAA;AAAA,EACf,kBAAA,EAAoB,mCAAA;AAAA,EACpB,mBAAA,EAAqB,oCAAA;AAAA,EACrB,kBAAA,EAAoB,mCAAA;AAAA,EACpB,gBAAA,EAAkB,iCAAA;AAAA,EAClB,mBAAA,EAAqB,oCAAA;AAAA,EACrB,gBAAA,EAAkB;AACpB;;;;;"}

package/build/cjs/orchestrion/config/remix.js

@@ -0,0 +1,54 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const remixInstrumentationConfig = (dir) => [
+  // `createRequestHandler` returns `async function requestHandler(request, loadContext)` — the main
+  // server span. We target the returned handler (so the span wraps each request, not the one-time
+  // handler construction). It's a *named function expression*, which name-based `functionQuery`
+  // can't match (that only sees declarations), so we select it with `astQuery`; `functionQuery`
+  // then just carries the behaviour (`kind: 'Async'`).
+  {
+    channelName: "requestHandler",
+    module: { name: "@remix-run/server-runtime", versionRange: ">=2.0.0 <3", filePath: `${dir}/server.js` },
+    astQuery: 'FunctionExpression[id.name="requestHandler"]',
+    functionQuery: { kind: "Async" }
+  },
+  // Sync; the subscriber reads its result to set `http.route` on the active request span.
+  {
+    channelName: "matchServerRoutes",
+    module: { name: "@remix-run/server-runtime", versionRange: ">=2.0.0 <3", filePath: `${dir}/routeMatching.js` },
+    functionQuery: { functionName: "matchServerRoutes", kind: "Sync" }
+  },
+  // Remix >= 2.9.0
+  {
+    channelName: "callRouteLoader",
+    module: { name: "@remix-run/server-runtime", versionRange: ">=2.9.0 <3", filePath: `${dir}/data.js` },
+    functionQuery: { functionName: "callRouteLoader", kind: "Async" }
+  },
+  {
+    channelName: "callRouteAction",
+    module: { name: "@remix-run/server-runtime", versionRange: ">=2.9.0 <3", filePath: `${dir}/data.js` },
+    functionQuery: { functionName: "callRouteAction", kind: "Async" }
+  },
+  // Remix 2.0.0 – 2.8.x: the same functions were suffixed `…RR`. Same channels as above.
+  {
+    channelName: "callRouteLoader",
+    module: { name: "@remix-run/server-runtime", versionRange: ">=2.0.0 <2.9.0", filePath: `${dir}/data.js` },
+    functionQuery: { functionName: "callRouteLoaderRR", kind: "Async" }
+  },
+  {
+    channelName: "callRouteAction",
+    module: { name: "@remix-run/server-runtime", versionRange: ">=2.0.0 <2.9.0", filePath: `${dir}/data.js` },
+    functionQuery: { functionName: "callRouteActionRR", kind: "Async" }
+  }
+];
+const remixConfig = ["dist", "dist/esm"].flatMap(remixInstrumentationConfig);
+const remixChannels = {
+  REMIX_REQUEST_HANDLER: "orchestrion:@remix-run/server-runtime:requestHandler",
+  REMIX_MATCH_SERVER_ROUTES: "orchestrion:@remix-run/server-runtime:matchServerRoutes",
+  REMIX_CALL_ROUTE_LOADER: "orchestrion:@remix-run/server-runtime:callRouteLoader",
+  REMIX_CALL_ROUTE_ACTION: "orchestrion:@remix-run/server-runtime:callRouteAction"
+};
+
+exports.remixChannels = remixChannels;
+exports.remixConfig = remixConfig;
+//# sourceMappingURL=remix.js.map

package/build/cjs/orchestrion/config/remix.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remix.js","sources":["../../../../src/orchestrion/config/remix.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\n// Four concepts, one channel each:\n//   - `requestHandler`    → the async handler returned by `createRequestHandler` (the server span)\n//   - `matchServerRoutes` → sync route match; enriches the active span (creates no span of its own)\n//   - `callRouteLoader`   → LOADER span. Remix 2.0–2.8 named it `callRouteLoaderRR`\n//   - `callRouteAction`   → ACTION span. Remix 2.0–2.8 named it `callRouteActionRR`\n//\n// Emitted for both the CJS (`dist/*`) and ESM (`dist/esm/*`) builds, which share function shapes.\nconst remixInstrumentationConfig = (dir: string): InstrumentationConfig[] => [\n  // `createRequestHandler` returns `async function requestHandler(request, loadContext)` — the main\n  // server span. We target the returned handler (so the span wraps each request, not the one-time\n  // handler construction). It's a *named function expression*, which name-based `functionQuery`\n  // can't match (that only sees declarations), so we select it with `astQuery`; `functionQuery`\n  // then just carries the behaviour (`kind: 'Async'`).\n  {\n    channelName: 'requestHandler',\n    module: { name: '@remix-run/server-runtime', versionRange: '>=2.0.0 <3', filePath: `${dir}/server.js` },\n    astQuery: 'FunctionExpression[id.name=\"requestHandler\"]',\n    functionQuery: { kind: 'Async' },\n  },\n  // Sync; the subscriber reads its result to set `http.route` on the active request span.\n  {\n    channelName: 'matchServerRoutes',\n    module: { name: '@remix-run/server-runtime', versionRange: '>=2.0.0 <3', filePath: `${dir}/routeMatching.js` },\n    functionQuery: { functionName: 'matchServerRoutes', kind: 'Sync' },\n  },\n  // Remix >= 2.9.0\n  {\n    channelName: 'callRouteLoader',\n    module: { name: '@remix-run/server-runtime', versionRange: '>=2.9.0 <3', filePath: `${dir}/data.js` },\n    functionQuery: { functionName: 'callRouteLoader', kind: 'Async' },\n  },\n  {\n    channelName: 'callRouteAction',\n    module: { name: '@remix-run/server-runtime', versionRange: '>=2.9.0 <3', filePath: `${dir}/data.js` },\n    functionQuery: { functionName: 'callRouteAction', kind: 'Async' },\n  },\n  // Remix 2.0.0 – 2.8.x: the same functions were suffixed `…RR`. Same channels as above.\n  {\n    channelName: 'callRouteLoader',\n    module: { name: '@remix-run/server-runtime', versionRange: '>=2.0.0 <2.9.0', filePath: `${dir}/data.js` },\n    functionQuery: { functionName: 'callRouteLoaderRR', kind: 'Async' },\n  },\n  {\n    channelName: 'callRouteAction',\n    module: { name: '@remix-run/server-runtime', versionRange: '>=2.0.0 <2.9.0', filePath: `${dir}/data.js` },\n    functionQuery: { functionName: 'callRouteActionRR', kind: 'Async' },\n  },\n];\n\nexport const remixConfig = ['dist', 'dist/esm'].flatMap(remixInstrumentationConfig);\n\nexport const remixChannels = {\n  REMIX_REQUEST_HANDLER: 'orchestrion:@remix-run/server-runtime:requestHandler',\n  REMIX_MATCH_SERVER_ROUTES: 'orchestrion:@remix-run/server-runtime:matchServerRoutes',\n  REMIX_CALL_ROUTE_LOADER: 'orchestrion:@remix-run/server-runtime:callRouteLoader',\n  REMIX_CALL_ROUTE_ACTION: 'orchestrion:@remix-run/server-runtime:callRouteAction',\n} as const;\n"],"names":[],"mappings":";;AASA,MAAM,0BAAA,GAA6B,CAAC,GAAA,KAAyC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAM3E;AAAA,IACE,WAAA,EAAa,gBAAA;AAAA,IACb,MAAA,EAAQ,EAAE,IAAA,EAAM,2BAAA,EAA6B,cAAc,YAAA,EAAc,QAAA,EAAU,CAAA,EAAG,GAAG,CAAA,UAAA,CAAA,EAAa;AAAA,IACtG,QAAA,EAAU,8CAAA;AAAA,IACV,aAAA,EAAe,EAAE,IAAA,EAAM,OAAA;AAAQ,GACjC;AAAA;AAAA,EAEA;AAAA,IACE,WAAA,EAAa,mBAAA;AAAA,IACb,MAAA,EAAQ,EAAE,IAAA,EAAM,2BAAA,EAA6B,cAAc,YAAA,EAAc,QAAA,EAAU,CAAA,EAAG,GAAG,CAAA,iBAAA,CAAA,EAAoB;AAAA,IAC7G,aAAA,EAAe,EAAE,YAAA,EAAc,mBAAA,EAAqB,MAAM,MAAA;AAAO,GACnE;AAAA;AAAA,EAEA;AAAA,IACE,WAAA,EAAa,iBAAA;AAAA,IACb,MAAA,EAAQ,EAAE,IAAA,EAAM,2BAAA,EAA6B,cAAc,YAAA,EAAc,QAAA,EAAU,CAAA,EAAG,GAAG,CAAA,QAAA,CAAA,EAAW;AAAA,IACpG,aAAA,EAAe,EAAE,YAAA,EAAc,iBAAA,EAAmB,MAAM,OAAA;AAAQ,GAClE;AAAA,EACA;AAAA,IACE,WAAA,EAAa,iBAAA;AAAA,IACb,MAAA,EAAQ,EAAE,IAAA,EAAM,2BAAA,EAA6B,cAAc,YAAA,EAAc,QAAA,EAAU,CAAA,EAAG,GAAG,CAAA,QAAA,CAAA,EAAW;AAAA,IACpG,aAAA,EAAe,EAAE,YAAA,EAAc,iBAAA,EAAmB,MAAM,OAAA;AAAQ,GAClE;AAAA;AAAA,EAEA;AAAA,IACE,WAAA,EAAa,iBAAA;AAAA,IACb,MAAA,EAAQ,EAAE,IAAA,EAAM,2BAAA,EAA6B,cAAc,gBAAA,EAAkB,QAAA,EAAU,CAAA,EAAG,GAAG,CAAA,QAAA,CAAA,EAAW;AAAA,IACxG,aAAA,EAAe,EAAE,YAAA,EAAc,mBAAA,EAAqB,MAAM,OAAA;AAAQ,GACpE;AAAA,EACA;AAAA,IACE,WAAA,EAAa,iBAAA;AAAA,IACb,MAAA,EAAQ,EAAE,IAAA,EAAM,2BAAA,EAA6B,cAAc,gBAAA,EAAkB,QAAA,EAAU,CAAA,EAAG,GAAG,CAAA,QAAA,CAAA,EAAW;AAAA,IACxG,aAAA,EAAe,EAAE,YAAA,EAAc,mBAAA,EAAqB,MAAM,OAAA;AAAQ;AAEtE,CAAA;AAEO,MAAM,cAAc,CAAC,MAAA,EAAQ,UAAU,CAAA,CAAE,QAAQ,0BAA0B;AAE3E,MAAM,aAAA,GAAgB;AAAA,EAC3B,qBAAA,EAAuB,sDAAA;AAAA,EACvB,yBAAA,EAA2B,yDAAA;AAAA,EAC3B,uBAAA,EAAyB,uDAAA;AAAA,EACzB,uBAAA,EAAyB;AAC3B;;;;;"}

package/build/cjs/orchestrion/config/tedious.js

@@ -0,0 +1,24 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const MODULE_NAME = "tedious";
+const FILE_PATH = "lib/connection.js";
+const VERSION_RANGE = ">=1.11.0 <20";
+const METHODS = ["connect", "execSql", "execSqlBatch", "callProcedure", "execBulkLoad", "prepare", "execute"];
+const tediousConfig = METHODS.map((methodName) => ({
+  channelName: methodName,
+  module: { name: MODULE_NAME, versionRange: VERSION_RANGE, filePath: FILE_PATH },
+  functionQuery: { className: "Connection", methodName, kind: "Sync" }
+}));
+const tediousChannels = {
+  TEDIOUS_CONNECT: "orchestrion:tedious:connect",
+  TEDIOUS_EXEC_SQL: "orchestrion:tedious:execSql",
+  TEDIOUS_EXEC_SQL_BATCH: "orchestrion:tedious:execSqlBatch",
+  TEDIOUS_CALL_PROCEDURE: "orchestrion:tedious:callProcedure",
+  TEDIOUS_EXEC_BULK_LOAD: "orchestrion:tedious:execBulkLoad",
+  TEDIOUS_PREPARE: "orchestrion:tedious:prepare",
+  TEDIOUS_EXECUTE: "orchestrion:tedious:execute"
+};
+
+exports.tediousChannels = tediousChannels;
+exports.tediousConfig = tediousConfig;
+//# sourceMappingURL=tedious.js.map

package/build/cjs/orchestrion/config/tedious.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tedious.js","sources":["../../../../src/orchestrion/config/tedious.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\nconst MODULE_NAME = 'tedious';\n\n// `Connection` has lived in `lib/connection.js` across the whole supported range (matches the vendored\n// OTel `supportedVersions`). Orchestrion never matches a file that doesn't exist, so a single entry is\n// safe even for versions that shipped extra layouts.\nconst FILE_PATH = 'lib/connection.js';\nconst VERSION_RANGE = '>=1.11.0 <20';\n\n// `Connection` methods that dispatch a request (each traced as one db span) plus `connect`, which the\n// subscriber wraps for bookkeeping only (tracking the connection's active database, read into `db.name`).\n// All return synchronously; the request completes later via its callback/events, so the subscriber owns\n// span-ending rather than the channel lifecycle.\nconst METHODS = ['connect', 'execSql', 'execSqlBatch', 'callProcedure', 'execBulkLoad', 'prepare', 'execute'] as const;\n\nexport const tediousConfig: InstrumentationConfig[] = METHODS.map(methodName => ({\n  channelName: methodName,\n  module: { name: MODULE_NAME, versionRange: VERSION_RANGE, filePath: FILE_PATH },\n  functionQuery: { className: 'Connection', methodName, kind: 'Sync' },\n}));\n\nexport const tediousChannels = {\n  TEDIOUS_CONNECT: 'orchestrion:tedious:connect',\n  TEDIOUS_EXEC_SQL: 'orchestrion:tedious:execSql',\n  TEDIOUS_EXEC_SQL_BATCH: 'orchestrion:tedious:execSqlBatch',\n  TEDIOUS_CALL_PROCEDURE: 'orchestrion:tedious:callProcedure',\n  TEDIOUS_EXEC_BULK_LOAD: 'orchestrion:tedious:execBulkLoad',\n  TEDIOUS_PREPARE: 'orchestrion:tedious:prepare',\n  TEDIOUS_EXECUTE: 'orchestrion:tedious:execute',\n} as const;\n"],"names":[],"mappings":";;AAEA,MAAM,WAAA,GAAc,SAAA;AAKpB,MAAM,SAAA,GAAY,mBAAA;AAClB,MAAM,aAAA,GAAgB,cAAA;AAMtB,MAAM,OAAA,GAAU,CAAC,SAAA,EAAW,SAAA,EAAW,gBAAgB,eAAA,EAAiB,cAAA,EAAgB,WAAW,SAAS,CAAA;AAErG,MAAM,aAAA,GAAyC,OAAA,CAAQ,GAAA,CAAI,CAAA,UAAA,MAAe;AAAA,EAC/E,WAAA,EAAa,UAAA;AAAA,EACb,QAAQ,EAAE,IAAA,EAAM,aAAa,YAAA,EAAc,aAAA,EAAe,UAAU,SAAA,EAAU;AAAA,EAC9E,eAAe,EAAE,SAAA,EAAW,YAAA,EAAc,UAAA,EAAY,MAAM,MAAA;AAC9D,CAAA,CAAE;AAEK,MAAM,eAAA,GAAkB;AAAA,EAC7B,eAAA,EAAiB,6BAAA;AAAA,EACjB,gBAAA,EAAkB,6BAAA;AAAA,EAClB,sBAAA,EAAwB,kCAAA;AAAA,EACxB,sBAAA,EAAwB,mCAAA;AAAA,EACxB,sBAAA,EAAwB,kCAAA;AAAA,EACxB,eAAA,EAAiB,6BAAA;AAAA,EACjB,eAAA,EAAiB;AACnB;;;;;"}

package/build/cjs/orchestrion/config/vercel-ai.js

@@ -0,0 +1,48 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const vercelAiConfig = [
+  // Vercel AI v6: mirror the v7 native `ai:telemetry` channel by injecting
+  // channels into the top-level entry points. `resolveLanguageModel` is wrapped
+  // not to span it, but so the subscriber can monkey-patch `doGenerate`/
+  // `doStream` on the returned model (the only way to span the model call,
+  // which is an inline call with no injectable definition in `ai`).
+  // `streamText` returns its result synchronously (streaming is lazy), so it's
+  // `Sync`; the subscriber binds the span via `bindTracingChannelToSpan`, which
+  // ends it when the (synchronous) call returns.
+  // The majority of entrypoints are present in all versions we support
+  ...vercelAiEntries(">=4.0.0 <7.0.0", "generateText", "generateText", "Async"),
+  ...vercelAiEntries(">=4.0.0 <7.0.0", "streamText", "streamText", "Sync"),
+  ...vercelAiEntries(">=4.0.0 <7.0.0", "generateObject", "generateObject", "Async"),
+  ...vercelAiEntries(">=4.0.0 <7.0.0", "embed", "embed", "Async"),
+  ...vercelAiEntries(">=4.0.0 <7.0.0", "embedMany", "embedMany", "Async"),
+  // The following entry is only present in v5 and later
+  ...vercelAiEntries(">=5.0.0 <7.0.0", "resolveLanguageModel", "resolveLanguageModel", "Sync"),
+  // The following entry is only present in v6 and later
+  ...vercelAiEntries(">=6.0.0 <7.0.0", "executeToolCall", "executeToolCall", "Async")
+];
+const vercelAiChannels = {
+  // Vercel AI (`ai`): orchestrion injects these so the same channel-based
+  // integration that consumes `ai`'s native `ai:telemetry` channel (v7) can
+  // also instrument v4/v5/v6. Each maps to a top-level function in `ai`'s bundle.
+  // All three versions share the same channel names (the subscriber is version-agnostic);
+  // `VERCEL_AI_EXECUTE_TOOL_CALL` is v6-only (v4/v5 have no `executeToolCall` export) and
+  // `VERCEL_AI_RESOLVE_LANGUAGE_MODEL` is v5/v6-only (v4 has no such chokepoint).
+  VERCEL_AI_GENERATE_TEXT: "orchestrion:ai:generateText",
+  VERCEL_AI_STREAM_TEXT: "orchestrion:ai:streamText",
+  VERCEL_AI_GENERATE_OBJECT: "orchestrion:ai:generateObject",
+  VERCEL_AI_EMBED: "orchestrion:ai:embed",
+  VERCEL_AI_EMBED_MANY: "orchestrion:ai:embedMany",
+  VERCEL_AI_EXECUTE_TOOL_CALL: "orchestrion:ai:executeToolCall",
+  VERCEL_AI_RESOLVE_LANGUAGE_MODEL: "orchestrion:ai:resolveLanguageModel"
+};
+function vercelAiEntries(versionRange, channelName, functionName, kind) {
+  return ["dist/index.js", "dist/index.mjs"].map((filePath) => ({
+    channelName,
+    module: { name: "ai", versionRange, filePath },
+    functionQuery: { functionName, kind }
+  }));
+}
+
+exports.vercelAiChannels = vercelAiChannels;
+exports.vercelAiConfig = vercelAiConfig;
+//# sourceMappingURL=vercel-ai.js.map

package/build/cjs/orchestrion/config/vercel-ai.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vercel-ai.js","sources":["../../../../src/orchestrion/config/vercel-ai.ts"],"sourcesContent":["import type { InstrumentationConfig } from '..';\n\nexport const vercelAiConfig = [\n  // Vercel AI v6: mirror the v7 native `ai:telemetry` channel by injecting\n  // channels into the top-level entry points. `resolveLanguageModel` is wrapped\n  // not to span it, but so the subscriber can monkey-patch `doGenerate`/\n  // `doStream` on the returned model (the only way to span the model call,\n  // which is an inline call with no injectable definition in `ai`).\n  // `streamText` returns its result synchronously (streaming is lazy), so it's\n  // `Sync`; the subscriber binds the span via `bindTracingChannelToSpan`, which\n  // ends it when the (synchronous) call returns.\n\n  // The majority of entrypoints are present in all versions we support\n  ...vercelAiEntries('>=4.0.0 <7.0.0', 'generateText', 'generateText', 'Async'),\n  ...vercelAiEntries('>=4.0.0 <7.0.0', 'streamText', 'streamText', 'Sync'),\n  ...vercelAiEntries('>=4.0.0 <7.0.0', 'generateObject', 'generateObject', 'Async'),\n  ...vercelAiEntries('>=4.0.0 <7.0.0', 'embed', 'embed', 'Async'),\n  ...vercelAiEntries('>=4.0.0 <7.0.0', 'embedMany', 'embedMany', 'Async'),\n\n  // The following entry is only present in v5 and later\n  ...vercelAiEntries('>=5.0.0 <7.0.0', 'resolveLanguageModel', 'resolveLanguageModel', 'Sync'),\n\n  // The following entry is only present in v6 and later\n  ...vercelAiEntries('>=6.0.0 <7.0.0', 'executeToolCall', 'executeToolCall', 'Async'),\n] satisfies InstrumentationConfig[];\n\nexport const vercelAiChannels = {\n  // Vercel AI (`ai`): orchestrion injects these so the same channel-based\n  // integration that consumes `ai`'s native `ai:telemetry` channel (v7) can\n  // also instrument v4/v5/v6. Each maps to a top-level function in `ai`'s bundle.\n  // All three versions share the same channel names (the subscriber is version-agnostic);\n  // `VERCEL_AI_EXECUTE_TOOL_CALL` is v6-only (v4/v5 have no `executeToolCall` export) and\n  // `VERCEL_AI_RESOLVE_LANGUAGE_MODEL` is v5/v6-only (v4 has no such chokepoint).\n  VERCEL_AI_GENERATE_TEXT: 'orchestrion:ai:generateText',\n  VERCEL_AI_STREAM_TEXT: 'orchestrion:ai:streamText',\n  VERCEL_AI_GENERATE_OBJECT: 'orchestrion:ai:generateObject',\n  VERCEL_AI_EMBED: 'orchestrion:ai:embed',\n  VERCEL_AI_EMBED_MANY: 'orchestrion:ai:embedMany',\n  VERCEL_AI_EXECUTE_TOOL_CALL: 'orchestrion:ai:executeToolCall',\n  VERCEL_AI_RESOLVE_LANGUAGE_MODEL: 'orchestrion:ai:resolveLanguageModel',\n} as const;\n\n/**\n * The central list of channel injections orchestrion should perform.\n *\n * This module has NO side effects — it's the only thing both the runtime hook\n * (`runtime/import-hook.mjs`) and the bundler plugins (`bundler/vite.ts`, …)\n * import from. Adding a new instrumented method is one entry here plus one\n * subscriber in `integrations/<lib>/tracing-channel.ts`.\n *\n * `channelName` here is the unprefixed suffix; the actual diagnostics_channel\n * name is `orchestrion:${module.name}:${channelName}` (see `channels.ts`).\n */\n/**\n * `ai` ships a single bundled entry per module system, so each instrumented\n * function needs one config entry per file (the app loads whichever matches its\n * module system). This expands a single target into both.\n */\nfunction vercelAiEntries(\n  versionRange: string,\n  channelName: string,\n  functionName: string,\n  kind: 'Async' | 'Sync',\n): InstrumentationConfig[] {\n  return ['dist/index.js', 'dist/index.mjs'].map(filePath => ({\n    channelName,\n    module: { name: 'ai', versionRange, filePath },\n    functionQuery: { functionName, kind },\n  }));\n}\n"],"names":[],"mappings":";;AAEO,MAAM,cAAA,GAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAW5B,GAAG,eAAA,CAAgB,gBAAA,EAAkB,cAAA,EAAgB,gBAAgB,OAAO,CAAA;AAAA,EAC5E,GAAG,eAAA,CAAgB,gBAAA,EAAkB,YAAA,EAAc,cAAc,MAAM,CAAA;AAAA,EACvE,GAAG,eAAA,CAAgB,gBAAA,EAAkB,gBAAA,EAAkB,kBAAkB,OAAO,CAAA;AAAA,EAChF,GAAG,eAAA,CAAgB,gBAAA,EAAkB,OAAA,EAAS,SAAS,OAAO,CAAA;AAAA,EAC9D,GAAG,eAAA,CAAgB,gBAAA,EAAkB,WAAA,EAAa,aAAa,OAAO,CAAA;AAAA;AAAA,EAGtE,GAAG,eAAA,CAAgB,gBAAA,EAAkB,sBAAA,EAAwB,wBAAwB,MAAM,CAAA;AAAA;AAAA,EAG3F,GAAG,eAAA,CAAgB,gBAAA,EAAkB,iBAAA,EAAmB,mBAAmB,OAAO;AACpF;AAEO,MAAM,gBAAA,GAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAO9B,uBAAA,EAAyB,6BAAA;AAAA,EACzB,qBAAA,EAAuB,2BAAA;AAAA,EACvB,yBAAA,EAA2B,+BAAA;AAAA,EAC3B,eAAA,EAAiB,sBAAA;AAAA,EACjB,oBAAA,EAAsB,0BAAA;AAAA,EACtB,2BAAA,EAA6B,gCAAA;AAAA,EAC7B,gCAAA,EAAkC;AACpC;AAkBA,SAAS,eAAA,CACP,YAAA,EACA,WAAA,EACA,YAAA,EACA,IAAA,EACyB;AACzB,EAAA,OAAO,CAAC,eAAA,EAAiB,gBAAgB,CAAA,CAAE,IAAI,CAAA,QAAA,MAAa;AAAA,IAC1D,WAAA;AAAA,IACA,MAAA,EAAQ,EAAE,IAAA,EAAM,IAAA,EAAM,cAAc,QAAA,EAAS;AAAA,IAC7C,aAAA,EAAe,EAAE,YAAA,EAAc,IAAA;AAAK,GACtC,CAAE,CAAA;AACJ;;;;;"}

package/build/cjs/orchestrion/detect.js

@@ -0,0 +1,26 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+
+function isOrchestrionInjected() {
+  return !!core.GLOBAL_OBJ.__SENTRY_ORCHESTRION__;
+}
+function detectOrchestrionSetup() {
+  const { runtime, bundler } = core.GLOBAL_OBJ.__SENTRY_ORCHESTRION__ ?? {};
+  if (!runtime && !bundler) {
+    core.debug.warn(
+      "[Sentry] No diagnostics-channel injection detected. Channel-based integrations will not record spans. Make sure the diagnostics channels are injected via the runtime `--import` hook or a bundler plugin before the instrumented modules load."
+    );
+    return;
+  }
+  core.debug.log(
+    runtime ? `[Sentry] Runtime hook registered, injected libraries=${JSON.stringify(runtime)}` : "[Sentry] Runtime hook not registered"
+  );
+  core.debug.log(
+    bundler ? `[Sentry] Bundler plugin ran, injected libraries=${JSON.stringify(bundler)}` : "[Sentry] Bundler plugin did not run"
+  );
+}
+
+exports.detectOrchestrionSetup = detectOrchestrionSetup;
+exports.isOrchestrionInjected = isOrchestrionInjected;
+//# sourceMappingURL=detect.js.map

package/build/cjs/orchestrion/detect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.js","sources":["../../../src/orchestrion/detect.ts"],"sourcesContent":["import { debug, GLOBAL_OBJ } from '@sentry/core';\n\n/**\n * Whether orchestrion has injected the diagnostics channels into this process,\n * either by the runtime `--import` hook / init-time registration (`runtime`)\n * or a bundler plugin (`bundler`). Both injectors set a flag on the\n * `globalThis.__SENTRY_ORCHESTRION__` marker.\n *\n * Use this to avoid wiring up channel-subscriber integrations when nothing\n * will ever publish to those channels.\n */\nexport function isOrchestrionInjected(): boolean {\n  return !!GLOBAL_OBJ.__SENTRY_ORCHESTRION__;\n}\n\n/**\n * Verifies that the diagnostics channels have been injected either by the\n * runtime `--import` hook (or init-time registration), a bundler plugin, or\n * both, and warns if not. When at least one injector is active, logs for each\n * mechanism whether it hooked (a defined array, even empty, means it did) and\n * which libraries it injected.\n *\n * Both injectors being active at once is fine: they operate on disjoint module\n * sets (a module is either loaded through Node's loader and transformed by the\n * runtime hook, or inlined by the bundler and transformed by the plugin), so\n * a single module can't be double-wrapped. A hybrid setup, with some deps\n * external and runtime-instrumented, others bundled and plugin-instrumented,\n * is fine.\n */\nexport function detectOrchestrionSetup(): void {\n  const { runtime, bundler } = GLOBAL_OBJ.__SENTRY_ORCHESTRION__ ?? {};\n\n  if (!runtime && !bundler) {\n    debug.warn(\n      '[Sentry] No diagnostics-channel injection detected. Channel-based integrations ' +\n        'will not record spans. Make sure the diagnostics channels are injected ' +\n        'via the runtime `--import` hook or a bundler plugin before the instrumented modules load.',\n    );\n    return;\n  }\n\n  debug.log(\n    runtime\n      ? `[Sentry] Runtime hook registered, injected libraries=${JSON.stringify(runtime)}`\n      : '[Sentry] Runtime hook not registered',\n  );\n  debug.log(\n    bundler\n      ? `[Sentry] Bundler plugin ran, injected libraries=${JSON.stringify(bundler)}`\n      : '[Sentry] Bundler plugin did not run',\n  );\n}\n"],"names":["GLOBAL_OBJ","debug"],"mappings":";;;;AAWO,SAAS,qBAAA,GAAiC;AAC/C,EAAA,OAAO,CAAC,CAACA,eAAA,CAAW,sBAAA;AACtB;AAgBO,SAAS,sBAAA,GAA+B;AAC7C,EAAA,MAAM,EAAE,OAAA,EAAS,OAAA,EAAQ,GAAIA,eAAA,CAAW,0BAA0B,EAAC;AAEnE,EAAA,IAAI,CAAC,OAAA,IAAW,CAAC,OAAA,EAAS;AACxB,IAAAC,UAAA,CAAM,IAAA;AAAA,MACJ;AAAA,KAGF;AACA,IAAA;AAAA,EACF;AAEA,EAAAA,UAAA,CAAM,GAAA;AAAA,IACJ,UACI,CAAA,qDAAA,EAAwD,IAAA,CAAK,SAAA,CAAU,OAAO,CAAC,CAAA,CAAA,GAC/E;AAAA,GACN;AACA,EAAAA,UAAA,CAAM,GAAA;AAAA,IACJ,UACI,CAAA,gDAAA,EAAmD,IAAA,CAAK,SAAA,CAAU,OAAO,CAAC,CAAA,CAAA,GAC1E;AAAA,GACN;AACF;;;;;"}

package/build/cjs/orchestrion/index.js

@@ -0,0 +1,89 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const amqplib = require('../integrations/tracing-channel/amqplib.js');
+const anthropic = require('../integrations/tracing-channel/anthropic.js');
+const index = require('../integrations/tracing-channel/aws-sdk/index.js');
+const dataloader = require('../integrations/tracing-channel/dataloader.js');
+const genericPool = require('../integrations/tracing-channel/generic-pool.js');
+const googleGenai = require('../integrations/tracing-channel/google-genai.js');
+const index$2 = require('../integrations/tracing-channel/graphql/index.js');
+const hapi = require('../integrations/tracing-channel/hapi.js');
+const koa = require('../integrations/tracing-channel/koa.js');
+const ioredis = require('../integrations/tracing-channel/ioredis.js');
+const index$3 = require('../integrations/tracing-channel/kafkajs/index.js');
+const knex = require('../integrations/tracing-channel/knex.js');
+const langchain = require('../integrations/tracing-channel/langchain.js');
+const langgraph = require('../integrations/tracing-channel/langgraph.js');
+const lruMemoizer = require('../integrations/tracing-channel/lru-memoizer.js');
+const mongodb = require('../integrations/tracing-channel/mongodb.js');
+const mongoose = require('../integrations/tracing-channel/mongoose.js');
+const mysql = require('../integrations/tracing-channel/mysql.js');
+const mysql2 = require('../integrations/tracing-channel/mysql2.js');
+const openai = require('../integrations/tracing-channel/openai.js');
+const postgres = require('../integrations/tracing-channel/postgres.js');
+const postgresJs = require('../integrations/tracing-channel/postgres-js.js');
+const tedious = require('../integrations/tracing-channel/tedious.js');
+const vercelAi = require('../integrations/tracing-channel/vercel-ai.js');
+const index$1 = require('../integrations/tracing-channel/express/index.js');
+const detect = require('./detect.js');
+const nestjs = require('./config/nestjs.js');
+const remix = require('./config/remix.js');
+const redis = require('../integrations/tracing-channel/redis.js');
+
+const channelIntegrations = {
+  postgresIntegration: postgres.postgresChannelIntegration,
+  postgresJsIntegration: postgresJs.postgresJsChannelIntegration,
+  mongoIntegration: mongodb.mongodbChannelIntegration,
+  mysqlIntegration: mysql.mysqlChannelIntegration,
+  mysql2Integration: mysql2.mysql2ChannelIntegration,
+  genericPoolIntegration: genericPool.genericPoolChannelIntegration,
+  mongooseIntegration: mongoose.mongooseChannelIntegration,
+  lruMemoizerIntegration: lruMemoizer.lruMemoizerChannelIntegration,
+  openaiIntegration: openai.openaiChannelIntegration,
+  anthropicIntegration: anthropic.anthropicChannelIntegration,
+  googleGenAIIntegration: googleGenai.googleGenAIChannelIntegration,
+  langChainIntegration: langchain.langChainChannelIntegration,
+  langGraphIntegration: langgraph.langGraphChannelIntegration,
+  vercelAiIntegration: vercelAi.vercelAiChannelIntegration,
+  amqplibIntegration: amqplib.amqplibChannelIntegration,
+  hapiIntegration: hapi.hapiChannelIntegration,
+  koaIntegration: koa.koaChannelIntegration,
+  expressIntegration: index$1.expressChannelIntegration,
+  graphqlIntegration: index$2.graphqlDiagnosticsChannelIntegration,
+  kafkajsIntegration: index$3.kafkajsChannelIntegration,
+  tediousIntegration: tedious.tediousChannelIntegration,
+  awsIntegration: index.awsChannelIntegration
+};
+
+exports.amqplibChannelIntegration = amqplib.amqplibChannelIntegration;
+exports.anthropicChannelIntegration = anthropic.anthropicChannelIntegration;
+exports.awsChannelIntegration = index.awsChannelIntegration;
+exports.dataloaderChannelIntegration = dataloader.dataloaderChannelIntegration;
+exports.genericPoolChannelIntegration = genericPool.genericPoolChannelIntegration;
+exports.googleGenAIChannelIntegration = googleGenai.googleGenAIChannelIntegration;
+exports.graphqlChannelIntegration = index$2.graphqlChannelIntegration;
+exports.hapiChannelIntegration = hapi.hapiChannelIntegration;
+exports.koaChannelIntegration = koa.koaChannelIntegration;
+exports.ioredisChannelIntegration = ioredis.ioredisChannelIntegration;
+exports.kafkajsChannelIntegration = index$3.kafkajsChannelIntegration;
+exports.knexChannelIntegration = knex.knexChannelIntegration;
+exports.langChainChannelIntegration = langchain.langChainChannelIntegration;
+exports.langGraphChannelIntegration = langgraph.langGraphChannelIntegration;
+exports.lruMemoizerChannelIntegration = lruMemoizer.lruMemoizerChannelIntegration;
+exports.mongodbChannelIntegration = mongodb.mongodbChannelIntegration;
+exports.mongooseChannelIntegration = mongoose.mongooseChannelIntegration;
+exports.mysqlChannelIntegration = mysql.mysqlChannelIntegration;
+exports.mysql2ChannelIntegration = mysql2.mysql2ChannelIntegration;
+exports.openaiChannelIntegration = openai.openaiChannelIntegration;
+exports.postgresChannelIntegration = postgres.postgresChannelIntegration;
+exports.postgresJsChannelIntegration = postgresJs.postgresJsChannelIntegration;
+exports.tediousChannelIntegration = tedious.tediousChannelIntegration;
+exports.vercelAiChannelIntegration = vercelAi.vercelAiChannelIntegration;
+exports.expressChannelIntegration = index$1.expressChannelIntegration;
+exports.detectOrchestrionSetup = detect.detectOrchestrionSetup;
+exports.isOrchestrionInjected = detect.isOrchestrionInjected;
+exports.nestjsChannels = nestjs.nestjsChannels;
+exports.remixChannels = remix.remixChannels;
+exports.redisChannelIntegration = redis.redisChannelIntegration;
+exports.channelIntegrations = channelIntegrations;
+//# sourceMappingURL=index.js.map

package/build/cjs/orchestrion/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../src/orchestrion/index.ts"],"sourcesContent":["import { amqplibChannelIntegration } from '../integrations/tracing-channel/amqplib';\nimport { anthropicChannelIntegration } from '../integrations/tracing-channel/anthropic';\nimport { awsChannelIntegration } from '../integrations/tracing-channel/aws-sdk';\nimport { dataloaderChannelIntegration } from '../integrations/tracing-channel/dataloader';\nimport { genericPoolChannelIntegration } from '../integrations/tracing-channel/generic-pool';\nimport { googleGenAIChannelIntegration } from '../integrations/tracing-channel/google-genai';\nimport {\n  graphqlChannelIntegration,\n  graphqlDiagnosticsChannelIntegration,\n} from '../integrations/tracing-channel/graphql';\nimport { hapiChannelIntegration } from '../integrations/tracing-channel/hapi';\nimport { koaChannelIntegration } from '../integrations/tracing-channel/koa';\nimport { ioredisChannelIntegration } from '../integrations/tracing-channel/ioredis';\nimport { kafkajsChannelIntegration } from '../integrations/tracing-channel/kafkajs';\nimport { knexChannelIntegration } from '../integrations/tracing-channel/knex';\nimport { langChainChannelIntegration } from '../integrations/tracing-channel/langchain';\nimport { langGraphChannelIntegration } from '../integrations/tracing-channel/langgraph';\nimport { lruMemoizerChannelIntegration } from '../integrations/tracing-channel/lru-memoizer';\nimport { mongodbChannelIntegration } from '../integrations/tracing-channel/mongodb';\nimport { mongooseChannelIntegration } from '../integrations/tracing-channel/mongoose';\nimport { mysqlChannelIntegration } from '../integrations/tracing-channel/mysql';\nimport { mysql2ChannelIntegration } from '../integrations/tracing-channel/mysql2';\nimport { openaiChannelIntegration } from '../integrations/tracing-channel/openai';\nimport { postgresChannelIntegration } from '../integrations/tracing-channel/postgres';\nimport { postgresJsChannelIntegration } from '../integrations/tracing-channel/postgres-js';\nimport { tediousChannelIntegration } from '../integrations/tracing-channel/tedious';\nimport { vercelAiChannelIntegration } from '../integrations/tracing-channel/vercel-ai';\nimport { expressChannelIntegration } from '../integrations/tracing-channel/express';\n\nexport { detectOrchestrionSetup, isOrchestrionInjected } from './detect';\n// The `@nestjs/*` channel names live here alongside their transform config; the\n// listener that subscribes to them lives in `@sentry/nestjs`, which imports this.\nexport { nestjsChannels } from './config/nestjs';\n// The remix channel names live here alongside their transform config; the\n// listener that subscribes to them lives in `@sentry/remix`, which imports this.\nexport { remixChannels } from './config/remix';\nexport {\n  amqplibChannelIntegration,\n  anthropicChannelIntegration,\n  awsChannelIntegration,\n  dataloaderChannelIntegration,\n  genericPoolChannelIntegration,\n  googleGenAIChannelIntegration,\n  graphqlChannelIntegration,\n  hapiChannelIntegration,\n  koaChannelIntegration,\n  ioredisChannelIntegration,\n  kafkajsChannelIntegration,\n  knexChannelIntegration,\n  langChainChannelIntegration,\n  langGraphChannelIntegration,\n  lruMemoizerChannelIntegration,\n  mongodbChannelIntegration,\n  mongooseChannelIntegration,\n  mysqlChannelIntegration,\n  mysql2ChannelIntegration,\n  openaiChannelIntegration,\n  postgresChannelIntegration,\n  postgresJsChannelIntegration,\n  tediousChannelIntegration,\n  vercelAiChannelIntegration,\n  expressChannelIntegration,\n};\nexport type { KoaChannelIntegrationOptions } from '../integrations/tracing-channel/koa';\nexport type { IORedisChannelIntegrationOptions, IORedisResponseHook } from '../integrations/tracing-channel/ioredis';\nexport type { PostgresJsChannelIntegrationOptions } from '../integrations/tracing-channel/postgres-js';\nexport { redisChannelIntegration } from '../integrations/tracing-channel/redis';\nexport type { RedisChannelIntegrationOptions, RedisResponseHook } from '../integrations/tracing-channel/redis';\nexport type { InstrumentationConfig, CustomTransform } from '@apm-js-collab/code-transformer-bundler-plugins/core';\n\n// The structural `graphql` package types are the single source of truth shared with `@sentry/node`'s\n// vendored OTel graphql instrumentation (re-exported from here so the two can't drift).\nexport type * from '../integrations/tracing-channel/graphql/graphql-types';\n\n/**\n * The canonical set of orchestrion diagnostics-channel integrations, keyed by their public\n * (OTel-parity) factory name.\n *\n * Single source of truth: add a new channel integration here and every consumer — the `@sentry/node`\n * opt-in helper (`experimentalUseDiagnosticsChannelInjection`) and its public\n * `diagnosticsChannelInjectionIntegrations()` map — picks it up automatically, so there's no separate\n * list to keep in sync.\n *\n * NOTE: `ioredisChannelIntegration` and `redisChannelIntegration` are intentionally NOT here. They\n * only partially replace the composite OTel `Redis` integration and need the node SDK's redis cache\n * `responseHook` (which can't live in `server-utils`), so `@sentry/node` wires them up separately.\n *\n * Framework SDKs that own their own channel listener (e.g. `@sentry/nestjs`'s `Nest`) are NOT here\n * either: their transform config is still in `SENTRY_INSTRUMENTATIONS`, but the listener lives in\n * their package and picks the channel-vs-OTel path itself at `setupOnce`, so it needs no central swap.\n *\n * NOTE: `dataloaderChannelIntegration` is also NOT here. Everything in this map is auto-appended to\n * the default integrations, but the OTel `Dataloader` integration is opt-in (never a default). Like\n * `@sentry/nestjs`'s `Nest`, its `@sentry/node` factory picks the channel-vs-OTel path itself at\n * `setupOnce` (via `isOrchestrionInjected()`), so there's nothing for the central swap to do.\n */\nexport const channelIntegrations = {\n  postgresIntegration: postgresChannelIntegration,\n  postgresJsIntegration: postgresJsChannelIntegration,\n  mongoIntegration: mongodbChannelIntegration,\n  mysqlIntegration: mysqlChannelIntegration,\n  mysql2Integration: mysql2ChannelIntegration,\n  genericPoolIntegration: genericPoolChannelIntegration,\n  mongooseIntegration: mongooseChannelIntegration,\n  lruMemoizerIntegration: lruMemoizerChannelIntegration,\n  openaiIntegration: openaiChannelIntegration,\n  anthropicIntegration: anthropicChannelIntegration,\n  googleGenAIIntegration: googleGenAIChannelIntegration,\n  langChainIntegration: langChainChannelIntegration,\n  langGraphIntegration: langGraphChannelIntegration,\n  vercelAiIntegration: vercelAiChannelIntegration,\n  amqplibIntegration: amqplibChannelIntegration,\n  hapiIntegration: hapiChannelIntegration,\n  koaIntegration: koaChannelIntegration,\n  expressIntegration: expressChannelIntegration,\n  graphqlIntegration: graphqlDiagnosticsChannelIntegration,\n  kafkajsIntegration: kafkajsChannelIntegration,\n  tediousIntegration: tediousChannelIntegration,\n  awsIntegration: awsChannelIntegration,\n} as const;\n"],"names":["postgresChannelIntegration","postgresJsChannelIntegration","mongodbChannelIntegration","mysqlChannelIntegration","mysql2ChannelIntegration","genericPoolChannelIntegration","mongooseChannelIntegration","lruMemoizerChannelIntegration","openaiChannelIntegration","anthropicChannelIntegration","googleGenAIChannelIntegration","langChainChannelIntegration","langGraphChannelIntegration","vercelAiChannelIntegration","amqplibChannelIntegration","hapiChannelIntegration","koaChannelIntegration","expressChannelIntegration","graphqlDiagnosticsChannelIntegration","kafkajsChannelIntegration","tediousChannelIntegration","awsChannelIntegration"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgGO,MAAM,mBAAA,GAAsB;AAAA,EACjC,mBAAA,EAAqBA,mCAAA;AAAA,EACrB,qBAAA,EAAuBC,uCAAA;AAAA,EACvB,gBAAA,EAAkBC,iCAAA;AAAA,EAClB,gBAAA,EAAkBC,6BAAA;AAAA,EAClB,iBAAA,EAAmBC,+BAAA;AAAA,EACnB,sBAAA,EAAwBC,yCAAA;AAAA,EACxB,mBAAA,EAAqBC,mCAAA;AAAA,EACrB,sBAAA,EAAwBC,yCAAA;AAAA,EACxB,iBAAA,EAAmBC,+BAAA;AAAA,EACnB,oBAAA,EAAsBC,qCAAA;AAAA,EACtB,sBAAA,EAAwBC,yCAAA;AAAA,EACxB,oBAAA,EAAsBC,qCAAA;AAAA,EACtB,oBAAA,EAAsBC,qCAAA;AAAA,EACtB,mBAAA,EAAqBC,mCAAA;AAAA,EACrB,kBAAA,EAAoBC,iCAAA;AAAA,EACpB,eAAA,EAAiBC,2BAAA;AAAA,EACjB,cAAA,EAAgBC,yBAAA;AAAA,EAChB,kBAAA,EAAoBC,iCAAA;AAAA,EACpB,kBAAA,EAAoBC,4CAAA;AAAA,EACpB,kBAAA,EAAoBC,iCAAA;AAAA,EACpB,kBAAA,EAAoBC,iCAAA;AAAA,EACpB,cAAA,EAAgBC;AAClB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/cjs/orchestrion/runtime/register.js

@@ -0,0 +1,77 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+const Module = require('node:module');
+const node_url = require('node:url');
+const node_worker_threads = require('node:worker_threads');
+const index = require('../config/index.js');
+
+function hasStableSyncModuleHooks(denoVersionString) {
+  const parseVersion = (v) => v.split(".").map((n) => parseInt(n, 10));
+  const nodeVersion = parseVersion(process.versions.node ?? "0.0.0");
+  const denoVersion = parseVersion(denoVersionString ?? "0.0.0");
+  return (nodeVersion[0] ?? 0) > 25 || nodeVersion[0] === 25 && (nodeVersion[1] ?? 0) >= 1 || nodeVersion[0] === 24 && (nodeVersion[1] ?? 0) >= 13 || (denoVersion[0] ?? 0) > 2 || denoVersion[0] === 2 && (denoVersion[1] ?? 0) >= 8;
+}
+function registerDiagnosticsChannelInjection(options) {
+  if (!node_worker_threads.isMainThread && !node_worker_threads.parentPort) {
+    return;
+  }
+  if (core.GLOBAL_OBJ?.__SENTRY_ORCHESTRION__?.runtime) {
+    return;
+  }
+  const globalAny = globalThis;
+  const stableSyncHooks = hasStableSyncModuleHooks(globalAny.Deno?.version?.deno);
+  let thisModuleUrl;
+  thisModuleUrl = node_url.pathToFileURL(__filename).href;
+  let nodeRequire;
+  nodeRequire = require;
+  const tracingHooksDir = options?.tracingHooksDir;
+  const requireFromHooksDir = tracingHooksDir ? Module.createRequire(thisModuleUrl) : void 0;
+  const mod = Module;
+  try {
+    const { setDiagnosticsHook } = requireFromHooksDir ? requireFromHooksDir(`${tracingHooksDir}/lib/diagnostics.js`) : nodeRequire("@apm-js-collab/tracing-hooks/lib/diagnostics.js");
+    const onDiagnostics = ({ moduleName, error }) => {
+      if (error) {
+        core.debug.warn(`[orchestrion] failed to inject diagnostics-channel into ${moduleName}:`, error);
+      } else {
+        core.GLOBAL_OBJ.__SENTRY_ORCHESTRION__ = core.GLOBAL_OBJ.__SENTRY_ORCHESTRION__ || {};
+        core.GLOBAL_OBJ.__SENTRY_ORCHESTRION__.runtime = core.GLOBAL_OBJ.__SENTRY_ORCHESTRION__.runtime || [];
+        core.GLOBAL_OBJ.__SENTRY_ORCHESTRION__.runtime.push(moduleName);
+      }
+    };
+    setDiagnosticsHook(onDiagnostics);
+    if (typeof mod.registerHooks === "function" && stableSyncHooks) {
+      const { initialize, resolve, load } = requireFromHooksDir ? requireFromHooksDir(`${tracingHooksDir}/hook-sync.mjs`) : nodeRequire("@apm-js-collab/tracing-hooks/hook-sync.mjs");
+      initialize({ instrumentations: index.SENTRY_INSTRUMENTATIONS });
+      mod.registerHooks({ resolve, load });
+      core.debug.log("Registered diagnostics-channel injection via Module.registerHooks()");
+    } else if (typeof mod.register === "function" && !globalAny.Bun && !globalAny.Deno) {
+      const hookSpecifier = tracingHooksDir ? node_url.pathToFileURL(`${tracingHooksDir}/hook.mjs`).href : "@apm-js-collab/tracing-hooks/hook.mjs";
+      const { port1, port2 } = new node_worker_threads.MessageChannel();
+      port1.on("message", onDiagnostics);
+      port1.unref();
+      mod.register(hookSpecifier, {
+        parentURL: thisModuleUrl,
+        data: { instrumentations: index.SENTRY_INSTRUMENTATIONS, diagnosticsPort: port2 },
+        transferList: [port2]
+      });
+      const ModulePatch = requireFromHooksDir && tracingHooksDir ? requireFromHooksDir(tracingHooksDir) : nodeRequire("@apm-js-collab/tracing-hooks");
+      new ModulePatch({ instrumentations: index.SENTRY_INSTRUMENTATIONS }).patch();
+      core.debug.log("Registered diagnostics-channel injection via Module.register()");
+    } else {
+      core.debug.warn("No available Node API to register diagnostics-channel injection hooks; skipping.");
+      return;
+    }
+  } catch (error) {
+    core.debug.warn(
+      "Failed to register diagnostics-channel injection hooks; channel-based integrations will not record spans.",
+      error
+    );
+    return;
+  }
+  core.GLOBAL_OBJ.__SENTRY_ORCHESTRION__ = core.GLOBAL_OBJ.__SENTRY_ORCHESTRION__ || {};
+  core.GLOBAL_OBJ.__SENTRY_ORCHESTRION__.runtime = core.GLOBAL_OBJ.__SENTRY_ORCHESTRION__.runtime || [];
+}
+
+exports.registerDiagnosticsChannelInjection = registerDiagnosticsChannelInjection;
+//# sourceMappingURL=register.js.map

package/build/cjs/orchestrion/runtime/register.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.js","sources":["../../../../src/orchestrion/runtime/register.ts"],"sourcesContent":["import { debug, GLOBAL_OBJ } from '@sentry/core';\nimport { createRequire } from 'node:module';\nimport * as Module from 'node:module';\nimport { pathToFileURL } from 'node:url';\nimport { isMainThread, MessageChannel, parentPort } from 'node:worker_threads';\nimport { SENTRY_INSTRUMENTATIONS } from '../config';\nimport type { register } from 'node:module';\nimport type { InstrumentationConfig } from '..';\n\ntype DiagnosticsEvent = { url: string; moduleName: string; error?: Error };\n\ntype TracingHooksSync = {\n  initialize: (opts: { instrumentations: InstrumentationConfig[] }) => void;\n  resolve: Function;\n  load: Function;\n};\n\ntype TracingHooksDiagnostics = {\n  setDiagnosticsHook: (callback: (event: DiagnosticsEvent) => void) => void;\n};\n\ntype NodeModule = {\n  registerHooks?: (options: unknown) => { deregister: () => void };\n  register?: typeof register;\n};\n\nexport interface RegisterDiagnosticsChannelInjectionOptions {\n  /**\n   * Absolute directory of the `@apm-js-collab/tracing-hooks` package (forward slashes).\n   *\n   * Needed when SDK code is bundled into an app's server build: the default bare-specifier\n   * require then resolves from the emitted chunk, which fails under isolated installs (pnpm).\n   * Framework SDKs (e.g. `@sentry/nextjs`) resolve the package at build time and pass its\n   * location here; it is loaded through an opaque `createRequire` that bundlers can't trace.\n   */\n  tracingHooksDir?: string;\n}\n\n/** `Module.registerHooks` only became stable in Node 24.13 / 25.1 and Deno 2.8. */\nfunction hasStableSyncModuleHooks(denoVersionString: string | undefined): boolean {\n  const parseVersion = (v: string): number[] => v.split('.').map(n => parseInt(n, 10));\n  const nodeVersion = parseVersion(process.versions.node ?? '0.0.0');\n  const denoVersion = parseVersion(denoVersionString ?? '0.0.0');\n  return (\n    (nodeVersion[0] ?? 0) > 25 ||\n    (nodeVersion[0] === 25 && (nodeVersion[1] ?? 0) >= 1) ||\n    (nodeVersion[0] === 24 && (nodeVersion[1] ?? 0) >= 13) ||\n    (denoVersion[0] ?? 0) > 2 ||\n    (denoVersion[0] === 2 && (denoVersion[1] ?? 0) >= 8)\n  );\n}\n\n/**\n * Synchronously register the diagnostics-channel injection module hooks.\n *\n * This is the single source of truth for the registration logic. It is used by:\n * - `Sentry.init()` (the Node SDK calls it directly — that's why this module\n *   must be CJS-compatible / dual-built, so it can be `require()`d synchronously\n *   before the app's `import`s resolve), and\n * - `import-hook.mjs`, the side-effecting `--import` entry, which just calls it.\n *\n * Libraries imported *after* this call publish the `tracingChannel` events that\n * the channel-based integrations subscribe to.\n */\nexport function registerDiagnosticsChannelInjection(options?: RegisterDiagnosticsChannelInjectionOptions): void {\n  // Skip Node's internal loader (hooks) threads, recognizable as the only threads without a\n  // `parentPort`. Node re-runs `--require` preloads (though not `--import` ones) on the loader\n  // thread it spawns for `Module.register()`, so this function runs there too — but that thread\n  // never executes app code, and its `register()` implementation (the in-thread `Hooks` class)\n  // has no `transferList` parameter: our transfer array lands in its `isInternal` parameter and\n  // Node crashes trying to load the hook as an internal builtin. User-created workers always\n  // have a `parentPort` and register through `CustomizedModuleLoader`, which handles\n  // `transferList` correctly, so they proceed and get their own instrumented loader.\n  if (!isMainThread && !parentPort) {\n    return;\n  }\n\n  if (GLOBAL_OBJ?.__SENTRY_ORCHESTRION__?.runtime) {\n    return;\n  }\n\n  const globalAny = globalThis as { Bun?: unknown; Deno?: { version?: { deno?: string } } };\n  const stableSyncHooks = hasStableSyncModuleHooks(globalAny.Deno?.version?.deno);\n\n  let thisModuleUrl: string;\n  /*! rollup-include-cjs-only */\n  thisModuleUrl = pathToFileURL(__filename).href;\n  /*! rollup-include-cjs-only-end */\n  /*! rollup-include-esm-only */\n  thisModuleUrl = import.meta.url;\n  /*! rollup-include-esm-only-end */\n\n  // Default: bare specifiers via a plain (aliased) `require`, so bundlers see and resolve them\n  // like any other dependency. Override: with `tracingHooksDir`, absolute paths are loaded through\n  // `createRequire`, which bundlers leave as a true runtime require — they must not statically\n  // resolve these (Turbopack fails the build on an absolute request, and the machinery breaks when\n  // bundled anyway). `createRequire` rather than ignore-comments because webpack only honors\n  // `webpackIgnore` on `import()`, not `require()` (it compiles the call to a broken module stub).\n  let nodeRequire: (specifier: string) => unknown;\n  /*! rollup-include-cjs-only */\n  nodeRequire = require;\n  /*! rollup-include-cjs-only-end */\n  /*! rollup-include-esm-only */\n  nodeRequire = createRequire(import.meta.url);\n  /*! rollup-include-esm-only-end */\n\n  const tracingHooksDir = options?.tracingHooksDir;\n  const requireFromHooksDir = tracingHooksDir ? createRequire(thisModuleUrl) : undefined;\n\n  // `Module.registerHooks` / `Module.register` are newer than the @types/node\n  // we build against, hence the cast.\n  const mod = Module as NodeModule;\n\n  // runs both at `--import` time and (synchronously) inside `Sentry.init()`,\n  // so an unguarded throw would either abort startup or make `init()` throw.\n  // On any failure (e.g. dep resolution, `require(esm)` / Node-compat\n  // incompatibility) we warn (DEBUG only) and continue without channel\n  // injection\n  try {\n    // `lib/diagnostics.js` is plain CJS, so unlike the ESM hook entry points it can be\n    // require()d on every supported Node version. It holds the hook state shared by\n    // everything that can transform a module on this thread (the sync ESM hooks and the\n    // `_compile` patch), so setting the hook once here covers both branches below.\n    const { setDiagnosticsHook } = (\n      requireFromHooksDir\n        ? requireFromHooksDir(`${tracingHooksDir}/lib/diagnostics.js`)\n        : nodeRequire('@apm-js-collab/tracing-hooks/lib/diagnostics.js')\n    ) as TracingHooksDiagnostics;\n\n    const onDiagnostics = ({ moduleName, error }: DiagnosticsEvent): void => {\n      if (error) {\n        debug.warn(`[orchestrion] failed to inject diagnostics-channel into ${moduleName}:`, error);\n      } else {\n        GLOBAL_OBJ.__SENTRY_ORCHESTRION__ = GLOBAL_OBJ.__SENTRY_ORCHESTRION__ || {};\n        GLOBAL_OBJ.__SENTRY_ORCHESTRION__.runtime = GLOBAL_OBJ.__SENTRY_ORCHESTRION__.runtime || [];\n        GLOBAL_OBJ.__SENTRY_ORCHESTRION__.runtime.push(moduleName);\n      }\n    };\n\n    setDiagnosticsHook(onDiagnostics);\n\n    if (typeof mod.registerHooks === 'function' && stableSyncHooks) {\n      // Sync hooks cover CJS and ESM, no separate `_compile` patch needed.\n      // We require() this ESM module so that we can synchronously load it,\n      // including from a CommonJS Sentry build; all versions in\n      // stableSyncHooks support require(esm).\n      const { initialize, resolve, load } = (\n        requireFromHooksDir\n          ? requireFromHooksDir(`${tracingHooksDir}/hook-sync.mjs`)\n          : nodeRequire('@apm-js-collab/tracing-hooks/hook-sync.mjs')\n      ) as TracingHooksSync;\n\n      initialize({ instrumentations: SENTRY_INSTRUMENTATIONS });\n      mod.registerHooks({ resolve, load });\n      debug.log('Registered diagnostics-channel injection via Module.registerHooks()');\n    } else if (typeof mod.register === 'function' && !globalAny.Bun && !globalAny.Deno) {\n      // `Module.register` + the `_compile` patch is Node 18.19–24.12 / 25.0\n      // path. Bun/Deno are excluded: they don't support this combination and\n      // must use the stable `registerHooks` path above (or none at all).\n      // `Module.register` resolves ESM-style: a bare package specifier is resolved against\n      // `parentURL`, but a filesystem path (the `tracingHooksDir` override) is not a valid ESM\n      // specifier and must be passed as a file:// URL.\n      const hookSpecifier = tracingHooksDir\n        ? pathToFileURL(`${tracingHooksDir}/hook.mjs`).href\n        : '@apm-js-collab/tracing-hooks/hook.mjs';\n\n      // The `Module.register` hooks run on a loader thread with its own copy of\n      // `lib/diagnostics.js`, so the hook set above never fires there; the loader thread\n      // posts diagnostics back over a MessagePort instead. This replicates\n      // `createDiagnosticsPort` from hook.mjs, which is ESM and therefore not\n      // synchronously loadable on all Node versions that take this branch.\n      const { port1, port2 } = new MessageChannel();\n      port1.on('message', onDiagnostics);\n      // The diagnostics channel must not keep the process alive.\n      port1.unref();\n      mod.register(hookSpecifier, {\n        parentURL: thisModuleUrl,\n        data: { instrumentations: SENTRY_INSTRUMENTATIONS, diagnosticsPort: port2 },\n        transferList: [port2],\n      });\n\n      // ALSO patch `Module.prototype._compile` for the CJS side: when an ESM\n      // file `import`s a CJS package, the package's internal `require()` calls\n      // are resolved through the CJS machinery and never reach the ESM\n      // register hook, so without this patch the file we want to instrument\n      // loads untransformed.\n      const ModulePatch = (\n        requireFromHooksDir && tracingHooksDir\n          ? requireFromHooksDir(tracingHooksDir)\n          : nodeRequire('@apm-js-collab/tracing-hooks')\n      ) as new (opts: { instrumentations: unknown }) => {\n        patch: () => void;\n      };\n      new ModulePatch({ instrumentations: SENTRY_INSTRUMENTATIONS }).patch();\n      debug.log('Registered diagnostics-channel injection via Module.register()');\n    } else {\n      debug.warn('No available Node API to register diagnostics-channel injection hooks; skipping.');\n      return;\n    }\n  } catch (error) {\n    debug.warn(\n      'Failed to register diagnostics-channel injection hooks; channel-based integrations will not record spans.',\n      error,\n    );\n    return;\n  }\n\n  GLOBAL_OBJ.__SENTRY_ORCHESTRION__ = GLOBAL_OBJ.__SENTRY_ORCHESTRION__ || {};\n  GLOBAL_OBJ.__SENTRY_ORCHESTRION__.runtime = GLOBAL_OBJ.__SENTRY_ORCHESTRION__.runtime || [];\n}\n"],"names":["isMainThread","parentPort","GLOBAL_OBJ","pathToFileURL","createRequire","debug","SENTRY_INSTRUMENTATIONS","MessageChannel"],"mappings":"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"}

package/build/cjs/prisma/global.js

@@ -0,0 +1,14 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const majorVersion = "7";
+const GLOBAL_INSTRUMENTATION_KEY = "PRISMA_INSTRUMENTATION";
+const GLOBAL_VERSIONED_INSTRUMENTATION_KEY = `V${majorVersion}_PRISMA_INSTRUMENTATION`;
+const globalThisWithPrismaInstrumentation = globalThis;
+function setGlobalTracingHelper(helper) {
+  const globalValue = { helper };
+  globalThisWithPrismaInstrumentation[GLOBAL_VERSIONED_INSTRUMENTATION_KEY] = globalValue;
+  globalThisWithPrismaInstrumentation[GLOBAL_INSTRUMENTATION_KEY] = globalValue;
+}
+
+exports.setGlobalTracingHelper = setGlobalTracingHelper;
+//# sourceMappingURL=global.js.map

package/build/cjs/prisma/global.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"global.js","sources":["../../../src/prisma/global.ts"],"sourcesContent":["/*\n * Copyright Prisma\n * SPDX-License-Identifier: Apache-2.0\n *\n * NOTICE from the Sentry authors:\n * - Vendored from: https://github.com/prisma/prisma/tree/b6feea5565ec577545a79547d24273ccdd11b4c7/packages/instrumentation-contract\n * - Upstream version: @prisma/instrumentation-contract@7.8.0\n * - Replaced `import packageJson from '../package.json'` with hardcoded major version\n */\n\nimport type { PrismaInstrumentationGlobalValue, TracingHelper } from './types';\n\nconst majorVersion = '7';\n\nconst GLOBAL_INSTRUMENTATION_KEY = 'PRISMA_INSTRUMENTATION';\nconst GLOBAL_VERSIONED_INSTRUMENTATION_KEY = `V${majorVersion}_PRISMA_INSTRUMENTATION` as const;\n\ntype GlobalThisWithPrismaInstrumentation = typeof globalThis & {\n  [GLOBAL_INSTRUMENTATION_KEY]?: PrismaInstrumentationGlobalValue;\n} & {\n  [K in typeof GLOBAL_VERSIONED_INSTRUMENTATION_KEY]?: PrismaInstrumentationGlobalValue;\n};\n\nconst globalThisWithPrismaInstrumentation = globalThis as GlobalThisWithPrismaInstrumentation;\n\nexport function getGlobalTracingHelper(): TracingHelper | undefined {\n  const versionedGlobal = globalThisWithPrismaInstrumentation[GLOBAL_VERSIONED_INSTRUMENTATION_KEY];\n\n  if (versionedGlobal?.helper) {\n    return versionedGlobal.helper;\n  }\n\n  const fallbackGlobal = globalThisWithPrismaInstrumentation[GLOBAL_INSTRUMENTATION_KEY];\n\n  return fallbackGlobal?.helper;\n}\n\nexport function setGlobalTracingHelper(helper: TracingHelper): void {\n  const globalValue: PrismaInstrumentationGlobalValue = { helper };\n\n  globalThisWithPrismaInstrumentation[GLOBAL_VERSIONED_INSTRUMENTATION_KEY] = globalValue;\n  globalThisWithPrismaInstrumentation[GLOBAL_INSTRUMENTATION_KEY] = globalValue;\n}\n\nexport function clearGlobalTracingHelper(): void {\n  globalThisWithPrismaInstrumentation[GLOBAL_VERSIONED_INSTRUMENTATION_KEY] = undefined;\n  globalThisWithPrismaInstrumentation[GLOBAL_INSTRUMENTATION_KEY] = undefined;\n}\n"],"names":[],"mappings":";;AAYA,MAAM,YAAA,GAAe,GAAA;AAErB,MAAM,0BAAA,GAA6B,wBAAA;AACnC,MAAM,oCAAA,GAAuC,IAAI,YAAY,CAAA,uBAAA,CAAA;AAQ7D,MAAM,mCAAA,GAAsC,UAAA;AAcrC,SAAS,uBAAuB,MAAA,EAA6B;AAClE,EAAA,MAAM,WAAA,GAAgD,EAAE,MAAA,EAAO;AAE/D,EAAA,mCAAA,CAAoC,oCAAoC,CAAA,GAAI,WAAA;AAC5E,EAAA,mCAAA,CAAoC,0BAA0B,CAAA,GAAI,WAAA;AACpE;;;;"}

package/build/cjs/prisma/index.js

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+const global = require('./global.js');
+const tracingHelper = require('./tracing-helper.js');
+
+const INTEGRATION_NAME = "Prisma";
+function instrumentPrisma(options) {
+  global.setGlobalTracingHelper(
+    new tracingHelper.ActiveTracingHelper({
+      ignoreSpanTypes: options?.instrumentationConfig?.ignoreSpanTypes ?? []
+    })
+  );
+}
+const _prismaIntegration = ((options) => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      instrumentPrisma(options);
+    }
+  };
+});
+const prismaIntegration = core.defineIntegration(_prismaIntegration);
+
+exports.instrumentPrisma = instrumentPrisma;
+exports.prismaIntegration = prismaIntegration;
+//# sourceMappingURL=index.js.map