@salesforce/lds-instrumentation 0.1.0-dev1

package/dist/ldsInstrumentation.js

@@ -0,0 +1,1582 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/*
+ *  ATTENTION!
+ *  THIS IS A GENERATED FILE FROM https://github.com/salesforce-experience-platform-emu/lds-lightning-platform
+ *  If you would like to contribute to LDS, please follow the steps outlined in the git repo.
+ *  Any changes made to this file in p4 will be automatically overwritten.
+ *  *******************************************************************************************
+ */
+/* proxy-compat-disable */
+import { getInstrumentation, idleDetector } from 'o11y/client';
+import { adapterUnfulfilledErrorSchema } from 'o11y_schema/sf_lds';
+import { ADAPTER_UNFULFILLED_ERROR, instrument } from 'force/ldsBindings';
+
+var SnapshotState;
+(function (SnapshotState) {
+    SnapshotState["Fulfilled"] = "Fulfilled";
+    SnapshotState["Unfulfilled"] = "Unfulfilled";
+    SnapshotState["Error"] = "Error";
+    SnapshotState["Pending"] = "Pending";
+    SnapshotState["Stale"] = "Stale";
+})(SnapshotState || (SnapshotState = {}));
+
+Promise.resolve();
+
+var StoreErrorStatus;
+(function (StoreErrorStatus) {
+    StoreErrorStatus[StoreErrorStatus["RESOURCE_NOT_FOUND"] = 404] = "RESOURCE_NOT_FOUND";
+})(StoreErrorStatus || (StoreErrorStatus = {}));
+var StoreRecordType;
+(function (StoreRecordType) {
+    StoreRecordType["Error"] = "error";
+})(StoreRecordType || (StoreRecordType = {}));
+var StoreLinkStateValues$1;
+(function (StoreLinkStateValues) {
+    StoreLinkStateValues[StoreLinkStateValues["NotPresent"] = 0] = "NotPresent";
+    StoreLinkStateValues[StoreLinkStateValues["RefNotPresent"] = 1] = "RefNotPresent";
+    StoreLinkStateValues[StoreLinkStateValues["RefPresent"] = 2] = "RefPresent";
+    StoreLinkStateValues[StoreLinkStateValues["Null"] = 3] = "Null";
+    StoreLinkStateValues[StoreLinkStateValues["Missing"] = 4] = "Missing";
+    StoreLinkStateValues[StoreLinkStateValues["Pending"] = 5] = "Pending";
+})(StoreLinkStateValues$1 || (StoreLinkStateValues$1 = {}));
+var StoreResolveResultState;
+(function (StoreResolveResultState) {
+    StoreResolveResultState[StoreResolveResultState["Found"] = 0] = "Found";
+    StoreResolveResultState[StoreResolveResultState["Error"] = 1] = "Error";
+    StoreResolveResultState[StoreResolveResultState["Null"] = 2] = "Null";
+    StoreResolveResultState[StoreResolveResultState["NotPresent"] = 3] = "NotPresent";
+    StoreResolveResultState[StoreResolveResultState["Stale"] = 4] = "Stale";
+})(StoreResolveResultState || (StoreResolveResultState = {}));
+var HttpStatusCode;
+(function (HttpStatusCode) {
+    HttpStatusCode[HttpStatusCode["Ok"] = 200] = "Ok";
+    HttpStatusCode[HttpStatusCode["Created"] = 201] = "Created";
+    HttpStatusCode[HttpStatusCode["NoContent"] = 204] = "NoContent";
+    HttpStatusCode[HttpStatusCode["NotModified"] = 304] = "NotModified";
+    HttpStatusCode[HttpStatusCode["BadRequest"] = 400] = "BadRequest";
+    HttpStatusCode[HttpStatusCode["Unauthorized"] = 401] = "Unauthorized";
+    HttpStatusCode[HttpStatusCode["Forbidden"] = 403] = "Forbidden";
+    HttpStatusCode[HttpStatusCode["NotFound"] = 404] = "NotFound";
+    HttpStatusCode[HttpStatusCode["ServerError"] = 500] = "ServerError";
+    HttpStatusCode[HttpStatusCode["GatewayTimeout"] = 504] = "GatewayTimeout";
+})(HttpStatusCode || (HttpStatusCode = {}));
+var GraphNodeType;
+(function (GraphNodeType) {
+    GraphNodeType["Link"] = "Link";
+    GraphNodeType["Node"] = "Node";
+    GraphNodeType["Error"] = "Error";
+    GraphNodeType["Locked"] = "Locked";
+})(GraphNodeType || (GraphNodeType = {}));
+
+var StoreLinkStateValues;
+(function (StoreLinkStateValues) {
+    StoreLinkStateValues[StoreLinkStateValues["NotPresent"] = 0] = "NotPresent";
+    StoreLinkStateValues[StoreLinkStateValues["RefNotPresent"] = 1] = "RefNotPresent";
+    StoreLinkStateValues[StoreLinkStateValues["RefPresent"] = 2] = "RefPresent";
+    StoreLinkStateValues[StoreLinkStateValues["Null"] = 3] = "Null";
+    StoreLinkStateValues[StoreLinkStateValues["Missing"] = 4] = "Missing";
+    StoreLinkStateValues[StoreLinkStateValues["Pending"] = 5] = "Pending";
+})(StoreLinkStateValues || (StoreLinkStateValues = {}));
+var FragmentReadResultState;
+(function (FragmentReadResultState) {
+    FragmentReadResultState[FragmentReadResultState["Missing"] = 0] = "Missing";
+    FragmentReadResultState[FragmentReadResultState["Success"] = 1] = "Success";
+    FragmentReadResultState[FragmentReadResultState["Error"] = 2] = "Error";
+})(FragmentReadResultState || (FragmentReadResultState = {}));
+({
+    state: FragmentReadResultState.Missing,
+});
+
+var ResourceParamType;
+(function (ResourceParamType) {
+    ResourceParamType[ResourceParamType["UrlParameter"] = 0] = "UrlParameter";
+    ResourceParamType[ResourceParamType["QueryParameter"] = 1] = "QueryParameter";
+    ResourceParamType[ResourceParamType["Body"] = 2] = "Body";
+    ResourceParamType[ResourceParamType["Header"] = 3] = "Header";
+})(ResourceParamType || (ResourceParamType = {}));
+var TypeCheckShapes;
+(function (TypeCheckShapes) {
+    TypeCheckShapes[TypeCheckShapes["String"] = 0] = "String";
+    TypeCheckShapes[TypeCheckShapes["Boolean"] = 1] = "Boolean";
+    TypeCheckShapes[TypeCheckShapes["Number"] = 2] = "Number";
+    TypeCheckShapes[TypeCheckShapes["Integer"] = 3] = "Integer";
+    TypeCheckShapes[TypeCheckShapes["Unsupported"] = 4] = "Unsupported";
+})(TypeCheckShapes || (TypeCheckShapes = {}));
+// engine version: 0.158.7-bafe2646
+
+const DurableEnvironmentEventDiscriminator = 'durable';
+function isDurableEnvironmentEvent(event) {
+    return (event.type === 'environment' && event.environment === DurableEnvironmentEventDiscriminator);
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+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 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 cacheLookupState = undefined;
+    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';
+                    }
+                    cacheLookupState = ev.snapshotState;
+                    if (ev.snapshotState === 'Stale') {
+                        staleLookup = true;
+                    }
+                    break;
+                case 'network-lookup-start':
+                    // if the lookup is stale or fulfilled it wasnt a cache miss
+                    // but refreshed due to explicitly being asked (cache-and-network) or because it was stale
+                    if (cacheLookupState &&
+                        cacheLookupState !== 'Stale' &&
+                        cacheLookupState !== 'Fulfilled') {
+                        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.eventObservers === undefined) {
+            requestContextWithInstrumentationObserver.eventObservers = [];
+        }
+        requestContextWithInstrumentationObserver.eventObservers.push(metricsEventObserver);
+        return requestContextWithInstrumentationObserver;
+    };
+    adapterStart = Date.now();
+    try {
+        const normalizedRequestContext = bindObserverToAdapterRequestContext(requestContext);
+        const adapterResult = adapter(adapterConfig, normalizedRequestContext);
+        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 GRAPHQL_QUERY_OTHER_ERROR_COUNT = 'graphql-query-other-error-count';
+/**
+ * W-12025795
+ * GraphQL metric
+ * Counter to track usage of legacy adapter
+ */
+const GRAPHQL_LEGACY_ADAPTER_USAGE_COUNT = 'graphql-legacy-adapter-usage-count';
+/**
+ * W-12025795
+ * GraphQL metric
+ * Counter to track errors in usage of legacy adapter
+ */
+const GRAPHQL_LEGACY_ADAPTER_ERRORS_IN_RESPONSE_COUNT = 'graphql-legacy-adapter-errors-in-response-count';
+/**
+ * W-15022402
+ * Predictive Data loading predict() Activity Tracking
+ * Activity name to track duration, errors for predictive data loading's predict() function
+ */
+const PREDICTIVE_DATA_LOADING_PREDICT = 'predictive-data-loading-predict';
+/**
+ * W-15022402
+ * Predictive Data loading saveRequest() Activity Tracking
+ * Activity name to track duration, errors for predictive data loading's saveRequest() function
+ */
+const PREDICTIVE_DATA_LOADING_SAVE_REQUEST = 'predictive-data-loading-save-request';
+/**
+ * W-18777099
+ * Prefetch Using State Managers Activity Tracking
+ * Activity name to track errors from prefetch data for top entities using state managers
+ */
+const PREFETCH_USING_STATE_MANAGERS = 'prefetch-using-state-managers';
+/**
+ * W-18812516
+ * State Manager metric
+ * Counter to track number of state managers created
+ */
+const STATE_CREATED_COUNT = 'state-created-count';
+
+var metricKeys = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ADAPTER_CACHE_HIT_COUNT_METRIC_NAME: ADAPTER_CACHE_HIT_COUNT_METRIC_NAME,
+    ADAPTER_CACHE_HIT_DURATION_METRIC_NAME: ADAPTER_CACHE_HIT_DURATION_METRIC_NAME,
+    ADAPTER_CACHE_HIT_L2_COUNT_METRIC_NAME: ADAPTER_CACHE_HIT_L2_COUNT_METRIC_NAME,
+    ADAPTER_CACHE_HIT_L2_DURATION_METRIC_NAME: ADAPTER_CACHE_HIT_L2_DURATION_METRIC_NAME,
+    ADAPTER_CACHE_MISS_COUNT_METRIC_NAME: ADAPTER_CACHE_MISS_COUNT_METRIC_NAME,
+    ADAPTER_CACHE_MISS_DURATION_METRIC_NAME: ADAPTER_CACHE_MISS_DURATION_METRIC_NAME,
+    ADAPTER_CACHE_MISS_OUT_OF_TTL_COUNT_METRIC_NAME: ADAPTER_CACHE_MISS_OUT_OF_TTL_COUNT_METRIC_NAME,
+    ADAPTER_CACHE_MISS_OUT_OF_TTL_DURATION_METRIC_NAME: ADAPTER_CACHE_MISS_OUT_OF_TTL_DURATION_METRIC_NAME,
+    AGGREGATE_UI_CHUNK_COUNT: AGGREGATE_UI_CHUNK_COUNT,
+    CACHE_HIT_COUNT: CACHE_HIT_COUNT,
+    CACHE_MISS_COUNT: CACHE_MISS_COUNT,
+    CACHE_POLICY_COUNTERS: CACHE_POLICY_COUNTERS,
+    CACHE_POLICY_UNDEFINED_COUNTER: CACHE_POLICY_UNDEFINED_COUNTER,
+    DUPLICATE_REQUEST_COUNT: DUPLICATE_REQUEST_COUNT,
+    DURABLE_STORE_COUNT: DURABLE_STORE_COUNT,
+    GET_GRAPHQL_RESPONSE_MIXED: GET_GRAPHQL_RESPONSE_MIXED,
+    GET_RECORD_AGGREGATE_INVOKE_COUNT: GET_RECORD_AGGREGATE_INVOKE_COUNT,
+    GET_RECORD_NORMAL_INVOKE_COUNT: GET_RECORD_NORMAL_INVOKE_COUNT,
+    GET_RECORD_NOTIFY_CHANGE_ALLOW_COUNT: GET_RECORD_NOTIFY_CHANGE_ALLOW_COUNT,
+    GET_RECORD_NOTIFY_CHANGE_DROP_COUNT: GET_RECORD_NOTIFY_CHANGE_DROP_COUNT,
+    GRAPHQL_ADAPTER_COUNT: GRAPHQL_ADAPTER_COUNT,
+    GRAPHQL_LEGACY_ADAPTER_ERRORS_IN_RESPONSE_COUNT: GRAPHQL_LEGACY_ADAPTER_ERRORS_IN_RESPONSE_COUNT,
+    GRAPHQL_LEGACY_ADAPTER_USAGE_COUNT: GRAPHQL_LEGACY_ADAPTER_USAGE_COUNT,
+    GRAPHQL_QUERY_OTHER_ERROR_COUNT: GRAPHQL_QUERY_OTHER_ERROR_COUNT,
+    GRAPHQL_QUERY_SYNTAX_ERROR_COUNT: GRAPHQL_QUERY_SYNTAX_ERROR_COUNT,
+    GRAPHQL_QUERY_VALIDATION_ERROR_COUNT: GRAPHQL_QUERY_VALIDATION_ERROR_COUNT,
+    NETWORK_RATE_LIMIT_EXCEEDED_COUNT: NETWORK_RATE_LIMIT_EXCEEDED_COUNT,
+    NOTIFY_RECORD_UPDATE_AVAILABLE_ALLOW_COUNT: NOTIFY_RECORD_UPDATE_AVAILABLE_ALLOW_COUNT,
+    NOTIFY_RECORD_UPDATE_AVAILABLE_DROP_COUNT: NOTIFY_RECORD_UPDATE_AVAILABLE_DROP_COUNT,
+    NOTIFY_STORE_UPDATE_AVAILABLE_DURATION: NOTIFY_STORE_UPDATE_AVAILABLE_DURATION,
+    PREDICTIVE_DATA_LOADING_PREDICT: PREDICTIVE_DATA_LOADING_PREDICT,
+    PREDICTIVE_DATA_LOADING_SAVE_REQUEST: PREDICTIVE_DATA_LOADING_SAVE_REQUEST,
+    PREFETCH_USING_STATE_MANAGERS: PREFETCH_USING_STATE_MANAGERS,
+    RECORD_TYPE_ID_IS_NULL_COUNT: RECORD_TYPE_ID_IS_NULL_COUNT,
+    REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_CHANGED_COUNT_METRIC_NAME: REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_CHANGED_COUNT_METRIC_NAME,
+    REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_CHANGED_DURATION_METRIC_NAME: REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_CHANGED_DURATION_METRIC_NAME,
+    REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_UNCHANGED_COUNT_METRIC_NAME: REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_UNCHANGED_COUNT_METRIC_NAME,
+    REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_UNCHANGED_DURATION_METRIC_NAME: REPRESENTATION_CACHE_MISS_OUT_OF_TTL_DATA_UNCHANGED_DURATION_METRIC_NAME,
+    STALE_TAG: STALE_TAG,
+    STATE_CREATED_COUNT: STATE_CREATED_COUNT,
+    STORE_BROADCAST_DURATION: STORE_BROADCAST_DURATION,
+    STORE_GRAPHQL_SIZE_COUNT: STORE_GRAPHQL_SIZE_COUNT,
+    STORE_INGEST_DURATION: STORE_INGEST_DURATION,
+    STORE_LOOKUP_DURATION: STORE_LOOKUP_DURATION,
+    STORE_SET_DEFAULT_TTL_OVERRIDE_DURATION: STORE_SET_DEFAULT_TTL_OVERRIDE_DURATION,
+    STORE_SET_TTL_OVERRIDE_DURATION: STORE_SET_TTL_OVERRIDE_DURATION,
+    STORE_SIZE_COUNT: STORE_SIZE_COUNT,
+    STORE_SNAPSHOT_SUBSCRIPTIONS_COUNT: STORE_SNAPSHOT_SUBSCRIPTIONS_COUNT,
+    STORE_TRIM_TASK_COUNT: STORE_TRIM_TASK_COUNT,
+    STORE_TRIM_TASK_DURATION: STORE_TRIM_TASK_DURATION,
+    STORE_WATCH_SUBSCRIPTIONS_COUNT: STORE_WATCH_SUBSCRIPTIONS_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] Search "[M1] Lightning Data Service Design Spike" in Quip
+ * [2] Search "Lightning Data Service R.E.A.D.S. Metrics" in Quip
+ */
+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 { 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);
+        }
+    }
+}
+
+/**
+ * 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 STATE_MANAGERS_NAMESPACE = 'state-managers';
+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);
+const stateManagersInstrumentation = getInstrumentation(STATE_MANAGERS_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),
+    });
+}
+/**
+ * W-13639107
+ * Logs when object info has changed
+ */
+function logObjectInfoChanged() {
+    ldsInstrumentation.log('objectInfoChanged');
+}
+/**
+ * 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);
+        }
+    }
+}
+/**
+ * Starts an o11y Activity using the supplied o11y Instrumention and adapterName.
+ * If a requestContext is supplied, we check for the existence of a requestCorrelator containing an ObservabilityContext.
+ * If an ObservabilityContext is defined, we build an object that conforms to the ApiOptions interface required by the startActivity API
+ */
+function startAdapterActivity(instrumentation, adapterName, requestContext) {
+    if (requestContext === undefined ||
+        requestContext.requestCorrelator === undefined ||
+        getObservabilityContext(requestContext) === undefined) {
+        return instrumentation.startActivity(adapterName);
+    }
+    const { traceId, ...rest } = requestContext.requestCorrelator
+        .observabilityContext;
+    const apiOptions = {
+        instrumentationContext: rest,
+    };
+    if (traceId !== undefined) {
+        apiOptions.instrumentationContext.parentId = traceId;
+    }
+    return instrumentation.startActivity(adapterName, apiOptions);
+}
+const executeAsyncActivityDefaultOptions = {
+    LOG_ERROR_ONLY: false,
+};
+/**
+ * Starts an async o11y Activity using ldsInstrumentation.
+ *
+ * Heavily borrowed from o11y asyncActivity, but actually swallows the error instead of rethrowing.
+ *
+ */
+async function executeAsyncActivity(name, execute, options) {
+    const normalizedOptions = Object.assign({}, executeAsyncActivityDefaultOptions, options);
+    const act = ldsInstrumentation.startActivity(name, options);
+    let isError = false;
+    try {
+        return await execute(act);
+    }
+    catch (err) {
+        if (normalizedOptions.errorPayload?.schema) {
+            act.error(err, normalizedOptions.errorPayload.schema, normalizedOptions.errorPayload?.payload);
+        }
+        else {
+            act.error(err, normalizedOptions.ERROR_SCOPE);
+        }
+        isError = true;
+    }
+    finally {
+        if (normalizedOptions.LOG_ERROR_ONLY && !isError) {
+            act.discard();
+        }
+        else {
+            act.stop(normalizedOptions?.stopPayload?.schema, normalizedOptions?.stopPayload?.payload);
+        }
+    }
+}
+function instrumentAdapter(adapter, metadata, adapterInstrumentationOptions) {
+    const { apiFamily, name, ttl } = metadata;
+    let trackL1Hits = false;
+    let trackL2Hits = false;
+    let trackCacheMisses = false;
+    let reportObserver = undefined;
+    if (adapterInstrumentationOptions !== undefined) {
+        ({ trackL1Hits, trackL2Hits, trackCacheMisses, 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 = startAdapterActivity(ldsInstrumentation, adapterName, requestContext);
+        // swap in activity's Id if observabilityContext exists
+        updateRequestContext(activity, requestContext);
+        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);
+                        ldsInstrumentation.incrementCounter(ADAPTER_CACHE_MISS_COUNT_METRIC_NAME, 1);
+                        ldsInstrumentation.incrementCounter(cacheMissCountByAdapterMetric, 1);
+                        if (trackCacheMisses) {
+                            activity.stop('cache-miss');
+                        }
+                        else {
+                            activity.discard();
+                        }
+                        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);
+                        }
+                        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;
+}
+/**
+ * Replaces observabilityContext's traceId with parentActivity's Id since traceId
+ * is treated as parentId when observabilityContext is passed to native as part of
+ * the network request.
+ * @param parentActivity
+ * @param requestContext
+ */
+function updateRequestContext(parentActivity, requestContext) {
+    if (requestContext !== undefined) {
+        const observabilityContext = getObservabilityContext(requestContext);
+        if (observabilityContext !== undefined) {
+            observabilityContext.traceId = parentActivity.getId();
+        }
+    }
+}
+function getObservabilityContext(requestContext) {
+    return requestContext.requestCorrelator !== undefined
+        ? requestContext.requestCorrelator.observabilityContext
+        : undefined;
+}
+/**
+ * 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, config) {
+    // 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 (config && 'useUiApiAdapter' in config && config.useUiApiAdapter === false) {
+        // using legacy adapter
+        ldsInstrumentation.incrementCounter(GRAPHQL_LEGACY_ADAPTER_USAGE_COUNT);
+        if (snapshotData && snapshotData.errors && snapshotData.errors.length > 0) {
+            // track errors in legacy adapter responses
+            ldsInstrumentation.incrementCounter(GRAPHQL_LEGACY_ADAPTER_ERRORS_IN_RESPONSE_COUNT);
+        }
+    }
+    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;
+}
+/**
+ * Logs an error to Splunk using o11y
+ */
+function logError(err) {
+    ldsInstrumentation.error(err);
+}
+/**
+ * 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 incrementStateCreatedCount() {
+    stateManagersInstrumentation.incrementCounter(STATE_CREATED_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, config);
+            });
+        }
+        else {
+            logGraphqlMetrics(result, config);
+        }
+        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);
+}
+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);
+}
+function onIdleDetected(callback) {
+    idleDetector.requestIdleDetectedCallback((timestamp) => {
+        callback(timestamp);
+    });
+}
+const instrumentation = new Instrumentation();
+
+export { Instrumentation, LRUCache, metricKeys as METRIC_KEYS, executeAsyncActivity, handleIngestedNewData, handleOnDataOutOfTtlDurationUpdate, incrementCounterMetric, incrementGetRecordNormalInvokeCount, incrementGetRecordNotifyChangeAllowCount, incrementGetRecordNotifyChangeDropCount, incrementNotifyRecordUpdateAvailableAllowCount, incrementNotifyRecordUpdateAvailableDropCount, incrementStateCreatedCount, instrumentAdapter, instrumentLuvio, instrumentMethods, instrumentStoreMethods, instrumentation, logError, logObjectInfoChanged, onIdleDetected, setInstrumentationHooks, setLdsAdaptersUiapiInstrumentation, setLdsNetworkAdapterInstrumentation, setStoreEventObservers, setupInstrumentation, startAdapterActivity, updatePercentileHistogramMetric };
+// version: 0.1.0-dev1-54c03dd38c