@salesforce/lds-instrumentation 1.124.2 → 1.124.4

package/dist/ldsInstrumentation.js

@@ -106,491 +106,491 @@ function isDurableEnvironmentEvent(event) {
 
 const { stringify: stringify$1 } = JSON;
 
-function isPromise$1(value) {
-    // check for Thenable due to test frameworks using custom Promise impls
-    return value !== null && value !== undefined && typeof value.then === 'function';
-}
-function isErrorSnapshot(snapshot) {
-    return snapshot.state === 'Error';
+function isPromise$1(value) {
+    // check for Thenable due to test frameworks using custom Promise impls
+    return value !== null && value !== undefined && typeof value.then === 'function';
+}
+function isErrorSnapshot(snapshot) {
+    return snapshot.state === 'Error';
 }
 
-function runAdapterWithReport(adapterName, adapter, adapterConfig, requestContext, onAdapterComplete) {
-    let adapterStart;
-    let adapterEnd;
-    let lookupStart;
-    let lookupEnd;
-    let cacheStart;
-    let cacheEnd;
-    let networkStart;
-    let networkEnd;
-    let staleLookup = false;
-    let result;
-    let snapshotState = '';
-    let error;
-    let exceptionMessage;
-    let completedNetworkRequests = [];
-    let collectedNetworkStartEvents = {};
-    let reviveStats = [];
-    let rawEvents = [];
-    const markEnd = (adapterEndedCallback) => {
-        if (adapterStart === undefined) {
-            throw Error('adapter has not been started yet');
-        }
-        if (adapterEnd) {
-            throw Error('adapter has already ended');
-        }
-        if (result === undefined) {
-            throw Error('no result type set');
-        }
-        adapterEnd = Date.now();
-        const executionTime = adapterEnd - adapterStart;
-        const cacheLookupTime = cacheEnd - cacheStart;
-        const lookupTime = lookupEnd - lookupStart;
-        const networkLookupTime = networkEnd - networkStart;
-        const config = stringify$1(adapterConfig);
-        switch (result) {
-            case 'l1-hit':
-                if (staleLookup === true) {
-                    adapterEndedCallback({
-                        result: 'l1-hit',
-                        adapterName,
-                        rawEvents,
-                        config,
-                        stale: true,
-                        executionTime,
-                        cacheLookupTime,
-                        lookupTime,
-                        snapshotState,
-                    });
-                }
-                else {
-                    adapterEndedCallback({
-                        result: 'l1-hit',
-                        adapterName,
-                        rawEvents,
-                        config,
-                        stale: false,
-                        executionTime,
-                        cacheLookupTime,
-                        lookupTime,
-                        snapshotState,
-                    });
-                }
-                break;
-            case 'l2-hit':
-                if (staleLookup === true) {
-                    adapterEndedCallback({
-                        result: 'l2-hit',
-                        adapterName,
-                        rawEvents,
-                        config,
-                        stale: true,
-                        executionTime,
-                        cacheLookupTime,
-                        lookupTime,
-                        snapshotState,
-                        revives: reviveStats,
-                    });
-                }
-                else {
-                    adapterEndedCallback({
-                        result: 'l2-hit',
-                        adapterName,
-                        rawEvents,
-                        config,
-                        stale: false,
-                        executionTime,
-                        cacheLookupTime,
-                        lookupTime,
-                        snapshotState,
-                        revives: reviveStats,
-                    });
-                }
-                break;
-            case 'cache-miss':
-                adapterEndedCallback({
-                    result: 'cache-miss',
-                    adapterName,
-                    rawEvents,
-                    config,
-                    executionTime,
-                    cacheLookupTime,
-                    lookupTime,
-                    networkLookupTime,
-                    completedNetworkRequests,
-                    snapshotState,
-                    revives: reviveStats,
-                });
-                break;
-            case 'invalid-config':
-                adapterEndedCallback({
-                    result: 'invalid-config',
-                    rawEvents,
-                    config,
-                    adapterName,
-                    executionTime,
-                });
-                break;
-            case 'error':
-                adapterEndedCallback({
-                    result: 'error',
-                    rawEvents,
-                    config,
-                    error,
-                    adapterName,
-                    executionTime,
-                    cacheLookupTime,
-                    lookupTime,
-                    networkLookupTime,
-                    snapshotState,
-                });
-                break;
-            case 'exception':
-                adapterEndedCallback({
-                    result: 'exception',
-                    rawEvents,
-                    config,
-                    exceptionMessage,
-                    adapterName,
-                    executionTime,
-                });
-                break;
-        }
-    };
-    const markException = (error) => {
-        let message = 'Unknown Error';
-        if (error instanceof Error)
-            message = error.message;
-        exceptionMessage = message;
-        result = 'exception';
-    };
-    const metricsEventObserver = {
-        onAdapterEvent: (ev) => {
-            rawEvents.push(ev);
-            switch (ev.type) {
-                case 'adapter-lookup-start':
-                    lookupStart = Date.now();
-                    break;
-                case 'adapter-lookup-end':
-                    lookupEnd = Date.now();
-                    break;
-                case 'cache-lookup-start':
-                    cacheStart = Date.now();
-                    break;
-                case 'cache-lookup-end':
-                    cacheEnd = Date.now();
-                    if (ev.wasResultAsync === false) {
-                        // L1 cache hit
-                        result = 'l1-hit';
-                    }
-                    else {
-                        // L2 cache hit
-                        result = 'l2-hit';
-                    }
-                    if (ev.snapshotState === 'Stale') {
-                        staleLookup = true;
-                    }
-                    break;
-                case 'network-lookup-start':
-                    // if the lookup is stale, the network lookup is
-                    // caused by an async refresh
-                    if (staleLookup === false) {
-                        result = 'cache-miss';
-                        networkStart = Date.now();
-                    }
-                    break;
-                case 'network-lookup-end':
-                    if (staleLookup === false) {
-                        networkEnd = Date.now();
-                    }
-                    break;
-                case 'network-request-start':
-                    collectedNetworkStartEvents[ev.uuid] = ev;
-                    break;
-                case 'network-request-end': {
-                    const startEvent = collectedNetworkStartEvents[ev.uuid];
-                    if (startEvent === undefined || startEvent.type !== 'network-request-start') {
-                        if (process.env.NODE_ENV !== 'production') {
-                            throw Error('no matching network start event emmited');
-                        }
-                        return;
-                    }
-                    completedNetworkRequests.push({
-                        request: startEvent.request,
-                        response: ev.response,
-                        duration: ev.timestamp - startEvent.timestamp,
-                    });
-                    break;
-                }
-            }
-        },
-        onEnvironmentEvent: (ev) => {
-            rawEvents.push(ev);
-            if (isDurableEnvironmentEvent(ev)) {
-                if (ev.data.type === 'l2-revive-end') {
-                    let missingKeys;
-                    const snapshot = ev.data.snapshot;
-                    if (snapshot.state === 'Unfulfilled') {
-                        missingKeys = snapshot.missingLinks.keysAsArray();
-                        if (snapshot.missingLinks.size() === 0) {
-                            missingKeys.push(snapshot.recordId);
-                        }
-                    }
-                    reviveStats.push({
-                        resultState: ev.data.snapshot.state,
-                        missingKeys,
-                        l2Trips: ev.data.l2Trips,
-                        duration: ev.data.duration,
-                    });
-                }
-            }
-        },
-        onCustomAdapterEvent: (ev) => {
-            rawEvents.push(ev);
-        },
-    };
-    const bindObserverToAdapterRequestContext = (requestContext) => {
-        let requestContextWithInstrumentationObserver = requestContext;
-        if (requestContextWithInstrumentationObserver === undefined) {
-            requestContextWithInstrumentationObserver = { eventObservers: [] };
-        }
-        if (requestContextWithInstrumentationObserver.eventObservers === undefined) {
-            requestContextWithInstrumentationObserver.eventObservers = [];
-        }
-        requestContextWithInstrumentationObserver.eventObservers.push(metricsEventObserver);
-    };
-    adapterStart = Date.now();
-    try {
-        bindObserverToAdapterRequestContext(requestContext);
-        const adapterResult = adapter(adapterConfig, requestContext);
-        if (isPromise$1(adapterResult)) {
-            adapterResult
-                .then((snapshot) => {
-                snapshotState = snapshot.state;
-                if (isErrorSnapshot(snapshot)) {
-                    result = 'error';
-                    error = stringify$1(snapshot.error);
-                }
-                markEnd(onAdapterComplete);
-            })
-                .catch((e) => {
-                // async error
-                markException(e);
-                markEnd(onAdapterComplete);
-            });
-        }
-        else {
-            if (adapterResult === null) {
-                // invalid config
-                result = 'invalid-config';
-            }
-            else if (isErrorSnapshot(adapterResult)) {
-                snapshotState = 'Error';
-                result = 'error';
-                error = stringify$1(adapterResult.error);
-            }
-            markEnd(onAdapterComplete);
-        }
-        return adapterResult;
-    }
-    catch (error) {
-        // synchronous error (lookup exception)
-        markException(error);
-        markEnd(onAdapterComplete);
-        throw error;
-    }
+function runAdapterWithReport(adapterName, adapter, adapterConfig, requestContext, onAdapterComplete) {
+    let adapterStart;
+    let adapterEnd;
+    let lookupStart;
+    let lookupEnd;
+    let cacheStart;
+    let cacheEnd;
+    let networkStart;
+    let networkEnd;
+    let staleLookup = false;
+    let result;
+    let snapshotState = '';
+    let error;
+    let exceptionMessage;
+    let completedNetworkRequests = [];
+    let collectedNetworkStartEvents = {};
+    let reviveStats = [];
+    let rawEvents = [];
+    const markEnd = (adapterEndedCallback) => {
+        if (adapterStart === undefined) {
+            throw Error('adapter has not been started yet');
+        }
+        if (adapterEnd) {
+            throw Error('adapter has already ended');
+        }
+        if (result === undefined) {
+            throw Error('no result type set');
+        }
+        adapterEnd = Date.now();
+        const executionTime = adapterEnd - adapterStart;
+        const cacheLookupTime = cacheEnd - cacheStart;
+        const lookupTime = lookupEnd - lookupStart;
+        const networkLookupTime = networkEnd - networkStart;
+        const config = stringify$1(adapterConfig);
+        switch (result) {
+            case 'l1-hit':
+                if (staleLookup === true) {
+                    adapterEndedCallback({
+                        result: 'l1-hit',
+                        adapterName,
+                        rawEvents,
+                        config,
+                        stale: true,
+                        executionTime,
+                        cacheLookupTime,
+                        lookupTime,
+                        snapshotState,
+                    });
+                }
+                else {
+                    adapterEndedCallback({
+                        result: 'l1-hit',
+                        adapterName,
+                        rawEvents,
+                        config,
+                        stale: false,
+                        executionTime,
+                        cacheLookupTime,
+                        lookupTime,
+                        snapshotState,
+                    });
+                }
+                break;
+            case 'l2-hit':
+                if (staleLookup === true) {
+                    adapterEndedCallback({
+                        result: 'l2-hit',
+                        adapterName,
+                        rawEvents,
+                        config,
+                        stale: true,
+                        executionTime,
+                        cacheLookupTime,
+                        lookupTime,
+                        snapshotState,
+                        revives: reviveStats,
+                    });
+                }
+                else {
+                    adapterEndedCallback({
+                        result: 'l2-hit',
+                        adapterName,
+                        rawEvents,
+                        config,
+                        stale: false,
+                        executionTime,
+                        cacheLookupTime,
+                        lookupTime,
+                        snapshotState,
+                        revives: reviveStats,
+                    });
+                }
+                break;
+            case 'cache-miss':
+                adapterEndedCallback({
+                    result: 'cache-miss',
+                    adapterName,
+                    rawEvents,
+                    config,
+                    executionTime,
+                    cacheLookupTime,
+                    lookupTime,
+                    networkLookupTime,
+                    completedNetworkRequests,
+                    snapshotState,
+                    revives: reviveStats,
+                });
+                break;
+            case 'invalid-config':
+                adapterEndedCallback({
+                    result: 'invalid-config',
+                    rawEvents,
+                    config,
+                    adapterName,
+                    executionTime,
+                });
+                break;
+            case 'error':
+                adapterEndedCallback({
+                    result: 'error',
+                    rawEvents,
+                    config,
+                    error,
+                    adapterName,
+                    executionTime,
+                    cacheLookupTime,
+                    lookupTime,
+                    networkLookupTime,
+                    snapshotState,
+                });
+                break;
+            case 'exception':
+                adapterEndedCallback({
+                    result: 'exception',
+                    rawEvents,
+                    config,
+                    exceptionMessage,
+                    adapterName,
+                    executionTime,
+                });
+                break;
+        }
+    };
+    const markException = (error) => {
+        let message = 'Unknown Error';
+        if (error instanceof Error)
+            message = error.message;
+        exceptionMessage = message;
+        result = 'exception';
+    };
+    const metricsEventObserver = {
+        onAdapterEvent: (ev) => {
+            rawEvents.push(ev);
+            switch (ev.type) {
+                case 'adapter-lookup-start':
+                    lookupStart = Date.now();
+                    break;
+                case 'adapter-lookup-end':
+                    lookupEnd = Date.now();
+                    break;
+                case 'cache-lookup-start':
+                    cacheStart = Date.now();
+                    break;
+                case 'cache-lookup-end':
+                    cacheEnd = Date.now();
+                    if (ev.wasResultAsync === false) {
+                        // L1 cache hit
+                        result = 'l1-hit';
+                    }
+                    else {
+                        // L2 cache hit
+                        result = 'l2-hit';
+                    }
+                    if (ev.snapshotState === 'Stale') {
+                        staleLookup = true;
+                    }
+                    break;
+                case 'network-lookup-start':
+                    // if the lookup is stale, the network lookup is
+                    // caused by an async refresh
+                    if (staleLookup === false) {
+                        result = 'cache-miss';
+                        networkStart = Date.now();
+                    }
+                    break;
+                case 'network-lookup-end':
+                    if (staleLookup === false) {
+                        networkEnd = Date.now();
+                    }
+                    break;
+                case 'network-request-start':
+                    collectedNetworkStartEvents[ev.uuid] = ev;
+                    break;
+                case 'network-request-end': {
+                    const startEvent = collectedNetworkStartEvents[ev.uuid];
+                    if (startEvent === undefined || startEvent.type !== 'network-request-start') {
+                        if (process.env.NODE_ENV !== 'production') {
+                            throw Error('no matching network start event emmited');
+                        }
+                        return;
+                    }
+                    completedNetworkRequests.push({
+                        request: startEvent.request,
+                        response: ev.response,
+                        duration: ev.timestamp - startEvent.timestamp,
+                    });
+                    break;
+                }
+            }
+        },
+        onEnvironmentEvent: (ev) => {
+            rawEvents.push(ev);
+            if (isDurableEnvironmentEvent(ev)) {
+                if (ev.data.type === 'l2-revive-end') {
+                    let missingKeys;
+                    const snapshot = ev.data.snapshot;
+                    if (snapshot.state === 'Unfulfilled') {
+                        missingKeys = snapshot.missingLinks.keysAsArray();
+                        if (snapshot.missingLinks.size() === 0) {
+                            missingKeys.push(snapshot.recordId);
+                        }
+                    }
+                    reviveStats.push({
+                        resultState: ev.data.snapshot.state,
+                        missingKeys,
+                        l2Trips: ev.data.l2Trips,
+                        duration: ev.data.duration,
+                    });
+                }
+            }
+        },
+        onCustomAdapterEvent: (ev) => {
+            rawEvents.push(ev);
+        },
+    };
+    const bindObserverToAdapterRequestContext = (requestContext) => {
+        let requestContextWithInstrumentationObserver = requestContext;
+        if (requestContextWithInstrumentationObserver === undefined) {
+            requestContextWithInstrumentationObserver = { eventObservers: [] };
+        }
+        if (requestContextWithInstrumentationObserver.eventObservers === undefined) {
+            requestContextWithInstrumentationObserver.eventObservers = [];
+        }
+        requestContextWithInstrumentationObserver.eventObservers.push(metricsEventObserver);
+    };
+    adapterStart = Date.now();
+    try {
+        bindObserverToAdapterRequestContext(requestContext);
+        const adapterResult = adapter(adapterConfig, requestContext);
+        if (isPromise$1(adapterResult)) {
+            adapterResult
+                .then((snapshot) => {
+                snapshotState = snapshot.state;
+                if (isErrorSnapshot(snapshot)) {
+                    result = 'error';
+                    error = stringify$1(snapshot.error);
+                }
+                markEnd(onAdapterComplete);
+            })
+                .catch((e) => {
+                // async error
+                markException(e);
+                markEnd(onAdapterComplete);
+            });
+        }
+        else {
+            if (adapterResult === null) {
+                // invalid config
+                result = 'invalid-config';
+            }
+            else if (isErrorSnapshot(adapterResult)) {
+                snapshotState = 'Error';
+                result = 'error';
+                error = stringify$1(adapterResult.error);
+            }
+            markEnd(onAdapterComplete);
+        }
+        return adapterResult;
+    }
+    catch (error) {
+        // synchronous error (lookup exception)
+        markException(error);
+        markEnd(onAdapterComplete);
+        throw error;
+    }
 }
 
-const ADAPTER_CACHE_HIT_COUNT_METRIC_NAME = 'cache-hit-count';
-const ADAPTER_CACHE_HIT_DURATION_METRIC_NAME = 'cache-hit-duration';
-const ADAPTER_CACHE_HIT_L2_COUNT_METRIC_NAME = 'cache-hit-l2-count';
-const ADAPTER_CACHE_HIT_L2_DURATION_METRIC_NAME = 'cache-hit-l2-duration';
-const ADAPTER_CACHE_MISS_COUNT_METRIC_NAME = 'cache-miss-count';
-const ADAPTER_CACHE_MISS_DURATION_METRIC_NAME = 'cache-miss-duration';
-const ADAPTER_CACHE_MISS_OUT_OF_TTL_COUNT_METRIC_NAME = 'cache-miss-out-of-ttl-count';
-const ADAPTER_CACHE_MISS_OUT_OF_TTL_DURATION_METRIC_NAME = 'cache-miss-out-of-ttl-duration';
-const REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_CHANGED_COUNT_METRIC_NAME = 'cache-miss-out-of-ttl-data-changed-count';
-const REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_UNCHANGED_COUNT_METRIC_NAME = 'cache-miss-out-of-ttl-data-unchanged-count';
-const REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_CHANGED_DURATION_METRIC_NAME = 'cache-miss-out-of-ttl-data-changed-duration';
-const REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_UNCHANGED_DURATION_METRIC_NAME = 'cache-miss-out-of-ttl-data-unchanged-duration';
-/**
- * W-8121791
- * Number of subqueries used when aggregateUi is invoked for getRecord
- */
-const AGGREGATE_UI_CHUNK_COUNT = 'aggregate-ui-chunk-count';
-/**
- * W-6981216
- * Counter for overall LDS cache hits.
- * Note: This is also being recorded in AILTN logging.
- */
-const CACHE_HIT_COUNT = ADAPTER_CACHE_HIT_COUNT_METRIC_NAME;
-/**
- * W-6981216
- * Counter for overall LDS cache hits.
- * Note: This is also being recorded in AILTN logging.
- */
-const CACHE_MISS_COUNT = ADAPTER_CACHE_MISS_COUNT_METRIC_NAME;
-/**
- * W-9949353
- * Used to track how often we dedupe HTTP requests
- * Invoked when an HTTP request is deduped against an already in-flight request
- */
-const DUPLICATE_REQUEST_COUNT = 'duplicate-request-count';
-/**
- * W-7667066
- * This count represents the number of times getRecord() was invoked, but not including
- * executeAggregateUi calls.  It can be represented as the sum of the Aura Action invocations
- * GetRecordWithLayouts and GetRecordWithFields.
- */
-const GET_RECORD_NORMAL_INVOKE_COUNT = 'get-record-normal-invoke-count';
-/**
- * W-7667066
- * This count represents the number of times getRecord() was invoked, with a large enough payload
- * that executeAggregateUi was used.
- */
-const GET_RECORD_AGGREGATE_INVOKE_COUNT = 'get-record-aggregate-invoke-count';
-/**
- * W-7301684
- * Counter for when getRecordNotifyChange api calls are allowed through.
- */
-const GET_RECORD_NOTIFY_CHANGE_ALLOW_COUNT = 'get-record-notify-change-allow-count';
-/**
- * W-7301684
- * Counter for when getRecordNotifyChange api calls are dropped/throttled.
- */
-const GET_RECORD_NOTIFY_CHANGE_DROP_COUNT = 'get-record-notify-change-drop-count';
-/**
- * W-11118785
- * Counter for when notifyRecordUpdateAvailable api calls are allowed through.
- */
-const NOTIFY_RECORD_UPDATE_AVAILABLE_ALLOW_COUNT = 'notify-record-update-available-allow-count';
-/**
- * W-11118785
- * Counter for when notifyRecordUpdateAvailable api calls are dropped/throttled.
- */
-const NOTIFY_RECORD_UPDATE_AVAILABLE_DROP_COUNT = 'notify-record-update-available-drop-count';
-/**
- * W-8278006
- * Counter for rate limiting telemetry. Is updated whenever the network adapter hits the specified limit.
- */
-const NETWORK_RATE_LIMIT_EXCEEDED_COUNT = 'network-rate-limit-exceeded-count';
-/**
- * W-6981216
- * Timer to measure performance for Luvio.storeBroadcast() method.
- */
-const STORE_BROADCAST_DURATION = 'store-broadcast-duration';
-/**
- * W-6981216
- * Timer to measure performance for Luvio.storeIngest() method.
- */
-const STORE_INGEST_DURATION = 'store-ingest-duration';
-/**
- * W-6981216
- * Timer to measure performance for Luvio.storeLookup() method.
- */
-const STORE_LOOKUP_DURATION = 'store-lookup-duration';
-/**
- * W-9805009
- * Timer to measure performance for Luvio.storeSetTTLOverride() method.
- */
-const STORE_SET_TTL_OVERRIDE_DURATION = 'store-set-ttl-override-duration';
-/**
- * W-9805009
- * Timer to measure performance for Luvio.storeSetDefaultTTLOverride() method.
- */
-const STORE_SET_DEFAULT_TTL_OVERRIDE_DURATION = 'store-set-default-ttl-override-duration';
-/**
- * W-11118785
- * Timer to measure performance for Luvio.notifyStoreUpdateAvailable() method.
- */
-const NOTIFY_STORE_UPDATE_AVAILABLE_DURATION = 'notify-store-update-available-duration';
-/**
- * W-6981216
- * Counter for number of records in LDS store. Is updated by periodicLogger invocations.
- * Note: This is also being recorded in AILTN logging.
- */
-const STORE_SIZE_COUNT = 'store-size-count';
-/**
- * W-6981216
- * Counter for number of LDS snapshot subscription. Is updated by periodicLogger invocations.
- * Note: This is also being recorded in AILTN logging.
- */
-const STORE_SNAPSHOT_SUBSCRIPTIONS_COUNT = 'store-snapshot-subscriptions-count';
-/**
- * W-6981216
- * Counter for number of LDS watch subscriptions. Is updated by periodicLogger invocations.
- * Note: This is also being recorded in AILTN logging.
- */
-const STORE_WATCH_SUBSCRIPTIONS_COUNT = 'store-watch-subscriptions-count';
-/**
- * W-9131128
- * Counter for graphQL get adapter response with mixed bag of both data and error in response
- */
-const GET_GRAPHQL_RESPONSE_MIXED = 'get-graphql-response-mixed-count';
-/**
- * W-9537401
- * Counter for Luvio store trim task invocation
- */
-const STORE_TRIM_TASK_COUNT = 'store-trim-task-count';
-/**
- * W-9537401
- * Timer to measure performance for Luvio store trim task
- */
-const STORE_TRIM_TASK_DURATION = 'store-trim-task-duration';
-/**
- * W-9804037
- * Counters for Luvio cache policy usage
- * Note: Undefined cache policy defaults to different cache policies based on runtime
- */
-const CACHE_POLICY_COUNTERS = {
-    'cache-and-network': 'cache-policy-cache-and-network',
-    'cache-then-network': 'cache-policy-cache-then-network',
-    'no-cache': 'cache-policy-no-cache',
-    'only-if-cached': 'cache-policy-only-if-cached',
-    'stale-while-revalidate': 'cache-policy-stale-while-revalidate',
-    'valid-at': 'cache-policy-valid-at',
-};
-const CACHE_POLICY_UNDEFINED_COUNTER = 'cache-policy-undefined';
-const STALE_TAG = 'stale';
-/**
- * W-9804037
- * Durable Store health metric
- * Counter to track Durable Store read, write and error rates
- */
-const DURABLE_STORE_COUNT = 'durable-store-count';
-/**
- * W-10490363
- * GraphQL Eval health metric
- * Counter to track Success and Error Rate on Eval
- */
-const GRAPHQL_ADAPTER_COUNT = 'graphql-adapter-count';
-/**
- * Counter for tracking invalid record type IDs
- */
-const RECORD_TYPE_ID_IS_NULL_COUNT = 'record-type-id-is-null-count';
-/**
- * W-12293528
- * GraphQL health metric
- * Counter to track size of the top-level GraphQL object
- */
-const STORE_GRAPHQL_SIZE_COUNT = 'store-graphql-size-count';
-/**
- * W-12293528
- * GraphQL health metric
- * Counter to track validation errors in query
- */
-const GRAPHQL_QUERY_VALIDATION_ERROR_COUNT = 'graphql-query-validation-error-count';
-/**
- * W-12293528
- * GraphQL health metric
- * Counter to track syntax errors in query
- */
-const GRAPHQL_QUERY_SYNTAX_ERROR_COUNT = 'graphql-query-syntax-error-count';
-/**
- * W-12293528
- * GraphQL health metric
- * Counter to track miscellaneous errors in query
- */
+const ADAPTER_CACHE_HIT_COUNT_METRIC_NAME = 'cache-hit-count';
+const ADAPTER_CACHE_HIT_DURATION_METRIC_NAME = 'cache-hit-duration';
+const ADAPTER_CACHE_HIT_L2_COUNT_METRIC_NAME = 'cache-hit-l2-count';
+const ADAPTER_CACHE_HIT_L2_DURATION_METRIC_NAME = 'cache-hit-l2-duration';
+const ADAPTER_CACHE_MISS_COUNT_METRIC_NAME = 'cache-miss-count';
+const ADAPTER_CACHE_MISS_DURATION_METRIC_NAME = 'cache-miss-duration';
+const ADAPTER_CACHE_MISS_OUT_OF_TTL_COUNT_METRIC_NAME = 'cache-miss-out-of-ttl-count';
+const ADAPTER_CACHE_MISS_OUT_OF_TTL_DURATION_METRIC_NAME = 'cache-miss-out-of-ttl-duration';
+const REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_CHANGED_COUNT_METRIC_NAME = 'cache-miss-out-of-ttl-data-changed-count';
+const REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_UNCHANGED_COUNT_METRIC_NAME = 'cache-miss-out-of-ttl-data-unchanged-count';
+const REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_CHANGED_DURATION_METRIC_NAME = 'cache-miss-out-of-ttl-data-changed-duration';
+const REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_UNCHANGED_DURATION_METRIC_NAME = 'cache-miss-out-of-ttl-data-unchanged-duration';
+/**
+ * W-8121791
+ * Number of subqueries used when aggregateUi is invoked for getRecord
+ */
+const AGGREGATE_UI_CHUNK_COUNT = 'aggregate-ui-chunk-count';
+/**
+ * W-6981216
+ * Counter for overall LDS cache hits.
+ * Note: This is also being recorded in AILTN logging.
+ */
+const CACHE_HIT_COUNT = ADAPTER_CACHE_HIT_COUNT_METRIC_NAME;
+/**
+ * W-6981216
+ * Counter for overall LDS cache hits.
+ * Note: This is also being recorded in AILTN logging.
+ */
+const CACHE_MISS_COUNT = ADAPTER_CACHE_MISS_COUNT_METRIC_NAME;
+/**
+ * W-9949353
+ * Used to track how often we dedupe HTTP requests
+ * Invoked when an HTTP request is deduped against an already in-flight request
+ */
+const DUPLICATE_REQUEST_COUNT = 'duplicate-request-count';
+/**
+ * W-7667066
+ * This count represents the number of times getRecord() was invoked, but not including
+ * executeAggregateUi calls.  It can be represented as the sum of the Aura Action invocations
+ * GetRecordWithLayouts and GetRecordWithFields.
+ */
+const GET_RECORD_NORMAL_INVOKE_COUNT = 'get-record-normal-invoke-count';
+/**
+ * W-7667066
+ * This count represents the number of times getRecord() was invoked, with a large enough payload
+ * that executeAggregateUi was used.
+ */
+const GET_RECORD_AGGREGATE_INVOKE_COUNT = 'get-record-aggregate-invoke-count';
+/**
+ * W-7301684
+ * Counter for when getRecordNotifyChange api calls are allowed through.
+ */
+const GET_RECORD_NOTIFY_CHANGE_ALLOW_COUNT = 'get-record-notify-change-allow-count';
+/**
+ * W-7301684
+ * Counter for when getRecordNotifyChange api calls are dropped/throttled.
+ */
+const GET_RECORD_NOTIFY_CHANGE_DROP_COUNT = 'get-record-notify-change-drop-count';
+/**
+ * W-11118785
+ * Counter for when notifyRecordUpdateAvailable api calls are allowed through.
+ */
+const NOTIFY_RECORD_UPDATE_AVAILABLE_ALLOW_COUNT = 'notify-record-update-available-allow-count';
+/**
+ * W-11118785
+ * Counter for when notifyRecordUpdateAvailable api calls are dropped/throttled.
+ */
+const NOTIFY_RECORD_UPDATE_AVAILABLE_DROP_COUNT = 'notify-record-update-available-drop-count';
+/**
+ * W-8278006
+ * Counter for rate limiting telemetry. Is updated whenever the network adapter hits the specified limit.
+ */
+const NETWORK_RATE_LIMIT_EXCEEDED_COUNT = 'network-rate-limit-exceeded-count';
+/**
+ * W-6981216
+ * Timer to measure performance for Luvio.storeBroadcast() method.
+ */
+const STORE_BROADCAST_DURATION = 'store-broadcast-duration';
+/**
+ * W-6981216
+ * Timer to measure performance for Luvio.storeIngest() method.
+ */
+const STORE_INGEST_DURATION = 'store-ingest-duration';
+/**
+ * W-6981216
+ * Timer to measure performance for Luvio.storeLookup() method.
+ */
+const STORE_LOOKUP_DURATION = 'store-lookup-duration';
+/**
+ * W-9805009
+ * Timer to measure performance for Luvio.storeSetTTLOverride() method.
+ */
+const STORE_SET_TTL_OVERRIDE_DURATION = 'store-set-ttl-override-duration';
+/**
+ * W-9805009
+ * Timer to measure performance for Luvio.storeSetDefaultTTLOverride() method.
+ */
+const STORE_SET_DEFAULT_TTL_OVERRIDE_DURATION = 'store-set-default-ttl-override-duration';
+/**
+ * W-11118785
+ * Timer to measure performance for Luvio.notifyStoreUpdateAvailable() method.
+ */
+const NOTIFY_STORE_UPDATE_AVAILABLE_DURATION = 'notify-store-update-available-duration';
+/**
+ * W-6981216
+ * Counter for number of records in LDS store. Is updated by periodicLogger invocations.
+ * Note: This is also being recorded in AILTN logging.
+ */
+const STORE_SIZE_COUNT = 'store-size-count';
+/**
+ * W-6981216
+ * Counter for number of LDS snapshot subscription. Is updated by periodicLogger invocations.
+ * Note: This is also being recorded in AILTN logging.
+ */
+const STORE_SNAPSHOT_SUBSCRIPTIONS_COUNT = 'store-snapshot-subscriptions-count';
+/**
+ * W-6981216
+ * Counter for number of LDS watch subscriptions. Is updated by periodicLogger invocations.
+ * Note: This is also being recorded in AILTN logging.
+ */
+const STORE_WATCH_SUBSCRIPTIONS_COUNT = 'store-watch-subscriptions-count';
+/**
+ * W-9131128
+ * Counter for graphQL get adapter response with mixed bag of both data and error in response
+ */
+const GET_GRAPHQL_RESPONSE_MIXED = 'get-graphql-response-mixed-count';
+/**
+ * W-9537401
+ * Counter for Luvio store trim task invocation
+ */
+const STORE_TRIM_TASK_COUNT = 'store-trim-task-count';
+/**
+ * W-9537401
+ * Timer to measure performance for Luvio store trim task
+ */
+const STORE_TRIM_TASK_DURATION = 'store-trim-task-duration';
+/**
+ * W-9804037
+ * Counters for Luvio cache policy usage
+ * Note: Undefined cache policy defaults to different cache policies based on runtime
+ */
+const CACHE_POLICY_COUNTERS = {
+    'cache-and-network': 'cache-policy-cache-and-network',
+    'cache-then-network': 'cache-policy-cache-then-network',
+    'no-cache': 'cache-policy-no-cache',
+    'only-if-cached': 'cache-policy-only-if-cached',
+    'stale-while-revalidate': 'cache-policy-stale-while-revalidate',
+    'valid-at': 'cache-policy-valid-at',
+};
+const CACHE_POLICY_UNDEFINED_COUNTER = 'cache-policy-undefined';
+const STALE_TAG = 'stale';
+/**
+ * W-9804037
+ * Durable Store health metric
+ * Counter to track Durable Store read, write and error rates
+ */
+const DURABLE_STORE_COUNT = 'durable-store-count';
+/**
+ * W-10490363
+ * GraphQL Eval health metric
+ * Counter to track Success and Error Rate on Eval
+ */
+const GRAPHQL_ADAPTER_COUNT = 'graphql-adapter-count';
+/**
+ * Counter for tracking invalid record type IDs
+ */
+const RECORD_TYPE_ID_IS_NULL_COUNT = 'record-type-id-is-null-count';
+/**
+ * W-12293528
+ * GraphQL health metric
+ * Counter to track size of the top-level GraphQL object
+ */
+const STORE_GRAPHQL_SIZE_COUNT = 'store-graphql-size-count';
+/**
+ * W-12293528
+ * GraphQL health metric
+ * Counter to track validation errors in query
+ */
+const GRAPHQL_QUERY_VALIDATION_ERROR_COUNT = 'graphql-query-validation-error-count';
+/**
+ * W-12293528
+ * GraphQL health metric
+ * Counter to track syntax errors in query
+ */
+const GRAPHQL_QUERY_SYNTAX_ERROR_COUNT = 'graphql-query-syntax-error-count';
+/**
+ * W-12293528
+ * GraphQL health metric
+ * Counter to track miscellaneous errors in query
+ */
 const GRAPHQL_QUERY_OTHER_ERROR_COUNT = 'graphql-query-other-error-count';
 
 var metricKeys = /*#__PURE__*/Object.freeze({
@@ -642,768 +642,768 @@ var metricKeys = /*#__PURE__*/Object.freeze({
     GRAPHQL_QUERY_OTHER_ERROR_COUNT: GRAPHQL_QUERY_OTHER_ERROR_COUNT
 });
 
-/**
- * Observability / Critical Availability Program (230+)
- *
- * This file is intended to be used as a consolidated place for all definitions, functions,
- * and helpers related to "M1"[1].
- *
- * Below are the R.E.A.D.S. metrics for the Lightning Data Service, defined here[2].
- *
- * [1] https://salesforce.quip.com/NfW9AsbGEaTY
- * [2] https://salesforce.quip.com/1dFvAba1b0eq
- */
-const OBSERVABILITY_NAMESPACE = 'LIGHTNING.lds.service';
-const ADAPTER_INVOCATION_COUNT_METRIC_NAME = 'request';
-const ADAPTER_ERROR_COUNT_METRIC_NAME = 'error';
-/**
- * W-8828410
- * Counter for the number of UnfulfilledSnapshotErrors the luvio engine has.
- */
-const TOTAL_ADAPTER_ERROR_COUNT = ADAPTER_ERROR_COUNT_METRIC_NAME;
-/**
- * W-8828410
- * Counter for the number of invocations made into LDS by a wire adapter.
- */
+/**
+ * Observability / Critical Availability Program (230+)
+ *
+ * This file is intended to be used as a consolidated place for all definitions, functions,
+ * and helpers related to "M1"[1].
+ *
+ * Below are the R.E.A.D.S. metrics for the Lightning Data Service, defined here[2].
+ *
+ * [1] https://salesforce.quip.com/NfW9AsbGEaTY
+ * [2] https://salesforce.quip.com/1dFvAba1b0eq
+ */
+const OBSERVABILITY_NAMESPACE = 'LIGHTNING.lds.service';
+const ADAPTER_INVOCATION_COUNT_METRIC_NAME = 'request';
+const ADAPTER_ERROR_COUNT_METRIC_NAME = 'error';
+/**
+ * W-8828410
+ * Counter for the number of UnfulfilledSnapshotErrors the luvio engine has.
+ */
+const TOTAL_ADAPTER_ERROR_COUNT = ADAPTER_ERROR_COUNT_METRIC_NAME;
+/**
+ * W-8828410
+ * Counter for the number of invocations made into LDS by a wire adapter.
+ */
 const TOTAL_ADAPTER_REQUEST_SUCCESS_COUNT = ADAPTER_INVOCATION_COUNT_METRIC_NAME;
 
-const { create, keys } = Object;
-const { isArray } = Array;
+const { create, keys } = Object;
+const { isArray } = Array;
 const { parse, stringify } = JSON;
 
-/**
- * Inspired by https://www.npmjs.com/package/hashlru
- */
-class LRUCache {
-    constructor(limit) {
-        this.oldCache = new Map();
-        this.newCache = new Map();
-        this.size = 0;
-        this.limit = limit;
-    }
-    checkSize() {
-        if (this.size >= this.limit) {
-            this.size = 0;
-            this.oldCache = this.newCache;
-            this.newCache = new Map();
-        }
-    }
-    get(key) {
-        if (this.newCache.has(key)) {
-            return this.newCache.get(key);
-        }
-        else if (this.oldCache.has(key)) {
-            const value = this.oldCache.get(key);
-            this.oldCache.delete(key);
-            this.newCache.set(key, value);
-            this.size += 1;
-            this.checkSize();
-            return value;
-        }
-        return undefined;
-    }
-    set(key, value) {
-        if (this.newCache.has(key)) {
-            this.newCache.set(key, value);
-        }
-        else {
-            this.newCache.set(key, value);
-            this.size += 1;
-            this.checkSize();
-        }
-    }
-    delete(key) {
-        if (this.newCache.has(key)) {
-            this.newCache.delete(key);
-            this.size -= 1;
-        }
-        else if (this.oldCache.has(key)) {
-            this.oldCache.delete(key);
-        }
-    }
+/**
+ * Inspired by https://www.npmjs.com/package/hashlru
+ */
+class LRUCache {
+    constructor(limit) {
+        this.oldCache = new Map();
+        this.newCache = new Map();
+        this.size = 0;
+        this.limit = limit;
+    }
+    checkSize() {
+        if (this.size >= this.limit) {
+            this.size = 0;
+            this.oldCache = this.newCache;
+            this.newCache = new Map();
+        }
+    }
+    get(key) {
+        if (this.newCache.has(key)) {
+            return this.newCache.get(key);
+        }
+        else if (this.oldCache.has(key)) {
+            const value = this.oldCache.get(key);
+            this.oldCache.delete(key);
+            this.newCache.set(key, value);
+            this.size += 1;
+            this.checkSize();
+            return value;
+        }
+        return undefined;
+    }
+    set(key, value) {
+        if (this.newCache.has(key)) {
+            this.newCache.set(key, value);
+        }
+        else {
+            this.newCache.set(key, value);
+            this.size += 1;
+            this.checkSize();
+        }
+    }
+    delete(key) {
+        if (this.newCache.has(key)) {
+            this.newCache.delete(key);
+            this.size -= 1;
+        }
+        else if (this.oldCache.has(key)) {
+            this.oldCache.delete(key);
+        }
+    }
 }
 
-/**
- * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
- * This is needed because insertion order for JSON.stringify(object) affects output:
- * JSON.stringify({a: 1, b: 2})
- *      "{"a":1,"b":2}"
- * JSON.stringify({b: 2, a: 1})
- *      "{"b":2,"a":1}"
- * Modified from the apex implementation to sort arrays non-destructively.
- * @param data Data to be JSON-stringified.
- * @returns JSON.stringified value with consistent ordering of keys.
- */
-function stableJSONStringify(node) {
-    // This is for Date values.
-    if (node && node.toJSON && typeof node.toJSON === 'function') {
-        // eslint-disable-next-line no-param-reassign
-        node = node.toJSON();
-    }
-    if (node === undefined) {
-        return;
-    }
-    if (typeof node === 'number') {
-        return isFinite(node) ? '' + node : 'null';
-    }
-    if (typeof node !== 'object') {
-        return stringify(node);
-    }
-    let i;
-    let out;
-    if (isArray(node)) {
-        // copy any array before sorting so we don't mutate the object.
-        // eslint-disable-next-line no-param-reassign
-        node = node.slice(0).sort();
-        out = '[';
-        for (i = 0; i < node.length; i++) {
-            if (i) {
-                out += ',';
-            }
-            out += stableJSONStringify(node[i]) || 'null';
-        }
-        return out + ']';
-    }
-    if (node === null) {
-        return 'null';
-    }
-    const keys$1 = keys(node).sort();
-    out = '';
-    for (i = 0; i < keys$1.length; i++) {
-        const key = keys$1[i];
-        const value = stableJSONStringify(node[key]);
-        if (!value) {
-            continue;
-        }
-        if (out) {
-            out += ',';
-        }
-        out += stringify(key) + ':' + value;
-    }
-    return '{' + out + '}';
-}
-function isPromise(value) {
-    // check for Thenable due to test frameworks using custom Promise impls
-    return value !== null && value !== undefined && typeof value.then === 'function';
-}
-function isAdapterError(error) {
-    if (typeof error !== 'string') {
-        return false;
-    }
-    const parsedError = parse(error);
-    return parsedError.errorType !== undefined && parsedError.errorType === 'adapterError';
-}
-function throttle(callback, ms) {
-    let waiting = false;
-    return () => {
-        if (!waiting) {
-            callback();
-            waiting = true;
-            setTimeout(() => (waiting = false), ms);
-        }
-    };
+/**
+ * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
+ * This is needed because insertion order for JSON.stringify(object) affects output:
+ * JSON.stringify({a: 1, b: 2})
+ *      "{"a":1,"b":2}"
+ * JSON.stringify({b: 2, a: 1})
+ *      "{"b":2,"a":1}"
+ * Modified from the apex implementation to sort arrays non-destructively.
+ * @param data Data to be JSON-stringified.
+ * @returns JSON.stringified value with consistent ordering of keys.
+ */
+function stableJSONStringify(node) {
+    // This is for Date values.
+    if (node && node.toJSON && typeof node.toJSON === 'function') {
+        // eslint-disable-next-line no-param-reassign
+        node = node.toJSON();
+    }
+    if (node === undefined) {
+        return;
+    }
+    if (typeof node === 'number') {
+        return isFinite(node) ? '' + node : 'null';
+    }
+    if (typeof node !== 'object') {
+        return stringify(node);
+    }
+    let i;
+    let out;
+    if (isArray(node)) {
+        // copy any array before sorting so we don't mutate the object.
+        // eslint-disable-next-line no-param-reassign
+        node = node.slice(0).sort();
+        out = '[';
+        for (i = 0; i < node.length; i++) {
+            if (i) {
+                out += ',';
+            }
+            out += stableJSONStringify(node[i]) || 'null';
+        }
+        return out + ']';
+    }
+    if (node === null) {
+        return 'null';
+    }
+    const keys$1 = keys(node).sort();
+    out = '';
+    for (i = 0; i < keys$1.length; i++) {
+        const key = keys$1[i];
+        const value = stableJSONStringify(node[key]);
+        if (!value) {
+            continue;
+        }
+        if (out) {
+            out += ',';
+        }
+        out += stringify(key) + ':' + value;
+    }
+    return '{' + out + '}';
+}
+function isPromise(value) {
+    // check for Thenable due to test frameworks using custom Promise impls
+    return value !== null && value !== undefined && typeof value.then === 'function';
+}
+function isAdapterError(error) {
+    if (typeof error !== 'string') {
+        return false;
+    }
+    const parsedError = parse(error);
+    return parsedError.errorType !== undefined && parsedError.errorType === 'adapterError';
+}
+function throttle(callback, ms) {
+    let waiting = false;
+    return () => {
+        if (!waiting) {
+            callback();
+            waiting = true;
+            setTimeout(() => (waiting = false), ms);
+        }
+    };
 }
 
-const NAMESPACE = 'lds';
-const APEX_ADAPTER_NAME = 'getApex';
-const NORMALIZED_APEX_ADAPTER_NAME = createMetricsKey('Apex', APEX_ADAPTER_NAME);
-const GRAPHQL_ADAPTER_NAME = 'graphQL';
-const GRAPHQL_RECORDS_KEY = 'GraphQL::graphql__uiapi__query';
-const ldsInstrumentation = getInstrumentation(NAMESPACE);
-const observabilityInstrumentation = getInstrumentation(OBSERVABILITY_NAMESPACE);
-class Instrumentation {
-    /**
-     * Injected to LDS for Luvio specific instrumentation.
-     *
-     * @param context The transaction context.
-     */
-    instrumentLuvio(_context) {
-        // TODO [W-9783151]: refactor luvio.instrument to not require this class
-    }
-}
-/**
- * Provide this method for the instrument option for a Luvio instance.
- * @param context The transaction context.
- */
-function instrumentLuvio(context) {
-    if (isAdapterUnfulfilledError(context)) {
-        // We are consolidating all apex adapter instrumentation calls under a single key
-        const normalizedContext = {
-            ...context,
-            adapterName: normalizeAdapterName(context.adapterName),
-        };
-        incrementAdapterRequestErrorCount(normalizedContext);
-        logAdapterRequestError(normalizedContext);
-    }
-}
-/**
- * Returns whether or not this is an AdapterUnfulfilledError.
- * @param context The transaction context.
- * @returns Whether or not this is an AdapterUnfulfilledError.
- */
-function isAdapterUnfulfilledError(context) {
-    return context[ADAPTER_UNFULFILLED_ERROR] === true;
-}
-/**
- * W-8620679
- * Increment the counter for an UnfulfilledSnapshotError coming from luvio
- *
- * @param context The transaction context.
- */
-function incrementAdapterRequestErrorCount(context) {
-    const adapterRequestErrorCounter = createMetricsKey(ADAPTER_ERROR_COUNT_METRIC_NAME, context.adapterName);
-    observabilityInstrumentation.incrementCounter(adapterRequestErrorCounter);
-    observabilityInstrumentation.incrementCounter(TOTAL_ADAPTER_ERROR_COUNT);
-}
-/**
- * W-10495632
- * Logs the missing paths and/or links associated with the UnfulfilledSnapshotError.
- *
- * @param context The transaction context.
- */
-function logAdapterRequestError(context) {
-    ldsInstrumentation.error(ADAPTER_UNFULFILLED_ERROR, adapterUnfulfilledErrorSchema, {
-        adapter: context.adapterName,
-        missing_paths: keys(context.missingPaths),
-        missing_links: keys(context.missingLinks),
-    });
-}
-/**
- * Increment the counter based on the cache policy type for an adapter call
- *
- * @param requestContext Adapter request context that includes cache policy
- */
-function incrementAdapterCachePolicyType(requestContext) {
-    const cachePolicy = requestContext && requestContext.cachePolicy && requestContext.cachePolicy.type;
-    if (cachePolicy !== undefined) {
-        ldsInstrumentation.incrementCounter(CACHE_POLICY_COUNTERS[cachePolicy], 1);
-        return;
-    }
-    ldsInstrumentation.incrementCounter(CACHE_POLICY_UNDEFINED_COUNTER, 1);
-}
-/**
- * Increment the counter based on missing recordTypeId in a record ingest
- *
- * @param apiName incoming API name for bad data
- */
-function incrementRecordTypeIdIsNullCount(apiName) {
-    const adapterRequestErrorCounter = createMetricsKey(RECORD_TYPE_ID_IS_NULL_COUNT, apiName);
-    observabilityInstrumentation.incrementCounter(adapterRequestErrorCounter);
-}
-/**
- * Logs when adapter requests come in. If we have subsequent cache misses on a given config, beyond its TTL then log the duration to metrics.
- * Backed by an LRU Cache implementation to prevent too many record entries from being stored in-memory.
- * @param name The wire adapter name.
- * @param config The config passed into wire adapter.
- * @param currentCacheMissTimestamp Timestamp for when the request was made.
- * @param ttl TTL for the wire adapter.
- * @param durationMetricName Name for duration metric.
- * @param counterMetricName Name for counter metric.
- */
-const adapterCacheMisses = new LRUCache(250);
-function logAdapterCacheMissOutOfTtlDuration(name, config, currentCacheMissTimestamp, ttl, counterMetricName, durationMetricName) {
-    const configKey = `${name}:${stableJSONStringify(config)}`;
-    const existingCacheMissTimestamp = adapterCacheMisses.get(configKey);
-    adapterCacheMisses.set(configKey, currentCacheMissTimestamp);
-    if (existingCacheMissTimestamp !== undefined) {
-        const duration = currentCacheMissTimestamp - existingCacheMissTimestamp;
-        if (duration > ttl) {
-            ldsInstrumentation.incrementCounter(counterMetricName, 1);
-            ldsInstrumentation.trackValue(durationMetricName, duration);
-        }
-    }
-}
-function instrumentAdapter(adapter, metadata, adapterInstrumentationOptions) {
-    const { apiFamily, name, ttl } = metadata;
-    let trackL1Hits = false;
-    let trackL2Hits = false;
-    let reportObserver = undefined;
-    if (adapterInstrumentationOptions !== undefined) {
-        ({ trackL1Hits, trackL2Hits, reportObserver } = adapterInstrumentationOptions);
-    }
-    const adapterName = normalizeAdapterName(name, apiFamily);
-    /**
-     * W-8076905
-     * Dynamically generated metric. Simple counter for all requests made by this adapter.
-     */
-    const wireAdapterRequestMetric = createMetricsKey(ADAPTER_INVOCATION_COUNT_METRIC_NAME, adapterName);
-    /**
-     * W-6981216
-     * Dynamically generated metric. Simple counter for cache hits by adapter name.
-     */
-    const cacheHitCountByAdapterMetric = createMetricsKey(ADAPTER_CACHE_HIT_COUNT_METRIC_NAME, adapterName);
-    /**
-     * W-10490326
-     * Dynamically generated metric. Simple counter for L2 cache hits by adapter name.
-     */
-    const l2CacheHitCountByAdapterMetric = createMetricsKey(ADAPTER_CACHE_HIT_L2_COUNT_METRIC_NAME, adapterName);
-    /**
-     * W-7404607
-     * Dynamically generated metric. Timer for cache hits by adapter name.
-     */
-    const cacheHitDurationByAdapterMetric = createMetricsKey(ADAPTER_CACHE_HIT_DURATION_METRIC_NAME, adapterName);
-    /**
-     * W-10490326
-     * Dynamically generated metric. Timer for L2 cache hits by adapter name.
-     */
-    const l2CacheHitDurationByAdapterMetric = createMetricsKey(ADAPTER_CACHE_HIT_L2_DURATION_METRIC_NAME, adapterName);
-    /**
-     * W-6981216
-     * Dynamically generated metric. Simple counter for cache misses by adapter name.
-     */
-    const cacheMissCountByAdapterMetric = createMetricsKey(ADAPTER_CACHE_MISS_COUNT_METRIC_NAME, adapterName);
-    /**
-     * W-7404607
-     * Dynamically generated metric. Timer for cache hits by adapter name.
-     */
-    const cacheMissDurationByAdapterMetric = createMetricsKey(ADAPTER_CACHE_MISS_DURATION_METRIC_NAME, adapterName);
-    /**
-     * W-7376275
-     * Dynamically generated metric. Measures the amount of time it takes for LDS to get another cache miss on
-     * a request we've made in the past.
-     * Request Record 1 -> Record 2 -> Back to Record 1 outside of TTL is an example of when this metric will fire.
-     */
-    const cacheMissOutOfTtlDurationByAdapterMetric = createMetricsKey(ADAPTER_CACHE_MISS_OUT_OF_TTL_DURATION_METRIC_NAME, adapterName);
-    const cacheMissOutOfTtlCountByAdapterMetric = createMetricsKey(ADAPTER_CACHE_MISS_OUT_OF_TTL_COUNT_METRIC_NAME, adapterName);
-    const instrumentedAdapter = (config, requestContext) => {
-        // increment adapter request metrics
-        observabilityInstrumentation.incrementCounter(wireAdapterRequestMetric, 1);
-        observabilityInstrumentation.incrementCounter(TOTAL_ADAPTER_REQUEST_SUCCESS_COUNT, 1);
-        // increment cache policy metrics
-        incrementAdapterCachePolicyType(requestContext);
-        // start collecting
-        const activity = ldsInstrumentation.startActivity(adapterName);
-        return runAdapterWithReport(metadata.name, adapter, config, requestContext || {}, (report) => {
-            const { executionTime } = report;
-            switch (report.result) {
-                case 'l1-hit': {
-                    ldsInstrumentation.incrementCounter(ADAPTER_CACHE_HIT_COUNT_METRIC_NAME, 1);
-                    ldsInstrumentation.incrementCounter(cacheHitCountByAdapterMetric, 1);
-                    ldsInstrumentation.trackValue(cacheHitDurationByAdapterMetric, executionTime);
-                    if (trackL1Hits) {
-                        activity.stop('l1-hit');
-                    }
-                    else {
-                        activity.discard();
-                    }
-                    break;
-                }
-                case 'l2-hit': {
-                    let tags = undefined;
-                    if (report.stale === true) {
-                        tags = { [STALE_TAG]: true };
-                    }
-                    ldsInstrumentation.incrementCounter(ADAPTER_CACHE_HIT_L2_COUNT_METRIC_NAME, 1, undefined, tags);
-                    ldsInstrumentation.incrementCounter(l2CacheHitCountByAdapterMetric, 1, undefined, tags);
-                    ldsInstrumentation.trackValue(l2CacheHitDurationByAdapterMetric, executionTime, undefined, tags);
-                    if (trackL2Hits) {
-                        activity.stop('l2-hit');
-                    }
-                    else {
-                        activity.discard();
-                    }
-                    break;
-                }
-                case 'cache-miss':
-                    {
-                        ldsInstrumentation.trackValue(cacheMissDurationByAdapterMetric, executionTime);
-                        // TODO [W-10484306]: Remove typecasting after this type bug is solved
-                        activity.stop('cache-miss');
-                        ldsInstrumentation.incrementCounter(ADAPTER_CACHE_MISS_COUNT_METRIC_NAME, 1);
-                        ldsInstrumentation.incrementCounter(cacheMissCountByAdapterMetric, 1);
-                        if (ttl !== undefined) {
-                            logAdapterCacheMissOutOfTtlDuration(adapterName, config, Date.now(), ttl, cacheMissOutOfTtlCountByAdapterMetric, cacheMissOutOfTtlDurationByAdapterMetric);
-                        }
-                    }
-                    break;
-                case 'error':
-                    {
-                        const error = report.error;
-                        // We are capturing userland transient errors through here, and
-                        // there is a chance that these errors could contain PII, as seen in W-12224448.
-                        // Log AdapterErrors only
-                        if (isAdapterError(error)) {
-                            activity.error(error);
-                        }
-                        // TODO [W-10484306]: Remove typecasting after this type bug is solved
-                        activity.stop('error');
-                    }
-                    break;
-                case 'exception':
-                case 'invalid-config':
-                    {
-                        activity.discard();
-                    }
-                    break;
-                default: {
-                    if ('production' !== process.env.NODE_ENV) {
-                        throw new Error(`unsupported adapter result`);
-                    }
-                }
-            }
-            if (reportObserver !== undefined) {
-                reportObserver(report);
-            }
-        });
-    };
-    // Set the name property on the function for debugging purposes.
-    Object.defineProperty(instrumentedAdapter, 'name', {
-        value: name + '__instrumented',
-    });
-    return isGraphqlAdapter(name) === true
-        ? instrumentGraphqlAdapter(instrumentedAdapter)
-        : instrumentedAdapter;
-}
-/**
- * Any graphql get adapter specific instrumentation that we need to log
- * @param snapshot from either in-memory or built after a network hit
- */
-function logGraphqlMetrics(snapshot) {
-    // We have both data and error in the returned response
-    const { data: snapshotData } = snapshot;
-    if (snapshotData &&
-        snapshotData.data &&
-        keys(snapshotData.data).length > 0 &&
-        snapshotData.errors &&
-        snapshotData.errors.length > 0) {
-        ldsInstrumentation.incrementCounter(GET_GRAPHQL_RESPONSE_MIXED);
-    }
-    if (snapshotData.errors && snapshotData.errors.length > 0) {
-        // W-12293528 GraphQL metrics
-        // log counts of returned errors
-        let validationErrorCount = 0;
-        let syntaxErrorCount = 0;
-        let otherErrorCount = 0;
-        // conslidate instrumentation calls with # of occurrences
-        snapshotData.errors.forEach((e) => {
-            if (e.message && e.message.startsWith('Validation error')) {
-                validationErrorCount++;
-            }
-            else if (e.message && e.message.startsWith('Invalid Syntax')) {
-                syntaxErrorCount++;
-            }
-            else {
-                otherErrorCount++;
-            }
-        });
-        if (validationErrorCount > 0) {
-            ldsInstrumentation.incrementCounter(GRAPHQL_QUERY_VALIDATION_ERROR_COUNT, validationErrorCount);
-        }
-        if (syntaxErrorCount > 0) {
-            ldsInstrumentation.incrementCounter(GRAPHQL_QUERY_SYNTAX_ERROR_COUNT, syntaxErrorCount);
-        }
-        if (otherErrorCount > 0) {
-            ldsInstrumentation.incrementCounter(GRAPHQL_QUERY_OTHER_ERROR_COUNT, otherErrorCount);
-        }
-    }
-}
-/**
- * Wraps methods to collect runtime performance using o11y's trackValue API
- * @param obj Object instance containing the methods to instrument
- * @param methods array containing objects with keys for the method name and the metric key to use in o11y
- */
-function instrumentMethods(obj, methods) {
-    for (let i = 0, len = methods.length; i < len; i++) {
-        const { methodName, metricKey } = methods[i];
-        const originalMethod = obj[methodName];
-        obj[methodName] = function (...args) {
-            const startTime = Date.now();
-            try {
-                const res = originalMethod.call(this, ...args);
-                const executionTime = Date.now() - startTime;
-                // handle async resolved/rejected
-                if (isPromise(res)) {
-                    res.then(() => {
-                        ldsInstrumentation.trackValue(metricKey, Date.now() - startTime);
-                    }).catch((_error) => {
-                        ldsInstrumentation.trackValue(metricKey, Date.now() - startTime, true);
-                    });
-                }
-                else {
-                    // handle synchronous success
-                    ldsInstrumentation.trackValue(metricKey, executionTime);
-                }
-                return res;
-            }
-            catch (error) {
-                // handle synchronous throw
-                ldsInstrumentation.trackValue(metricKey, Date.now() - startTime, true);
-                // rethrow error
-                throw error;
-            }
-        };
-    }
-}
-function createMetricsKey(name, unit) {
-    let metricName = name;
-    if (unit) {
-        metricName = metricName + '.' + unit;
-    }
-    return metricName;
-}
-/**
- * Returns whether adapter is an Apex one or not.
- * @param adapterName The name of the adapter.
- */
-function isApexAdapter(adapterName) {
-    return adapterName.indexOf(APEX_ADAPTER_NAME) > -1;
-}
-/**
- * Returns boolean whether adapter is a graphQL one or not.
- * @param adapterName The name of the adapter.
- */
-function isGraphqlAdapter(adapterName) {
-    return adapterName === GRAPHQL_ADAPTER_NAME;
-}
-/**
- * Normalizes getApex adapter names to `Apex.getApex`. Non-Apex adapters will be prefixed with
- * API family, if supplied. Example: `UiApi.getRecord`.
- *
- * Note: If you are adding additional logging that can come from getApex adapter contexts that provide
- * the full getApex adapter name (i.e. getApex_[namespace]_[class]_[function]_[continuation]),
- * ensure to call this method to normalize all logging to 'getApex'. This
- * is because Argus has a 50k key cardinality limit. More context: W-8379680.
- *
- * @param adapterName The name of the adapter.
- * @param apiFamily The API family of the adapter.
- */
-function normalizeAdapterName(adapterName, apiFamily) {
-    if (isApexAdapter(adapterName)) {
-        return NORMALIZED_APEX_ADAPTER_NAME;
-    }
-    return apiFamily ? `${apiFamily}.${adapterName}` : adapterName;
-}
-/**
- * Calls instrumentation/service telemetry counter
- * @param name Name of the metric
- * @param value number to increment by, if undefined increment by 1
- */
-function incrementCounterMetric(name, number) {
-    ldsInstrumentation.incrementCounter(name, number);
-}
-/**
- * Calls instrumentation/service telemetry percentileHistogram
- * @param name Name of the metric
- * @param value number used to update the percentileHistogram
- */
-function updatePercentileHistogramMetric(name, value) {
-    ldsInstrumentation.trackValue(name, value);
-}
-function setAggregateUiChunkCountMetric(chunkCount) {
-    updatePercentileHistogramMetric(AGGREGATE_UI_CHUNK_COUNT, chunkCount);
-}
-function incrementGetRecordNormalInvokeCount() {
-    incrementCounterMetric(GET_RECORD_NORMAL_INVOKE_COUNT);
-}
-function incrementGetRecordAggregateInvokeCount() {
-    incrementCounterMetric(GET_RECORD_AGGREGATE_INVOKE_COUNT);
-}
-function incrementGetRecordNotifyChangeAllowCount() {
-    incrementCounterMetric(GET_RECORD_NOTIFY_CHANGE_ALLOW_COUNT);
-}
-function incrementGetRecordNotifyChangeDropCount() {
-    incrementCounterMetric(GET_RECORD_NOTIFY_CHANGE_DROP_COUNT);
-}
-function incrementNotifyRecordUpdateAvailableAllowCount() {
-    incrementCounterMetric(NOTIFY_RECORD_UPDATE_AVAILABLE_ALLOW_COUNT);
-}
-function incrementNotifyRecordUpdateAvailableDropCount() {
-    incrementCounterMetric(NOTIFY_RECORD_UPDATE_AVAILABLE_DROP_COUNT);
-}
-function incrementNetworkRateLimitExceededCount() {
-    incrementCounterMetric(NETWORK_RATE_LIMIT_EXCEEDED_COUNT);
-}
-function instrumentStoreTrimTask(callback) {
-    return () => {
-        ldsInstrumentation.incrementCounter(STORE_TRIM_TASK_COUNT);
-        const startTime = Date.now();
-        const res = callback();
-        ldsInstrumentation.trackValue(STORE_TRIM_TASK_DURATION, Date.now() - startTime);
-        // TODO [W-10060579]: replace record count per trim task with metric
-        return res;
-    };
-}
-function setStoreScheduler(store) {
-    const originalScheduler = store.scheduler;
-    store.scheduler = (callback, done) => {
-        originalScheduler(instrumentStoreTrimTask(callback), done);
-    };
-}
-function instrumentStoreStatsCallback(store) {
-    return () => {
-        const { snapshotSubscriptions, watchSubscriptions } = store;
-        const records = store.fallbackStringKeyInMemoryStore.records;
-        updatePercentileHistogramMetric(STORE_SIZE_COUNT, keys(records).length);
-        if (GRAPHQL_RECORDS_KEY in records) {
-            const graphQLRecordSize = keys(records[GRAPHQL_RECORDS_KEY]).length;
-            updatePercentileHistogramMetric(STORE_GRAPHQL_SIZE_COUNT, graphQLRecordSize);
-        }
-        updatePercentileHistogramMetric(STORE_SNAPSHOT_SUBSCRIPTIONS_COUNT, keys(snapshotSubscriptions).length);
-        updatePercentileHistogramMetric(STORE_WATCH_SUBSCRIPTIONS_COUNT, keys(watchSubscriptions).length);
-    };
-}
-/**
- * Collects additional store statistics by tying its periodic,
- * point-in-time data collection with a luvio method
- * @param luvio
- * @param store
- */
-function setupStoreStatsCollection(luvio, callback) {
-    const wrapMethod = 'storeBroadcast';
-    const originalMethod = luvio[wrapMethod];
-    const throttledCallback = throttle(callback, 200);
-    luvio[wrapMethod] = function (...args) {
-        throttledCallback();
-        return originalMethod.call(this, ...args);
-    };
-}
-/**
- * @param instrumentedAdapter
- * @returns instrumentedGraphqlAdapter, which logs additional metrics for get graphQL adapter
- */
-function instrumentGraphqlAdapter(instrumentedAdapter) {
-    const instrumentedGraphqlAdapter = (config, requestContext) => {
-        const result = instrumentedAdapter(config, requestContext);
-        if (result === null) {
-            return result;
-        }
-        if (isPromise(result)) {
-            result.then((_snapshot) => {
-                logGraphqlMetrics(_snapshot);
-            });
-        }
-        else {
-            logGraphqlMetrics(result);
-        }
-        return result;
-    };
-    return instrumentedGraphqlAdapter;
-}
-/**
- * Sets up instrumentation for @salesforce/lds-adapters-uiapi
- */
-function setLdsAdaptersUiapiInstrumentation(uiapiRegistration) {
-    uiapiRegistration.instrument({
-        recordConflictsResolved: (serverRequestCount) => {
-            // Ignore 0 values which can originate from ADS bridge
-            if (serverRequestCount > 0) {
-                updatePercentileHistogramMetric('record-conflicts-resolved', serverRequestCount);
-            }
-        },
-        nullDisplayValueConflict: ({ fieldType, areValuesEqual }) => {
-            const metricName = `merge-null-dv-count.${fieldType}`;
-            if (fieldType === 'scalar') {
-                incrementCounterMetric(`${metricName}.${areValuesEqual}`);
-            }
-            else {
-                incrementCounterMetric(metricName);
-            }
-        },
-        getRecordNotifyChangeAllowed: incrementGetRecordNotifyChangeAllowCount,
-        getRecordNotifyChangeDropped: incrementGetRecordNotifyChangeDropCount,
-        notifyRecordUpdateAvailableAllowed: incrementNotifyRecordUpdateAvailableAllowCount,
-        notifyRecordUpdateAvailableDropped: incrementNotifyRecordUpdateAvailableDropCount,
-        recordTypeIdIsNull: incrementRecordTypeIdIsNullCount,
-    });
-}
-/**
- * Sets up instrumentation for @salesforce/lds-network-adapter
- */
-function setLdsNetworkAdapterInstrumentation(networkAdapterRegistration) {
-    networkAdapterRegistration.instrument({
-        aggregateUiChunkCount: (cb) => setAggregateUiChunkCountMetric(cb()),
-        duplicateRequest: () => incrementCounterMetric(DUPLICATE_REQUEST_COUNT),
-        getRecordAggregateInvoke: incrementGetRecordAggregateInvokeCount,
-        getRecordNormalInvoke: incrementGetRecordNormalInvokeCount,
-        networkRateLimitExceeded: incrementNetworkRateLimitExceededCount,
-    });
-}
-/**
- * Provides concrete implementations using o11y/client for instrumentation hooks
- */
-function setInstrumentationHooks() {
-    instrument({
-        instrumentAdapter: instrumentAdapter,
-    });
-}
-/**
- * Initialize the instrumentation and instrument the LDS instance and the InMemoryStore.
- *
- * @param luvio The Luvio instance to instrument.
- * @param store The InMemoryStore to instrument.
- */
-function setupInstrumentation(luvio, store) {
-    setInstrumentationHooks();
-    instrumentStoreMethods(luvio);
-    setupStoreStatsCollection(luvio, instrumentStoreStatsCallback(store));
-    setStoreScheduler(store);
-    setStoreEventObservers(store);
-    // TODO [W-10061321]: use periodic logger to log aggregated store stats
-}
-function instrumentStoreMethods(luvio, _store) {
-    instrumentMethods(luvio, [
-        { methodName: 'storeBroadcast', metricKey: STORE_BROADCAST_DURATION },
-        { methodName: 'storeIngest', metricKey: STORE_INGEST_DURATION },
-        { methodName: 'storeLookup', metricKey: STORE_LOOKUP_DURATION },
-        { methodName: 'storeSetTTLOverride', metricKey: STORE_SET_TTL_OVERRIDE_DURATION },
-        {
-            methodName: 'storeSetDefaultTTLOverride',
-            metricKey: STORE_SET_DEFAULT_TTL_OVERRIDE_DURATION,
-        },
-        {
-            methodName: 'notifyStoreUpdateAvailable',
-            metricKey: NOTIFY_STORE_UPDATE_AVAILABLE_DURATION,
-        },
-    ]);
-}
-function handleIngestedNewData(event) {
-    if (event.type === 'cache-miss-out-of-ttl') {
-        const { recordMetadata, oldSnapshot, newSnapshot } = event;
-        const lastExpiredDurationEntry = cacheMissOutOfTtlDurations.get(event.recordId);
-        if (lastExpiredDurationEntry !== undefined) {
-            const representationName = `${recordMetadata.namespace}__${recordMetadata.representationName}`;
-            let durationMetricName;
-            let countMetricName;
-            if (oldSnapshot !== newSnapshot) {
-                durationMetricName =
-                    REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_CHANGED_DURATION_METRIC_NAME;
-                countMetricName =
-                    REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_CHANGED_COUNT_METRIC_NAME;
-            }
-            else {
-                durationMetricName =
-                    REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_UNCHANGED_DURATION_METRIC_NAME;
-                countMetricName =
-                    REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_UNCHANGED_COUNT_METRIC_NAME;
-            }
-            const metricTags = {
-                state: lastExpiredDurationEntry.storeResolveResultState,
-                representationName: representationName,
-            };
-            ldsInstrumentation.trackValue(durationMetricName, lastExpiredDurationEntry.value, undefined, metricTags);
-            ldsInstrumentation.incrementCounter(countMetricName, 1, undefined, metricTags);
-            cacheMissOutOfTtlDurations.delete(event.recordId);
-        }
-    }
-}
-const cacheMissOutOfTtlDurations = new LRUCache(250);
-function handleOnDataOutOfTtlDurationUpdate(event) {
-    cacheMissOutOfTtlDurations.set(event.recordId, {
-        value: event.lastExpiredDuration,
-        storeResolveResultState: event.storeResolveResultState,
-    });
-}
-function setStoreEventObservers(store) {
-    const cacheMissOutOfTtlEventObserver = {
-        onCacheMissOutOfTtl: handleIngestedNewData,
-    };
-    const cacheMissOutOfTtlDurationUpdateEventObserver = {
-        onDataOutOfTtlDurationUpdate: handleOnDataOutOfTtlDurationUpdate,
-    };
-    store.addStoreEventObserver(cacheMissOutOfTtlEventObserver);
-    store.addStoreEventObserver(cacheMissOutOfTtlDurationUpdateEventObserver);
-}
+const NAMESPACE = 'lds';
+const APEX_ADAPTER_NAME = 'getApex';
+const NORMALIZED_APEX_ADAPTER_NAME = createMetricsKey('Apex', APEX_ADAPTER_NAME);
+const GRAPHQL_ADAPTER_NAME = 'graphQL';
+const GRAPHQL_RECORDS_KEY = 'GraphQL::graphql__uiapi__query';
+const ldsInstrumentation = getInstrumentation(NAMESPACE);
+const observabilityInstrumentation = getInstrumentation(OBSERVABILITY_NAMESPACE);
+class Instrumentation {
+    /**
+     * Injected to LDS for Luvio specific instrumentation.
+     *
+     * @param context The transaction context.
+     */
+    instrumentLuvio(_context) {
+        // TODO [W-9783151]: refactor luvio.instrument to not require this class
+    }
+}
+/**
+ * Provide this method for the instrument option for a Luvio instance.
+ * @param context The transaction context.
+ */
+function instrumentLuvio(context) {
+    if (isAdapterUnfulfilledError(context)) {
+        // We are consolidating all apex adapter instrumentation calls under a single key
+        const normalizedContext = {
+            ...context,
+            adapterName: normalizeAdapterName(context.adapterName),
+        };
+        incrementAdapterRequestErrorCount(normalizedContext);
+        logAdapterRequestError(normalizedContext);
+    }
+}
+/**
+ * Returns whether or not this is an AdapterUnfulfilledError.
+ * @param context The transaction context.
+ * @returns Whether or not this is an AdapterUnfulfilledError.
+ */
+function isAdapterUnfulfilledError(context) {
+    return context[ADAPTER_UNFULFILLED_ERROR] === true;
+}
+/**
+ * W-8620679
+ * Increment the counter for an UnfulfilledSnapshotError coming from luvio
+ *
+ * @param context The transaction context.
+ */
+function incrementAdapterRequestErrorCount(context) {
+    const adapterRequestErrorCounter = createMetricsKey(ADAPTER_ERROR_COUNT_METRIC_NAME, context.adapterName);
+    observabilityInstrumentation.incrementCounter(adapterRequestErrorCounter);
+    observabilityInstrumentation.incrementCounter(TOTAL_ADAPTER_ERROR_COUNT);
+}
+/**
+ * W-10495632
+ * Logs the missing paths and/or links associated with the UnfulfilledSnapshotError.
+ *
+ * @param context The transaction context.
+ */
+function logAdapterRequestError(context) {
+    ldsInstrumentation.error(ADAPTER_UNFULFILLED_ERROR, adapterUnfulfilledErrorSchema, {
+        adapter: context.adapterName,
+        missing_paths: keys(context.missingPaths),
+        missing_links: keys(context.missingLinks),
+    });
+}
+/**
+ * Increment the counter based on the cache policy type for an adapter call
+ *
+ * @param requestContext Adapter request context that includes cache policy
+ */
+function incrementAdapterCachePolicyType(requestContext) {
+    const cachePolicy = requestContext && requestContext.cachePolicy && requestContext.cachePolicy.type;
+    if (cachePolicy !== undefined) {
+        ldsInstrumentation.incrementCounter(CACHE_POLICY_COUNTERS[cachePolicy], 1);
+        return;
+    }
+    ldsInstrumentation.incrementCounter(CACHE_POLICY_UNDEFINED_COUNTER, 1);
+}
+/**
+ * Increment the counter based on missing recordTypeId in a record ingest
+ *
+ * @param apiName incoming API name for bad data
+ */
+function incrementRecordTypeIdIsNullCount(apiName) {
+    const adapterRequestErrorCounter = createMetricsKey(RECORD_TYPE_ID_IS_NULL_COUNT, apiName);
+    observabilityInstrumentation.incrementCounter(adapterRequestErrorCounter);
+}
+/**
+ * Logs when adapter requests come in. If we have subsequent cache misses on a given config, beyond its TTL then log the duration to metrics.
+ * Backed by an LRU Cache implementation to prevent too many record entries from being stored in-memory.
+ * @param name The wire adapter name.
+ * @param config The config passed into wire adapter.
+ * @param currentCacheMissTimestamp Timestamp for when the request was made.
+ * @param ttl TTL for the wire adapter.
+ * @param durationMetricName Name for duration metric.
+ * @param counterMetricName Name for counter metric.
+ */
+const adapterCacheMisses = new LRUCache(250);
+function logAdapterCacheMissOutOfTtlDuration(name, config, currentCacheMissTimestamp, ttl, counterMetricName, durationMetricName) {
+    const configKey = `${name}:${stableJSONStringify(config)}`;
+    const existingCacheMissTimestamp = adapterCacheMisses.get(configKey);
+    adapterCacheMisses.set(configKey, currentCacheMissTimestamp);
+    if (existingCacheMissTimestamp !== undefined) {
+        const duration = currentCacheMissTimestamp - existingCacheMissTimestamp;
+        if (duration > ttl) {
+            ldsInstrumentation.incrementCounter(counterMetricName, 1);
+            ldsInstrumentation.trackValue(durationMetricName, duration);
+        }
+    }
+}
+function instrumentAdapter(adapter, metadata, adapterInstrumentationOptions) {
+    const { apiFamily, name, ttl } = metadata;
+    let trackL1Hits = false;
+    let trackL2Hits = false;
+    let reportObserver = undefined;
+    if (adapterInstrumentationOptions !== undefined) {
+        ({ trackL1Hits, trackL2Hits, reportObserver } = adapterInstrumentationOptions);
+    }
+    const adapterName = normalizeAdapterName(name, apiFamily);
+    /**
+     * W-8076905
+     * Dynamically generated metric. Simple counter for all requests made by this adapter.
+     */
+    const wireAdapterRequestMetric = createMetricsKey(ADAPTER_INVOCATION_COUNT_METRIC_NAME, adapterName);
+    /**
+     * W-6981216
+     * Dynamically generated metric. Simple counter for cache hits by adapter name.
+     */
+    const cacheHitCountByAdapterMetric = createMetricsKey(ADAPTER_CACHE_HIT_COUNT_METRIC_NAME, adapterName);
+    /**
+     * W-10490326
+     * Dynamically generated metric. Simple counter for L2 cache hits by adapter name.
+     */
+    const l2CacheHitCountByAdapterMetric = createMetricsKey(ADAPTER_CACHE_HIT_L2_COUNT_METRIC_NAME, adapterName);
+    /**
+     * W-7404607
+     * Dynamically generated metric. Timer for cache hits by adapter name.
+     */
+    const cacheHitDurationByAdapterMetric = createMetricsKey(ADAPTER_CACHE_HIT_DURATION_METRIC_NAME, adapterName);
+    /**
+     * W-10490326
+     * Dynamically generated metric. Timer for L2 cache hits by adapter name.
+     */
+    const l2CacheHitDurationByAdapterMetric = createMetricsKey(ADAPTER_CACHE_HIT_L2_DURATION_METRIC_NAME, adapterName);
+    /**
+     * W-6981216
+     * Dynamically generated metric. Simple counter for cache misses by adapter name.
+     */
+    const cacheMissCountByAdapterMetric = createMetricsKey(ADAPTER_CACHE_MISS_COUNT_METRIC_NAME, adapterName);
+    /**
+     * W-7404607
+     * Dynamically generated metric. Timer for cache hits by adapter name.
+     */
+    const cacheMissDurationByAdapterMetric = createMetricsKey(ADAPTER_CACHE_MISS_DURATION_METRIC_NAME, adapterName);
+    /**
+     * W-7376275
+     * Dynamically generated metric. Measures the amount of time it takes for LDS to get another cache miss on
+     * a request we've made in the past.
+     * Request Record 1 -> Record 2 -> Back to Record 1 outside of TTL is an example of when this metric will fire.
+     */
+    const cacheMissOutOfTtlDurationByAdapterMetric = createMetricsKey(ADAPTER_CACHE_MISS_OUT_OF_TTL_DURATION_METRIC_NAME, adapterName);
+    const cacheMissOutOfTtlCountByAdapterMetric = createMetricsKey(ADAPTER_CACHE_MISS_OUT_OF_TTL_COUNT_METRIC_NAME, adapterName);
+    const instrumentedAdapter = (config, requestContext) => {
+        // increment adapter request metrics
+        observabilityInstrumentation.incrementCounter(wireAdapterRequestMetric, 1);
+        observabilityInstrumentation.incrementCounter(TOTAL_ADAPTER_REQUEST_SUCCESS_COUNT, 1);
+        // increment cache policy metrics
+        incrementAdapterCachePolicyType(requestContext);
+        // start collecting
+        const activity = ldsInstrumentation.startActivity(adapterName);
+        return runAdapterWithReport(metadata.name, adapter, config, requestContext || {}, (report) => {
+            const { executionTime } = report;
+            switch (report.result) {
+                case 'l1-hit': {
+                    ldsInstrumentation.incrementCounter(ADAPTER_CACHE_HIT_COUNT_METRIC_NAME, 1);
+                    ldsInstrumentation.incrementCounter(cacheHitCountByAdapterMetric, 1);
+                    ldsInstrumentation.trackValue(cacheHitDurationByAdapterMetric, executionTime);
+                    if (trackL1Hits) {
+                        activity.stop('l1-hit');
+                    }
+                    else {
+                        activity.discard();
+                    }
+                    break;
+                }
+                case 'l2-hit': {
+                    let tags = undefined;
+                    if (report.stale === true) {
+                        tags = { [STALE_TAG]: true };
+                    }
+                    ldsInstrumentation.incrementCounter(ADAPTER_CACHE_HIT_L2_COUNT_METRIC_NAME, 1, undefined, tags);
+                    ldsInstrumentation.incrementCounter(l2CacheHitCountByAdapterMetric, 1, undefined, tags);
+                    ldsInstrumentation.trackValue(l2CacheHitDurationByAdapterMetric, executionTime, undefined, tags);
+                    if (trackL2Hits) {
+                        activity.stop('l2-hit');
+                    }
+                    else {
+                        activity.discard();
+                    }
+                    break;
+                }
+                case 'cache-miss':
+                    {
+                        ldsInstrumentation.trackValue(cacheMissDurationByAdapterMetric, executionTime);
+                        // TODO [W-10484306]: Remove typecasting after this type bug is solved
+                        activity.stop('cache-miss');
+                        ldsInstrumentation.incrementCounter(ADAPTER_CACHE_MISS_COUNT_METRIC_NAME, 1);
+                        ldsInstrumentation.incrementCounter(cacheMissCountByAdapterMetric, 1);
+                        if (ttl !== undefined) {
+                            logAdapterCacheMissOutOfTtlDuration(adapterName, config, Date.now(), ttl, cacheMissOutOfTtlCountByAdapterMetric, cacheMissOutOfTtlDurationByAdapterMetric);
+                        }
+                    }
+                    break;
+                case 'error':
+                    {
+                        const error = report.error;
+                        // We are capturing userland transient errors through here, and
+                        // there is a chance that these errors could contain PII, as seen in W-12224448.
+                        // Log AdapterErrors only
+                        if (isAdapterError(error)) {
+                            activity.error(error);
+                        }
+                        // TODO [W-10484306]: Remove typecasting after this type bug is solved
+                        activity.stop('error');
+                    }
+                    break;
+                case 'exception':
+                case 'invalid-config':
+                    {
+                        activity.discard();
+                    }
+                    break;
+                default: {
+                    if ('production' !== process.env.NODE_ENV) {
+                        throw new Error(`unsupported adapter result`);
+                    }
+                }
+            }
+            if (reportObserver !== undefined) {
+                reportObserver(report);
+            }
+        });
+    };
+    // Set the name property on the function for debugging purposes.
+    Object.defineProperty(instrumentedAdapter, 'name', {
+        value: name + '__instrumented',
+    });
+    return isGraphqlAdapter(name) === true
+        ? instrumentGraphqlAdapter(instrumentedAdapter)
+        : instrumentedAdapter;
+}
+/**
+ * Any graphql get adapter specific instrumentation that we need to log
+ * @param snapshot from either in-memory or built after a network hit
+ */
+function logGraphqlMetrics(snapshot) {
+    // We have both data and error in the returned response
+    const { data: snapshotData } = snapshot;
+    if (snapshotData &&
+        snapshotData.data &&
+        keys(snapshotData.data).length > 0 &&
+        snapshotData.errors &&
+        snapshotData.errors.length > 0) {
+        ldsInstrumentation.incrementCounter(GET_GRAPHQL_RESPONSE_MIXED);
+    }
+    if (snapshotData.errors && snapshotData.errors.length > 0) {
+        // W-12293528 GraphQL metrics
+        // log counts of returned errors
+        let validationErrorCount = 0;
+        let syntaxErrorCount = 0;
+        let otherErrorCount = 0;
+        // conslidate instrumentation calls with # of occurrences
+        snapshotData.errors.forEach((e) => {
+            if (e.message && e.message.startsWith('Validation error')) {
+                validationErrorCount++;
+            }
+            else if (e.message && e.message.startsWith('Invalid Syntax')) {
+                syntaxErrorCount++;
+            }
+            else {
+                otherErrorCount++;
+            }
+        });
+        if (validationErrorCount > 0) {
+            ldsInstrumentation.incrementCounter(GRAPHQL_QUERY_VALIDATION_ERROR_COUNT, validationErrorCount);
+        }
+        if (syntaxErrorCount > 0) {
+            ldsInstrumentation.incrementCounter(GRAPHQL_QUERY_SYNTAX_ERROR_COUNT, syntaxErrorCount);
+        }
+        if (otherErrorCount > 0) {
+            ldsInstrumentation.incrementCounter(GRAPHQL_QUERY_OTHER_ERROR_COUNT, otherErrorCount);
+        }
+    }
+}
+/**
+ * Wraps methods to collect runtime performance using o11y's trackValue API
+ * @param obj Object instance containing the methods to instrument
+ * @param methods array containing objects with keys for the method name and the metric key to use in o11y
+ */
+function instrumentMethods(obj, methods) {
+    for (let i = 0, len = methods.length; i < len; i++) {
+        const { methodName, metricKey } = methods[i];
+        const originalMethod = obj[methodName];
+        obj[methodName] = function (...args) {
+            const startTime = Date.now();
+            try {
+                const res = originalMethod.call(this, ...args);
+                const executionTime = Date.now() - startTime;
+                // handle async resolved/rejected
+                if (isPromise(res)) {
+                    res.then(() => {
+                        ldsInstrumentation.trackValue(metricKey, Date.now() - startTime);
+                    }).catch((_error) => {
+                        ldsInstrumentation.trackValue(metricKey, Date.now() - startTime, true);
+                    });
+                }
+                else {
+                    // handle synchronous success
+                    ldsInstrumentation.trackValue(metricKey, executionTime);
+                }
+                return res;
+            }
+            catch (error) {
+                // handle synchronous throw
+                ldsInstrumentation.trackValue(metricKey, Date.now() - startTime, true);
+                // rethrow error
+                throw error;
+            }
+        };
+    }
+}
+function createMetricsKey(name, unit) {
+    let metricName = name;
+    if (unit) {
+        metricName = metricName + '.' + unit;
+    }
+    return metricName;
+}
+/**
+ * Returns whether adapter is an Apex one or not.
+ * @param adapterName The name of the adapter.
+ */
+function isApexAdapter(adapterName) {
+    return adapterName.indexOf(APEX_ADAPTER_NAME) > -1;
+}
+/**
+ * Returns boolean whether adapter is a graphQL one or not.
+ * @param adapterName The name of the adapter.
+ */
+function isGraphqlAdapter(adapterName) {
+    return adapterName === GRAPHQL_ADAPTER_NAME;
+}
+/**
+ * Normalizes getApex adapter names to `Apex.getApex`. Non-Apex adapters will be prefixed with
+ * API family, if supplied. Example: `UiApi.getRecord`.
+ *
+ * Note: If you are adding additional logging that can come from getApex adapter contexts that provide
+ * the full getApex adapter name (i.e. getApex_[namespace]_[class]_[function]_[continuation]),
+ * ensure to call this method to normalize all logging to 'getApex'. This
+ * is because Argus has a 50k key cardinality limit. More context: W-8379680.
+ *
+ * @param adapterName The name of the adapter.
+ * @param apiFamily The API family of the adapter.
+ */
+function normalizeAdapterName(adapterName, apiFamily) {
+    if (isApexAdapter(adapterName)) {
+        return NORMALIZED_APEX_ADAPTER_NAME;
+    }
+    return apiFamily ? `${apiFamily}.${adapterName}` : adapterName;
+}
+/**
+ * Calls instrumentation/service telemetry counter
+ * @param name Name of the metric
+ * @param value number to increment by, if undefined increment by 1
+ */
+function incrementCounterMetric(name, number) {
+    ldsInstrumentation.incrementCounter(name, number);
+}
+/**
+ * Calls instrumentation/service telemetry percentileHistogram
+ * @param name Name of the metric
+ * @param value number used to update the percentileHistogram
+ */
+function updatePercentileHistogramMetric(name, value) {
+    ldsInstrumentation.trackValue(name, value);
+}
+function setAggregateUiChunkCountMetric(chunkCount) {
+    updatePercentileHistogramMetric(AGGREGATE_UI_CHUNK_COUNT, chunkCount);
+}
+function incrementGetRecordNormalInvokeCount() {
+    incrementCounterMetric(GET_RECORD_NORMAL_INVOKE_COUNT);
+}
+function incrementGetRecordAggregateInvokeCount() {
+    incrementCounterMetric(GET_RECORD_AGGREGATE_INVOKE_COUNT);
+}
+function incrementGetRecordNotifyChangeAllowCount() {
+    incrementCounterMetric(GET_RECORD_NOTIFY_CHANGE_ALLOW_COUNT);
+}
+function incrementGetRecordNotifyChangeDropCount() {
+    incrementCounterMetric(GET_RECORD_NOTIFY_CHANGE_DROP_COUNT);
+}
+function incrementNotifyRecordUpdateAvailableAllowCount() {
+    incrementCounterMetric(NOTIFY_RECORD_UPDATE_AVAILABLE_ALLOW_COUNT);
+}
+function incrementNotifyRecordUpdateAvailableDropCount() {
+    incrementCounterMetric(NOTIFY_RECORD_UPDATE_AVAILABLE_DROP_COUNT);
+}
+function incrementNetworkRateLimitExceededCount() {
+    incrementCounterMetric(NETWORK_RATE_LIMIT_EXCEEDED_COUNT);
+}
+function instrumentStoreTrimTask(callback) {
+    return () => {
+        ldsInstrumentation.incrementCounter(STORE_TRIM_TASK_COUNT);
+        const startTime = Date.now();
+        const res = callback();
+        ldsInstrumentation.trackValue(STORE_TRIM_TASK_DURATION, Date.now() - startTime);
+        // TODO [W-10060579]: replace record count per trim task with metric
+        return res;
+    };
+}
+function setStoreScheduler(store) {
+    const originalScheduler = store.scheduler;
+    store.scheduler = (callback, done) => {
+        originalScheduler(instrumentStoreTrimTask(callback), done);
+    };
+}
+function instrumentStoreStatsCallback(store) {
+    return () => {
+        const { snapshotSubscriptions, watchSubscriptions } = store;
+        const records = store.fallbackStringKeyInMemoryStore.records;
+        updatePercentileHistogramMetric(STORE_SIZE_COUNT, keys(records).length);
+        if (GRAPHQL_RECORDS_KEY in records) {
+            const graphQLRecordSize = keys(records[GRAPHQL_RECORDS_KEY]).length;
+            updatePercentileHistogramMetric(STORE_GRAPHQL_SIZE_COUNT, graphQLRecordSize);
+        }
+        updatePercentileHistogramMetric(STORE_SNAPSHOT_SUBSCRIPTIONS_COUNT, keys(snapshotSubscriptions).length);
+        updatePercentileHistogramMetric(STORE_WATCH_SUBSCRIPTIONS_COUNT, keys(watchSubscriptions).length);
+    };
+}
+/**
+ * Collects additional store statistics by tying its periodic,
+ * point-in-time data collection with a luvio method
+ * @param luvio
+ * @param store
+ */
+function setupStoreStatsCollection(luvio, callback) {
+    const wrapMethod = 'storeBroadcast';
+    const originalMethod = luvio[wrapMethod];
+    const throttledCallback = throttle(callback, 200);
+    luvio[wrapMethod] = function (...args) {
+        throttledCallback();
+        return originalMethod.call(this, ...args);
+    };
+}
+/**
+ * @param instrumentedAdapter
+ * @returns instrumentedGraphqlAdapter, which logs additional metrics for get graphQL adapter
+ */
+function instrumentGraphqlAdapter(instrumentedAdapter) {
+    const instrumentedGraphqlAdapter = (config, requestContext) => {
+        const result = instrumentedAdapter(config, requestContext);
+        if (result === null) {
+            return result;
+        }
+        if (isPromise(result)) {
+            result.then((_snapshot) => {
+                logGraphqlMetrics(_snapshot);
+            });
+        }
+        else {
+            logGraphqlMetrics(result);
+        }
+        return result;
+    };
+    return instrumentedGraphqlAdapter;
+}
+/**
+ * Sets up instrumentation for @salesforce/lds-adapters-uiapi
+ */
+function setLdsAdaptersUiapiInstrumentation(uiapiRegistration) {
+    uiapiRegistration.instrument({
+        recordConflictsResolved: (serverRequestCount) => {
+            // Ignore 0 values which can originate from ADS bridge
+            if (serverRequestCount > 0) {
+                updatePercentileHistogramMetric('record-conflicts-resolved', serverRequestCount);
+            }
+        },
+        nullDisplayValueConflict: ({ fieldType, areValuesEqual }) => {
+            const metricName = `merge-null-dv-count.${fieldType}`;
+            if (fieldType === 'scalar') {
+                incrementCounterMetric(`${metricName}.${areValuesEqual}`);
+            }
+            else {
+                incrementCounterMetric(metricName);
+            }
+        },
+        getRecordNotifyChangeAllowed: incrementGetRecordNotifyChangeAllowCount,
+        getRecordNotifyChangeDropped: incrementGetRecordNotifyChangeDropCount,
+        notifyRecordUpdateAvailableAllowed: incrementNotifyRecordUpdateAvailableAllowCount,
+        notifyRecordUpdateAvailableDropped: incrementNotifyRecordUpdateAvailableDropCount,
+        recordTypeIdIsNull: incrementRecordTypeIdIsNullCount,
+    });
+}
+/**
+ * Sets up instrumentation for @salesforce/lds-network-adapter
+ */
+function setLdsNetworkAdapterInstrumentation(networkAdapterRegistration) {
+    networkAdapterRegistration.instrument({
+        aggregateUiChunkCount: (cb) => setAggregateUiChunkCountMetric(cb()),
+        duplicateRequest: () => incrementCounterMetric(DUPLICATE_REQUEST_COUNT),
+        getRecordAggregateInvoke: incrementGetRecordAggregateInvokeCount,
+        getRecordNormalInvoke: incrementGetRecordNormalInvokeCount,
+        networkRateLimitExceeded: incrementNetworkRateLimitExceededCount,
+    });
+}
+/**
+ * Provides concrete implementations using o11y/client for instrumentation hooks
+ */
+function setInstrumentationHooks() {
+    instrument({
+        instrumentAdapter: instrumentAdapter,
+    });
+}
+/**
+ * Initialize the instrumentation and instrument the LDS instance and the InMemoryStore.
+ *
+ * @param luvio The Luvio instance to instrument.
+ * @param store The InMemoryStore to instrument.
+ */
+function setupInstrumentation(luvio, store) {
+    setInstrumentationHooks();
+    instrumentStoreMethods(luvio);
+    setupStoreStatsCollection(luvio, instrumentStoreStatsCallback(store));
+    setStoreScheduler(store);
+    setStoreEventObservers(store);
+    // TODO [W-10061321]: use periodic logger to log aggregated store stats
+}
+function instrumentStoreMethods(luvio, _store) {
+    instrumentMethods(luvio, [
+        { methodName: 'storeBroadcast', metricKey: STORE_BROADCAST_DURATION },
+        { methodName: 'storeIngest', metricKey: STORE_INGEST_DURATION },
+        { methodName: 'storeLookup', metricKey: STORE_LOOKUP_DURATION },
+        { methodName: 'storeSetTTLOverride', metricKey: STORE_SET_TTL_OVERRIDE_DURATION },
+        {
+            methodName: 'storeSetDefaultTTLOverride',
+            metricKey: STORE_SET_DEFAULT_TTL_OVERRIDE_DURATION,
+        },
+        {
+            methodName: 'notifyStoreUpdateAvailable',
+            metricKey: NOTIFY_STORE_UPDATE_AVAILABLE_DURATION,
+        },
+    ]);
+}
+function handleIngestedNewData(event) {
+    if (event.type === 'cache-miss-out-of-ttl') {
+        const { recordMetadata, oldSnapshot, newSnapshot } = event;
+        const lastExpiredDurationEntry = cacheMissOutOfTtlDurations.get(event.recordId);
+        if (lastExpiredDurationEntry !== undefined) {
+            const representationName = `${recordMetadata.namespace}__${recordMetadata.representationName}`;
+            let durationMetricName;
+            let countMetricName;
+            if (oldSnapshot !== newSnapshot) {
+                durationMetricName =
+                    REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_CHANGED_DURATION_METRIC_NAME;
+                countMetricName =
+                    REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_CHANGED_COUNT_METRIC_NAME;
+            }
+            else {
+                durationMetricName =
+                    REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_UNCHANGED_DURATION_METRIC_NAME;
+                countMetricName =
+                    REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_UNCHANGED_COUNT_METRIC_NAME;
+            }
+            const metricTags = {
+                state: lastExpiredDurationEntry.storeResolveResultState,
+                representationName: representationName,
+            };
+            ldsInstrumentation.trackValue(durationMetricName, lastExpiredDurationEntry.value, undefined, metricTags);
+            ldsInstrumentation.incrementCounter(countMetricName, 1, undefined, metricTags);
+            cacheMissOutOfTtlDurations.delete(event.recordId);
+        }
+    }
+}
+const cacheMissOutOfTtlDurations = new LRUCache(250);
+function handleOnDataOutOfTtlDurationUpdate(event) {
+    cacheMissOutOfTtlDurations.set(event.recordId, {
+        value: event.lastExpiredDuration,
+        storeResolveResultState: event.storeResolveResultState,
+    });
+}
+function setStoreEventObservers(store) {
+    const cacheMissOutOfTtlEventObserver = {
+        onCacheMissOutOfTtl: handleIngestedNewData,
+    };
+    const cacheMissOutOfTtlDurationUpdateEventObserver = {
+        onDataOutOfTtlDurationUpdate: handleOnDataOutOfTtlDurationUpdate,
+    };
+    store.addStoreEventObserver(cacheMissOutOfTtlEventObserver);
+    store.addStoreEventObserver(cacheMissOutOfTtlDurationUpdateEventObserver);
+}
 const instrumentation = new Instrumentation();
 
 export { Instrumentation, LRUCache, metricKeys as METRIC_KEYS, handleIngestedNewData, handleOnDataOutOfTtlDurationUpdate, incrementCounterMetric, incrementGetRecordNormalInvokeCount, incrementGetRecordNotifyChangeAllowCount, incrementGetRecordNotifyChangeDropCount, incrementNotifyRecordUpdateAvailableAllowCount, incrementNotifyRecordUpdateAvailableDropCount, instrumentAdapter, instrumentLuvio, instrumentMethods, instrumentStoreMethods, instrumentation, setInstrumentationHooks, setLdsAdaptersUiapiInstrumentation, setLdsNetworkAdapterInstrumentation, setStoreEventObservers, setupInstrumentation, updatePercentileHistogramMetric };
-// version: 1.124.2-a5418d550
+// version: 1.124.4-f07bfc14d