velocious 1.0.602 → 1.0.604

package/build/database/drivers/mysql/deadlock-diagnostic-parser.js

@@ -0,0 +1,227 @@
+// @ts-check
+
+/**
+ * InnodbDeadlockLockNode type.
+ * @typedef {object} InnodbDeadlockLockNode
+ * @property {string} indexFingerprint - Opaque index identity.
+ * @property {string} lockMode - Allowlisted lock mode.
+ * @property {"conflicting" | "held" | "waiting"} state - Lock relationship to its transaction.
+ * @property {string} tableFingerprint - Opaque table identity.
+ */
+
+/**
+ * InnodbDeadlockTransactionNode type.
+ * @typedef {object} InnodbDeadlockTransactionNode
+ * @property {InnodbDeadlockLockNode[]} conflictingLocks - Bounded counterparty conflict edges whose owner is unavailable.
+ * @property {InnodbDeadlockLockNode[]} locks - Bounded locks owned or awaited by this transaction.
+ * @property {number} ordinal - Report-local transaction ordinal.
+ */
+
+/**
+ * InnodbDeadlockParserState type.
+ * @typedef {object} InnodbDeadlockParserState
+ * @property {InnodbDeadlockTransactionNode | undefined} currentTransaction - Current bounded transaction node.
+ * @property {"conflicting" | "held" | "waiting" | undefined} currentLockState - Current lock section state.
+ * @property {number} lockRecordCount - Total emitted lock nodes.
+ * @property {boolean} lockRecordsTruncated - Whether a lock-node bound was reached.
+ * @property {InnodbDeadlockTransactionNode[]} transactionNodes - Bounded transaction nodes.
+ * @property {boolean} transactionNodesTruncated - Whether the transaction-node bound was reached.
+ * @property {number} transactions - Transaction headers observed in the bounded section.
+ * @property {number | null} victimTransaction - Victim ordinal.
+ */
+
+import sha256Hex from "../../../utils/sha256-hex.js"
+
+const INNODB_STATUS_SCAN_MAX_CHARS = 65536
+const INNODB_DEADLOCK_SECTION_MAX_CHARS = 16384
+const INNODB_DEADLOCK_TRANSACTION_MAX = 8
+const INNODB_DEADLOCK_LOCKS_PER_TRANSACTION_MAX = 8
+const INNODB_DEADLOCK_LOCK_RECORD_MAX = 32
+const INNODB_DEADLOCK_LINE_MAX_CHARS = 1024
+
+/**
+ * Parses a bounded InnoDB latest-deadlock section into safe structural context.
+ * @param {string} status - SHOW ENGINE INNODB STATUS text.
+ * @returns {{lockRecordsTruncated: boolean, sectionTruncated: boolean, transactionNodes: InnodbDeadlockTransactionNode[], transactionNodesTruncated: boolean, transactions: number, victimTransaction: number | null}} - Structural deadlock summary.
+ */
+export default function parseInnodbDeadlockSummary(status) {
+  const {candidate, sectionTruncated} = boundedDeadlockSection(status)
+  /** @type {InnodbDeadlockParserState} */
+  const state = {
+    currentTransaction: undefined,
+    currentLockState: undefined,
+    lockRecordCount: 0,
+    lockRecordsTruncated: false,
+    transactionNodes: [],
+    transactionNodesTruncated: false,
+    transactions: 0,
+    victimTransaction: null
+  }
+
+  for (const line of candidate.split(/\r?\n/)) {
+    const trimmed = line.slice(0, INNODB_DEADLOCK_LINE_MAX_CHARS).trim()
+    const transactionOrdinal = transactionHeaderOrdinal(trimmed)
+
+    if (transactionOrdinal !== undefined) {
+      startTransactionNode(state, transactionOrdinal)
+      continue
+    }
+
+    const lockStateMarker = transactionLockStateMarker(trimmed, state.currentTransaction)
+
+    if (lockStateMarker.matched) {
+      state.currentLockState = lockStateMarker.state
+      continue
+    }
+
+    const victimOrdinal = victimTransactionOrdinal(trimmed)
+
+    if (victimOrdinal !== undefined) state.victimTransaction = victimOrdinal
+    appendLockNode(state, trimmed)
+  }
+
+  return {
+    lockRecordsTruncated: state.lockRecordsTruncated,
+    sectionTruncated,
+    transactionNodes: state.transactionNodes,
+    transactionNodesTruncated: state.transactionNodesTruncated,
+    transactions: state.transactions,
+    victimTransaction: state.victimTransaction
+  }
+}
+
+/**
+ * Extracts and caps the latest-deadlock section.
+ * @param {string} status - Raw server status.
+ * @returns {{candidate: string, sectionTruncated: boolean}} - Bounded candidate and truncation state.
+ */
+function boundedDeadlockSection(status) {
+  const scannedStatus = status.slice(0, INNODB_STATUS_SCAN_MAX_CHARS)
+  const deadlockStart = scannedStatus.indexOf("LATEST DETECTED DEADLOCK")
+  const availableSection = deadlockStart >= 0 ? scannedStatus.slice(deadlockStart) : ""
+  const boundedSection = availableSection.slice(0, INNODB_DEADLOCK_SECTION_MAX_CHARS)
+  const sectionEndMatch = /\n-{10,}\r?\nTRANSACTIONS\r?\n-{10,}/.exec(boundedSection)
+  const scannedStatusTruncated = status.length > scannedStatus.length
+
+  return {
+    candidate: sectionEndMatch ? boundedSection.slice(0, sectionEndMatch.index) : boundedSection,
+    sectionTruncated: !sectionEndMatch && deadlockStart >= 0 && (
+      availableSection.length > boundedSection.length || scannedStatusTruncated
+    )
+  }
+}
+
+/**
+ * Returns a fixed-format transaction header ordinal.
+ * @param {string} line - Bounded status line.
+ * @returns {number | undefined} - Transaction ordinal.
+ */
+function transactionHeaderOrdinal(line) {
+  const match = /^\*\*\* \((\d{1,6})\) TRANSACTION:$/.exec(line)
+
+  return match ? Number(match[1]) : undefined
+}
+
+/**
+ * Starts a bounded transaction node.
+ * @param {InnodbDeadlockParserState} state - Parser state.
+ * @param {number} ordinal - Transaction ordinal.
+ * @returns {void}
+ */
+function startTransactionNode(state, ordinal) {
+  state.transactions++
+  state.currentLockState = undefined
+
+  if (state.transactionNodes.length >= INNODB_DEADLOCK_TRANSACTION_MAX) {
+    state.currentTransaction = undefined
+    state.transactionNodesTruncated = true
+    return
+  }
+
+  state.currentTransaction = {conflictingLocks: [], locks: [], ordinal}
+  state.transactionNodes.push(state.currentTransaction)
+}
+
+/**
+ * Parses a fixed-format held/waiting marker for the current transaction.
+ * @param {string} line - Bounded status line.
+ * @param {InnodbDeadlockTransactionNode | undefined} currentTransaction - Current transaction.
+ * @returns {{matched: boolean, state: "conflicting" | "held" | "waiting" | undefined}} - Marker result.
+ */
+function transactionLockStateMarker(line, currentTransaction) {
+  const numberedMatch = /^\*\*\* \((\d{1,6})\) (HOLDS THE LOCK\(S\)|WAITING FOR THIS LOCK TO BE GRANTED):$/.exec(line)
+
+  if (numberedMatch) {
+    if (!currentTransaction || currentTransaction.ordinal != Number(numberedMatch[1])) return {matched: true, state: undefined}
+
+    return {matched: true, state: numberedMatch[2] == "HOLDS THE LOCK(S)" ? "held" : "waiting"}
+  }
+
+  const unnumberedMatch = /^\*\*\* (WAITING FOR THIS LOCK TO BE GRANTED|CONFLICTING WITH):$/.exec(line)
+
+  if (!unnumberedMatch) return {matched: false, state: undefined}
+  if (!currentTransaction) return {matched: true, state: undefined}
+
+  return {matched: true, state: unnumberedMatch[1] == "CONFLICTING WITH" ? "conflicting" : "waiting"}
+}
+
+/**
+ * Returns a fixed-format victim ordinal.
+ * @param {string} line - Bounded status line.
+ * @returns {number | undefined} - Victim ordinal.
+ */
+function victimTransactionOrdinal(line) {
+  const match = /^\*\*\* WE ROLL BACK TRANSACTION \((\d{1,6})\)$/.exec(line)
+
+  return match ? Number(match[1]) : undefined
+}
+
+/**
+ * Appends one bounded, fixed-format lock node when the line is eligible.
+ * @param {InnodbDeadlockParserState} state - Parser state.
+ * @param {string} line - Bounded status line.
+ * @returns {void}
+ */
+function appendLockNode(state, line) {
+  if (!state.currentTransaction || !state.currentLockState || !line.startsWith("RECORD LOCKS ")) return
+
+  if (
+    state.lockRecordCount >= INNODB_DEADLOCK_LOCK_RECORD_MAX ||
+    state.currentTransaction.locks.length + state.currentTransaction.conflictingLocks.length >= INNODB_DEADLOCK_LOCKS_PER_TRANSACTION_MAX
+  ) {
+    state.lockRecordsTruncated = true
+    return
+  }
+
+  const lock = deadlockLockNode(line, state.currentLockState)
+
+  if (!lock) return
+
+  if (state.currentLockState == "conflicting") {
+    state.currentTransaction.conflictingLocks.push(lock)
+  } else {
+    state.currentTransaction.locks.push(lock)
+  }
+  state.lockRecordCount++
+}
+
+/**
+ * Parses one fixed-format RECORD LOCKS line into safe structural fields.
+ * @param {string} line - One bounded InnoDB status line.
+ * @param {"conflicting" | "held" | "waiting"} state - Lock relationship to its transaction.
+ * @returns {InnodbDeadlockLockNode | undefined} - Safe lock node.
+ */
+function deadlockLockNode(line, state) {
+  const identifier = "(?:`(?:``|[^`\\r\\n]){1,128}`|[A-Za-z0-9_$-]{1,128})"
+  const tableIdentifier = `(?:${identifier}\\.)?${identifier}`
+  const lockMatch = new RegExp(`^RECORD LOCKS .{1,512}? index (${identifier}) of table (${tableIdentifier}) trx id \\S{1,64}(?: \\S{1,64})? lock_mode (X|S|IX|IS|AUTO_INC)(?:\\s|$)`).exec(line)
+
+  if (!lockMatch) return undefined
+
+  return {
+    indexFingerprint: `sha256:${sha256Hex(`innodb-index:v1\0${lockMatch[1]}`)}`,
+    lockMode: lockMatch[3],
+    state,
+    tableFingerprint: `sha256:${sha256Hex(`innodb-table:v1\0${lockMatch[2]}`)}`
+  }
+}

