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

@@ -1,50 +1,115 @@
+import type { SerializedStreamedSpan, SerializedStreamedSpanContainer } from '@sentry/core';
 import { afterAll, describe, expect } from 'vitest';
 import { cleanupChildProcesses, createEsmAndCjsTests, describeWithDockerCompose } from '../../../utils/runner';
 
 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 Node's module hooks only see from
+// Node 22 on; on Node 20 the ORM terminals load uninstrumented.
+const cjsLoadsInstrumentedEsm = Number(process.versions.node.split('.')[0]) >= 22;
+
+function getSegment(container: SerializedStreamedSpanContainer): SerializedStreamedSpan {
+  const segment = container.items.find(item => item.is_segment);
+  expect(segment?.name).toBe('Test Transaction');
+  return segment!;
+}
+
+function getQuerySpans(container: SerializedStreamedSpanContainer): SerializedStreamedSpan[] {
+  const querySpans = container.items.filter(
+    item => item.attributes['sentry.origin']?.value === 'auto.db.postgres' && item.attributes['db.query.text']?.value,
+  );
+  expect(querySpans.map(span => span.name)).toEqual(
+    expect.arrayContaining(['INSERT "public"."user"', 'SELECT "public"."user"', 'DELETE "public"."user"']),
+  );
+  querySpans.forEach(span => {
+    expect(span.attributes['sentry.op']?.value).toBe('db');
+    expect(span.attributes['db.system.name']?.value).toBe('postgresql');
+  });
+  return querySpans;
+}
+
+function getOperationSpans(container: SerializedStreamedSpanContainer): SerializedStreamedSpan[] {
+  return container.items.filter(item => item.attributes['sentry.origin']?.value === 'auto.db.prisma');
+}
+
+// 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) => {
+        if (mode === 'cjs' && !cjsLoadsInstrumentedEsm) {
+          test(
+            'should keep the pg spans on the transaction when require(esm) bypasses the loader',
+            { timeout: 75_000 },
+            async () => {
+              await createRunner()
+                .unordered()
+                .expect({
+                  span: container => {
+                    const segment = getSegment(container);
+                    expect(getOperationSpans(container)).toEqual([]);
+                    getQuerySpans(container).forEach(span => expect(span.parent_span_id).toBe(segment.span_id));
+                  },
+                })
+                .start()
+                .completed();
+            },
+          );
+          return;
+        }
+
+        test('should instrument Prisma ORM operations and nest their queries', { timeout: 75_000 }, async () => {
           await createRunner()
             .unordered()
             .expect({
               span: container => {
-                const segment = container.items.find(item => item.is_segment);
-                expect(segment?.name).toBe('Test Transaction');
+                const segment = getSegment(container);
+                const querySpans = getQuerySpans(container);
+                const operationSpans = getOperationSpans(container);
 
-                const querySpans = container.items.filter(
-                  item =>
-                    item.attributes['sentry.origin']?.value === 'auto.db.postgres' &&
-                    item.attributes['db.query.text']?.value,
-                );
-                expect(querySpans.map(span => span.name)).toEqual(
-                  expect.arrayContaining([
-                    'INSERT "public"."user"',
-                    'SELECT "public"."user"',
-                    'DELETE "public"."user"',
-                  ]),
-                );
-                querySpans.forEach(span => {
-                  expect(span.attributes['sentry.op']?.value).toBe('db');
-                  expect(span.attributes['db.system.name']?.value).toBe('postgresql');
-                  expect(span.parent_span_id).toBe(segment?.span_id);
+                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:
  *
  *    ```