velocious 1.0.693 → 1.0.695

package/build/src/database/advisory-lock-runner.d.ts

@@ -99,6 +99,38 @@ export default class AdvisoryLockRunner {
         holdTimeoutMs?: number | null;
         dedicatedConnection?: boolean;
     }): Promise<T>;
+    /**
+     * Runs a callback if the advisory lock can be acquired without waiting;
+     * otherwise returns a `{acquired: false}` defer result instead of throwing.
+     *
+     * This is the non-throwing counterpart of `withAdvisoryLockOrFail` for hot
+     * paths: "holder busy, defer me" is a first-class outcome, so a contended
+     * lock produces zero exception traffic and — because the probe is a single
+     * immediate try-acquire — zero pinned connections. Callers reschedule via
+     * their own event-driven retry machinery. The result form is identical
+     * across tiers: the driver's `tryAcquireAdvisoryLock` maps per-tier (MySQL
+     * `GET_LOCK(name, 0)`, PostgreSQL `pg_try_advisory_lock`, SQL Server
+     * `sp_getapplock @LockTimeout = 0`, SQLite process-local queue, SQLite Node
+     * file lock), so a caller never branches on the backend.
+     * @template T
+     * @param {string} name - Lock name.
+     * @param {(args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>} callback - Callback to invoke while the lock is held.
+     * @param {{holdTimeoutMs?: number | null, dedicatedConnection?: boolean}} [args] - Hold timeout options.
+     * @returns {Promise<{acquired: true, result: T} | {acquired: false, reason: "contended", lockName: string}>} - Either the held-callback result or the defer outcome.
+     */
+    withAdvisoryLockOrDefer<T>(name: string, callback: (args?: {
+        control: import("awaitery/build/timeout.js").TimeoutControl;
+    }) => Promise<T>, args?: {
+        holdTimeoutMs?: number | null;
+        dedicatedConnection?: boolean;
+    }): Promise<{
+        acquired: true;
+        result: T;
+    } | {
+        acquired: false;
+        reason: "contended";
+        lockName: string;
+    }>;
     /**
      * Runs the lock holder callback and releases the lock from its owning connection.
      * @template T

package/build/src/database/advisory-lock-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"advisory-lock-runner.d.ts","sourceRoot":"","sources":["../../../src/database/advisory-lock-runner.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"advisory-lock-runner.d.ts","sourceRoot":"","sources":["../../../src/database/advisory-lock-runner.js"],"names":[],"mappings":"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"}

package/build/src/database/advisory-lock-runner.js

@@ -106,6 +106,34 @@ export default class AdvisoryLockRunner {
             return await this.runLockedCallback({ callback, connection, holdTimeoutMs: args.holdTimeoutMs, name });
         });
     }
+    /**
+     * Runs a callback if the advisory lock can be acquired without waiting;
+     * otherwise returns a `{acquired: false}` defer result instead of throwing.
+     *
+     * This is the non-throwing counterpart of `withAdvisoryLockOrFail` for hot
+     * paths: "holder busy, defer me" is a first-class outcome, so a contended
+     * lock produces zero exception traffic and — because the probe is a single
+     * immediate try-acquire — zero pinned connections. Callers reschedule via
+     * their own event-driven retry machinery. The result form is identical
+     * across tiers: the driver's `tryAcquireAdvisoryLock` maps per-tier (MySQL
+     * `GET_LOCK(name, 0)`, PostgreSQL `pg_try_advisory_lock`, SQL Server
+     * `sp_getapplock @LockTimeout = 0`, SQLite process-local queue, SQLite Node
+     * file lock), so a caller never branches on the backend.
+     * @template T
+     * @param {string} name - Lock name.
+     * @param {(args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>} callback - Callback to invoke while the lock is held.
+     * @param {{holdTimeoutMs?: number | null, dedicatedConnection?: boolean}} [args] - Hold timeout options.
+     * @returns {Promise<{acquired: true, result: T} | {acquired: false, reason: "contended", lockName: string}>} - Either the held-callback result or the defer outcome.
+     */
+    async withAdvisoryLockOrDefer(name, callback, args = {}) {
+        return await this.withLockConnection(args, async (connection) => {
+            const acquired = await connection.tryAcquireAdvisoryLock(name);
+            if (!acquired)
+                return { acquired: false, reason: "contended", lockName: name };
+            const result = await this.runLockedCallback({ callback, connection, holdTimeoutMs: args.holdTimeoutMs, name });
+            return { acquired: true, result };
+        });
+    }
     /**
      * Runs the lock holder callback and releases the lock from its owning connection.
      * @template T
@@ -202,4 +230,4 @@ export default class AdvisoryLockRunner {
     }
 }
 export { AdvisoryLockBusyError, AdvisoryLockHoldTimeoutError, AdvisoryLockTimeoutError };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"advisory-lock-runner.js","sourceRoot":"","sources":["../../../src/database/advisory-lock-runner.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,OAAO,EAAE,EAAC,YAAY,EAAC,MAAM,2BAA2B,CAAA;AAE/D;;GAEG;AACH,MAAM,wBAAyB,SAAQ,KAAK;IAC1C;;;;OAIG;IACH,YAAY,OAAO,EAAE,EAAC,IAAI,EAAC;QACzB,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,IAAI,GAAG,0BAA0B,CAAA;QACtC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAA;IACtB,CAAC;CACF;AAED;;GAEG;AACH,MAAM,qBAAsB,SAAQ,KAAK;IACvC;;;;OAIG;IACH,YAAY,OAAO,EAAE,EAAC,IAAI,EAAC;QACzB,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAA;QACnC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAA;IACtB,CAAC;CACF;AAED;;GAEG;AACH,MAAM,4BAA6B,SAAQ,KAAK;IAC9C;;;;OAIG;IACH,YAAY,OAAO,EAAE,EAAC,IAAI,EAAC;QACzB,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,IAAI,GAAG,8BAA8B,CAAA;QAC1C,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAA;IACtB,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,CAAC,OAAO,OAAO,kBAAkB;IACrC;;;OAGG;IACH,YAAY,EAAC,aAAa,EAAE,kBAAkB,EAAE,kBAAkB,EAAC;QACjE,IAAI,CAAC,aAAa,GAAG,aAAa,CAAA;QAClC,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAA;QAC5C,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAA;IAC9C,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,KAAK,CAAC,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,GAAG,EAAE;QAC9C,OAAO,MAAM,IAAI,CAAC,kBAAkB,CAAC,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,EAAE;YAC9D,MAAM,QAAQ,GAAG,MAAM,UAAU,CAAC,mBAAmB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;YAEjE,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,MAAM,IAAI,wBAAwB,CAAC,uCAAuC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,EAAE,EAAC,IAAI,EAAC,CAAC,CAAA;YAC3G,CAAC;YAED,OAAO,MAAM,IAAI,CAAC,iBAAiB,CAAC,EAAC,QAAQ,EAAE,UAAU,EAAE,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,IAAI,EAAC,CAAC,CAAA;QACtG,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,KAAK,CAAC,sBAAsB,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,GAAG,EAAE;QACpD,OAAO,MAAM,IAAI,CAAC,kBAAkB,CAAC,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,EAAE;YAC9D,MAAM,QAAQ,GAAG,MAAM,UAAU,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAA;YAE9D,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,MAAM,IAAI,qBAAqB,CAAC,iBAAiB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,kBAAkB,EAAE,EAAC,IAAI,EAAC,CAAC,CAAA;YAClG,CAAC;YAED,OAAO,MAAM,IAAI,CAAC,iBAAiB,CAAC,EAAC,QAAQ,EAAE,UAAU,EAAE,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,IAAI,EAAC,CAAC,CAAA;QACtG,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,iBAAiB,CAAC,EAAC,QAAQ,EAAE,UAAU,EAAE,aAAa,EAAE,IAAI,EAAC;QACjE,IAAI,CAAC;YACH,OAAO,MAAM,kBAAkB,CAAC,8BAA8B,CAAC,IAAI,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAA;QAC/F,CAAC;gBAAS,CAAC;YACT,MAAM,UAAU,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAA;QAC5C,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,kBAAkB,CAAC,IAAI,EAAE,QAAQ;QACrC,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAA;QAExC,IAAI,IAAI,CAAC,mBAAmB,IAAI,CAAC,aAAa,IAAI,aAAa,GAAG,CAAC,CAAC,EAAE,CAAC;YACrE,OAAO,MAAM,IAAI,CAAC,uBAAuB,CAAC,QAAQ,CAAC,CAAA;QACrD,CAAC;QAED,OAAO,MAAM,QAAQ,CAAC,IAAI,CAAC,kBAAkB,EAAE,CAAC,CAAA;IAClD,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,uBAAuB,CAAC,QAAQ;QACpC,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,eAAe,EAAE,CAAA;QAEtG,iFAAiF;QACjF,kFAAkF;QAClF,kFAAkF;QAClF,8EAA8E;QAC9E,MAAM,cAAc,GAAG,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,aAAa,CAAA;QAE1D,IAAI,cAAc;YAAE,IAAI,CAAC,aAAa,CAAC,8BAA8B,CAAC,UAAU,CAAC,CAAA;QAEjF,IAAI,CAAC;YACH,OAAO,MAAM,QAAQ,CAAC,UAAU,CAAC,CAAA;QACnC,CAAC;gBAAS,CAAC;YACT,IAAI,cAAc,EAAE,CAAC;gBACnB,IAAI,CAAC,aAAa,CAAC,gCAAgC,CAAC,UAAU,CAAC,CAAA;gBAC/D,MAAM,UAAU,CAAC,KAAK,EAAE,CAAA;YAC1B,CAAC;iBAAM,CAAC;gBACN,MAAM,UAAU,CAAC,wBAAwB,EAAE,CAAA;YAC7C,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,KAAK,CAAC,8BAA8B,CAAC,IAAI,EAAE,QAAQ,EAAE,aAAa;QACvE,IAAI,CAAC,aAAa,IAAI,aAAa,IAAI,CAAC,EAAE,CAAC;YACzC,OAAO,MAAM,QAAQ,EAAE,CAAA;QACzB,CAAC;QAED,IAAI,eAAe,GAAG,KAAK,CAAA;QAE3B,IAAI,CAAC;YACH,OAAO,MAAM,OAAO,CAAC,EAAC,OAAO,EAAE,aAAa,EAAC,EAAE,KAAK,EAAE,EAAC,OAAO,EAAC,EAAE,EAAE;gBACjE,IAAI,CAAC;oBACH,OAAO,MAAM,QAAQ,CAAC,EAAC,OAAO,EAAC,CAAC,CAAA;gBAClC,CAAC;wBAAS,CAAC;oBACT,eAAe,GAAG,IAAI,CAAA;gBACxB,CAAC;YACH,CAAC,CAAC,CAAA;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,eAAe,IAAI,KAAK,YAAY,YAAY,EAAE,CAAC;gBACtD,MAAM,IAAI,4BAA4B,CAAC,iBAAiB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,qBAAqB,aAAa,IAAI,EAAE,EAAC,IAAI,EAAC,CAAC,CAAA;YAC7H,CAAC;YAED,MAAM,KAAK,CAAA;QACb,CAAC;IACH,CAAC;CACF;AAED,OAAO,EAAC,qBAAqB,EAAE,4BAA4B,EAAE,wBAAwB,EAAC,CAAA","sourcesContent":["// @ts-check\n\nimport timeout, {TimeoutError} from \"awaitery/build/timeout.js\"\n\n/**\n * Thrown when an advisory lock could not be acquired before `timeoutMs` elapsed.\n */\nclass AdvisoryLockTimeoutError extends Error {\n  /**\n   * Runs constructor.\n   * @param {string} message - Error message.\n   * @param {{name: string}} args - The advisory lock name that timed out.\n   */\n  constructor(message, {name}) {\n    super(message)\n    this.name = \"AdvisoryLockTimeoutError\"\n    this.lockName = name\n  }\n}\n\n/**\n * Thrown when `withAdvisoryLockOrFail` finds the lock already held.\n */\nclass AdvisoryLockBusyError extends Error {\n  /**\n   * Runs constructor.\n   * @param {string} message - Error message.\n   * @param {{name: string}} args - The advisory lock name that was already held.\n   */\n  constructor(message, {name}) {\n    super(message)\n    this.name = \"AdvisoryLockBusyError\"\n    this.lockName = name\n  }\n}\n\n/**\n * Thrown when a callback holds an advisory lock longer than `holdTimeoutMs`.\n */\nclass AdvisoryLockHoldTimeoutError extends Error {\n  /**\n   * Runs constructor.\n   * @param {string} message - Error message.\n   * @param {{name: string}} args - The advisory lock name whose hold timed out.\n   */\n  constructor(message, {name}) {\n    super(message)\n    this.name = \"AdvisoryLockHoldTimeoutError\"\n    this.lockName = name\n  }\n}\n\n/**\n * Runs advisory locks on the caller connection by default, using a dedicated\n * lock connection when `dedicatedConnection` is requested or when a positive\n * hold timeout needs separate ownership.\n */\nexport default class AdvisoryLockRunner {\n  /**\n   * Creates an advisory-lock runner for one model database identifier.\n   * @param {{configuration: import(\"../configuration.js\").default, connectionProvider: () => import(\"./drivers/base.js\").default, databaseIdentifier: string}} args - Runner dependencies.\n   */\n  constructor({configuration, connectionProvider, databaseIdentifier}) {\n    this.configuration = configuration\n    this.connectionProvider = connectionProvider\n    this.databaseIdentifier = databaseIdentifier\n  }\n\n  /**\n   * Runs a callback after acquiring the advisory lock, waiting up to `timeoutMs`.\n   * When `dedicatedConnection` is true the lock is acquired on a spawned\n   * connection that is released after the callback finishes, while the callback\n   * itself still runs against the caller/model connection. When a `holdTimeoutMs`\n   * is set the callback receives a `TimeoutControl` from awaitery for cooperative\n   * cancellation (`control.check()`, `control.signal`, `control.timedOut`,\n   * `control.remaining()`); a dedicated connection is also used so timeout\n   * cleanup can release the lock even if callback database work is stuck.\n   * @template T\n   * @param {string} name - Lock name.\n   * @param {(args?: {control: import(\"awaitery/build/timeout.js\").TimeoutControl}) => Promise<T>} callback - Callback to invoke while the lock is held.\n   * @param {{timeoutMs?: number | null, holdTimeoutMs?: number | null, dedicatedConnection?: boolean}} [args] - Lock and hold timeout options.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withAdvisoryLock(name, callback, args = {}) {\n    return await this.withLockConnection(args, async (connection) => {\n      const acquired = await connection.acquireAdvisoryLock(name, args)\n\n      if (!acquired) {\n        throw new AdvisoryLockTimeoutError(`Timed out waiting for advisory lock ${JSON.stringify(name)}`, {name})\n      }\n\n      return await this.runLockedCallback({callback, connection, holdTimeoutMs: args.holdTimeoutMs, name})\n    })\n  }\n\n  /**\n   * Runs a callback only if the advisory lock can be acquired immediately.\n   * When `dedicatedConnection` is true the lock is acquired on a spawned\n   * connection that is released after the callback finishes, while the callback\n   * itself still runs against the caller/model connection. When a `holdTimeoutMs`\n   * is set the callback receives a `TimeoutControl` from awaitery for cooperative\n   * cancellation.\n   * @template T\n   * @param {string} name - Lock name.\n   * @param {(args?: {control: import(\"awaitery/build/timeout.js\").TimeoutControl}) => Promise<T>} callback - Callback to invoke while the lock is held.\n   * @param {{holdTimeoutMs?: number | null, dedicatedConnection?: boolean}} [args] - Hold timeout options.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withAdvisoryLockOrFail(name, callback, args = {}) {\n    return await this.withLockConnection(args, async (connection) => {\n      const acquired = await connection.tryAcquireAdvisoryLock(name)\n\n      if (!acquired) {\n        throw new AdvisoryLockBusyError(`Advisory lock ${JSON.stringify(name)} is already held`, {name})\n      }\n\n      return await this.runLockedCallback({callback, connection, holdTimeoutMs: args.holdTimeoutMs, name})\n    })\n  }\n\n  /**\n   * Runs the lock holder callback and releases the lock from its owning connection.\n   * @template T\n   * @param {{callback: (args?: {control: import(\"awaitery/build/timeout.js\").TimeoutControl}) => Promise<T>, connection: import(\"./drivers/base.js\").default, holdTimeoutMs?: number | null, name: string}} args - Locked callback args.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async runLockedCallback({callback, connection, holdTimeoutMs, name}) {\n    try {\n      return await AdvisoryLockRunner.runWithAdvisoryLockHoldTimeout(name, callback, holdTimeoutMs)\n    } finally {\n      await connection.releaseAdvisoryLock(name)\n    }\n  }\n\n  /**\n   * Runs lock work on the caller connection unless `dedicatedConnection` is\n   * requested or a positive hold timeout needs its own lock connection.\n   * @template T\n   * @param {{dedicatedConnection?: boolean, holdTimeoutMs?: number | null}} args - Lock connection options.\n   * @param {(connection: import(\"./drivers/base.js\").default) => Promise<T>} callback - Callback receiving the connection that owns the advisory lock.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withLockConnection(args, callback) {\n    const holdTimeoutMs = args.holdTimeoutMs\n\n    if (args.dedicatedConnection || (holdTimeoutMs && holdTimeoutMs > 0)) {\n      return await this.withDedicatedConnection(callback)\n    }\n\n    return await callback(this.connectionProvider())\n  }\n\n  /**\n   * Spawns a dedicated lock connection and closes it after lock work completes\n   * when the spawned driver owns the underlying physical connection.\n   * @template T\n   * @param {(connection: import(\"./drivers/base.js\").default) => Promise<T>} callback - Callback that receives the dedicated lock connection.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withDedicatedConnection(callback) {\n    const connection = await this.configuration.getDatabasePool(this.databaseIdentifier).spawnConnection()\n\n    // The spawned driver owns its physical connection unless it borrows a shared one\n    // via `getConnection`. An owned connection lives outside the pools' tracked sets,\n    // so register it while the lock is held: a shutdown then closes it (releasing the\n    // lock) instead of orphaning a half-open session until the DB `wait_timeout`.\n    const ownsConnection = !connection.getArgs().getConnection\n\n    if (ownsConnection) this.configuration.registerAdvisoryLockConnection(connection)\n\n    try {\n      return await callback(connection)\n    } finally {\n      if (ownsConnection) {\n        this.configuration.unregisterAdvisoryLockConnection(connection)\n        await connection.close()\n      } else {\n        await connection.releaseHeldAdvisoryLocks()\n      }\n    }\n  }\n\n  /**\n   * Runs `callback`, rejecting with `AdvisoryLockHoldTimeoutError` if it has\n   * not settled within `holdTimeoutMs`. The callback is not cancelled; callers\n   * use a dedicated advisory-lock connection so the lock can still be released.\n   *\n   * The callback receives a `TimeoutControl` from awaitery, enabling cooperative\n   * cancellation via `control.check()`, `control.signal`, `control.timedOut`,\n   * and `control.remaining()`.\n   * @template T\n   * @param {string} name - Lock name (for the error message).\n   * @param {(args?: {control: import(\"awaitery/build/timeout.js\").TimeoutControl}) => Promise<T>} callback - Callback holding the lock.\n   * @param {number | null} [holdTimeoutMs] - Max hold time; falsy disables the timeout.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  static async runWithAdvisoryLockHoldTimeout(name, callback, holdTimeoutMs) {\n    if (!holdTimeoutMs || holdTimeoutMs <= 0) {\n      return await callback()\n    }\n\n    let callbackSettled = false\n\n    try {\n      return await timeout({timeout: holdTimeoutMs}, async ({control}) => {\n        try {\n          return await callback({control})\n        } finally {\n          callbackSettled = true\n        }\n      })\n    } catch (error) {\n      if (!callbackSettled || error instanceof TimeoutError) {\n        throw new AdvisoryLockHoldTimeoutError(`Advisory lock ${JSON.stringify(name)} held longer than ${holdTimeoutMs}ms`, {name})\n      }\n\n      throw error\n    }\n  }\n}\n\nexport {AdvisoryLockBusyError, AdvisoryLockHoldTimeoutError, AdvisoryLockTimeoutError}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"advisory-lock-runner.js","sourceRoot":"","sources":["../../../src/database/advisory-lock-runner.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport timeout, {TimeoutError} from \"awaitery/build/timeout.js\"\n\n/**\n * Thrown when an advisory lock could not be acquired before `timeoutMs` elapsed.\n */\nclass AdvisoryLockTimeoutError extends Error {\n  /**\n   * Runs constructor.\n   * @param {string} message - Error message.\n   * @param {{name: string}} args - The advisory lock name that timed out.\n   */\n  constructor(message, {name}) {\n    super(message)\n    this.name = \"AdvisoryLockTimeoutError\"\n    this.lockName = name\n  }\n}\n\n/**\n * Thrown when `withAdvisoryLockOrFail` finds the lock already held.\n */\nclass AdvisoryLockBusyError extends Error {\n  /**\n   * Runs constructor.\n   * @param {string} message - Error message.\n   * @param {{name: string}} args - The advisory lock name that was already held.\n   */\n  constructor(message, {name}) {\n    super(message)\n    this.name = \"AdvisoryLockBusyError\"\n    this.lockName = name\n  }\n}\n\n/**\n * Thrown when a callback holds an advisory lock longer than `holdTimeoutMs`.\n */\nclass AdvisoryLockHoldTimeoutError extends Error {\n  /**\n   * Runs constructor.\n   * @param {string} message - Error message.\n   * @param {{name: string}} args - The advisory lock name whose hold timed out.\n   */\n  constructor(message, {name}) {\n    super(message)\n    this.name = \"AdvisoryLockHoldTimeoutError\"\n    this.lockName = name\n  }\n}\n\n/**\n * Runs advisory locks on the caller connection by default, using a dedicated\n * lock connection when `dedicatedConnection` is requested or when a positive\n * hold timeout needs separate ownership.\n */\nexport default class AdvisoryLockRunner {\n  /**\n   * Creates an advisory-lock runner for one model database identifier.\n   * @param {{configuration: import(\"../configuration.js\").default, connectionProvider: () => import(\"./drivers/base.js\").default, databaseIdentifier: string}} args - Runner dependencies.\n   */\n  constructor({configuration, connectionProvider, databaseIdentifier}) {\n    this.configuration = configuration\n    this.connectionProvider = connectionProvider\n    this.databaseIdentifier = databaseIdentifier\n  }\n\n  /**\n   * Runs a callback after acquiring the advisory lock, waiting up to `timeoutMs`.\n   * When `dedicatedConnection` is true the lock is acquired on a spawned\n   * connection that is released after the callback finishes, while the callback\n   * itself still runs against the caller/model connection. When a `holdTimeoutMs`\n   * is set the callback receives a `TimeoutControl` from awaitery for cooperative\n   * cancellation (`control.check()`, `control.signal`, `control.timedOut`,\n   * `control.remaining()`); a dedicated connection is also used so timeout\n   * cleanup can release the lock even if callback database work is stuck.\n   * @template T\n   * @param {string} name - Lock name.\n   * @param {(args?: {control: import(\"awaitery/build/timeout.js\").TimeoutControl}) => Promise<T>} callback - Callback to invoke while the lock is held.\n   * @param {{timeoutMs?: number | null, holdTimeoutMs?: number | null, dedicatedConnection?: boolean}} [args] - Lock and hold timeout options.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withAdvisoryLock(name, callback, args = {}) {\n    return await this.withLockConnection(args, async (connection) => {\n      const acquired = await connection.acquireAdvisoryLock(name, args)\n\n      if (!acquired) {\n        throw new AdvisoryLockTimeoutError(`Timed out waiting for advisory lock ${JSON.stringify(name)}`, {name})\n      }\n\n      return await this.runLockedCallback({callback, connection, holdTimeoutMs: args.holdTimeoutMs, name})\n    })\n  }\n\n  /**\n   * Runs a callback only if the advisory lock can be acquired immediately.\n   * When `dedicatedConnection` is true the lock is acquired on a spawned\n   * connection that is released after the callback finishes, while the callback\n   * itself still runs against the caller/model connection. When a `holdTimeoutMs`\n   * is set the callback receives a `TimeoutControl` from awaitery for cooperative\n   * cancellation.\n   * @template T\n   * @param {string} name - Lock name.\n   * @param {(args?: {control: import(\"awaitery/build/timeout.js\").TimeoutControl}) => Promise<T>} callback - Callback to invoke while the lock is held.\n   * @param {{holdTimeoutMs?: number | null, dedicatedConnection?: boolean}} [args] - Hold timeout options.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withAdvisoryLockOrFail(name, callback, args = {}) {\n    return await this.withLockConnection(args, async (connection) => {\n      const acquired = await connection.tryAcquireAdvisoryLock(name)\n\n      if (!acquired) {\n        throw new AdvisoryLockBusyError(`Advisory lock ${JSON.stringify(name)} is already held`, {name})\n      }\n\n      return await this.runLockedCallback({callback, connection, holdTimeoutMs: args.holdTimeoutMs, name})\n    })\n  }\n\n  /**\n   * Runs a callback if the advisory lock can be acquired without waiting;\n   * otherwise returns a `{acquired: false}` defer result instead of throwing.\n   *\n   * This is the non-throwing counterpart of `withAdvisoryLockOrFail` for hot\n   * paths: \"holder busy, defer me\" is a first-class outcome, so a contended\n   * lock produces zero exception traffic and — because the probe is a single\n   * immediate try-acquire — zero pinned connections. Callers reschedule via\n   * their own event-driven retry machinery. The result form is identical\n   * across tiers: the driver's `tryAcquireAdvisoryLock` maps per-tier (MySQL\n   * `GET_LOCK(name, 0)`, PostgreSQL `pg_try_advisory_lock`, SQL Server\n   * `sp_getapplock @LockTimeout = 0`, SQLite process-local queue, SQLite Node\n   * file lock), so a caller never branches on the backend.\n   * @template T\n   * @param {string} name - Lock name.\n   * @param {(args?: {control: import(\"awaitery/build/timeout.js\").TimeoutControl}) => Promise<T>} callback - Callback to invoke while the lock is held.\n   * @param {{holdTimeoutMs?: number | null, dedicatedConnection?: boolean}} [args] - Hold timeout options.\n   * @returns {Promise<{acquired: true, result: T} | {acquired: false, reason: \"contended\", lockName: string}>} - Either the held-callback result or the defer outcome.\n   */\n  async withAdvisoryLockOrDefer(name, callback, args = {}) {\n    return await this.withLockConnection(args, async (connection) => {\n      const acquired = await connection.tryAcquireAdvisoryLock(name)\n\n      if (!acquired) return {acquired: false, reason: \"contended\", lockName: name}\n\n      const result = await this.runLockedCallback({callback, connection, holdTimeoutMs: args.holdTimeoutMs, name})\n\n      return {acquired: true, result}\n    })\n  }\n\n  /**\n   * Runs the lock holder callback and releases the lock from its owning connection.\n   * @template T\n   * @param {{callback: (args?: {control: import(\"awaitery/build/timeout.js\").TimeoutControl}) => Promise<T>, connection: import(\"./drivers/base.js\").default, holdTimeoutMs?: number | null, name: string}} args - Locked callback args.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async runLockedCallback({callback, connection, holdTimeoutMs, name}) {\n    try {\n      return await AdvisoryLockRunner.runWithAdvisoryLockHoldTimeout(name, callback, holdTimeoutMs)\n    } finally {\n      await connection.releaseAdvisoryLock(name)\n    }\n  }\n\n  /**\n   * Runs lock work on the caller connection unless `dedicatedConnection` is\n   * requested or a positive hold timeout needs its own lock connection.\n   * @template T\n   * @param {{dedicatedConnection?: boolean, holdTimeoutMs?: number | null}} args - Lock connection options.\n   * @param {(connection: import(\"./drivers/base.js\").default) => Promise<T>} callback - Callback receiving the connection that owns the advisory lock.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withLockConnection(args, callback) {\n    const holdTimeoutMs = args.holdTimeoutMs\n\n    if (args.dedicatedConnection || (holdTimeoutMs && holdTimeoutMs > 0)) {\n      return await this.withDedicatedConnection(callback)\n    }\n\n    return await callback(this.connectionProvider())\n  }\n\n  /**\n   * Spawns a dedicated lock connection and closes it after lock work completes\n   * when the spawned driver owns the underlying physical connection.\n   * @template T\n   * @param {(connection: import(\"./drivers/base.js\").default) => Promise<T>} callback - Callback that receives the dedicated lock connection.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  async withDedicatedConnection(callback) {\n    const connection = await this.configuration.getDatabasePool(this.databaseIdentifier).spawnConnection()\n\n    // The spawned driver owns its physical connection unless it borrows a shared one\n    // via `getConnection`. An owned connection lives outside the pools' tracked sets,\n    // so register it while the lock is held: a shutdown then closes it (releasing the\n    // lock) instead of orphaning a half-open session until the DB `wait_timeout`.\n    const ownsConnection = !connection.getArgs().getConnection\n\n    if (ownsConnection) this.configuration.registerAdvisoryLockConnection(connection)\n\n    try {\n      return await callback(connection)\n    } finally {\n      if (ownsConnection) {\n        this.configuration.unregisterAdvisoryLockConnection(connection)\n        await connection.close()\n      } else {\n        await connection.releaseHeldAdvisoryLocks()\n      }\n    }\n  }\n\n  /**\n   * Runs `callback`, rejecting with `AdvisoryLockHoldTimeoutError` if it has\n   * not settled within `holdTimeoutMs`. The callback is not cancelled; callers\n   * use a dedicated advisory-lock connection so the lock can still be released.\n   *\n   * The callback receives a `TimeoutControl` from awaitery, enabling cooperative\n   * cancellation via `control.check()`, `control.signal`, `control.timedOut`,\n   * and `control.remaining()`.\n   * @template T\n   * @param {string} name - Lock name (for the error message).\n   * @param {(args?: {control: import(\"awaitery/build/timeout.js\").TimeoutControl}) => Promise<T>} callback - Callback holding the lock.\n   * @param {number | null} [holdTimeoutMs] - Max hold time; falsy disables the timeout.\n   * @returns {Promise<T>} - Resolves with the callback result.\n   */\n  static async runWithAdvisoryLockHoldTimeout(name, callback, holdTimeoutMs) {\n    if (!holdTimeoutMs || holdTimeoutMs <= 0) {\n      return await callback()\n    }\n\n    let callbackSettled = false\n\n    try {\n      return await timeout({timeout: holdTimeoutMs}, async ({control}) => {\n        try {\n          return await callback({control})\n        } finally {\n          callbackSettled = true\n        }\n      })\n    } catch (error) {\n      if (!callbackSettled || error instanceof TimeoutError) {\n        throw new AdvisoryLockHoldTimeoutError(`Advisory lock ${JSON.stringify(name)} held longer than ${holdTimeoutMs}ms`, {name})\n      }\n\n      throw error\n    }\n  }\n}\n\nexport {AdvisoryLockBusyError, AdvisoryLockHoldTimeoutError, AdvisoryLockTimeoutError}\n"]}