package/build/database/drivers/mysql/index.js

@@ -21,6 +21,7 @@ import Table from "./table.js"
 import StructureSql from "./structure-sql.js"
 import Upsert from "./sql/upsert.js"
 import Update from "./sql/update.js"
+import parseInnodbDeadlockSummary from "./deadlock-diagnostic-parser.js"
 
 /**
  * Sentinel timeout (in seconds) used as the "block forever" value when a
@@ -365,14 +366,12 @@ export default class VelociousDatabaseDriversMysql extends Base{
       // A deadlock or lock-wait-timeout aborts the whole transaction; it must be retried at the
       // transaction level (re-running the callback), not the query level, so flag it as such and
       // keep `retry` false so an in-transaction query does not retry against the dead transaction.
-      if (
-        errorCode == "ER_LOCK_DEADLOCK" ||
-        errorCode == "ER_LOCK_WAIT_TIMEOUT" ||
-        message.includes("ER_LOCK_DEADLOCK") ||
-        message.includes("Deadlock found") ||
-        message.includes("Lock wait timeout exceeded")
-      ) {
-        return {retry: false, reconnect: false, deadlock: true, waitMs: 50}
+      if (errorCode == "ER_LOCK_DEADLOCK" || message.includes("ER_LOCK_DEADLOCK") || message.includes("Deadlock found")) {
+        return {retry: false, reconnect: false, deadlock: true, contentionKind: "deadlock", waitMs: 50}
+      }
+
+      if (errorCode == "ER_LOCK_WAIT_TIMEOUT" || message.includes("Lock wait timeout exceeded")) {
+        return {retry: false, reconnect: false, deadlock: true, contentionKind: "lock-wait-timeout", waitMs: 50}
       }
 
       shouldReconnect ||= (
@@ -397,19 +396,24 @@ export default class VelociousDatabaseDriversMysql extends Base{
    * Adds a redacted, bounded excerpt from MySQL's latest InnoDB deadlock report. Capture uses a
    * separate short-lived connection so it cannot queue ahead of rollback or the next retry on this
    * driver's single-connection pool.
+   * @param {import("../base.js").DeadlockRetryDiagnosticSnapshot} snapshot - Immutable retry snapshot.
    * @returns {Promise<Record<string, ReturnType<typeof JSON.parse>>>} - Safe diagnostic context.
    */
