feat: migrate Prisma from 6.14.0 to 7.7.0 with driver adapters (PR #3391)

- Update schema.prisma for Prisma 7 compatibility
- Add prisma.config.ts with driver adapter setup
- Update transaction.ts for new Prisma client API
- Update docker/entrypoint.sh and Dockerfile for pnpm 10.23.0
- Update package.json across packages for Prisma 7 deps
- Update testcontainers, run-engine tests for new Prisma version
- Add references/prisma-7/package.json placeholder

Closes #3391

Author: deepshekhardas

apps/webapp/app/db.server.ts

@@ -7,6 +7,8 @@ import {
   type PrismaTransactionClient,
   type PrismaTransactionOptions,
 } from "@trigger.dev/database";
+import { PrismaPg } from "@prisma/adapter-pg";
+import { createHash } from "node:crypto";
 import invariant from "tiny-invariant";
 import { z } from "zod";
 import { env } from "./env.server";
@@ -127,21 +129,30 @@ function getClient() {
   const { DATABASE_URL } = process.env;
   invariant(typeof DATABASE_URL === "string", "DATABASE_URL env var not set");
 
-  const databaseUrl = extendQueryParams(DATABASE_URL, {
-    connection_limit: env.DATABASE_CONNECTION_LIMIT.toString(),
-    pool_timeout: env.DATABASE_POOL_TIMEOUT.toString(),
-    connection_timeout: env.DATABASE_CONNECTION_TIMEOUT.toString(),
-    application_name: env.SERVICE_NAME,
-  });
+  const databaseUrl = new URL(DATABASE_URL);
+
+  // Set application_name as a query param on the connection string (pg understands this)
+  databaseUrl.searchParams.set("application_name", env.SERVICE_NAME);
 
   console.log(`🔌 setting up prisma client to ${redactUrlSecrets(databaseUrl)}`);
 
-  const client = new PrismaClient({
-    datasources: {
-      db: {
-        url: databaseUrl.href,
-      },
+  const adapter = new PrismaPg(
+    {
+      connectionString: databaseUrl.href,
+      max: env.DATABASE_CONNECTION_LIMIT,
+      idleTimeoutMillis: env.DATABASE_CONNECTION_TIMEOUT * 1000,
+      connectionTimeoutMillis: env.DATABASE_CONNECTION_TIMEOUT * 1000,
     },
+    {
+      // Generate deterministic prepared statement names from query SQL so PostgreSQL
+      // can reuse cached query plans. Without this, every query uses an anonymous
+      // prepared statement that PG must parse and plan from scratch each time.
+      statementNameGenerator: (query) => `p_${createHash("sha256").update(query.sql).digest("hex").slice(0, 16)}`,
+    }
+  );
+
+  const client = new PrismaClient({
+    adapter,
     log: [
       // events
       {
@@ -251,21 +262,25 @@ function getReplicaClient() {
     return;
   }
 
-  const replicaUrl = extendQueryParams(env.DATABASE_READ_REPLICA_URL, {
-    connection_limit: env.DATABASE_CONNECTION_LIMIT.toString(),
-    pool_timeout: env.DATABASE_POOL_TIMEOUT.toString(),
-    connection_timeout: env.DATABASE_CONNECTION_TIMEOUT.toString(),
-    application_name: env.SERVICE_NAME,
-  });
+  const replicaUrl = new URL(env.DATABASE_READ_REPLICA_URL);
+  replicaUrl.searchParams.set("application_name", env.SERVICE_NAME);
 
   console.log(`🔌 setting up read replica connection to ${redactUrlSecrets(replicaUrl)}`);
 
-  const replicaClient = new PrismaClient({
-    datasources: {
-      db: {
-        url: replicaUrl.href,
-      },
+  const adapter = new PrismaPg(
+    {
+      connectionString: replicaUrl.href,
+      max: env.DATABASE_CONNECTION_LIMIT,
+      idleTimeoutMillis: env.DATABASE_CONNECTION_TIMEOUT * 1000,
+      connectionTimeoutMillis: env.DATABASE_CONNECTION_TIMEOUT * 1000,
     },
+    {
+      statementNameGenerator: (query) => `p_${createHash("sha256").update(query.sql).digest("hex").slice(0, 16)}`,
+    }
+  );
+
+  const replicaClient = new PrismaClient({
+    adapter,
     log: [
       // events
       {
@@ -368,19 +383,6 @@ function getReplicaClient() {
   return replicaClient;
 }
 
-function extendQueryParams(hrefOrUrl: string | URL, queryParams: Record<string, string>) {
-  const url = new URL(hrefOrUrl);
-  const query = url.searchParams;
-
-  for (const [key, val] of Object.entries(queryParams)) {
-    query.set(key, val);
-  }
-
-  url.search = query.toString();
-
-  return url;
-}
-
 function redactUrlSecrets(hrefOrUrl: string | URL) {
   const url = new URL(hrefOrUrl);
   url.password = "";

apps/webapp/app/routes/metrics.ts

@@ -1,5 +1,4 @@
 import { LoaderFunctionArgs } from "@remix-run/server-runtime";
-import { prisma } from "~/db.server";
 import { metricsRegister } from "~/metrics.server";
 
 export async function loader({ request }: LoaderFunctionArgs) {
@@ -13,14 +12,9 @@ export async function loader({ request }: LoaderFunctionArgs) {
     }
   }
 
-  // We need to remove empty lines from the prisma metrics, grafana doesn't like them
-  const prismaMetrics = (await prisma.$metrics.prometheus()).replace(/^\s*[\r\n]/gm, "");
   const coreMetrics = await metricsRegister.metrics();
 
-  // Order matters, core metrics end with `# EOF`, prisma metrics don't
-  const metrics = prismaMetrics + coreMetrics;
-
-  return new Response(metrics, {
+  return new Response(coreMetrics, {
     headers: {
       "Content-Type": metricsRegister.contentType,
     },

apps/webapp/app/v3/tracer.server.ts

@@ -56,9 +56,7 @@ import { LoggerSpanExporter } from "./telemetry/loggerExporter.server";
 import { CompactMetricExporter } from "./telemetry/compactMetricExporter.server";
 import { logger } from "~/services/logger.server";
 import { flattenAttributes } from "@trigger.dev/core/v3";
-import { prisma } from "~/db.server";
 import { metricsRegister } from "~/metrics.server";
-import type { Prisma } from "@trigger.dev/database";
 import { performance } from "node:perf_hooks";
 
 export const SEMINTATTRS_FORCE_RECORDING = "forceRecording";
@@ -352,221 +350,12 @@ function setupMetrics() {
 
   const meter = meterProvider.getMeter("trigger.dev", "3.3.12");
 
-  configurePrismaMetrics({ meter });
   configureNodejsMetrics({ meter });
   configureHostMetrics({ meterProvider });
 
   return meter;
 }
 
-function configurePrismaMetrics({ meter }: { meter: Meter }) {
-  // Counters
-  const queriesTotal = meter.createObservableCounter("db.client.queries.total", {
-    description: "Total number of Prisma Client queries executed",
-    unit: "queries",
-  });
-  const datasourceQueriesTotal = meter.createObservableCounter("db.datasource.queries.total", {
-    description: "Total number of datasource queries executed",
-    unit: "queries",
-  });
-  const connectionsOpenedTotal = meter.createObservableCounter("db.pool.connections.opened.total", {
-    description: "Total number of pool connections opened",
-    unit: "connections",
-  });
-  const connectionsClosedTotal = meter.createObservableCounter("db.pool.connections.closed.total", {
-    description: "Total number of pool connections closed",
-    unit: "connections",
-  });
-
-  // Gauges
-  const queriesActive = meter.createObservableGauge("db.client.queries.active", {
-    description: "Number of currently active Prisma Client queries",
-    unit: "queries",
-  });
-  const queriesWait = meter.createObservableGauge("db.client.queries.wait", {
-    description: "Number of queries currently waiting for a connection",
-    unit: "queries",
-  });
-  const totalGauge = meter.createObservableGauge("db.pool.connections.total", {
-    description: "Open Prisma-pool connections",
-    unit: "connections",
-  });
-  const busyGauge = meter.createObservableGauge("db.pool.connections.busy", {
-    description: "Connections currently executing queries",
-    unit: "connections",
-  });
-  const freeGauge = meter.createObservableGauge("db.pool.connections.free", {
-    description: "Idle (free) connections in the pool",
-    unit: "connections",
-  });
-
-  // Histogram statistics as gauges
-  const queriesWaitTimeCount = meter.createObservableGauge("db.client.queries.wait_time.count", {
-    description: "Number of wait time observations",
-    unit: "observations",
-  });
-  const queriesWaitTimeSum = meter.createObservableGauge("db.client.queries.wait_time.sum", {
-    description: "Total wait time across all observations",
-    unit: "ms",
-  });
-  const queriesWaitTimeMean = meter.createObservableGauge("db.client.queries.wait_time.mean", {
-    description: "Average wait time for a connection",
-    unit: "ms",
-  });
-
-  const queriesDurationCount = meter.createObservableGauge("db.client.queries.duration.count", {
-    description: "Number of query duration observations",
-    unit: "observations",
-  });
-  const queriesDurationSum = meter.createObservableGauge("db.client.queries.duration.sum", {
-    description: "Total query duration across all observations",
-    unit: "ms",
-  });
-  const queriesDurationMean = meter.createObservableGauge("db.client.queries.duration.mean", {
-    description: "Average duration of Prisma Client queries",
-    unit: "ms",
-  });
-
-  const datasourceQueriesDurationCount = meter.createObservableGauge(
-    "db.datasource.queries.duration.count",
-    {
-      description: "Number of datasource query duration observations",
-      unit: "observations",
-    }
-  );
-  const datasourceQueriesDurationSum = meter.createObservableGauge(
-    "db.datasource.queries.duration.sum",
-    {
-      description: "Total datasource query duration across all observations",
-      unit: "ms",
-    }
-  );
-  const datasourceQueriesDurationMean = meter.createObservableGauge(
-    "db.datasource.queries.duration.mean",
-    {
-      description: "Average duration of datasource queries",
-      unit: "ms",
-    }
-  );
-
-  // Single helper so we hit Prisma only once per scrape ---------------------
-  async function readPrismaMetrics() {
-    const metrics = await prisma.$metrics.json();
-
-    // Extract counter values
-    const counters: Record<string, number> = {};
-    for (const counter of metrics.counters) {
-      counters[counter.key] = counter.value;
-    }
-
-    // Extract gauge values
-    const gauges: Record<string, number> = {};
-    for (const gauge of metrics.gauges) {
-      gauges[gauge.key] = gauge.value;
-    }
-
-    // Extract histogram values
-    const histograms: Record<string, Prisma.MetricHistogram> = {};
-    for (const histogram of metrics.histograms) {
-      histograms[histogram.key] = histogram.value;
-    }
-
-    return {
-      counters: {
-        queriesTotal: counters["prisma_client_queries_total"] ?? 0,
-        datasourceQueriesTotal: counters["prisma_datasource_queries_total"] ?? 0,
-        connectionsOpenedTotal: counters["prisma_pool_connections_opened_total"] ?? 0,
-        connectionsClosedTotal: counters["prisma_pool_connections_closed_total"] ?? 0,
-      },
-      gauges: {
-        queriesActive: gauges["prisma_client_queries_active"] ?? 0,
-        queriesWait: gauges["prisma_client_queries_wait"] ?? 0,
-        connectionsOpen: gauges["prisma_pool_connections_open"] ?? 0,
-        connectionsBusy: gauges["prisma_pool_connections_busy"] ?? 0,
-        connectionsIdle: gauges["prisma_pool_connections_idle"] ?? 0,
-      },
-      histograms: {
-        queriesWait: histograms["prisma_client_queries_wait_histogram_ms"],
-        queriesDuration: histograms["prisma_client_queries_duration_histogram_ms"],
-        datasourceQueriesDuration: histograms["prisma_datasource_queries_duration_histogram_ms"],
-      },
-    };
-  }
-
-  meter.addBatchObservableCallback(
-    async (res) => {
-      const { counters, gauges, histograms } = await readPrismaMetrics();
-
-      // Observe counters
-      res.observe(queriesTotal, counters.queriesTotal);
-      res.observe(datasourceQueriesTotal, counters.datasourceQueriesTotal);
-      res.observe(connectionsOpenedTotal, counters.connectionsOpenedTotal);
-      res.observe(connectionsClosedTotal, counters.connectionsClosedTotal);
-
-      // Observe gauges
-      res.observe(queriesActive, gauges.queriesActive);
-      res.observe(queriesWait, gauges.queriesWait);
-      res.observe(totalGauge, gauges.connectionsOpen);
-      res.observe(busyGauge, gauges.connectionsBusy);
-      res.observe(freeGauge, gauges.connectionsIdle);
-
-      // Observe histogram statistics as gauges
-      if (histograms.queriesWait) {
-        res.observe(queriesWaitTimeCount, histograms.queriesWait.count);
-        res.observe(queriesWaitTimeSum, histograms.queriesWait.sum);
-        res.observe(
-          queriesWaitTimeMean,
-          histograms.queriesWait.count > 0
-            ? histograms.queriesWait.sum / histograms.queriesWait.count
-            : 0
-        );
-      }
-
-      if (histograms.queriesDuration) {
-        res.observe(queriesDurationCount, histograms.queriesDuration.count);
-        res.observe(queriesDurationSum, histograms.queriesDuration.sum);
-        res.observe(
-          queriesDurationMean,
-          histograms.queriesDuration.count > 0
-            ? histograms.queriesDuration.sum / histograms.queriesDuration.count
-            : 0
-        );
-      }
-
-      if (histograms.datasourceQueriesDuration) {
-        res.observe(datasourceQueriesDurationCount, histograms.datasourceQueriesDuration.count);
-        res.observe(datasourceQueriesDurationSum, histograms.datasourceQueriesDuration.sum);
-        res.observe(
-          datasourceQueriesDurationMean,
-          histograms.datasourceQueriesDuration.count > 0
-            ? histograms.datasourceQueriesDuration.sum / histograms.datasourceQueriesDuration.count
-            : 0
-        );
-      }
-    },
-    [
-      queriesTotal,
-      datasourceQueriesTotal,
-      connectionsOpenedTotal,
-      connectionsClosedTotal,
-      queriesActive,
-      queriesWait,
-      totalGauge,
-      busyGauge,
-      freeGauge,
-      queriesWaitTimeCount,
-      queriesWaitTimeSum,
-      queriesWaitTimeMean,
-      queriesDurationCount,
-      queriesDurationSum,
-      queriesDurationMean,
-      datasourceQueriesDurationCount,
-      datasourceQueriesDurationSum,
-      datasourceQueriesDurationMean,
-    ]
-  );
-}
-
 function configureNodejsMetrics({ meter }: { meter: Meter }) {
   if (!env.INTERNAL_OTEL_NODEJS_METRICS_ENABLED) {
     return;

apps/webapp/package.json

@@ -89,7 +89,7 @@
     "@opentelemetry/sdk-trace-node": "2.0.1",
     "@opentelemetry/semantic-conventions": "1.36.0",
     "@popperjs/core": "^2.11.8",
-    "@prisma/instrumentation": "^6.14.0",
+    "@prisma/instrumentation": "^7.7.0",
     "@radix-ui/react-accordion": "^1.2.11",
     "@radix-ui/react-alert-dialog": "^1.0.4",
     "@radix-ui/react-dialog": "^1.0.3",

apps/webapp/test/runsReplicationBenchmark.producer.ts

@@ -5,6 +5,7 @@
  */
 
 import { PrismaClient } from "@trigger.dev/database";
+import { PrismaPg } from "@prisma/adapter-pg";
 import { performance } from "node:perf_hooks";
 
 interface ProducerConfig {
@@ -91,13 +92,8 @@ function generateError() {
 }
 
 async function runProducer(config: ProducerConfig) {
-  const prisma = new PrismaClient({
-    datasources: {
-      db: {
-        url: config.postgresUrl,
-      },
-    },
-  });
+  const adapter = new PrismaPg(config.postgresUrl);
+  const prisma = new PrismaClient({ adapter });
 
   try {
     console.log(