package/build/src/database/advisory-lock-telemetry.d.ts

@@ -0,0 +1,129 @@
+export type AdvisoryLockTelemetryReport = {
+    /**
+     * - Which event fired.
+     */
+    event: "advisory-lock-slow-acquire" | "advisory-lock-acquire-timeout" | "advisory-lock-slow-hold";
+    /**
+     * - The contended advisory-lock name.
+     */
+    lockName: string;
+    /**
+     * - Tier that served (or refused) the acquisition: `driver-native`, `process-local`, or `file`.
+     */
+    backendTier: string;
+    /**
+     * - Measured duration of the acquire wait (or the hold).
+     */
+    durationMs: number;
+    /**
+     * - For acquire events: whether the wait eventually acquired the lock. Null for hold reports.
+     */
+    outcome: "acquired" | "timeout" | null;
+    /**
+     * - The effective acquire bound for acquire events. Null for hold reports or an unbounded wait.
+     */
+    timeoutMs: number | null;
+    /**
+     * - Process-local holder attribution when the tier can name its local holder.
+     */
+    holderId: string | null;
+    /**
+     * - Driver-native holder attribution captured at the event moment (MariaDB `IS_USED_LOCK` connection id, PostgreSQL pid, SQL Server session id, SQLite file `pid@hostname`).
+     */
+    holderConnectionId: string | null;
+    /**
+     * - Set when the best-effort holder lookup itself failed; the lookup never affects the acquisition.
+     */
+    holderLookupError: string | null;
+};
+export type AdvisoryLockTelemetryThresholds = {
+    /**
+     * - Report an acquire wait slower than this; `null` disables slow-acquire reports.
+     */
+    slowAcquireMs: number | null;
+    /**
+     * - Report a hold longer than this at release; `null` disables hold reports.
+     */
+    slowHoldMs: number | null;
+};
+/**
+ * Event-driven advisory-lock duration telemetry (STC-261, parent epic STC-209).
+ *
+ * A lock convoy is only fixable when it is *attributable*: which lock name was
+ * contended, on which backend tier, for how long, and who held it. These reports
+ * fire on the acquisition/release events themselves — never from a periodic
+ * scanner — so a contended lock in production surfaces on the framework-error
+ * channel with the holder identity available on that tier at that moment,
+ * without SSH forensics.
+ *
+ * Three events, each with its own threshold (all configurable per database via
+ * `advisoryLockTelemetry`, see `docs/advisory-locks.md`):
+ *
+ * - `advisory-lock-slow-acquire` — an acquire wait completed slower than
+ *   `slowAcquireMs` (default 5000), including the eventual outcome (`acquired`
+ *   or `timeout`).
+ * - `advisory-lock-acquire-timeout` — a wait exceeded its timeout. The report
+ *   carries the holder identity available on the tier at that moment: the
+ *   driver-native tiers attribute the holder connection (MariaDB
+ *   `IS_USED_LOCK`, PostgreSQL `pg_locks` joined to `pg_stat_activity`, SQL
+ *   Server `sys.dm_tran_locks` request session, SQLite Node file tier
+ *   `owner.json` pid/hostname); the process-local tier reports the owning
+ *   driver's `holderId`.
+ * - `advisory-lock-slow-hold` — a hold lasted longer than `slowHoldMs`
+ *   (default 60000), emitted at release.
+ *
+ * Reports are emitted on `configuration.getErrorEvents()` as `framework-error`
+ * (plus the matching `all-error`) with `{context: "advisory-lock-telemetry",
+ * event, lockName, backendTier, ...}` payloads, matching the repo's "never
+ * swallow" rule so process-level bug reporters capture them.
+ *
+ * Holder lookups are strictly best-effort *after* the acquisition already
+ * settled: a failed lookup never changes the acquisition outcome and never
+ * throws to the caller.
+ */
+/**
+ * One advisory-lock telemetry report.
+ * @typedef {object} AdvisoryLockTelemetryReport
+ * @property {"advisory-lock-slow-acquire" | "advisory-lock-acquire-timeout" | "advisory-lock-slow-hold"} event - Which event fired.
+ * @property {string} lockName - The contended advisory-lock name.
+ * @property {string} backendTier - Tier that served (or refused) the acquisition: `driver-native`, `process-local`, or `file`.
+ * @property {number} durationMs - Measured duration of the acquire wait (or the hold).
+ * @property {"acquired" | "timeout" | null} outcome - For acquire events: whether the wait eventually acquired the lock. Null for hold reports.
+ * @property {number | null} timeoutMs - The effective acquire bound for acquire events. Null for hold reports or an unbounded wait.
+ * @property {string | null} holderId - Process-local holder attribution when the tier can name its local holder.
+ * @property {string | null} holderConnectionId - Driver-native holder attribution captured at the event moment (MariaDB `IS_USED_LOCK` connection id, PostgreSQL pid, SQL Server session id, SQLite file `pid@hostname`).
+ * @property {string | null} holderLookupError - Set when the best-effort holder lookup itself failed; the lookup never affects the acquisition.
+ */
+/**
+ * Resolved per-database telemetry thresholds.
+ * @typedef {object} AdvisoryLockTelemetryThresholds
+ * @property {number | null} slowAcquireMs - Report an acquire wait slower than this; `null` disables slow-acquire reports.
+ * @property {number | null} slowHoldMs - Report a hold longer than this at release; `null` disables hold reports.
+ */
+/** Framework default: report an acquire wait that completed slower than this. */
+export declare const DEFAULT_ADVISORY_LOCK_SLOW_ACQUIRE_MS = 5000;
+/** Framework default: report a hold that outlives this at release. */
+export declare const DEFAULT_ADVISORY_LOCK_SLOW_HOLD_MS: number;
+/**
+ * Resolve the telemetry thresholds for one database configuration.
+ * An explicit per-database `advisoryLockTelemetry` value wins; `null` opts out
+ * of that report; only when neither is configured does the framework default
+ * apply.
+ * @param {import("../configuration-types.js").DatabaseConfigurationType} args - Database configuration args.
+ * @returns {AdvisoryLockTelemetryThresholds} - Resolved thresholds.
+ */
+export declare function advisoryLockTelemetryThresholds(args: import("../configuration-types.js").DatabaseConfigurationType): AdvisoryLockTelemetryThresholds;
+/**
+ * Emit one telemetry report on the framework-error channel.
+ *
+ * Mirrors the repo's framework-error emission shape (see `configuration.js`
+ * `_reportBeaconError`): when no listener is attached to `framework-error` or
+ * `all-error`, a one-line summary goes to `stderr` so a convoy is never
+ * completely silent. A listener failure can never break lock handling, so
+ * emissions are guarded.
+ * @param {import("../configuration.js").default} configuration - Configuration instance owning the error channel.
+ * @param {AdvisoryLockTelemetryReport} report - The report payload.
+ * @returns {void} - No return value.
+ */
+export declare function emitAdvisoryLockTelemetryReport(configuration: import("../configuration.js").default, report: AdvisoryLockTelemetryReport): void;
+//# sourceMappingURL=advisory-lock-telemetry.d.ts.map

