@salesforce/lds-runtime-mobile 1.453.0 → 1.455.0

package/sfdc/main.js

@@ -1973,16 +1973,18 @@ class LdsAbortController {
 }
 
 class AsyncWorkerPool {
-    constructor(concurrency) {
+    constructor(concurrency, onWorkTiming) {
         this.queue = [];
         this.activeWork = [];
         this.concurrency = concurrency;
+        this.onWorkTiming = onWorkTiming;
     }
     push(work) {
         return new Promise((resolve, reject) => {
             this.queue.push({
                 ...work,
                 workFn: (abortController) => work.workFn(abortController).then(resolve).catch(reject),
+                enqueuedAt: Date.now(),
             });
             this.doWork();
         });
@@ -2025,10 +2027,30 @@ class AsyncWorkerPool {
                 const abortController = new LdsAbortController();
                 const newWork = { ...work, abortController };
                 this.activeWork.push(newWork);
-                const { workFn } = work;
+                const { workFn, enqueuedAt } = work;
+                const onWorkTiming = this.onWorkTiming;
+                let startedAt = 0;
+                let waitMs = 0;
+                let queueDepthAtStart = 0;
+                if (onWorkTiming !== undefined) {
+                    startedAt = Date.now();
+                    waitMs = startedAt - enqueuedAt;
+                    // depth AFTER this unit was shifted off — units still waiting behind it.
+                    queueDepthAtStart = this.queue.length;
+                }
                 workFn(abortController).finally(() => {
-                    this.activeWork = this.activeWork.filter((w) => w !== newWork);
-                    this.doWork();
+                    try {
+                        if (onWorkTiming !== undefined) {
+                            onWorkTiming(waitMs, Date.now() - startedAt, queueDepthAtStart);
+                        }
+                    }
+                    catch {
+                        // Instrumentation must not prevent the pool from releasing the worker slot.
+                    }
+                    finally {
+                        this.activeWork = this.activeWork.filter((w) => w !== newWork);
+                        this.doWork();
+                    }
                 });
             }
         }
@@ -2358,6 +2380,25 @@ const DRAFT_SEGMENT = 'DRAFT';
  */
 const DRAFT_ACTION_RETRY_COUNT_METADATA_KEY = 'retryCount';
 class DurableDraftQueue {
+    // Instrumentation is strictly measure-only: a broken sink must never change queue behavior.
+    // Pass the sink into the callback so methods are invoked through their owning object and retain
+    // their receiver (some sinks use `this` to reach their metric registry).
+    emitInstrumentation(emit) {
+        const { instrumentation } = this;
+        if (instrumentation === undefined) {
+            return;
+        }
+        try {
+            emit(instrumentation);
+        }
+        catch {
+            // Telemetry failures must not interrupt draft processing.
+        }
+    }
+    resetDrainCycle() {
+        this.drainCycleStart = undefined;
+        this.drainCycleBatchCount = 0;
+    }
     getHandler(id) {
         const handler = this.handlers[id];
         if (handler === undefined) {
@@ -2380,9 +2421,19 @@ class DurableDraftQueue {
             ? __nimbus.plugins.JSLoggerPlugin
             : undefined;
         this.handlers = {};
+        // Drain-wait attribution state. uploadStartTimes stamps when each action first began
+        // uploading (keyed by action id) so actionCompleted/failed can emit its end-to-end drain time,
+        // including automatic retries/backoff. actionQueueWaitEmittedIds ensures those retries do not
+        // report the original enqueue wait more than once. drainCycleStart/BatchCount track one full
+        // idle->empty sweep. All measure-only; when no instrumentation is injected these stay untouched.
+        this.uploadStartTimes = new Map();
+        this.actionQueueWaitEmittedIds = new Set();
+        this.drainCycleBatchCount = 0;
         this.draftStore = draftStore;
-        this.workerPool = new AsyncWorkerPool(1);
         this.instrumentation = instrumentation;
+        this.workerPool = new AsyncWorkerPool(1, instrumentation?.onWorkerTiming !== undefined
+            ? (waitMs, holdMs, queueDepth) => this.emitInstrumentation((sink) => sink.onWorkerTiming?.(waitMs, holdMs, queueDepth))
+            : undefined);
     }
     addHandler(handler) {
         const id = handler.handlerId;
@@ -2470,6 +2521,9 @@ class DurableDraftQueue {
             clearTimeout(this.timeoutHandler);
             this.timeoutHandler = undefined;
         }
+        // A stop/user edit breaks the current sweep. A later restart starts a fresh cycle rather
+        // than attributing stopped time to an offline drain.
+        this.resetDrainCycle();
         this.state = DraftQueueState.Stopped;
     }
     async getQueueActions() {
@@ -2500,7 +2554,7 @@ class DurableDraftQueue {
             }
             return aTime - bTime;
         });
-        instrumentation?.onGetQueueActions?.(Date.now() - start, sorted.length);
+        this.emitInstrumentation((sink) => sink.onGetQueueActions?.(Date.now() - start, sorted.length));
         return sorted;
     }
     async enqueue(handlerId, data, observabilityContext) {
@@ -2544,6 +2598,13 @@ class DurableDraftQueue {
                 await handler.handleActionCompleted(action, queueOperations, values$2(this.handlers));
                 this.retryIntervalMilliseconds = 0;
                 this.uploadingActionId = undefined;
+                // The action finished draining — emit its end-to-end drain time and
+                // count it toward the current drain-cycle batch. Measure-only.
+                this.emitActionDrainDuration(action.id, action.handler);
+                this.actionQueueWaitEmittedIds.delete(action.id);
+                if (this.drainCycleStart !== undefined) {
+                    this.drainCycleBatchCount += 1;
+                }
                 await this.notifyChangedListeners({
                     type: DraftQueueEventType.ActionCompleted,
                     action,
@@ -2555,6 +2616,16 @@ class DurableDraftQueue {
             },
         });
     }
+    // Read+clear the action's upload-start stamp and emit its drain duration. Safe to
+    // call when instrumentation is absent or the id was never stamped (no-op). Never emits the id.
+    emitActionDrainDuration(id, handlerId) {
+        const start = this.uploadStartTimes.get(id);
+        if (start === undefined) {
+            return;
+        }
+        this.uploadStartTimes.delete(id);
+        this.emitInstrumentation((sink) => sink.onActionDrainDuration?.(handlerId, Date.now() - start));
+    }
     async actionFailed(action, retry, retryDelayInMs, actionDataChanged) {
         if (actionDataChanged === true) {
             await this.draftStore.writeAction({
@@ -2564,14 +2635,24 @@ class DurableDraftQueue {
         }
         this.uploadingActionId = undefined;
         if (retry && this.state !== DraftQueueState.Stopped) {
+            // A retry means this action is NOT done draining. Keep its first-upload stamp and the
+            // open cycle so the eventual outcome includes network time and retry/backoff.
             this.state = DraftQueueState.Waiting;
             return retryDelayInMs !== undefined
                 ? this.scheduleRetryWithSpecifiedDelay(retryDelayInMs)
                 : this.scheduleRetry();
         }
         else if (isDraftError(action)) {
+            // Terminal failure — this action is done draining. Emit its drain time.
+            this.emitActionDrainDuration(action.id, action.handler);
+            // This was not a clean drain-to-empty. Discard the sweep before user intervention so a
+            // later manual retry/removal cannot inherit its elapsed time or completed batch count.
+            this.resetDrainCycle();
             return this.handleServerError(action, action.error);
         }
+        // Any other terminal path — ensure no stale start stamp lingers.
+        this.emitActionDrainDuration(action.id, action.handler);
+        this.resetDrainCycle();
     }
     handle(action) {
         const handler = this.getHandler(action.handler);
@@ -2591,12 +2672,22 @@ class DurableDraftQueue {
                 this.state = DraftQueueState.Started;
             }
             this.processingAction = undefined;
+            // The queue drained empty — close the drain-cycle window if one was open.
+            if (this.drainCycleStart !== undefined) {
+                const durationMs = Date.now() - this.drainCycleStart;
+                const batchSize = this.drainCycleBatchCount;
+                this.resetDrainCycle();
+                this.emitInstrumentation((sink) => sink.onDrainCycle?.(durationMs, batchSize));
+            }
             return ProcessActionResult.NO_ACTION_TO_PROCESS;
         }
         const { status, id } = action;
         if (status === DraftActionStatus.Error) {
             this.state = DraftQueueState.Error;
             this.processingAction = undefined;
+            // The sweep is blocked on an errored action, not a clean drain-to-empty —
+            // discard the open drain-cycle window so it doesn't inflate a later cycle's duration.
+            this.resetDrainCycle();
             await this.notifyChangedListeners({
                 type: DraftQueueEventType.ActionFailed,
                 action: action,
@@ -2614,6 +2705,31 @@ class DurableDraftQueue {
         if (this.state === DraftQueueState.Waiting) {
             this.state = DraftQueueState.Started;
         }
+        // The action is now leaving the queue to upload. Emit head-of-line FIFO wait
+        // (enqueue -> upload start), stamp its drain-start for end-to-end timing on completion, and
+        // open a drain-cycle window if the queue was previously idle. All measure-only.
+        const { instrumentation } = this;
+        if (instrumentation !== undefined) {
+            const now = Date.now();
+            const { timestamp } = action;
+            if (instrumentation.onActionQueueWait !== undefined &&
+                !this.actionQueueWaitEmittedIds.has(id) &&
+                typeof timestamp === 'number' &&
+                timestamp > 0) {
+                // Mark before invoking the sink: even a throwing callback must not make a retry
+                // report the same action's enqueue wait again.
+                this.actionQueueWaitEmittedIds.add(id);
+                this.emitInstrumentation((sink) => sink.onActionQueueWait?.(action.handler, now - timestamp));
+            }
+            if (instrumentation.onActionDrainDuration !== undefined &&
+                !this.uploadStartTimes.has(id)) {
+                this.uploadStartTimes.set(id, now);
+            }
+            if (instrumentation.onDrainCycle !== undefined && this.drainCycleStart === undefined) {
+                this.drainCycleStart = now;
+                this.drainCycleBatchCount = 0;
+            }
+        }
         await this.notifyChangedListeners({
             type: DraftQueueEventType.ActionUploading,
             action: { ...action, status: DraftActionStatus.Uploading },
@@ -2651,7 +2767,7 @@ class DurableDraftQueue {
             results.push(listener(event));
         }
         // W-23515682: listener fan-out per event type. Measure-only.
-        this.instrumentation?.onNotifyChangedListeners?.(event.type, draftQueueLen);
+        this.emitInstrumentation((sink) => sink.onNotifyChangedListeners?.(event.type, draftQueueLen));
         await Promise.all(results);
     }
     /**
@@ -2680,9 +2796,17 @@ class DurableDraftQueue {
         const shouldDeleteRelated = handler.shouldDeleteActionByTagOnRemoval(action);
         if (shouldDeleteRelated) {
             await this.draftStore.deleteByTag(action.tag);
+            queue.forEach((queuedAction) => {
+                if (queuedAction.tag === action.tag) {
+                    this.uploadStartTimes.delete(queuedAction.id);
+                    this.actionQueueWaitEmittedIds.delete(queuedAction.id);
+                }
+            });
         }
         else {
             await this.draftStore.deleteDraft(action.id);
+            this.uploadStartTimes.delete(action.id);
+            this.actionQueueWaitEmittedIds.delete(action.id);
         }
         await handler.handleActionRemoved(action, queue.filter((x) => x.id !== actionId));
         await this.notifyChangedListeners({
@@ -42336,6 +42460,20 @@ const DRAFT_QUEUE_GET_QUEUE_ACTIONS_DURATION = 'draft-queue-get-queue-actions-du
 const DRAFT_QUEUE_NOTIFY_CHANGED_LISTENERS_COUNT = 'draft-queue-notify-changed-listeners-count';
 const DRAFT_QUEUE_DURABLE_OP_COUNT = 'draft-queue-durable-op-count';
 const DRAFT_QUEUE_DURABLE_OP_DURATION = 'draft-queue-durable-op-duration';
+// Drain-wait attribution telemetry: the wall-clock spine of where an offline drain actually spends
+// WAITING. Operational counts/durations/depths only — no draft content, field values, or server
+// record ids (matching the existing draft-queue privacy stance).
+const DRAFT_QUEUE_WORKER_WAIT_DURATION = 'draft-queue-worker-wait-duration';
+const DRAFT_QUEUE_WORKER_HOLD_DURATION = 'draft-queue-worker-hold-duration';
+const DRAFT_QUEUE_ACTION_QUEUE_WAIT_DURATION = 'draft-queue-action-queue-wait-duration';
+const DRAFT_QUEUE_ACTION_DRAIN_DURATION = 'draft-queue-action-drain-duration';
+const DRAFT_QUEUE_DRAIN_CYCLE_DURATION = 'draft-queue-drain-cycle-duration';
+const DRAFT_QUEUE_DRAIN_CYCLE_BATCH_SIZE = 'draft-queue-drain-cycle-batch-size';
+const DRAFT_QUEUE_ACTION_NETWORK_DURATION = 'draft-queue-action-network-duration';
+const DRAFT_QUEUE_ACTION_RETRY_ATTEMPT = 'draft-queue-action-retry-attempt';
+const DRAFT_QUEUE_SIDEEFFECT_OP_DURATION = 'draft-queue-sideeffect-op-duration';
+const DRAFT_QUEUE_SIDEEFFECT_MAP_SIZE = 'draft-queue-sideeffect-map-size';
+const DRAFT_QUEUE_SIDEEFFECT_REGION_DURATION = 'draft-queue-sideeffect-region-duration';
 /** Content Document */
 const CREATE_CONTENT_DOCUMENT_AND_VERSION_TOTAL_SYNTHESIZE_CALLS = 'content-document-version-total-synthesize-calls';
 const CREATE_CONTENT_DOCUMENT_AND_VERSION_DRAFT_SYNTHESIZE_ERROR = 'create-content-document-version-draft-synthesize-error';
@@ -42455,6 +42593,134 @@ function reportDraftQueueDurableOperation(op, segment, durationMs) {
     });
     ldsMobileInstrumentation.trackValue(DRAFT_QUEUE_DURABLE_OP_DURATION, durationMs);
 }
+const DRAIN_DURATION_BUCKETS = [50, 100, 250, 500, 1000, 2500, 5000, 10000, 30000];
+const WORKER_DEPTH_BUCKETS = [1, 2, 5, 10, 20, 50, 100, 250, 500];
+// Handler ids are extensible through DraftManager, so only retain the fixed mobile handlers in
+// metric tags. Everything else shares one bounded bucket rather than creating an unbounded series.
+function draftQueueHandlerTagOf(handlerId) {
+    switch (handlerId) {
+        case 'LDS_ACTION_HANDLER':
+        case 'ContentDocumentCompositeRepresentationActionHandler':
+        case 'QUICK_ACTION_HANDLER':
+        case 'UPDATE_RECORD_QUICK_ACTION_HANDLER':
+            return handlerId;
+        default:
+            return 'custom';
+    }
+}
+// Coarse, bounded-cardinality label for the pool depth a unit saw when it began, so the
+// wait/hold durations can be sliced BY backlog size without emitting depth as a free integer tag.
+function workerDepthBucketOf(queueDepth) {
+    if (queueDepth <= 0) {
+        return '0';
+    }
+    if (queueDepth <= 2) {
+        return '1-2';
+    }
+    if (queueDepth <= 10) {
+        return '3-10';
+    }
+    if (queueDepth <= 50) {
+        return '11-50';
+    }
+    if (queueDepth <= 250) {
+        return '51-250';
+    }
+    return '250+';
+}
+/**
+ * Per-unit lifecycle split for the AsyncWorkerPool(1) serial queue, emitted once when a unit settles
+ * so the two halves are a JOINED event (rather than shipping wait and depth as unrelated aggregates).
+ * Isolates WHERE the time goes:
+ *   waitMs — enqueue -> work began (waiting on the serial queue before any logic runs).
+ *   holdMs — work began -> work settled (the critical section's own O(N) service time).
+ * Both are additionally tagged by a depthBucket so "does per-unit cost scale with backlog depth"
+ * (the O(N^2) signature) survives aggregation. queueDepth itself is also tracked. Operational only.
+ */
+function reportDraftQueueWorkerTiming(waitMs, holdMs, queueDepth) {
+    const depthBucket = workerDepthBucketOf(queueDepth);
+    ldsMobileInstrumentation.trackValue(DRAFT_QUEUE_WORKER_WAIT_DURATION, waitMs, undefined, {
+        depthBucket,
+    });
+    ldsMobileInstrumentation.trackValue(DRAFT_QUEUE_WORKER_HOLD_DURATION, holdMs, undefined, {
+        depthBucket,
+    });
+    ldsMobileInstrumentation.bucketValue(DRAFT_QUEUE_WORKER_WAIT_DURATION + '-depth', queueDepth, WORKER_DEPTH_BUCKETS);
+}
+/**
+ * Head-of-line FIFO wait for one draft (enqueue -> upload start), bucketed so the
+ * "does wait grow with backlog depth" (O(N^2)) signal is visible per handler type. Custom handler
+ * ids are normalized to one bounded tag so caller-defined values never become metric dimensions.
+ */
+function reportDraftQueueActionQueueWait(handlerId, waitMs) {
+    ldsMobileInstrumentation.bucketValue(DRAFT_QUEUE_ACTION_QUEUE_WAIT_DURATION, waitMs, DRAIN_DURATION_BUCKETS, undefined, { handlerId: draftQueueHandlerTagOf(handlerId) });
+}
+/**
+ * End-to-end drain time for one action (first upload attempt -> completed/failed), including
+ * retry/backoff. Compare it with network-duration and retry-attempt signals to understand the
+ * non-request portion of the drain interval.
+ */
+function reportDraftQueueActionDrainDuration(handlerId, durationMs) {
+    ldsMobileInstrumentation.bucketValue(DRAFT_QUEUE_ACTION_DRAIN_DURATION, durationMs, DRAIN_DURATION_BUCKETS, undefined, { handlerId: draftQueueHandlerTagOf(handlerId) });
+}
+/**
+ * One full drain sweep — first action starts uploading -> queue empties. Both raw values share a
+ * bounded batch-size cohort so aggregate duration remains sliceable by the number of actions drained.
+ */
+function reportDraftQueueDrainCycle(durationMs, batchSize) {
+    const batchSizeBucket = workerDepthBucketOf(batchSize);
+    ldsMobileInstrumentation.trackValue(DRAFT_QUEUE_DRAIN_CYCLE_DURATION, durationMs, undefined, {
+        batchSizeBucket,
+    });
+    ldsMobileInstrumentation.trackValue(DRAFT_QUEUE_DRAIN_CYCLE_BATCH_SIZE, batchSize, undefined, {
+        batchSizeBucket,
+    });
+}
+/**
+ * Server round-trip duration for one upload. Isolates slow-network from CPU-bound
+ * quadratic work — today only a THROWN error is captured, so a slow-but-successful (or slow 4xx/5xx)
+ * response is invisible. Tags: handler type, HTTP method, and a bucketed status class ('2xx'/'4xx'/
+ * '5xx'/'0'). No URL, body, or record id.
+ */
+function reportDraftQueueActionNetworkDuration(handlerId, method, statusBucket, durationMs) {
+    ldsMobileInstrumentation.trackValue(DRAFT_QUEUE_ACTION_NETWORK_DURATION, durationMs, undefined, {
+        handlerId: draftQueueHandlerTagOf(handlerId),
+        method,
+        statusBucket,
+    });
+}
+/**
+ * Retry event count. Repeated events identify actions cycling through the drain even when the retry
+ * cap is disabled and an exact attempt number is not persisted. cappedOut marks cap exhaustion.
+ */
+function reportDraftQueueActionRetryAttempt(handlerId, cappedOut) {
+    ldsMobileInstrumentation.incrementCounter(DRAFT_QUEUE_ACTION_RETRY_ATTEMPT, 1, undefined, {
+        handlerId: draftQueueHandlerTagOf(handlerId),
+        cappedOut: String(cappedOut),
+    });
+}
+/**
+ * SideEffectStore operation duration + map size. The incremental map sped up the by-KEY lookup but
+ * getEffectsByTag still linearly scans all effects — this measures whether that residual scan is
+ * silently quadratic during churn. op is 'add'|'remove'|'getByTag'; incremental flags the fast path;
+ * mapSize is an integer effect count. No record keys, field names, or field values.
+ */
+function reportDraftQueueSideEffectOp(op, incremental, durationMs, mapSize) {
+    ldsMobileInstrumentation.trackValue(DRAFT_QUEUE_SIDEEFFECT_OP_DURATION, durationMs, undefined, {
+        op,
+        incremental: String(incremental),
+    });
+    ldsMobileInstrumentation.trackValue(DRAFT_QUEUE_SIDEEFFECT_MAP_SIZE, mapSize, undefined, {
+        op,
+    });
+}
+/**
+ * Broad side-effect lifecycle duration. The fixed region and lifecycle tags identify which part of
+ * serialized draft processing is slow without emitting record keys, action ids, or field data.
+ */
+function reportDraftQueueSideEffectRegionDuration(region, lifecycle, durationMs) {
+    ldsMobileInstrumentation.trackValue(DRAFT_QUEUE_SIDEEFFECT_REGION_DURATION, durationMs, undefined, { region, lifecycle });
+}
 /**
  * Reports an exception thrown while uploading a draft action. The thrown error is
  * otherwise swallowed by the upload handler's retry path, leaving the failure
@@ -42662,8 +42928,16 @@ class AbstractResourceRequestActionHandler {
         const dispatchOptions = action.observabilityContext !== undefined
             ? { requestCorrelator: { observabilityContext: action.observabilityContext } }
             : {};
+        const method = request?.method?.toUpperCase() ?? 'UNKNOWN';
+        const networkStart = Date.now();
+        let responseReceived = false;
         try {
             const response = await this.networkAdapter(request, dispatchOptions);
+            responseReceived = true;
+            // Time the round-trip regardless of outcome (ok, retryable HTTP error, or non-ok
+            // terminal error) — today only a THROWN error is visible; a slow-but-successful or
+            // slow 4xx/5xx response is not.
+            this.reportNetworkDuration(method, statusBucketOf(response.status), networkStart);
             if (response.ok) {
                 await actionCompleted({
                     ...action,
@@ -42749,19 +43023,32 @@ class AbstractResourceRequestActionHandler {
                     actionDataChanged = true;
                 }
                 else if (!this.isServerGeneratedError(response.body)) {
-                    // Killswitch CLOSED (default) — only an edge/gateway-injected 400 (no
+                    // Killswitch CLOSED (default) — an edge/gateway-injected 400 (no
                     // recognizable server error body) is retried with the SAME key, so the
                     // server can dedupe a write that may already have committed at the origin.
-                    // A real, server-generated 400 (UiApiError[] or an enhancedErrorType body,
-                    // e.g. a field-validation failure) falls through to the error path below:
-                    // retrying it unchanged would only be rejected again, so the draft is
-                    // errored for the user to fix or discard — the same terminal outcome as
-                    // before this fix, minus the duplicating key rotation. The key is only ever
-                    // rotated by the recognized idempotency error codes above, by a backdating
-                    // collision (new body), or when the user edits an errored draft
-                    // (mergeActions/handleReplaceAction).
+                    // Rotating here is what duplicated the WOLI records (@W-23445154), so the
+                    // key is preserved.
                     shouldRetry = true;
                 }
+                else {
+                    // Killswitch CLOSED — a REAL, server-generated 400 (UiApiError[] or an
+                    // enhancedErrorType body, e.g. a field-validation failure). The origin
+                    // understood the request and rejected it, so it definitively did NOT
+                    // commit — there is no already-written record to duplicate, which is what
+                    // makes rotation safe here (unlike the edge-injected case above).
+                    //
+                    // We still do NOT retry (shouldRetry stays false): the request as-is would
+                    // just be rejected again and wedge the queue. The draft errors for the user
+                    // to fix or discard. But we DO rotate the key: the server's idempotency
+                    // layer caches the 400 against the key, so if the same request is later
+                    // resubmitted unchanged after the server-side validation rule changes to
+                    // allow it, reusing the key would replay that cached 400 and the now-valid
+                    // write would never be applied. Rotating gives the retried request a fresh
+                    // key so the origin re-evaluates it. @W-23445154
+                    updatedAction.data.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
+                    reportIdempotencyKeyRotated(updatedAction.targetId, 'server-validation-400');
+                    actionDataChanged = true;
+                }
             }
             if (response.status === HttpStatusCode$1.BadRequest &&
                 this.isBackdatingError(response.body, action)) {
@@ -42806,6 +43093,11 @@ class AbstractResourceRequestActionHandler {
             const error = normalizeError$1(e);
             const attempt = this.getUploadRetryCount(action) + 1;
             reportDraftActionUploadError(error, this.handlerId, attempt);
+            // A thrown network call still has a round-trip duration worth surfacing — a slow
+            // FAILING call is otherwise as invisible as a slow successful one.
+            if (!responseReceived) {
+                this.reportNetworkDuration(method, 'error', networkStart);
+            }
             await this.retryOrCap(action, error, actionErrored);
             return ProcessActionResult.NETWORK_ERROR;
         }
@@ -42841,12 +43133,17 @@ class AbstractResourceRequestActionHandler {
      */
     async retryOrCap(action, lastFailure, actionErrored, retryDelayInMs, actionDataChanged) {
         if (!draftQueueMaxRetryAttemptsGate.isOpen({ fallback: false })) {
-            // Gate closed: preserve the pre-existing unbounded-retry behavior exactly.
+            // Gate closed: preserve the pre-existing unbounded-retry behavior exactly. The
+            // metric is still emitted (measure-only) so retry attempts are visible even with
+            // the cap gate closed — cappedOut is always false here since nothing ever caps
+            // out on this path.
+            this.reportRetryAttempt(false);
             await actionErrored(action, true, retryDelayInMs, actionDataChanged);
             return;
         }
         const attempt = this.getUploadRetryCount(action) + 1;
         if (attempt >= MAX_RETRY_ATTEMPTS) {
+            this.reportRetryAttempt(true);
             await actionErrored({
                 ...action,
                 error: buildMaxRetryError(lastFailure),
@@ -42854,6 +43151,7 @@ class AbstractResourceRequestActionHandler {
             }, false);
             return;
         }
+        this.reportRetryAttempt(false);
         // Persist the incremented attempt count so it survives restarts. Forcing
         // actionDataChanged ensures the queue writes the updated metadata before the
         // action is rescheduled for retry.
@@ -42867,12 +43165,12 @@ class AbstractResourceRequestActionHandler {
         await actionErrored(retryingAction, true, retryDelayInMs, true);
     }
     async handleActionEnqueued(action) {
-        const impactedKeys = await this.recordService.setSideEffectsForActions([action]);
-        await this.recordService.reapplyRecordSideEffects(impactedKeys);
+        const impactedKeys = await this.recordService.setSideEffectsForActions([action], 'enqueued');
+        await this.recordService.reapplyRecordSideEffects(impactedKeys, 'enqueued');
     }
     async handleActionRemoved(action) {
         const impactedKeys = await this.recordService.removeSideEffectsForAction(action);
-        await this.recordService.reapplyRecordSideEffects(impactedKeys);
+        await this.recordService.reapplyRecordSideEffects(impactedKeys, 'removed');
     }
     async handleActionReplaced(target, source) {
         // remove both the siden effects from the actions being merged before we
@@ -42880,10 +43178,10 @@ class AbstractResourceRequestActionHandler {
         const impactedKeysFromRemove = await this.recordService.removeSideEffectsForAction(source);
         const removedSideEffectFromSet = await this.recordService.removeSideEffectsForAction(target);
         // revert the values in the DEFAULT store back to what it was before the removed side effects
-        await this.recordService.reapplyRecordSideEffects(new Set([...impactedKeysFromRemove, ...removedSideEffectFromSet]));
+        await this.recordService.reapplyRecordSideEffects(new Set([...impactedKeysFromRemove, ...removedSideEffectFromSet]), 'replaced-remove');
         // set the new side effect values for the merged action
-        const impactedKeysFromSet = await this.recordService.setSideEffectsForActions([target]);
-        await this.recordService.reapplyRecordSideEffects(new Set([...impactedKeysFromSet]));
+        const impactedKeysFromSet = await this.recordService.setSideEffectsForActions([target], 'replaced-set');
+        await this.recordService.reapplyRecordSideEffects(new Set([...impactedKeysFromSet]), 'replaced-set');
     }
     async handleActionCompleted(action, queueOperations) {
         const { data: request, tag } = action;
@@ -42917,8 +43215,8 @@ class AbstractResourceRequestActionHandler {
                 actionsNeedingReplay.push(qo.action);
             }
         });
-        const impactedKeys = await this.recordService.setSideEffectsForActions(actionsNeedingReplay);
-        await this.recordService.reapplyRecordSideEffects(impactedKeys);
+        const impactedKeys = await this.recordService.setSideEffectsForActions(actionsNeedingReplay, 'completed-replay');
+        await this.recordService.reapplyRecordSideEffects(impactedKeys, 'completed-replay');
     }
     getQueueOperationsForCompletingDrafts(queue, action) {
         const queueOperations = [];
@@ -43244,6 +43542,39 @@ class AbstractResourceRequestActionHandler {
             return new StoreKeyMap();
         });
     }
+    reportNetworkDuration(method, statusBucket, startedAt) {
+        try {
+            reportDraftQueueActionNetworkDuration(this.handlerId, method, statusBucket, Date.now() - startedAt);
+        }
+        catch {
+            // Telemetry must not change upload processing behavior.
+        }
+    }
+    reportRetryAttempt(cappedOut) {
+        try {
+            reportDraftQueueActionRetryAttempt(this.handlerId, cappedOut);
+        }
+        catch {
+            // Telemetry must not change retry or cap behavior.
+        }
+    }
+}
+// Classifies an HTTP status into a small, greppable tag set for the network-duration metric —
+// never the raw status, to keep the metric's tag cardinality bounded.
+function statusBucketOf(status) {
+    if (status === 0) {
+        return '0';
+    }
+    if (status >= 200 && status <= 299) {
+        return '2xx';
+    }
+    if (status >= 400 && status <= 499) {
+        return '4xx';
+    }
+    if (status >= 500) {
+        return '5xx';
+    }
+    return 'other';
 }
 function actionsForTag(tag, queue) {
     return queue.filter((action) => action.tag === tag);
@@ -43607,10 +43938,16 @@ class UiApiDraftRecordService {
     }
     // calculates the side effects for a given set of actions
     // and returns a set of impacted record keys
-    async setSideEffectsForActions(changedActions) {
-        const operations = await this.recalculateForChangedActions(changedActions);
-        await this.sideEffectStore.addEffects(operations);
-        return new Set(operations.map((o) => o.key));
+    async setSideEffectsForActions(changedActions, lifecycle) {
+        const startedAt = Date.now();
+        try {
+            const operations = await this.recalculateForChangedActions(changedActions);
+            await this.sideEffectStore.addEffects(operations);
+            return new Set(operations.map((o) => o.key));
+        }
+        finally {
+            this.reportSideEffectRegionDuration('set', lifecycle, startedAt);
+        }
     }
     // removes the associated side effects for a given action and returns
     // a set of impacted record keys
@@ -43621,31 +43958,45 @@ class UiApiDraftRecordService {
     }
     // reads a set of records out of the durable store, re-applies current side
     // effects and persists the changed record
-    async reapplyRecordSideEffects(recordKeys) {
-        const luvio = this.getLuvio();
-        const keys = Array.from(recordKeys);
-        const recordEntries = await this.durableRecordStore.getRecordsWithMetadata(keys);
-        keys.forEach((key) => {
-            let record;
-            const metadata = {
-                namespace: 'UiApi',
-                representationName: 'RecordRepresentation',
-                version: VERSION$1v,
-                ingestionTimestamp: Date.now(),
-                ttl: Number.MAX_SAFE_INTEGER,
-            };
-            const recordEntry = recordEntries.get(key);
-            if (recordEntry) {
-                record = recordEntry.record;
-                if (recordEntry.metadata) {
-                    metadata.ingestionTimestamp = recordEntry.metadata.ingestionTimestamp;
-                    metadata.ttl = RecordRepresentationTTL;
+    async reapplyRecordSideEffects(recordKeys, lifecycle) {
+        const startedAt = Date.now();
+        try {
+            const luvio = this.getLuvio();
+            const keys = Array.from(recordKeys);
+            const recordEntries = await this.durableRecordStore.getRecordsWithMetadata(keys);
+            keys.forEach((key) => {
+                let record;
+                const metadata = {
+                    namespace: 'UiApi',
+                    representationName: 'RecordRepresentation',
+                    version: VERSION$1v,
+                    ingestionTimestamp: Date.now(),
+                    ttl: Number.MAX_SAFE_INTEGER,
+                };
+                const recordEntry = recordEntries.get(key);
+                if (recordEntry) {
+                    record = recordEntry.record;
+                    if (recordEntry.metadata) {
+                        metadata.ingestionTimestamp = recordEntry.metadata.ingestionTimestamp;
+                        metadata.ttl = RecordRepresentationTTL;
+                    }
                 }
-            }
-            luvio.storePublish(key, record);
-            luvio.publishStoreMetadata(key, metadata);
-        });
-        await luvio.storeBroadcast();
+                luvio.storePublish(key, record);
+                luvio.publishStoreMetadata(key, metadata);
+            });
+            await luvio.storeBroadcast();
+        }
+        finally {
+            this.reportSideEffectRegionDuration('reapply', lifecycle, startedAt);
+        }
+    }
+    reportSideEffectRegionDuration(region, lifecycle, startedAt) {
+        try {
+            reportDraftQueueSideEffectRegionDuration(region, lifecycle, Date.now() - startedAt);
+        }
+        catch {
+            // Telemetry must not change draft processing behavior.
+        }
     }
     async synthesizeId(apiName) {
         const objectInfo = await this.objectInfoService.getObjectInfo(apiName);
@@ -43881,7 +44232,7 @@ class UpdateRecordQuickActionExecutionRepresentationHandler extends AbstractQuic
         // since we don't ingest a record from the response, we need to manually trigger a re-apply here to ensure we
         // re-ingest the record without effects applied
         await this.recordService.removeSideEffectsForAction(action);
-        await this.recordService.reapplyRecordSideEffects(new Set([action.tag]));
+        await this.recordService.reapplyRecordSideEffects(new Set([action.tag]), 'quick-action-completed');
         // notify luvio that record is now changed and needs to be refreshed
         await luvio.notifyStoreUpdateAvailable([action.tag]);
     }
@@ -52567,6 +52918,18 @@ const draftQueueInstrumentation = {
     onDurableOperation(op, segment, durationMs) {
         reportDraftQueueDurableOperation(op, segment, durationMs);
     },
+    onWorkerTiming(waitMs, holdMs, queueDepth) {
+        reportDraftQueueWorkerTiming(waitMs, holdMs, queueDepth);
+    },
+    onActionQueueWait(handlerId, waitMs) {
+        reportDraftQueueActionQueueWait(handlerId, waitMs);
+    },
+    onActionDrainDuration(handlerId, durationMs) {
+        reportDraftQueueActionDrainDuration(handlerId, durationMs);
+    },
+    onDrainCycle(durationMs, batchSize) {
+        reportDraftQueueDrainCycle(durationMs, batchSize);
+    },
 };
 
 // so eslint doesn't complain about nimbus
@@ -56057,6 +56420,9 @@ class SideEffectStore {
         this.initialize();
     }
     async addEffects(effects) {
+        // Wall-clock across the whole method (including the durable write), matching
+        // how the equivalent removeEffects/getEffectsByTag windows are measured.
+        const startTime = Date.now();
         const incremental = draftQueueSideEffectMapGate.isOpen({ fallback: true });
         const durableEntries = {};
         effects.forEach((effect) => {
@@ -56071,8 +56437,11 @@ class SideEffectStore {
             this.regenerateKeyToEffectMap();
         }
         await this.durableStore.setEntries(durableEntries, SIDE_EFFECT_SEGMENT);
+        this.reportOperation('add', incremental, startTime);
     }
     async removeEffects(effects) {
+        // See addEffects — same wall-clock-across-the-method measurement.
+        const startTime = Date.now();
         const incremental = draftQueueSideEffectMapGate.isOpen({ fallback: true });
         const effectKeys = effects.map((e) => e.uniqueId);
         effects.forEach((effect) => {
@@ -56086,6 +56455,7 @@ class SideEffectStore {
             this.regenerateKeyToEffectMap();
         }
         await this.durableStore.evictEntries(effectKeys, SIDE_EFFECT_SEGMENT);
+        this.reportOperation('remove', incremental, startTime);
     }
     getEffects(key) {
         const effects = this.keyToEffectMap.get(key);
@@ -56095,6 +56465,10 @@ class SideEffectStore {
         return effects;
     }
     getEffectsByTag(tag) {
+        // This scan is still O(N) over every effect regardless of the incremental-map
+        // gate — timing it tells us whether that residual scan is the quadratic hotspot during churn.
+        const startTime = Date.now();
+        const incremental = draftQueueSideEffectMapGate.isOpen({ fallback: true });
         const filteredEffects = [];
         const { keyToEffectMap } = this;
         // Loop through every entry in the map
@@ -56104,7 +56478,17 @@ class SideEffectStore {
             // Add the matching effects to the filtered list
             filteredEffects.push(...matchingEffects);
         }
-        return filteredEffects.sort((a, b) => a.timestamp - b.timestamp);
+        const result = filteredEffects.sort((a, b) => a.timestamp - b.timestamp);
+        this.reportOperation('getByTag', incremental, startTime);
+        return result;
+    }
+    reportOperation(op, incremental, startedAt) {
+        try {
+            reportDraftQueueSideEffectOp(op, incremental, Date.now() - startedAt, this.allEffects.size);
+        }
+        catch {
+            // Telemetry must not change side-effect store behavior.
+        }
     }
     async initialize() {
         const effects = await this.durableStore.getAllEntries(SIDE_EFFECT_SEGMENT);
@@ -59318,7 +59702,7 @@ function buildServiceDescriptor$b(luvio) {
         },
     };
 }
-// version: 1.453.0-725e09cf25
+// version: 1.455.0-c53c97de2a
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -59344,7 +59728,7 @@ function buildServiceDescriptor$a(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.453.0-725e09cf25
+// version: 1.455.0-c53c97de2a
 
 function findExecutableOperation(input) {
   const operations = input.query.definitions.filter(
@@ -62056,4 +62440,4 @@ register({
 });
 
 export { O11Y_NAMESPACE_LDS_MOBILE, getRuntime, ingest$1o as ingestDenormalizedRecordRepresentation, initializeOneStore, registerReportObserver, reportGraphqlQueryParseError };
-// version: 1.453.0-725e09cf25
+// version: 1.455.0-c53c97de2a