-  async _deadlockDiagnosticContext() {
-    try {
-      const status = await this._captureInnodbDeadlockStatus()
+  async _deadlockDiagnosticContext(snapshot) {
+    if (snapshot.contentionKind == "lock-wait-timeout") return {statusCapture: "not-applicable"}
 
-      return {
-        innodbDeadlockSummary: this._innodbDeadlockSummary(status),
-        statusCapture: "captured"
-      }
+    let status
+
+    try {
+      status = await this._captureInnodbDeadlockStatus()
     } catch {
       return {statusCapture: "failed"}
     }
+
+    return {
+      innodbDeadlockSummary: this._innodbDeadlockSummary(status),
+      statusCapture: "captured"
+    }
   }
 
   /**
@@ -465,23 +469,10 @@ export default class VelociousDatabaseDriversMysql extends Base{
    * Extracts only fixed-format deadlock counters. The server report contains raw SQL, identifiers,
    * and physical record data, so no source text is ever included in an application diagnostic.
    * @param {string} status - SHOW ENGINE INNODB STATUS text.
-   * @returns {{transactions: number, victimTransaction: number | null}} - Structural deadlock summary.
+   * @returns {{lockRecordsTruncated: boolean, sectionTruncated: boolean, transactionNodes: Array<{conflictingLocks: Array<{indexFingerprint: string, lockMode: string, state: string, tableFingerprint: string}>, locks: Array<{indexFingerprint: string, lockMode: string, state: string, tableFingerprint: string}>, ordinal: number}>, transactionNodesTruncated: boolean, transactions: number, victimTransaction: number | null}} - Structural deadlock summary.
    */
   _innodbDeadlockSummary(status) {
-    const deadlockStart = status.indexOf("LATEST DETECTED DEADLOCK")
-    const candidate = deadlockStart >= 0 ? status.slice(deadlockStart) : status
-    let transactions = 0
-    /** @type {number | null} */
-    let victimTransaction = null
-
-    for (const line of candidate.split(/\r?\n/)) {
-      const trimmed = line.trim()
-      if (/^\*\*\* \(\d+\) TRANSACTION:$/.test(trimmed)) transactions++
-      const victimMatch = /^\*\*\* WE ROLL BACK TRANSACTION \((\d+)\)$/.exec(trimmed)
-      if (victimMatch) victimTransaction = Number(victimMatch[1])
-    }
-
-    return {transactions, victimTransaction}
+    return parseInnodbDeadlockSummary(status)
   }
 
   /**
@@ -527,7 +518,15 @@ export default class VelociousDatabaseDriversMysql extends Base{
     if (!this.pool) await this.connect()
     if (!this.pool) throw new Error("MySQL pool failed to initialize")
 
-    yield* streamQuery(this.pool, sql)
+    const profileAttempt = this._startProfiledQueryAttempt(sql)
+    let failed = true
+
+    try {
+      yield* streamQuery(this.pool, sql)
+      failed = false
+    } finally {
+      this._finishProfiledQueryAttempt(profileAttempt, failed)
+    }
   }
 
   /**
@@ -567,13 +566,20 @@ export default class VelociousDatabaseDriversMysql extends Base{
     if (!this.pool) throw new Error("MySQL pool failed to initialize")
 
     const pool = this.pool
+    const profileAttempt = this._startProfiledQueryAttempt(structureSql)
+    let failed = true
 
-    await new Promise((resolve, reject) => {
-      pool.query(structureSql, (error) => {
-        if (error) reject(error)
-        else resolve(undefined)
+    try {
+      await new Promise((resolve, reject) => {
+        pool.query(structureSql, (error) => {
+          if (error) reject(error)
+          else resolve(undefined)
+        })
       })
-    })
+      failed = false
+    } finally {
+      this._finishProfiledQueryAttempt(profileAttempt, failed)
+    }
 
     return true
   }

package/build/database/pool/async-tracked-multi-connection.js

@@ -1,7 +1,8 @@
 // @ts-check
 
-import {AsyncLocalStorage} from "async_hooks"
-import BasePool, {POOL_CONFIGURATION_KEY} from "./base.js"
+import { AsyncLocalStorage } from "async_hooks"
+import BasePool, { POOL_CONFIGURATION_KEY } from "./base.js"
+import { currentTestProfileContext } from "../../testing/test-profile-context.js"
 
 /**
  * PendingCheckout type.
@@ -15,6 +16,7 @@ import BasePool, {POOL_CONFIGURATION_KEY} from "./base.js"
  * @property {number | null} timeoutAt - Timestamp when the checkout will time out, or null when disabled.
  * @property {number | null} timeoutMillis - Milliseconds to wait before rejecting, or null when disabled.
  * @property {ReturnType<typeof setTimeout> | undefined} timeoutTimer - Timer that rejects the pending checkout.
+ * @property {import("../../testing/test-profiler.js").TestProfileAsyncContext | undefined} [testProfileContext] - Async-safe profile attribution captured at enqueue.
  */
 export const CLOSED_CONNECTION = Symbol("velociousClosedConnection")
 const IDLE_CONNECTION_CHECKED_IN_AT = Symbol("velociousIdleConnectionCheckedInAt")
@@ -115,10 +117,20 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
 
   /** Cumulative low-cardinality pool telemetry. */
   telemetry = {
+    connectionCreationCount: 0,
+    connectionCreationFailureCount: 0,
+    connectionCreationMaxMs: 0,
+    connectionCreationTotalMs: 0,
+    checkoutTimeoutCount: 0,
     checkoutWaitCount: 0,
     checkoutWaitMaxMs: 0,
     checkoutWaitTotalMs: 0,
-    idleReapDisposalCount: 0
+    idleReapCount: 0,
+    idleReapDisposalCount: 0,
+    idleReapFailureCount: 0,
+    idleReapMaxMs: 0,
+    idleReapTotalMs: 0,
+    peakLiveConnections: 0
   }
 
   idSeq = 0
@@ -139,6 +151,58 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
     this._withoutCurrentConnectionContext = withoutCurrentConnectionContext
   }
 
+  /**
+   * Returns the pool telemetry clock.
+   * @returns {number} - Current time in milliseconds.
+   */
+  nowMs() { return Date.now() }
+
+  /**
+   * Records a pool metric in the active async-safe test profile context.
+   * @param {import("../../testing/test-profiler.js").TestProfileAsyncContext | undefined} context - Captured profile context.
+   * @param {"connectionCreation" | "checkoutWait" | "checkoutTimeout" | "idleReap" | "idleReapDisposal" | "peakLiveConnections"} metric - Metric name.
+   * @param {{durationMs?: number, failed?: boolean, value?: number}} [values] - Aggregate values.
+   * @returns {void}
+   */
+  recordTestProfilePoolMetric(context, metric, values = {}) {
+    if (!context) return
+
+    context.profiler.recordPoolMetric(context, this.identifier, metric, values)
+  }
+
+  /**
+   * Spawns and times a physical connection without retaining its configuration.
+   * @param {import("../../configuration-types.js").DatabaseConfigurationType} config - Resolved database configuration.
+   * @returns {Promise<import("../drivers/base.js").default>} - Connected driver.
+   */
+  async spawnConnectionWithConfiguration(config) {
+    const startedAt = this.nowMs()
+    const profileContext = currentTestProfileContext(this.configuration)
+    let failed = true
+
+    try {
+      const connection = await super.spawnConnectionWithConfiguration(config)
+
+      failed = false
+      const liveConnectionCount = this.liveConnectionCount() - this.connectionsBeingSpawned + 1
+
+      if (liveConnectionCount > this.telemetry.peakLiveConnections) {
+        this.telemetry.peakLiveConnections = liveConnectionCount
+        this.recordTestProfilePoolMetric(profileContext, "peakLiveConnections", {value: liveConnectionCount})
+      }
+
+      return connection
+    } finally {
+      const durationMs = Math.max(0, this.nowMs() - startedAt)
+
+      this.telemetry.connectionCreationCount++
+      if (failed) this.telemetry.connectionCreationFailureCount++
+      this.telemetry.connectionCreationTotalMs += durationMs
+      this.telemetry.connectionCreationMaxMs = Math.max(this.telemetry.connectionCreationMaxMs, durationMs)
+      this.recordTestProfilePoolMetric(profileContext, "connectionCreation", {durationMs, failed})
+    }
+  }
+
   /**
    * Runs checkin.
    * @param {import("../drivers/base.js").default} connection - Database connection instance.
@@ -241,24 +305,28 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
    * @returns {Promise<import("../drivers/base.js").default>} - Resolves with the checkout.
    */
   async checkout(options = {}) {
-    const databaseConfig = this.getConfiguration()
-    const reuseKey = this.getConfigurationReuseKey()
+    let databaseConfig = this.getConfiguration()
+    let reuseKey = this.getConfigurationReuseKey(databaseConfig)
     let connection = this.takeIdleConnectionForReuseKey(reuseKey)
 
     if (connection) return await this.activateConnection(connection, options)
 
     await this.reapIdleConnections()
+    databaseConfig = this.getConfiguration()
+    reuseKey = this.getConfigurationReuseKey(databaseConfig)
     connection = this.takeIdleConnectionForReuseKey(reuseKey)
 
     if (connection) return await this.activateConnection(connection, options)
 
-    if (this.canSpawnConnection()) {
-      // Spawn via spawnConnection() so the tenant-aware configuration is resolved FRESH at
-      // spawn time for the current caller. Reusing the databaseConfig captured at the top of
-      // checkout() could bind the connection to a stale tenant/database, which breaks
-      // per-request isolation (e.g. test truncation appearing not to take effect). The queued
-      // path below keeps the waiting caller's captured config via waitForCheckout().
-      connection = await this.spawnConnectionForCheckout(this.getConfiguration(), this.getConfigurationReuseKey())
+    if (this.canSpawnConnection(databaseConfig)) {
+      // The post-reap configuration is fresh for the current caller, and its reuse key is
+      // derived from this exact captured object so the connection cannot open one tenant while
+      // being stamped for another. The queued path retains the same captured pair.
+      connection = await this.spawnConnectionForCheckout(
+        databaseConfig,
+        reuseKey,
+        currentTestProfileContext(this.configuration)
+      )
 
       return await this.activateConnection(connection, options)
     }
@@ -291,7 +359,11 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
     if (connection) return await this.activateConnection(connection, options)
 
     if (this.canSpawnConnection(databaseConfig)) {
-      connection = await this.spawnConnectionForCheckout(databaseConfig, reuseKey)
+      connection = await this.spawnConnectionForCheckout(
+        databaseConfig,
+        reuseKey,
+        currentTestProfileContext(this.configuration)
+      )
 
       return await this.activateConnection(connection, options)
     }
@@ -436,21 +508,20 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
    * Runs spawn connection for checkout.
    * @param {import("../../configuration-types.js").DatabaseConfigurationType} databaseConfig - Resolved database config for the checkout.
    * @param {string} reuseKey - Database configuration reuse key for the checkout.
+   * @param {import("../../testing/test-profiler.js").TestProfileAsyncContext | undefined} profileContext - Profile context captured when checkout began.
    * @returns {Promise<import("../drivers/base.js").default>} - Spawned connection.
    */
-  async spawnConnectionForCheckout(databaseConfig, reuseKey) {
+  async spawnConnectionForCheckout(databaseConfig, reuseKey, profileContext) {
     this.connectionsBeingSpawned++
 
     try {
-      const connection = await this.spawnConnectionWithConfiguration(databaseConfig)
-      const connectionWithPoolKey = /** @type {import("../drivers/base.js").default & {[POOL_CONFIGURATION_KEY]?: string}} */ (connection)
-
-      connectionWithPoolKey[POOL_CONFIGURATION_KEY] = reuseKey
-      connection.setSchemaCacheInvalidator(() => {
-        this.clearSchemaCache()
-        this.configuration.clearSchemaCachesForReuseKey(reuseKey)
+      const environmentHandler = this.configuration.getEnvironmentHandler()
+      const connection = await environmentHandler.runWithTestProfileContext(profileContext, async () => {
+        return await this.spawnConnectionWithConfiguration(databaseConfig)
       })
 
+      this.stampConnectionForConfigurationReuseKey(connection, reuseKey)
+
       return connection
     } finally {
       this.connectionsBeingSpawned--
@@ -478,7 +549,8 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
         reuseKey,
         timeoutAt: timeoutMillis === null ? null : enqueuedAt + timeoutMillis,
         timeoutMillis,
-        timeoutTimer: undefined
+        timeoutTimer: undefined,
+        testProfileContext: currentTestProfileContext(this.configuration)
       }
 
       checkout.timeoutTimer = this.startPendingCheckoutTimeout(checkout)
@@ -578,11 +650,12 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
    * @returns {void}
    */
   recordCheckoutWait(checkout) {
-    const waitedForMs = Math.max(0, Date.now() - checkout.enqueuedAt)
+    const waitedForMs = Math.max(0, this.nowMs() - checkout.enqueuedAt)
 
     this.telemetry.checkoutWaitCount++
     this.telemetry.checkoutWaitTotalMs += waitedForMs
     this.telemetry.checkoutWaitMaxMs = Math.max(this.telemetry.checkoutWaitMaxMs, waitedForMs)
+    this.recordTestProfilePoolMetric(checkout.testProfileContext, "checkoutWait", {durationMs: waitedForMs})
   }
 
   /**
@@ -611,6 +684,8 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
     if (index === -1) return
 
     this.removePendingCheckoutAt(index)
+    this.telemetry.checkoutTimeoutCount++
+    this.recordTestProfilePoolMetric(checkout.testProfileContext, "checkoutTimeout")
     checkout.reject(this.pendingCheckoutTimeoutError(checkout))
   }
 
@@ -744,16 +819,24 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
    * @returns {Promise<void>} - Resolves when the checkout has been handled.
    */
   async spawnAndResolvePendingCheckout(checkout) {
-    let connection
+    const environmentHandler = this.configuration.getEnvironmentHandler()
 
-    try {
-      connection = await this.spawnConnectionForCheckout(checkout.databaseConfig, checkout.reuseKey)
-    } catch (error) {
-      checkout.reject(error instanceof Error ? error : new Error("Failed to spawn database connection.", {cause: error}))
-      return
-    }
+    return await environmentHandler.runWithTestProfileContext(checkout.testProfileContext, async () => {
+      let connection
+
+      try {
+        connection = await this.spawnConnectionForCheckout(
+          checkout.databaseConfig,
+          checkout.reuseKey,
+          checkout.testProfileContext
+        )
+      } catch (error) {
+        checkout.reject(error instanceof Error ? error : new Error("Failed to spawn database connection.", {cause: error}))
+        return
+      }
 
-    await this.resolvePendingCheckout(checkout, connection)
+      await this.resolvePendingCheckout(checkout, connection)
+    })
   }
 
   /**
@@ -763,11 +846,15 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
    * @returns {Promise<void>} - Resolves when the checkout has been handled.
    */
   async resolvePendingCheckout(checkout, connection) {
-    try {
-      checkout.resolve(await this.activateConnection(connection, checkout.options))
-    } catch (error) {
-      checkout.reject(error instanceof Error ? error : new Error("Failed to activate database connection.", {cause: error}))
-    }
+    const environmentHandler = this.configuration.getEnvironmentHandler()
+
+    return await environmentHandler.runWithTestProfileContext(checkout.testProfileContext, async () => {
+      try {
+        checkout.resolve(await this.activateConnection(connection, checkout.options))
+      } catch (error) {
+        checkout.reject(error instanceof Error ? error : new Error("Failed to activate database connection.", {cause: error}))
+      }
+    })
   }
 
   /**
@@ -1313,24 +1400,40 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
     const idleTimeoutMillis = this.idleTimeoutMillis()
 
     if (idleTimeoutMillis === null) return
+    const startedAt = this.nowMs()
+    const profileContext = currentTestProfileContext(this.configuration)
+    let failed = true
+
+    try {
+      const {expiredConnections, keptConnections} = this.classifyIdleConnectionsForReaping({idleTimeoutMillis, now: this.nowMs()})
 
-    const {expiredConnections, keptConnections} = this.classifyIdleConnectionsForReaping({idleTimeoutMillis, now: Date.now()})
+      this.connections = keptConnections
+      await this.closeExpiredIdleConnections(expiredConnections, profileContext)
+      await this.awaitInflightConnectionCloses()
+      if (this.connections.length > 0) this.scheduleIdleConnectionReaper()
+      failed = false
+    } finally {
+      const durationMs = Math.max(0, this.nowMs() - startedAt)
 
-    this.connections = keptConnections
-    await this.closeExpiredIdleConnections(expiredConnections)
-    await this.awaitInflightConnectionCloses()
-    if (this.connections.length > 0) this.scheduleIdleConnectionReaper()
+      this.telemetry.idleReapCount++
+      if (failed) this.telemetry.idleReapFailureCount++
+      this.telemetry.idleReapTotalMs += durationMs
+      this.telemetry.idleReapMaxMs = Math.max(this.telemetry.idleReapMaxMs, durationMs)
+      this.recordTestProfilePoolMetric(profileContext, "idleReap", {durationMs, failed})
+    }
   }
 
   /**
    * Runs close expired idle connections.
    * @param {import("../drivers/base.js").default[]} expiredConnections - Connections to close.
+   * @param {import("../../testing/test-profiler.js").TestProfileAsyncContext | undefined} [profileContext] - Reaper profile context.
    * @returns {Promise<void>} - Resolves when closed.
    */
-  async closeExpiredIdleConnections(expiredConnections) {
+  async closeExpiredIdleConnections(expiredConnections, profileContext) {
     for (const connection of expiredConnections) {
       await this.closeConnection(connection)
       this.telemetry.idleReapDisposalCount++
+      this.recordTestProfilePoolMetric(profileContext, "idleReapDisposal")
     }
   }