package/build/src/database/advisory-lock-telemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advisory-lock-telemetry.d.ts","sourceRoot":"","sources":["../../../src/database/advisory-lock-telemetry.js"],"names":[],"mappings":"AAwCG,YAAkB,2BAA2B,GAC7C;;;;IAAuG,KAAK,EAAjG,4BAA4B,GAAG,+BAA+B,GAAG,yBAAyB,CACrG;;;;IAAmB,QAAQ,EAAhB,MAAM,CACjB;;;;IAAmB,WAAW,EAAnB,MAAM,CACjB;;;;IAAmB,UAAU,EAAlB,MAAM,CACjB;;;;IAA0C,OAAO,EAAtC,UAAU,GAAG,SAAS,GAAG,IAAI,CACxC;;;;IAA0B,SAAS,EAAxB,MAAM,GAAG,IAAI,CACxB;;;;IAA0B,QAAQ,EAAvB,MAAM,GAAG,IAAI,CACxB;;;;IAA0B,kBAAkB,EAAjC,MAAM,GAAG,IAAI,CACxB;;;;IAA0B,iBAAiB,EAAhC,MAAM,GAAG,IAAI,CAC1B;CAAA,CAAA;AAIE,YAAkB,+BAA+B,GACjD;;;;IAA0B,aAAa,EAA5B,MAAM,GAAG,IAAI,CACxB;;;;IAA0B,UAAU,EAAzB,MAAM,GAAG,IAAI,CAC1B;CAAA,CAAA;AAvDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH;;;;;;;;;;;;GAYG;AAEH;;;;;GAKG;AAEH,iFAAiF;AACjF,eAAO,MAAM,qCAAqC,OAAO,CAAA;AAEzD,sEAAsE;AACtE,eAAO,MAAM,kCAAkC,QAAY,CAAA;AAE3D;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAAC,IAAI,EAHzC,OAAO,2BAA2B,EAAE,yBAGK,GAFvC,+BAA+B,CAiB3C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,+BAA+B,CAAC,aAAa,EAJlD,OAAO,qBAAqB,EAAE,OAIoB,EAAE,MAAM,EAH1D,2BAG0D,GAFxD,IAAI,CA4BhB"}

