velocious 1.0.710 → 1.0.711

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

@@ -72,10 +72,15 @@ export type AdvisoryLockTelemetryThresholds = {
  * - `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.
+ * Reports are emitted on `configuration.getTelemetryEvents()` as `telemetry`
+ * with `{context: "advisory-lock-telemetry", event, lockName, backendTier, ...}`
+ * payloads.
+ *
+ * These are measurements, not failures, so they are deliberately kept off the
+ * framework-error channel: a bug reporter subscribed to `framework-error` /
+ * `all-error` must be able to assume every payload carries a thrown value, and a
+ * contention report delivered there became one bug report (plus its symbolication
+ * and notification work) per event.
  *
  * Holder lookups are strictly best-effort *after* the acquisition already
  * settled: a failed lookup never changes the acquisition outcome and never
@@ -114,14 +119,12 @@ export declare const DEFAULT_ADVISORY_LOCK_SLOW_HOLD_MS: number;
  */
 export declare function advisoryLockTelemetryThresholds(args: import("../configuration-types.js").DatabaseConfigurationType): AdvisoryLockTelemetryThresholds;
 /**
- * Emit one telemetry report on the framework-error channel.
+ * Emit one telemetry report on the framework-telemetry 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.
+ * When no `telemetry` listener is attached, 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 telemetry channel.
  * @param {AdvisoryLockTelemetryReport} report - The report payload.
  * @returns {void} - No return value.
  */

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

@@ -1 +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"}
+{"version":3,"file":"advisory-lock-telemetry.d.ts","sourceRoot":"","sources":["../../../src/database/advisory-lock-telemetry.js"],"names":[],"mappings":"AA6CG,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;AA5DD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;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;;;;;;;;;GASG;AACH,wBAAgB,+BAA+B,CAAC,aAAa,EAJlD,OAAO,qBAAqB,EAAE,OAIoB,EAAE,MAAM,EAH1D,2BAG0D,GAFxD,IAAI,CA0BhB"}

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

@@ -25,10 +25,15 @@
  * - `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.
+ * Reports are emitted on `configuration.getTelemetryEvents()` as `telemetry`
+ * with `{context: "advisory-lock-telemetry", event, lockName, backendTier, ...}`
+ * payloads.
+ *
+ * These are measurements, not failures, so they are deliberately kept off the
+ * framework-error channel: a bug reporter subscribed to `framework-error` /
+ * `all-error` must be able to assume every payload carries a thrown value, and a
+ * contention report delivered there became one bug report (plus its symbolication
+ * and notification work) per event.
  *
  * Holder lookups are strictly best-effort *after* the acquisition already
  * settled: a failed lookup never changes the acquisition outcome and never
@@ -83,40 +88,36 @@ export function advisoryLockTelemetryThresholds(args) {
     return thresholds;
 }
 /**
- * Emit one telemetry report on the framework-error channel.
+ * Emit one telemetry report on the framework-telemetry 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.
+ * When no `telemetry` listener is attached, 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 telemetry channel.
  * @param {AdvisoryLockTelemetryReport} report - The report payload.
  * @returns {void} - No return value.
  */
 export function emitAdvisoryLockTelemetryReport(configuration, report) {
     /** @type {import("eventemitter3").EventEmitter | undefined} */
-    let errorEvents;
+    let telemetryEvents;
     try {
-        errorEvents = configuration?.getErrorEvents();
+        telemetryEvents = configuration?.getTelemetryEvents();
     }
     catch {
         return; // No configuration to report through — never break lock handling.
     }
-    if (!errorEvents)
+    if (!telemetryEvents)
         return;
-    const hasListener = errorEvents.listenerCount("framework-error") > 0
-        || errorEvents.listenerCount("all-error") > 0;
+    const hasListener = telemetryEvents.listenerCount("telemetry") > 0;
     const payload = { context: "advisory-lock-telemetry", ...report };
     try {
-        errorEvents.emit("framework-error", payload);
-        errorEvents.emit("all-error", { ...payload, errorType: "framework-error" });
+        telemetryEvents.emit("telemetry", payload);
     }
     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`);
+        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.getTelemetryEvents().on("telemetry", …) to route these measurements to your metrics`);
     }
 }
