feat(node): Support Prisma 8 in prismaIntegration

Prisma 8 has no tracing surface, so wrap its ORM terminals via
orchestrion instead. Each ORM call gets a `prisma:client:operation` span
(`db.operation.name`, `db.collection.name`, plus v7's `method`, `model`
and `name`) with the `pg` query spans nested underneath. No user code
is needed.

The patch point is `CollectionImpl` in the transitive
`@prisma/orm-family-sql` package, pinned to `>=8.0.0-rc.8 <9`. Lazy
terminals (`all`, `createAll`, `updateAll`, `deleteAll`) return a
single-use thenable that orchestrion's promise wrapper would consume,
so they are wrapped `Sync` and the subscriber hooks `toArray` and the
async iterator instead. Terminals calling terminals reuse the outer
span. Operation spans require a parent span.

CommonJS apps load the ESM-only runtime through `require(esm)`, which
only the synchronous module hooks (Node 24.13 / 25.1) transform; older
Node keeps `pg`-only spans in CJS. ESM apps are fully covered.

Fixes #24237
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

Author: chargome

.size-limit.js

@@ -406,7 +406,7 @@ module.exports = [
     import: createImport('init'),
     ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
     gzip: true,
-    limit: '135 KB',
+    limit: '137 KB',
     disablePlugins: ['@size-limit/esbuild'],
   },
   {
@@ -452,7 +452,7 @@ module.exports = [
     path: 'packages/node/build/esm/index.js',
     import: createImport('init'),
     gzip: true,
-    limit: '114 KB',
+    limit: '115 KB',
     disablePlugins: ['@size-limit/esbuild'],
     ignore: [...builtinModules, ...nodePrefixedBuiltinModules],
     modifyWebpackConfig: function (config) {

dev-packages/node-integration-tests/suites/tracing/prisma-orm-v8/test.ts

@@ -5,18 +5,24 @@ afterAll(() => {
   cleanupChildProcesses();
 });
 
-// Prisma 8 ("Prisma Next") has no tracing surface (its scorecard lists OpenTelemetry spans as not in 8.0), so
-// `prismaIntegration` is inert and only the `pg` spans from `postgresIntegration` remain. Pinned here so a
-// Prisma release that adds a tracing surface shows up. The runtime runs on every Node version in the matrix;
-// only the Prisma 8 CLI needs Node 22.18+, which is why the generated files are committed.
+// The CJS scenario loads the ESM-only package via `require(esm)`, which only the sync `Module.registerHooks`
+// loader (Node 24.13 / 25.1) transforms; on older Node the ORM terminals load uninstrumented.
+const [nodeMajor = 0, nodeMinor = 0] = process.versions.node.split('.').map(Number);
+const cjsLoadsInstrumentedEsm =
+  nodeMajor > 25 || (nodeMajor === 25 && nodeMinor >= 1) || (nodeMajor === 24 && nodeMinor >= 13);
+
+// Prisma 8 has no tracing surface: the operation spans come from the orchestrion channels the runtime hook
+// injects, and the `pg` spans underneath stand in for v7's `db_query` spans.
 describe('Prisma ORM v8 Tests', () => {
   describeWithDockerCompose('Prisma ORM v8', { workingDirectory: [__dirname] }, () => {
     createEsmAndCjsTests(
       __dirname,
       'scenario.mjs',
       'instrument.mjs',
-      (createRunner, test) => {
-        test('should instrument PostgreSQL queries from Prisma ORM via pg', { timeout: 75_000 }, async () => {
+      (createRunner, test, mode) => {
+        const expectsOperationSpans = mode === 'esm' || cjsLoadsInstrumentedEsm;
+
+        test('should instrument Prisma ORM operations and nest their queries', { timeout: 75_000 }, async () => {
           await createRunner()
             .unordered()
             .expect({
@@ -39,12 +45,55 @@ describe('Prisma ORM v8 Tests', () => {
                 querySpans.forEach(span => {
                   expect(span.attributes['sentry.op']?.value).toBe('db');
                   expect(span.attributes['db.system.name']?.value).toBe('postgresql');
+                });
+
+                const operationSpans = container.items.filter(
+                  item => item.attributes['sentry.origin']?.value === 'auto.db.prisma',
+                );
+
+                if (!expectsOperationSpans) {
+                  expect(operationSpans).toEqual([]);
+                  querySpans.forEach(span => expect(span.parent_span_id).toBe(segment?.span_id));
+                  return;
+                }
+
+                expect(operationSpans.map(span => span.name)).toEqual([
+                  'prisma:client:operation',
+                  'prisma:client:operation',
+                  'prisma:client:operation',
+                ]);
+                expect(operationSpans.map(span => span.attributes['method']?.value)).toEqual([
+                  'create',
+                  'all',
+                  'delete',
+                ]);
+                operationSpans.forEach(span => {
+                  const method = span.attributes['method']?.value;
                   expect(span.parent_span_id).toBe(segment?.span_id);
+                  expect(span.attributes).toMatchObject({
+                    'sentry.origin': { value: 'auto.db.prisma', type: 'string' },
+                    'sentry.op': { value: 'db', type: 'string' },
+                    'db.operation.name': { value: method, type: 'string' },
+                    'db.collection.name': { value: 'user', type: 'string' },
+                    model: { value: 'User', type: 'string' },
+                    name: { value: `User.${method}`, type: 'string' },
+                  });
                 });
 
-                expect(
-                  container.items.filter(item => item.attributes['sentry.origin']?.value === 'auto.db.prisma'),
-                ).toEqual([]);
+                const queriesByOperation = (method: string): unknown[] => {
+                  const operation = operationSpans.find(span => span.attributes['method']?.value === method);
+                  return querySpans
+                    .filter(span => span.parent_span_id === operation?.span_id)
+                    .map(span => span.attributes['db.query.text']?.value);
+                };
+                expect(queriesByOperation('create')).toEqual(
+                  expect.arrayContaining([expect.stringMatching(/^INSERT INTO "public"\."user" /)]),
+                );
+                expect(queriesByOperation('all')).toEqual([expect.stringMatching(/^SELECT .* FROM "public"\."user"$/)]);
+                expect(queriesByOperation('delete')).toEqual(
+                  expect.arrayContaining([expect.stringMatching(/^DELETE FROM "public"\."user" /)]),
+                );
+                expect(querySpans.filter(span => span.parent_span_id === segment?.span_id)).toEqual([]);
               },
             })
             .start()

packages/server-utils/src/integrations/prisma/index.ts

@@ -1,6 +1,9 @@
 import type { IntegrationFn } from '@sentry/core';
 import { defineIntegration } from '@sentry/core';
+import { prismaModuleNames } from '../../orchestrion/config/prisma';
+import { invokeOrchestrionInstrumentation } from '../../orchestrion/instrumentation';
 import { setGlobalTracingHelper } from './global';
+import { instrumentPrismaV8 } from './orchestrion';
 import { ActiveTracingHelper } from './tracing-helper';
 
 const INTEGRATION_NAME = 'Prisma' as const;
@@ -43,14 +46,22 @@ const _prismaIntegration = ((options?: PrismaOptions) => {
     setupOnce() {
       instrumentPrisma(options);
     },
+    // Prisma 8 has no tracing helper to install; its ORM terminals are instrumented via orchestrion instead.
+    setup(client) {
+      invokeOrchestrionInstrumentation(client, prismaModuleNames, instrumentPrismaV8, [
+        { ignoreSpanTypes: options?.instrumentationConfig?.ignoreSpanTypes ?? [] },
+      ]);
+    },
   };
 }) satisfies IntegrationFn;
 
 /**
  * Adds Sentry tracing instrumentation for the [prisma](https://www.npmjs.com/package/prisma) library.
  * For more information, see the [`prismaIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/prisma/).
  *
- * NOTE: This integration works out of the box with Prisma v6, and v7.
+ * NOTE: This integration works out of the box with Prisma v6, v7 and v8. Prisma v8 ("Prisma Next")
+ * has no tracing surface of its own, so its ORM calls are instrumented through Sentry's runtime hook
+ * or bundler plugin, like the other channel-based integrations.
  * On Prisma versions prior to v6, add `previewFeatures = ["tracing"]` to the client generator block of your Prisma schema:
  *
  *    ```

packages/server-utils/src/integrations/prisma/orchestrion.ts

@@ -0,0 +1,212 @@
+import * as diagnosticsChannel from 'node:diagnostics_channel';
+import type { Span } from '@sentry/core';
+import {
+  getActiveSpan,
+  getRootSpan,
+  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
+  spanIsIgnored,
+  startInactiveSpan,
+  withActiveSpan,
+} from '@sentry/core';
+import { DB_COLLECTION_NAME, DB_OPERATION_NAME, SENTRY_OP } from '@sentry/conventions/attributes';
+import { DB } from '@sentry/conventions/op';
+import { prismaChannels, PRISMA_LAZY_TERMINALS } from '../../orchestrion/config/prisma';
+import type { TracingChannelLifeCycleOptions } from '../../tracing-channel';
+import { bindTracingChannelToSpan, safeChannelCallback } from '../../tracing-channel';
+import { shouldIgnoreSpan } from './tracing-helper';
+
+// Same span name as Prisma v5–v7's own operation span, so the tree looks the same across majors.
+const OPERATION_SPAN_NAME = 'prisma:client:operation';
+const PRISMA_ORIGIN = 'auto.db.prisma';
+
+// Terminals call each other (`delete` reads the row through `first`); only the outermost call is the operation.
+const operationSpans = new WeakSet<Span>();
+
+interface PrismaCollection {
+  modelName?: unknown;
+  tableName?: unknown;
+}
+
+interface PrismaTerminalChannelContext {
+  arguments: unknown[];
+  self?: PrismaCollection;
+  moduleVersion?: string;
+  result?: unknown;
+  error?: unknown;
+}
+
+// Prisma's `AsyncIterableResult`: `await`, `.then()` and `.first()` all funnel through `toArray()`; only
+// `for await` goes through the iterator.
+interface LazyResult {
+  toArray: () => Promise<unknown>;
+  [Symbol.asyncIterator]: () => AsyncIterator<unknown>;
+}
+
+interface PrismaV8InstrumentationOptions {
+  ignoreSpanTypes: (string | RegExp)[];
+}
+
+/**
+ * Opens a `prisma:client:operation` span per ORM call, kept active while the terminal runs so the `pg`
+ * query spans nest under it like the `db_query` spans did on v5–v7.
+ */
+export function instrumentPrismaV8(options: PrismaV8InstrumentationOptions): void {
+  if (shouldIgnoreSpan(OPERATION_SPAN_NAME, options.ignoreSpanTypes)) {
+    return;
+  }
+
+  for (const channelName of Object.values(prismaChannels)) {
+    const method = channelName.slice(channelName.lastIndexOf(':') + 1);
+    const isLazy = (PRISMA_LAZY_TERMINALS as readonly string[]).includes(method);
+
+    bindTracingChannelToSpan<PrismaTerminalChannelContext>(
+      diagnosticsChannel.tracingChannel<PrismaTerminalChannelContext>(channelName),
+      data => startOperationSpan(method, data),
+      {
+        // A stray query outside a request must not become a segment of its own.
+        requiresParentSpan: true,
+        ...(isLazy ? { deferSpanEnd: deferSpanEndUntilConsumed } : {}),
+      },
+    );
+  }
+}
+
+function startOperationSpan(method: string, data: PrismaTerminalChannelContext): Span | undefined {
+  const parentSpan = getActiveSpan();
+  if (parentSpan && operationSpans.has(parentSpan)) {
+    return undefined;
+  }
+
+  const model = stringOrUndefined(data.self?.modelName);
+  const table = stringOrUndefined(data.self?.tableName);
+
+  const span = startInactiveSpan({
+    name: OPERATION_SPAN_NAME,
+    parentSpan,
+    attributes: {
+      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: PRISMA_ORIGIN,
+      [SENTRY_OP]: DB,
+      [DB_OPERATION_NAME]: method,
+      [DB_COLLECTION_NAME]: table ?? model,
+      // Prisma v5–v7's own attributes, kept so existing queries keep matching across the major.
+      method,
+      model,
+      name: model ? `${model}.${method}` : method,
+    },
+  });
+  operationSpans.add(span);
+  return span;
+}
+
+// A lazy terminal returns before anything is queried, so the span stays open until the result is consumed,
+// with consumption re-routed through the span's context so the driver call lands under it. A result that is
+// never consumed never ran a query; its span is simply never ended.
+const deferSpanEndUntilConsumed: NonNullable<
+  TracingChannelLifeCycleOptions<PrismaTerminalChannelContext>['deferSpanEnd']
+> = ({ span, data, end }) => {
+  const result = data.result;
+  if (!isLazyResult(result)) {
+    return false;
+  }
+
+  // A throw in a channel subscriber is an uncaught exception; an unpatchable (frozen) result ends the span now.
+  return safeChannelCallback(() => patchConsumption(result, span, end)) ?? false;
+};
+
+function patchConsumption(result: LazyResult, span: Span, end: (error?: unknown) => void): boolean {
+  const toArray = result.toArray;
+  const asyncIterator = result[Symbol.asyncIterator];
+
+  // Built before either is installed, so a failed assignment can't leave a half-patched result.
+  const patchedToArray = function (this: LazyResult): Promise<unknown> {
+    const rows: Promise<unknown> = runUnderSpan(span, () => toArray.call(this));
+    // Chained, not side-observed, so a rejected fire-and-forget `toArray()` still surfaces as unhandled.
+    return rows.then(
+      value => {
+        end();
+        return value;
+      },
+      (error: unknown) => {
+        end(error);
+        throw error;
+      },
+    );
+  };
+  const patchedAsyncIterator = function (this: LazyResult): AsyncIterableIterator<unknown> {
+    return wrapIterator(
+      runUnderSpan(span, () => asyncIterator.call(this)),
+      span,
+      end,
+    );
+  };
+
+  result.toArray = patchedToArray;
+  result[Symbol.asyncIterator] = patchedAsyncIterator;
+
+  return true;
+}
+
+// An ignored child span is never emitted, so its children must keep parenting to the nearest emitted span
+// (same rule as the tracing-channel binding and core `startSpan`).
+function runUnderSpan<T>(span: Span, callback: () => T): T {
+  if (spanIsIgnored(span) && getRootSpan(span) !== span) {
+    return callback();
+  }
+  return withActiveSpan(span, callback);
+}
+
+function wrapIterator(
+  iterator: AsyncIterator<unknown>,
+  span: Span,
+  end: (error?: unknown) => void,
+): AsyncIterableIterator<unknown> {
+  const settle = (step: Promise<IteratorResult<unknown>>): Promise<IteratorResult<unknown>> =>
+    step.then(
+      result => {
+        if (result.done) {
+          end();
+        }
+        return result;
+      },
+      error => {
+        end(error);
+        throw error;
+      },
+    );
+
+  return {
+    next: (...args) => settle(runUnderSpan(span, () => iterator.next(...args))),
+    return: value => {
+      const iteratorReturn = iterator.return?.bind(iterator);
+      if (!iteratorReturn) {
+        end();
+        return Promise.resolve({ done: true, value });
+      }
+      return settle(runUnderSpan(span, () => iteratorReturn(value)));
+    },
+    throw: error => {
+      const iteratorThrow = iterator.throw?.bind(iterator);
+      if (!iteratorThrow) {
+        end(error);
+        return Promise.reject(error);
+      }
+      return settle(runUnderSpan(span, () => iteratorThrow(error)));
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+  };
+}
+
+function stringOrUndefined(value: unknown): string | undefined {
+  return typeof value === 'string' ? value : undefined;
+}
+
+function isLazyResult(value: unknown): value is LazyResult {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as LazyResult).toArray === 'function' &&
+    typeof (value as LazyResult)[Symbol.asyncIterator] === 'function'
+  );
+}

packages/server-utils/src/integrations/prisma/tracing-helper.ts

@@ -398,6 +398,7 @@ function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
   return value != null && typeof (value as Record<string, unknown>)['then'] === 'function';
 }
 
-function shouldIgnoreSpan(spanName: string, ignoreSpanTypes: (string | RegExp)[]): boolean {
+/** Whether `spanName` matches one of the configured `ignoreSpanTypes` patterns. */
+export function shouldIgnoreSpan(spanName: string, ignoreSpanTypes: (string | RegExp)[]): boolean {
   return ignoreSpanTypes.some(pattern => (typeof pattern === 'string' ? pattern === spanName : pattern.test(spanName)));
 }

packages/server-utils/src/orchestrion/channels.ts

@@ -26,6 +26,7 @@ import { nestjsChannels } from './config/nestjs';
 import { openaiChannels } from './config/openai';
 import { pgChannels } from './config/pg';
 import { postgresJsChannels } from './config/postgres';
+import { prismaChannels } from './config/prisma';
 import { redisChannels } from './config/redis';
 import { remixChannels } from './config/remix';
 import { tediousChannels } from './config/tedious';
@@ -77,6 +78,7 @@ export const CHANNELS = {
   ...openaiChannels,
   ...pgChannels,
   ...postgresJsChannels,
+  ...prismaChannels,
   ...redisChannels,
   ...remixChannels,
   ...tediousChannels,

packages/server-utils/src/orchestrion/config/channel-integration-definitions.ts

@@ -18,6 +18,7 @@
 export const CHANNEL_INTEGRATION_DEFINITIONS = [
   { exportName: 'postgresIntegration', modules: ['pg', 'pg-pool'] },
   { exportName: 'postgresJsIntegration', modules: ['postgres'] },
+  { exportName: 'prismaIntegration', modules: ['@prisma/orm-family-sql'] },
   { exportName: 'mysqlIntegration', modules: ['mysql'] },
   { exportName: 'mysql2Integration', modules: ['mysql2'] },
   { exportName: 'mongoIntegration', modules: ['mongodb'] },