package/build/src/database/advisory-lock-telemetry.js

@@ -0,0 +1,122 @@
+// @ts-check
+/**
+ * Event-driven advisory-lock duration telemetry (STC-261, parent epic STC-209).
+ *
+ * A lock convoy is only fixable when it is *attributable*: which lock name was
+ * contended, on which backend tier, for how long, and who held it. These reports
+ * fire on the acquisition/release events themselves — never from a periodic
+ * scanner — so a contended lock in production surfaces on the framework-error
+ * channel with the holder identity available on that tier at that moment,
+ * without SSH forensics.
+ *
+ * Three events, each with its own threshold (all configurable per database via
+ * `advisoryLockTelemetry`, see `docs/advisory-locks.md`):
+ *
+ * - `advisory-lock-slow-acquire` — an acquire wait completed slower than
+ *   `slowAcquireMs` (default 5000), including the eventual outcome (`acquired`
+ *   or `timeout`).
+ * - `advisory-lock-acquire-timeout` — a wait exceeded its timeout. The report
+ *   carries the holder identity available on the tier at that moment: the
+ *   driver-native tiers attribute the holder connection (MariaDB
+ *   `IS_USED_LOCK`, PostgreSQL `pg_locks` joined to `pg_stat_activity`, SQL
+ *   Server `sys.dm_tran_locks` request session, SQLite Node file tier
+ *   `owner.json` pid/hostname); the process-local tier reports the owning
+ *   driver's `holderId`.
+ * - `advisory-lock-slow-hold` — a hold lasted longer than `slowHoldMs`
+ *   (default 60000), emitted at release.
+ *
+ * Reports are emitted on `configuration.getErrorEvents()` as `framework-error`
+ * (plus the matching `all-error`) with `{context: "advisory-lock-telemetry",
+ * event, lockName, backendTier, ...}` payloads, matching the repo's "never
+ * swallow" rule so process-level bug reporters capture them.
+ *
+ * Holder lookups are strictly best-effort *after* the acquisition already
+ * settled: a failed lookup never changes the acquisition outcome and never
+ * throws to the caller.
+ */
+/**
+ * One advisory-lock telemetry report.
+ * @typedef {object} AdvisoryLockTelemetryReport
+ * @property {"advisory-lock-slow-acquire" | "advisory-lock-acquire-timeout" | "advisory-lock-slow-hold"} event - Which event fired.
+ * @property {string} lockName - The contended advisory-lock name.
+ * @property {string} backendTier - Tier that served (or refused) the acquisition: `driver-native`, `process-local`, or `file`.
+ * @property {number} durationMs - Measured duration of the acquire wait (or the hold).
+ * @property {"acquired" | "timeout" | null} outcome - For acquire events: whether the wait eventually acquired the lock. Null for hold reports.
+ * @property {number | null} timeoutMs - The effective acquire bound for acquire events. Null for hold reports or an unbounded wait.
+ * @property {string | null} holderId - Process-local holder attribution when the tier can name its local holder.
+ * @property {string | null} holderConnectionId - Driver-native holder attribution captured at the event moment (MariaDB `IS_USED_LOCK` connection id, PostgreSQL pid, SQL Server session id, SQLite file `pid@hostname`).
+ * @property {string | null} holderLookupError - Set when the best-effort holder lookup itself failed; the lookup never affects the acquisition.
+ */
+/**
+ * Resolved per-database telemetry thresholds.
+ * @typedef {object} AdvisoryLockTelemetryThresholds
+ * @property {number | null} slowAcquireMs - Report an acquire wait slower than this; `null` disables slow-acquire reports.
+ * @property {number | null} slowHoldMs - Report a hold longer than this at release; `null` disables hold reports.
+ */
+/** Framework default: report an acquire wait that completed slower than this. */
+export const DEFAULT_ADVISORY_LOCK_SLOW_ACQUIRE_MS = 5000;
+/** Framework default: report a hold that outlives this at release. */
+export const DEFAULT_ADVISORY_LOCK_SLOW_HOLD_MS = 60 * 1000;
+/**
+ * Resolve the telemetry thresholds for one database configuration.
+ * An explicit per-database `advisoryLockTelemetry` value wins; `null` opts out
+ * of that report; only when neither is configured does the framework default
+ * apply.
+ * @param {import("../configuration-types.js").DatabaseConfigurationType} args - Database configuration args.
+ * @returns {AdvisoryLockTelemetryThresholds} - Resolved thresholds.
+ */
+export function advisoryLockTelemetryThresholds(args) {
+    const configured = args?.advisoryLockTelemetry;
+    /** @type {AdvisoryLockTelemetryThresholds} */
+    const thresholds = {
+        slowAcquireMs: DEFAULT_ADVISORY_LOCK_SLOW_ACQUIRE_MS,
+        slowHoldMs: DEFAULT_ADVISORY_LOCK_SLOW_HOLD_MS
+    };
+    if (configured?.slowAcquireMs === null)
+        thresholds.slowAcquireMs = null;
+    else if (typeof configured?.slowAcquireMs === "number" && configured.slowAcquireMs >= 0)
+        thresholds.slowAcquireMs = configured.slowAcquireMs;
+    if (configured?.slowHoldMs === null)
+        thresholds.slowHoldMs = null;
+    else if (typeof configured?.slowHoldMs === "number" && configured.slowHoldMs >= 0)
+        thresholds.slowHoldMs = configured.slowHoldMs;
+    return thresholds;
+}
+/**
+ * Emit one telemetry report on the framework-error channel.
+ *
+ * Mirrors the repo's framework-error emission shape (see `configuration.js`
+ * `_reportBeaconError`): when no listener is attached to `framework-error` or
+ * `all-error`, a one-line summary goes to `stderr` so a convoy is never
+ * completely silent. A listener failure can never break lock handling, so
+ * emissions are guarded.
+ * @param {import("../configuration.js").default} configuration - Configuration instance owning the error channel.
+ * @param {AdvisoryLockTelemetryReport} report - The report payload.
+ * @returns {void} - No return value.
+ */
+export function emitAdvisoryLockTelemetryReport(configuration, report) {
+    /** @type {import("eventemitter3").EventEmitter | undefined} */
+    let errorEvents;
+    try {
+        errorEvents = configuration?.getErrorEvents();
+    }
+    catch {
+        return; // No configuration to report through — never break lock handling.
+    }
+    if (!errorEvents)
+        return;
+    const hasListener = errorEvents.listenerCount("framework-error") > 0
+        || errorEvents.listenerCount("all-error") > 0;
+    const payload = { context: "advisory-lock-telemetry", ...report };
+    try {
+        errorEvents.emit("framework-error", payload);
+        errorEvents.emit("all-error", { ...payload, errorType: "framework-error" });
+    }
+    catch {
+        // A broken listener must never surface as a lock failure.
+    }
+    if (!hasListener) {
+        console.error(`[velocious advisory-lock-telemetry ${report.event}] lock=${JSON.stringify(report.lockName)} tier=${report.backendTier} durationMs=${report.durationMs}${report.outcome ? ` outcome=${report.outcome}` : ""}${report.holderConnectionId ? ` holderConnectionId=${report.holderConnectionId}` : ""}${report.holderId ? ` holderId=${report.holderId}` : ""} — subscribe via configuration.getErrorEvents().on("framework-error", …) to route these reports to your bug reporter`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"advisory-lock-telemetry.js","sourceRoot":"","sources":["../../../src/database/advisory-lock-telemetry.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH;;;;;;;;;;;;GAYG;AAEH;;;;;GAKG;AAEH,iFAAiF;AACjF,MAAM,CAAC,MAAM,qCAAqC,GAAG,IAAI,CAAA;AAEzD,sEAAsE;AACtE,MAAM,CAAC,MAAM,kCAAkC,GAAG,EAAE,GAAG,IAAI,CAAA;AAE3D;;;;;;;GAOG;AACH,MAAM,UAAU,+BAA+B,CAAC,IAAI;IAClD,MAAM,UAAU,GAAG,IAAI,EAAE,qBAAqB,CAAA;IAC9C,8CAA8C;IAC9C,MAAM,UAAU,GAAG;QACjB,aAAa,EAAE,qCAAqC;QACpD,UAAU,EAAE,kCAAkC;KAC/C,CAAA;IAED,IAAI,UAAU,EAAE,aAAa,KAAK,IAAI;QAAE,UAAU,CAAC,aAAa,GAAG,IAAI,CAAA;SAClE,IAAI,OAAO,UAAU,EAAE,aAAa,KAAK,QAAQ,IAAI,UAAU,CAAC,aAAa,IAAI,CAAC;QAAE,UAAU,CAAC,aAAa,GAAG,UAAU,CAAC,aAAa,CAAA;IAE5I,IAAI,UAAU,EAAE,UAAU,KAAK,IAAI;QAAE,UAAU,CAAC,UAAU,GAAG,IAAI,CAAA;SAC5D,IAAI,OAAO,UAAU,EAAE,UAAU,KAAK,QAAQ,IAAI,UAAU,CAAC,UAAU,IAAI,CAAC;QAAE,UAAU,CAAC,UAAU,GAAG,UAAU,CAAC,UAAU,CAAA;IAEhI,OAAO,UAAU,CAAA;AACnB,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,+BAA+B,CAAC,aAAa,EAAE,MAAM;IACnE,+DAA+D;IAC/D,IAAI,WAAW,CAAA;IAEf,IAAI,CAAC;QACH,WAAW,GAAG,aAAa,EAAE,cAAc,EAAE,CAAA;IAC/C,CAAC;IAAC,MAAM,CAAC;QACP,OAAM,CAAC,kEAAkE;IAC3E,CAAC;IAED,IAAI,CAAC,WAAW;QAAE,OAAM;IAExB,MAAM,WAAW,GAAG,WAAW,CAAC,aAAa,CAAC,iBAAiB,CAAC,GAAG,CAAC;WAC/D,WAAW,CAAC,aAAa,CAAC,WAAW,CAAC,GAAG,CAAC,CAAA;IAC/C,MAAM,OAAO,GAAG,EAAC,OAAO,EAAE,yBAAyB,EAAE,GAAG,MAAM,EAAC,CAAA;IAE/D,IAAI,CAAC;QACH,WAAW,CAAC,IAAI,CAAC,iBAAiB,EAAE,OAAO,CAAC,CAAA;QAC5C,WAAW,CAAC,IAAI,CAAC,WAAW,EAAE,EAAC,GAAG,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAC,CAAC,CAAA;IAC3E,CAAC;IAAC,MAAM,CAAC;QACP,0DAA0D;IAC5D,CAAC;IAED,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,OAAO,CAAC,KAAK,CAAC,sCAAsC,MAAM,CAAC,KAAK,UAAU,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,MAAM,CAAC,WAAW,eAAe,MAAM,CAAC,UAAU,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,YAAY,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,CAAC,kBAAkB,CAAC,CAAC,CAAC,uBAAuB,MAAM,CAAC,kBAAkB,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,aAAa,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,sHAAsH,CAAC,CAAA;IAChe,CAAC;AACH,CAAC","sourcesContent":["// @ts-check\n\n/**\n * Event-driven advisory-lock duration telemetry (STC-261, parent epic STC-209).\n *\n * A lock convoy is only fixable when it is *attributable*: which lock name was\n * contended, on which backend tier, for how long, and who held it. These reports\n * fire on the acquisition/release events themselves — never from a periodic\n * scanner — so a contended lock in production surfaces on the framework-error\n * channel with the holder identity available on that tier at that moment,\n * without SSH forensics.\n *\n * Three events, each with its own threshold (all configurable per database via\n * `advisoryLockTelemetry`, see `docs/advisory-locks.md`):\n *\n * - `advisory-lock-slow-acquire` — an acquire wait completed slower than\n *   `slowAcquireMs` (default 5000), including the eventual outcome (`acquired`\n *   or `timeout`).\n * - `advisory-lock-acquire-timeout` — a wait exceeded its timeout. The report\n *   carries the holder identity available on the tier at that moment: the\n *   driver-native tiers attribute the holder connection (MariaDB\n *   `IS_USED_LOCK`, PostgreSQL `pg_locks` joined to `pg_stat_activity`, SQL\n *   Server `sys.dm_tran_locks` request session, SQLite Node file tier\n *   `owner.json` pid/hostname); the process-local tier reports the owning\n *   driver's `holderId`.\n * - `advisory-lock-slow-hold` — a hold lasted longer than `slowHoldMs`\n *   (default 60000), emitted at release.\n *\n * Reports are emitted on `configuration.getErrorEvents()` as `framework-error`\n * (plus the matching `all-error`) with `{context: \"advisory-lock-telemetry\",\n * event, lockName, backendTier, ...}` payloads, matching the repo's \"never\n * swallow\" rule so process-level bug reporters capture them.\n *\n * Holder lookups are strictly best-effort *after* the acquisition already\n * settled: a failed lookup never changes the acquisition outcome and never\n * throws to the caller.\n */\n\n/**\n * One advisory-lock telemetry report.\n * @typedef {object} AdvisoryLockTelemetryReport\n * @property {\"advisory-lock-slow-acquire\" | \"advisory-lock-acquire-timeout\" | \"advisory-lock-slow-hold\"} event - Which event fired.\n * @property {string} lockName - The contended advisory-lock name.\n * @property {string} backendTier - Tier that served (or refused) the acquisition: `driver-native`, `process-local`, or `file`.\n * @property {number} durationMs - Measured duration of the acquire wait (or the hold).\n * @property {\"acquired\" | \"timeout\" | null} outcome - For acquire events: whether the wait eventually acquired the lock. Null for hold reports.\n * @property {number | null} timeoutMs - The effective acquire bound for acquire events. Null for hold reports or an unbounded wait.\n * @property {string | null} holderId - Process-local holder attribution when the tier can name its local holder.\n * @property {string | null} holderConnectionId - Driver-native holder attribution captured at the event moment (MariaDB `IS_USED_LOCK` connection id, PostgreSQL pid, SQL Server session id, SQLite file `pid@hostname`).\n * @property {string | null} holderLookupError - Set when the best-effort holder lookup itself failed; the lookup never affects the acquisition.\n */\n\n/**\n * Resolved per-database telemetry thresholds.\n * @typedef {object} AdvisoryLockTelemetryThresholds\n * @property {number | null} slowAcquireMs - Report an acquire wait slower than this; `null` disables slow-acquire reports.\n * @property {number | null} slowHoldMs - Report a hold longer than this at release; `null` disables hold reports.\n */\n\n/** Framework default: report an acquire wait that completed slower than this. */\nexport const DEFAULT_ADVISORY_LOCK_SLOW_ACQUIRE_MS = 5000\n\n/** Framework default: report a hold that outlives this at release. */\nexport const DEFAULT_ADVISORY_LOCK_SLOW_HOLD_MS = 60 * 1000\n\n/**\n * Resolve the telemetry thresholds for one database configuration.\n * An explicit per-database `advisoryLockTelemetry` value wins; `null` opts out\n * of that report; only when neither is configured does the framework default\n * apply.\n * @param {import(\"../configuration-types.js\").DatabaseConfigurationType} args - Database configuration args.\n * @returns {AdvisoryLockTelemetryThresholds} - Resolved thresholds.\n */\nexport function advisoryLockTelemetryThresholds(args) {\n  const configured = args?.advisoryLockTelemetry\n  /** @type {AdvisoryLockTelemetryThresholds} */\n  const thresholds = {\n    slowAcquireMs: DEFAULT_ADVISORY_LOCK_SLOW_ACQUIRE_MS,\n    slowHoldMs: DEFAULT_ADVISORY_LOCK_SLOW_HOLD_MS\n  }\n\n  if (configured?.slowAcquireMs === null) thresholds.slowAcquireMs = null\n  else if (typeof configured?.slowAcquireMs === \"number\" && configured.slowAcquireMs >= 0) thresholds.slowAcquireMs = configured.slowAcquireMs\n\n  if (configured?.slowHoldMs === null) thresholds.slowHoldMs = null\n  else if (typeof configured?.slowHoldMs === \"number\" && configured.slowHoldMs >= 0) thresholds.slowHoldMs = configured.slowHoldMs\n\n  return thresholds\n}\n\n/**\n * Emit one telemetry report on the framework-error channel.\n *\n * Mirrors the repo's framework-error emission shape (see `configuration.js`\n * `_reportBeaconError`): when no listener is attached to `framework-error` or\n * `all-error`, a one-line summary goes to `stderr` so a convoy is never\n * completely silent. A listener failure can never break lock handling, so\n * emissions are guarded.\n * @param {import(\"../configuration.js\").default} configuration - Configuration instance owning the error channel.\n * @param {AdvisoryLockTelemetryReport} report - The report payload.\n * @returns {void} - No return value.\n */\nexport function emitAdvisoryLockTelemetryReport(configuration, report) {\n  /** @type {import(\"eventemitter3\").EventEmitter | undefined} */\n  let errorEvents\n\n  try {\n    errorEvents = configuration?.getErrorEvents()\n  } catch {\n    return // No configuration to report through — never break lock handling.\n  }\n\n  if (!errorEvents) return\n\n  const hasListener = errorEvents.listenerCount(\"framework-error\") > 0\n    || errorEvents.listenerCount(\"all-error\") > 0\n  const payload = {context: \"advisory-lock-telemetry\", ...report}\n\n  try {\n    errorEvents.emit(\"framework-error\", payload)\n    errorEvents.emit(\"all-error\", {...payload, errorType: \"framework-error\"})\n  } catch {\n    // A broken listener must never surface as a lock failure.\n  }\n\n  if (!hasListener) {\n    console.error(`[velocious advisory-lock-telemetry ${report.event}] lock=${JSON.stringify(report.lockName)} tier=${report.backendTier} durationMs=${report.durationMs}${report.outcome ? ` outcome=${report.outcome}` : \"\"}${report.holderConnectionId ? ` holderConnectionId=${report.holderConnectionId}` : \"\"}${report.holderId ? ` holderId=${report.holderId}` : \"\"} — subscribe via configuration.getErrorEvents().on(\"framework-error\", …) to route these reports to your bug reporter`)\n  }\n}\n"]}

package/build/src/database/drivers/base.d.ts

@@ -406,6 +406,18 @@ export default class VelociousDatabaseDriversBase {
     }>;
     /** @type {Map<string, number>} */
     _heldAdvisoryLocks: Map<string, number>;
+    /**
+     * When each tracked advisory lock was first acquired, so the final release can
+     * report a hold that outlived `advisoryLockTelemetry.slowHoldMs`.
+     * @type {Map<string, number>}
+     */
+    _advisoryLockAcquiredAtByName: Map<string, number>;
+    /**
+     * Stable per-connection holder identity used by advisory-lock telemetry when
+     * the tier can only name local holders.
+     * @type {string | undefined}
+     */
+    _advisoryLockHolderId: string | undefined;
     /**
      * Exclusive operation lease installed by a single-multi-use pool.
      * @type {import("../operation-lease.js").default | undefined}
@@ -1560,5 +1572,44 @@ export default class VelociousDatabaseDriversBase {
      * @returns {Promise<boolean>} - Resolves to true if the lock is held by ? session.
      */
     isAdvisoryLockHeld(name: string): Promise<boolean>;
+    /**
+     * Which advisory-lock backend tier this connection serves (STC-210 chain
+     * naming). The base driver is the driver-native tier; the SQLite drivers
+     * override to `process-local` / `file`.
+     * @returns {string} - Tier name reported on telemetry payloads.
+     */
+    advisoryLockBackendTier(): string;
+    /**
+     * Stable identity of this connection as a lock holder, reported on
+     * telemetry payloads so a slow acquire/hold is attributable to the reporting
+     * connection itself.
+     * @returns {string} - Holder id.
+     */
+    advisoryLockHolderId(): string;
+    /**
+     * Best-effort identity of the connection currently holding the named lock,
+     * captured on the tier that served the acquisition. The base driver has no
+     * portable server-side lookup; MySQL/PostgreSQL/SQL Server/Node-SQLite
+     * override with their tier's holder attribution.
+     * @param {string} name - Lock name.
+     * @returns {Promise<string | null>} - Holder connection identity, or null when the tier cannot attribute it.
+     */
+    advisoryLockHolderConnectionId(name: string): Promise<string | null>;
+    /**
+     * Emit one event-driven advisory-lock telemetry report (slow acquire,
+     * acquire timeout with holder attribution, slow hold). The holder lookup is
+     * best-effort: a failed lookup is recorded on the report and never affects
+     * the acquisition that already settled.
+     * @param {{event: "advisory-lock-slow-acquire" | "advisory-lock-acquire-timeout" | "advisory-lock-slow-hold", lockName: string, durationMs: number, outcome: "acquired" | "timeout" | null, timeoutMs: number | null, captureHolder?: boolean}} args - Report args.
+     * @returns {Promise<void>} - Resolves after the report is emitted.
+     */
+    _reportAdvisoryLockTelemetry(args: {
+        event: "advisory-lock-slow-acquire" | "advisory-lock-acquire-timeout" | "advisory-lock-slow-hold";
+        lockName: string;
+        durationMs: number;
+        outcome: "acquired" | "timeout" | null;
+        timeoutMs: number | null;
+        captureHolder?: boolean;
+    }): Promise<void>;
 }
 //# sourceMappingURL=base.d.ts.map