-//# 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"]}
+//# 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;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;;;;;;;;;GASG;AACH,MAAM,UAAU,+BAA+B,CAAC,aAAa,EAAE,MAAM;IACnE,+DAA+D;IAC/D,IAAI,eAAe,CAAA;IAEnB,IAAI,CAAC;QACH,eAAe,GAAG,aAAa,EAAE,kBAAkB,EAAE,CAAA;IACvD,CAAC;IAAC,MAAM,CAAC;QACP,OAAM,CAAC,kEAAkE;IAC3E,CAAC;IAED,IAAI,CAAC,eAAe;QAAE,OAAM;IAE5B,MAAM,WAAW,GAAG,eAAe,CAAC,aAAa,CAAC,WAAW,CAAC,GAAG,CAAC,CAAA;IAClE,MAAM,OAAO,GAAG,EAAC,OAAO,EAAE,yBAAyB,EAAE,GAAG,MAAM,EAAC,CAAA;IAE/D,IAAI,CAAC;QACH,eAAe,CAAC,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,CAAA;IAC5C,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,oHAAoH,CAAC,CAAA;IAC9d,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.getTelemetryEvents()` as `telemetry`\n * with `{context: \"advisory-lock-telemetry\", event, lockName, backendTier, ...}`\n * payloads.\n *\n * These are measurements, not failures, so they are deliberately kept off the\n * framework-error channel: a bug reporter subscribed to `framework-error` /\n * `all-error` must be able to assume every payload carries a thrown value, and a\n * contention report delivered there became one bug report (plus its symbolication\n * and notification work) per event.\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-telemetry channel.\n *\n * When no `telemetry` listener is attached, a one-line summary goes to `stderr`\n * so a convoy is never completely silent. A listener failure can never break\n * lock handling, so emissions are guarded.\n * @param {import(\"../configuration.js\").default} configuration - Configuration instance owning the telemetry 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 telemetryEvents\n\n  try {\n    telemetryEvents = configuration?.getTelemetryEvents()\n  } catch {\n    return // No configuration to report through — never break lock handling.\n  }\n\n  if (!telemetryEvents) return\n\n  const hasListener = telemetryEvents.listenerCount(\"telemetry\") > 0\n  const payload = {context: \"advisory-lock-telemetry\", ...report}\n\n  try {\n    telemetryEvents.emit(\"telemetry\", payload)\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.getTelemetryEvents().on(\"telemetry\", …) to route these measurements to your metrics`)\n  }\n}\n"]}

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "build/bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.710",
+  "version": "1.0.711",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [

package/src/configuration-types.js

@@ -85,7 +85,7 @@
 /**
  * @typedef {object} DatabaseConfigurationType
  * @property {number | null} [advisoryLockAcquireTimeoutMs] - Bound (ms) a blocking advisory-lock acquisition waits for a contended lock before reporting failure. Default: `900000` (15 minutes). `null` opts out and restores the driver's indefinite wait. A per-call `timeoutMs` argument always overrides this.
- * @property {{slowAcquireMs?: number | null, slowHoldMs?: number | null}} [advisoryLockTelemetry] - Event-driven advisory-lock duration telemetry thresholds. `slowAcquireMs` (default `5000`) reports an acquire wait that completed slower than the threshold, including the eventual outcome; `advisory-lock-acquire-timeout` always fires when a wait exceeds its bound and carries the holder identity available on the tier at that moment. `slowHoldMs` (default `60000`) reports a hold that outlives the threshold at release. `null` disables that report. Reports fire on the events themselves — no periodic scanner — on `getErrorEvents()` as `framework-error` with `context: "advisory-lock-telemetry"`. See [docs/advisory-locks.md](../docs/advisory-locks.md).
+ * @property {{slowAcquireMs?: number | null, slowHoldMs?: number | null}} [advisoryLockTelemetry] - Event-driven advisory-lock duration telemetry thresholds. `slowAcquireMs` (default `5000`) reports an acquire wait that completed slower than the threshold, including the eventual outcome; `advisory-lock-acquire-timeout` always fires when a wait exceeds its bound and carries the holder identity available on the tier at that moment. `slowHoldMs` (default `60000`) reports a hold that outlives the threshold at release. `null` disables that report. Reports fire on the events themselves — no periodic scanner — on `getTelemetryEvents()` as `telemetry` with `context: "advisory-lock-telemetry"`. See [docs/advisory-locks.md](../docs/advisory-locks.md).
  * @property {string} [databaseCharset] - Default character set applied by `db:create` via mysql/mariadb `CREATE DATABASE ... CHARACTER SET`. Distinct from `charset`, which is the client connection charset forwarded to the mysql2 driver.
  * @property {string} [databaseCollation] - Default collation applied by `db:create` via mysql/mariadb `CREATE DATABASE ... COLLATE`.
  * @property {string} [database] - Database name for this connection.

package/src/configuration.js

@@ -525,6 +525,7 @@ export default class VelociousConfiguration {
      * @type {WeakSet<object>} */
     this._appliedRouteMounts = new WeakSet()
     this._errorEvents = new EventEmitter()
+    this._telemetryEvents = new EventEmitter()
 
     /**
      * Stores the database pools value.
@@ -3865,6 +3866,19 @@ export default class VelociousConfiguration {
     return this._errorEvents
   }
 
+  /**
+   * Framework telemetry emitter. Telemetry reports measurements — lock contention,
+   * slow queries, queue depth — that are worth observing but are not failures. It is
+   * deliberately separate from `getErrorEvents()`: a bug reporter subscribes to the
+   * error channel on the promise that every payload there carries a thrown value, and
+   * a contention measurement emitted as `framework-error` turns into a bug report on
+   * every occurrence instead of a metric.
+   * @returns {import("eventemitter3").EventEmitter} - Framework telemetry events emitter.
+   */
+  getTelemetryEvents() {
+    return this._telemetryEvents
+  }
+
   /**
    * Registers a reporter that can add client-safe metadata to frontend-model error payloads.
    * @param {import("./configuration-types.js").ClientErrorPayloadReporterType} reporter - Reporter callback.

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

@@ -26,10 +26,15 @@
  * - `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.
+ * Reports are emitted on `configuration.getTelemetryEvents()` as `telemetry`
+ * with `{context: "advisory-lock-telemetry", event, lockName, backendTier, ...}`
+ * payloads.
+ *
+ * These are measurements, not failures, so they are deliberately kept off the
+ * framework-error channel: a bug reporter subscribed to `framework-error` /
+ * `all-error` must be able to assume every payload carries a thrown value, and a
+ * contention report delivered there became one bug report (plus its symbolication
+ * and notification work) per event.
  *
  * Holder lookups are strictly best-effort *after* the acquisition already
  * settled: a failed lookup never changes the acquisition outcome and never
@@ -89,41 +94,37 @@ export function advisoryLockTelemetryThresholds(args) {
 }
 
 /**
- * Emit one telemetry report on the framework-error channel.
+ * Emit one telemetry report on the framework-telemetry 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.
+ * When no `telemetry` listener is attached, 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 telemetry channel.
  * @param {AdvisoryLockTelemetryReport} report - The report payload.
  * @returns {void} - No return value.
  */
 export function emitAdvisoryLockTelemetryReport(configuration, report) {
   /** @type {import("eventemitter3").EventEmitter | undefined} */
-  let errorEvents
+  let telemetryEvents
 
   try {
-    errorEvents = configuration?.getErrorEvents()
+    telemetryEvents = configuration?.getTelemetryEvents()
   } catch {
     return // No configuration to report through — never break lock handling.
   }
 
-  if (!errorEvents) return
+  if (!telemetryEvents) return
 
-  const hasListener = errorEvents.listenerCount("framework-error") > 0
-    || errorEvents.listenerCount("all-error") > 0
+  const hasListener = telemetryEvents.listenerCount("telemetry") > 0
   const payload = {context: "advisory-lock-telemetry", ...report}
 
   try {
-    errorEvents.emit("framework-error", payload)
-    errorEvents.emit("all-error", {...payload, errorType: "framework-error"})
+    telemetryEvents.emit("telemetry", payload)
   } 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`)
+    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.getTelemetryEvents().on("telemetry", …) to route these measurements to your metrics`)
   }
 }