ref(node): Streamline Prisma instrumentation (v6 and v7)

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

@@ -25,6 +25,22 @@ describe('Prisma ORM v6 Tests', () => {
  const spans = transaction.spans || [];
  expect(spans.length).toBeGreaterThanOrEqual(5);
 
+ // Each operation span is a direct child of the transaction; the db query span is a child of the engine query span.
+ const rootSpanId = transaction.contexts?.trace?.span_id;
+
+ const operationSpans = spans.filter(s => s.description === 'prisma:client:operation');
+ expect(operationSpans.length).toBeGreaterThanOrEqual(1);
+ operationSpans.forEach(operation => {
+ expect(operation.parent_span_id).toBe(rootSpanId);
+ });
+
+ const dbQuerySpan = spans.find(
+ s => s.data?.['sentry.origin'] === 'auto.db.otel.prisma' && s.data?.['db.query.text'],
+ );
+ expect(dbQuerySpan).toBeDefined();
+ const dbQueryParent = spans.find(s => s.span_id === dbQuerySpan?.parent_span_id);
+ expect(dbQueryParent?.description).toBe('prisma:engine:query');
+
  function expectPrismaSpanToIncludeSpanWith(span: Partial<SpanJSON>) {
  expect(spans).toContainEqual(
  expect.objectContaining({
@@ -92,6 +108,10 @@ describe('Prisma ORM v6 Tests', () => {
  },
  description: 'DELETE FROM "public"."User" WHERE "public"."User"."email"::text LIKE $1',
  });
+
+ // The db query span name must always be rewritten to the SQL text; the raw engine span
+ // name should never leak through.
+ expect(spans.find(span => span.description === 'prisma:engine:db_query')).toBeUndefined();
  },
  })
  .start()

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

@@ -26,6 +26,22 @@ conditionalTest({ min: 20 })('Prisma ORM v7 Tests', () => {
  const spans = transaction.spans || [];
  expect(spans.length).toBeGreaterThanOrEqual(5);
 
+ // Each operation span is a direct child of the transaction; the db query span is a child of its operation span.
+ const rootSpanId = transaction.contexts?.trace?.span_id;
+
+ const operationSpans = spans.filter(s => s.description === 'prisma:client:operation');
+ expect(operationSpans.length).toBeGreaterThanOrEqual(1);
+ operationSpans.forEach(operation => {
+ expect(operation.parent_span_id).toBe(rootSpanId);
+ });
+
+ const prismaDbQuerySpan = spans.find(
+ s => s.data?.['sentry.origin'] === 'auto.db.otel.prisma' && s.data?.['db.query.text'],
+ );
+ expect(prismaDbQuerySpan).toBeDefined();
+ const dbQueryParent = spans.find(s => s.span_id === prismaDbQuerySpan?.parent_span_id);
+ expect(dbQueryParent?.description).toBe('prisma:client:operation');
+
  // Verify Prisma spans have the correct origin
  const prismaSpans = spans.filter(
  span => span.data && span.data['sentry.origin'] === 'auto.db.otel.prisma',
@@ -58,6 +74,10 @@ conditionalTest({ min: 20 })('Prisma ORM v7 Tests', () => {
  expect(dbQuerySpan?.op).toBe('db');
  expect(dbQuerySpan?.description).toBe(dbQuerySpan?.data?.['db.query.text']);
  expect(dbQuerySpan?.description).not.toBe('prisma:client:db_query');
+
+ // The db query span name must always be rewritten to the SQL text; the raw client span
+ // name should never leak through.
+ expect(spans.find(span => span.description === 'prisma:client:db_query')).toBeUndefined();
  },
  })
  .start()

packages/node/src/integrations/tracing/prisma/index.ts

@@ -104,7 +104,7 @@ class SentryPrismaInteropInstrumentation extends PrismaInstrumentation {
 
  try {
  engineSpanEvent.spans.forEach(engineSpan => {
- const kind = engineSpanKindToOTELSpanKind(engineSpan.kind);
+ const kind = engineSpan.kind === 'client' ? SpanKind.CLIENT : SpanKind.INTERNAL;
 
  const parentSpanId = engineSpan.parent_span_id;
  const spanId = engineSpan.span_id;
@@ -159,16 +159,6 @@ class SentryPrismaInteropInstrumentation extends PrismaInstrumentation {
  }
 }
 
-function engineSpanKindToOTELSpanKind(engineSpanKind: V5EngineSpanKind): SpanKind {
- switch (engineSpanKind) {
- case 'client':
- return SpanKind.CLIENT;
- case 'internal':
- default: // Other span kinds aren't currently supported
- return SpanKind.INTERNAL;
- }
-}
-
 export const instrumentPrisma = generateInstrumentOnce<PrismaOptions>(INTEGRATION_NAME, options => {
  return new SentryPrismaInteropInstrumentation(options);
 });
@@ -177,26 +167,8 @@ export const instrumentPrisma = generateInstrumentOnce<PrismaOptions>(INTEGRATIO
  * 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: By default, this integration works with Prisma version 6.
- * To get performance instrumentation for other Prisma versions,
- * 1. Install the `@prisma/instrumentation` package with the desired version.
- * 1. Pass a `new PrismaInstrumentation()` instance as exported from `@prisma/instrumentation` to the `prismaInstrumentation` option of this integration:
- *
- * ```js
- * import { PrismaInstrumentation } from '@prisma/instrumentation'
- *
- * Sentry.init({
- * integrations: [
- * prismaIntegration({
- * // Override the default instrumentation that Sentry uses
- * prismaInstrumentation: new PrismaInstrumentation()
- * })
- * ]
- * })
- * ```
- *
- * The passed instrumentation instance will override the default instrumentation instance the integration would use, while the `prismaIntegration` will still ensure data compatibility for the various Prisma versions.
- * 1. Depending on your Prisma version (prior to version 6), add `previewFeatures = ["tracing"]` to the client generator block of your Prisma schema:
+ * NOTE: This integration works out of the box with Prisma v6, and v7.
+ * On Prisma versions prior to v6, add `previewFeatures = ["tracing"]` to the client generator block of your Prisma schema:
  *
  * ```
  * generator client {
@@ -218,6 +190,9 @@ export const prismaIntegration = defineIntegration((options?: PrismaOptions) =>
  return;
  }
 
+ // Prisma v5 engine spans are created via the `createEngineSpan` path above, which bypasses the
+ // tracing helper, so this hook applies origin, the db_query rename, and the db.system backfill to
+ // them. v6/v7 spans already get these from the helper; the guards are idempotent, so it's a no-op there.
  client.on('spanStart', span => {
  const spanJSON = spanToJSON(span);
  if (spanJSON.description?.startsWith('prisma:')) {

packages/node/src/integrations/tracing/prisma/vendored/active-tracing-helper.ts

@@ -6,149 +6,184 @@
  * - Vendored from: https://github.com/prisma/prisma/tree/b6feea5565ec577545a79547d24273ccdd11b4c7/packages/instrumentation
  * - Upstream version: @prisma/instrumentation@7.8.0
  * - Replaced `@prisma/instrumentation-contract` imports with local vendored types
- * - Minor TypeScript strictness adjustments for this repository's compiler settings
+ * - Span creation uses Sentry's span APIs (`startSpanManual` / `startInactiveSpan`) instead of the OTel tracer
+ * - Span creation sets the Sentry origin, renames `db_query` spans to their SQL text, and backfills
+ * `db.system` for older Prisma versions
  */
-/* eslint-disable */
 
+import type { Span, SpanAttributes, SpanKindValue, SpanLink } from '@sentry/core';
 import {
- Attributes,
- Context,
- context as _context,
- Span,
- SpanKind,
- SpanOptions,
- trace,
- Tracer,
- TracerProvider,
-} from '@opentelemetry/api';
-import type { EngineSpan, EngineSpanKind, ExtendedSpanOptions, SpanCallback, TracingHelper } from './types';
+ getActiveSpan,
+ SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
+ SPAN_KIND,
+ startInactiveSpan,
+ startSpanManual,
+} from '@sentry/core';
+import type { EngineSpan, ExtendedSpanOptions, SpanCallback, TracingHelper } from './types';
 
 const showAllTraces = process.env.PRISMA_SHOW_ALL_TRACES === 'true';
 
 const nonSampledTraceParent = `00-10-10-00`;
 
+const PRISMA_ORIGIN = 'auto.db.otel.prisma';
+
 type Options = {
- tracerProvider: TracerProvider;
  ignoreSpanTypes: (string | RegExp)[];
 };
 
-function engineSpanKindToOtelSpanKind(engineSpanKind: EngineSpanKind): SpanKind {
- switch (engineSpanKind) {
- case 'client':
- return SpanKind.CLIENT;
- case 'internal':
- default:
- return SpanKind.INTERNAL;
+/**
+ * Older Prisma versions emit `prisma:engine:db_query` spans without a `db.system`, so it's backfilled here.
+ */
+function buildSpanAttributes(name: string, attributes: Record<string, unknown> | undefined): SpanAttributes {
+ const merged: SpanAttributes = {
+ ...(attributes as SpanAttributes | undefined),
+ [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: PRISMA_ORIGIN,
+ };
+
+ if (name === 'prisma:engine:db_query' && merged['db.system'] == null) {
+ merged['db.system'] = 'prisma';
+ }
+
+ return merged;
+}
+
+/**
+ * Db query spans are named after their SQL text (e.g. `SELECT * FROM "User"`) rather than the generic
+ * engine name. v5/v6 emit `prisma:engine:db_query`; v7 inlined the engine and emits `prisma:client:db_query`.
+ */
+function buildSpanName(name: string, attributes: SpanAttributes): string {
+ const queryText = attributes['db.query.text'];
+ if ((name === 'prisma:engine:db_query' || name === 'prisma:client:db_query') && typeof queryText === 'string') {
+ return queryText;
  }
+ return name;
 }
 
 export class ActiveTracingHelper implements TracingHelper {
- private tracerProvider: TracerProvider;
  private ignoreSpanTypes: (string | RegExp)[];
 
- constructor({ tracerProvider, ignoreSpanTypes }: Options) {
- this.tracerProvider = tracerProvider;
+ public constructor({ ignoreSpanTypes }: Options) {
  this.ignoreSpanTypes = ignoreSpanTypes;
  }
 
- isEnabled(): boolean {
+public isEnabled(): boolean {
  return true;
  }
 
- getTraceParent(context?: Context | undefined): string {
- const span = trace.getSpanContext(context ?? _context.active());
- if (span) {
- return `00-${span.traceId}-${span.spanId}-0${span.traceFlags}`;
+public getTraceParent(span?: Span): string {
+ const spanContext = (span ?? getActiveSpan())?.spanContext();
+ if (spanContext) {
+ return `00-${spanContext.traceId}-${spanContext.spanId}-0${spanContext.traceFlags}`;
  }
  return nonSampledTraceParent;
  }
 
- dispatchEngineSpans(spans: EngineSpan[]): void {
- const tracer = this.tracerProvider.getTracer('prisma');
+ public dispatchEngineSpans(spans: EngineSpan[]): void {
  const linkIds = new Map<string, string>();
  const roots = spans.filter(span => span.parentId === null);
 
  for (const root of roots) {
- dispatchEngineSpan(tracer, root, spans, linkIds, this.ignoreSpanTypes);
+ dispatchEngineSpan(root, spans, linkIds, this.ignoreSpanTypes);
  }
  }
 
- getActiveContext(): Context | undefined {
- return _context.active();
+public getActiveContext(): Span | undefined {
+ return getActiveSpan();
  }
 
- runInChildSpan<R>(options: string | ExtendedSpanOptions, callback: SpanCallback<R>): R {
- if (typeof options === 'string') {
- options = { name: options };
- }
+ public runInChildSpan<R>(nameOrOptions: string | ExtendedSpanOptions, callback: SpanCallback<R>): R {
+ const options: ExtendedSpanOptions = typeof nameOrOptions === 'string' ? { name: nameOrOptions } : nameOrOptions;
 
  if (options.internal && !showAllTraces) {
  return callback();
  }
 
- const tracer = this.tracerProvider.getTracer('prisma');
- const context = options.context ?? this.getActiveContext();
  const name = `prisma:client:${options.name}`;
 
  if (shouldIgnoreSpan(name, this.ignoreSpanTypes)) {
  return callback();
  }
 
+ const parentSpan = getActiveSpan();
+
+ const attributes = buildSpanAttributes(name, options.attributes as Record<string, unknown> | undefined);
+ const spanOptions = {
+ name: buildSpanName(name, attributes),
+ attributes,
+ kind: options.kind as SpanKindValue | undefined,
+ links: options.links as SpanLink[] | undefined,
+ startTime: options.startTime,
+ parentSpan,
+ };
+
  if (options.active === false) {
- const span = tracer.startSpan(name, options, context);
- return endSpan(span, callback(span, context));
+ const span = startInactiveSpan(spanOptions);
+ return endSpan(span, () => callback(span, parentSpan));
  }
 
- return tracer.startActiveSpan(name, options, span => endSpan(span, callback(span, context)));
+ return startSpanManual(spanOptions, span => endSpan(span, () => callback(span, parentSpan)));
  }
 }
 
 function dispatchEngineSpan(
- tracer: Tracer,
  engineSpan: EngineSpan,
  allSpans: EngineSpan[],
  linkIds: Map<string, string>,
  ignoreSpanTypes: (string | RegExp)[],
-) {
- if (shouldIgnoreSpan(engineSpan.name, ignoreSpanTypes)) return;
-
- const spanOptions = {
- attributes: engineSpan.attributes as Attributes,
- kind: engineSpanKindToOtelSpanKind(engineSpan.kind),
- startTime: engineSpan.startTime,
- } satisfies SpanOptions;
-
- tracer.startActiveSpan(engineSpan.name, spanOptions, span => {
- linkIds.set(engineSpan.id, span.spanContext().spanId);
-
- if (engineSpan.links) {
- span.addLinks(
- engineSpan.links.flatMap(link => {
- const linkedId = linkIds.get(link);
- if (!linkedId) {
- return [];
- }
- return {
- context: {
- spanId: linkedId,
- traceId: span.spanContext().traceId,
- traceFlags: span.spanContext().traceFlags,
- },
- };
- }),
- );
- }
-
- const children = allSpans.filter(s => s.parentId === engineSpan.id);
- for (const child of children) {
- dispatchEngineSpan(tracer, child, allSpans, linkIds, ignoreSpanTypes);
- }
+): void {
+ if (shouldIgnoreSpan(engineSpan.name, ignoreSpanTypes)) {
+ return;
+ }
 
- span.end(engineSpan.endTime);
- });
+ const attributes = buildSpanAttributes(engineSpan.name, engineSpan.attributes);
+
+ startSpanManual(
+ {
+ name: buildSpanName(engineSpan.name, attributes),
+ attributes,
+ kind: engineSpan.kind === 'client' ? SPAN_KIND.CLIENT : SPAN_KIND.INTERNAL,
+ startTime: engineSpan.startTime,
+ },
+ span => {
+ linkIds.set(engineSpan.id, span.spanContext().spanId);
+
+ if (engineSpan.links) {
+ span.addLinks(
+ engineSpan.links.flatMap(link => {
+ const linkedId = linkIds.get(link);
+ if (!linkedId) {
+ return [];
+ }
+ return {
+ context: {
+ spanId: linkedId,
+ traceId: span.spanContext().traceId,
+ traceFlags: span.spanContext().traceFlags,
+ },
+ };
+ }),
+ );
+ }
+
+ const children = allSpans.filter(s => s.parentId === engineSpan.id);
+ for (const child of children) {
+ dispatchEngineSpan(child, allSpans, linkIds, ignoreSpanTypes);
+ }
+
+ span.end(engineSpan.endTime);
+ },
+ );
 }
 
-function endSpan<T>(span: Span, result: T): T {
+function endSpan<T>(span: Span, run: () => T): T {
+ let result: T;
+ try {
+ result = run();
+ } catch (reason) {
+ span.end();
+ throw reason;
+ }
+
  if (isPromiseLike(result)) {
  return result.then(
  value => {