@launchdarkly/js-client-sdk-common 1.14.1 → 1.15.0

package/dist/esm/async/AsyncTaskQueue.d.ts

@@ -24,6 +24,22 @@ export interface ErroredTask {
  * Represents the result of a task.
  */
 export type TaskResult<TTaskResult> = CompletedTask<TTaskResult> | ErroredTask | ShedTask;
+export interface Task<TTaskResult, TBeforeResult> {
+    /**
+     * Method ran before the task is executed or shed.
+     */
+    before?: () => Promise<TBeforeResult>;
+    /**
+     * Execute the task. This is not ran if the task is shed.
+     * @returns The result of the task.
+     */
+    execute: (beforeResult?: TBeforeResult) => Promise<TTaskResult>;
+    /**
+     * Method ran after the task is executed or shed.
+     * @param result The result of the task.
+     */
+    after?: (result: TaskResult<TTaskResult>, beforeResult?: TBeforeResult) => void;
+}
 /**
  * An asynchronous task queue with the ability to replace pending tasks.
  *
@@ -33,7 +49,7 @@ export type TaskResult<TTaskResult> = CompletedTask<TTaskResult> | ErroredTask |
  * For instance, the SDK can only have one active context at a time, if you request identification of many contexts,
  * then the ultimate state will be based on the last request. The intermediate identifies can be discarded.
  *
- * This class will always begin execution of the first item added to the queue, at that point the item itself is not
+ * This queue will always begin execution of the first item added to the queue, at that point the item itself is not
  * queued, but active. If another request is made while that item is still active, then it is added to the queue.
  * A third request would then replace the second request if the second request had not yet become active, and it was
  * sheddable.
@@ -49,11 +65,7 @@ export type TaskResult<TTaskResult> = CompletedTask<TTaskResult> | ErroredTask |
  * Queue management should be done synchronously. There should not be asynchronous operations between checking the queue
  * and acting on the results of said check.
  */
-export declare class AsyncTaskQueue<TTaskResult> {
-    private readonly _logger?;
-    private _activeTask?;
-    private _queue;
-    constructor(_logger?: LDLogger | undefined);
+export declare function createAsyncTaskQueue<TTaskResult>(logger?: LDLogger): {
     /**
      * Execute a task using the queue.
      *
@@ -61,7 +73,14 @@ export declare class AsyncTaskQueue<TTaskResult> {
      * @param sheddable Whether the task can be shed from the queue.
      * @returns A promise that resolves to the result of the task.
      */
-    execute(task: () => Promise<TTaskResult>, sheddable?: boolean): Promise<TaskResult<TTaskResult>>;
-    private _checkPending;
-}
+    execute<TBeforeResult>(task: Task<TTaskResult, TBeforeResult>, sheddable?: boolean): Promise<TaskResult<TTaskResult>>;
+    /**
+     * Returns the number of pending tasks in the queue.
+     * Intended for testing purposes only.
+     *
+     * @internal
+     * @returns The number of pending tasks in the queue.
+     */
+    pendingCount(): number;
+};
 //# sourceMappingURL=AsyncTaskQueue.d.ts.map

package/dist/esm/async/AsyncTaskQueue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AsyncTaskQueue.d.ts","sourceRoot":"","sources":["../../src/async/AsyncTaskQueue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAEvD;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa,CAAC,WAAW;IACxC,MAAM,EAAE,UAAU,CAAC;IACnB,MAAM,EAAE,WAAW,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,KAAK,CAAC;CACd;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,WAAW,IAAI,aAAa,CAAC,WAAW,CAAC,GAAG,WAAW,GAAG,QAAQ,CAAC;AA2D1F;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,cAAc,CAAC,WAAW;IAIzB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;IAHrC,OAAO,CAAC,WAAW,CAAC,CAAmC;IACvD,OAAO,CAAC,MAAM,CAAkC;gBAEnB,OAAO,CAAC,sBAAU;IAE/C;;;;;;OAMG;IACH,OAAO,CACL,IAAI,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,EAChC,SAAS,GAAE,OAAe,GACzB,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;IAoBnC,OAAO,CAAC,aAAa;CA6BtB"}
+{"version":3,"file":"AsyncTaskQueue.d.ts","sourceRoot":"","sources":["../../src/async/AsyncTaskQueue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAEvD;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa,CAAC,WAAW;IACxC,MAAM,EAAE,UAAU,CAAC;IACnB,MAAM,EAAE,WAAW,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,KAAK,CAAC;CACd;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,WAAW,IAAI,aAAa,CAAC,WAAW,CAAC,GAAG,WAAW,GAAG,QAAQ,CAAC;AAa1F,MAAM,WAAW,IAAI,CAAC,WAAW,EAAE,aAAa;IAC9C;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,OAAO,CAAC,aAAa,CAAC,CAAC;IAEtC;;;OAGG;IAEH,OAAO,EAAE,CAAC,YAAY,CAAC,EAAE,aAAa,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;IAEhE;;;OAGG;IACH,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,UAAU,CAAC,WAAW,CAAC,EAAE,YAAY,CAAC,EAAE,aAAa,KAAK,IAAI,CAAC;CACjF;AAoED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,CAAC,EAAE,QAAQ;IAwB/D;;;;;;OAMG;+EAGU,OAAO,GACjB,QAAQ,WAAW,WAAW,CAAC,CAAC;IAoBnC;;;;;;OAMG;oBACa,MAAM;EAIzB"}

package/dist/esm/index.d.ts

@@ -6,7 +6,7 @@ import LDClientImpl from './LDClientImpl';
 import LDEmitter, { EventName } from './LDEmitter';
 export * from '@launchdarkly/js-sdk-common';
 export * as platform from '@launchdarkly/js-sdk-common';
-export type { LDEvaluationDetail, LDEvaluationDetailTyped, LDClient, LDOptions, ConnectionMode, LDIdentifyOptions, Hook, HookMetadata, EvaluationSeriesContext, EvaluationSeriesData, IdentifySeriesContext, IdentifySeriesData, IdentifySeriesResult, IdentifySeriesStatus, TrackSeriesContext, LDInspection, } from './api';
+export type { LDEvaluationDetail, LDEvaluationDetailTyped, LDClient, LDOptions, ConnectionMode, LDIdentifyOptions, Hook, HookMetadata, EvaluationSeriesContext, EvaluationSeriesData, IdentifySeriesContext, IdentifySeriesData, IdentifySeriesResult, IdentifySeriesStatus, TrackSeriesContext, LDInspection, LDIdentifyResult, LDIdentifySuccess, LDIdentifyError, LDIdentifyTimeout, LDIdentifyShed, LDClientIdentifyResult, } from './api';
 export type { DataManager, DataManagerFactory, ConnectionParams } from './DataManager';
 export type { FlagManager } from './flag-manager/FlagManager';
 export type { Configuration } from './configuration/Configuration';

package/dist/esm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,gBAAgB,EAAE,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAClF,OAAO,yBAAyB,MAAM,wCAAwC,CAAC;AAC/E,OAAO,SAAS,EAAE,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,YAAY,MAAM,gBAAgB,CAAC;AAC1C,OAAO,SAAS,EAAE,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAEnD,cAAc,6BAA6B,CAAC;AAE5C,OAAO,KAAK,QAAQ,MAAM,6BAA6B,CAAC;AAMxD,YAAY,EACV,kBAAkB,EAClB,uBAAuB,EACvB,QAAQ,EACR,SAAS,EACT,cAAc,EACd,iBAAiB,EACjB,IAAI,EACJ,YAAY,EACZ,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EAClB,YAAY,GACb,MAAM,OAAO,CAAC;AAEf,YAAY,EAAE,WAAW,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACvF,YAAY,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,YAAY,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAEnE,YAAY,EAAE,SAAS,EAAE,CAAC;AAC1B,YAAY,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AACpE,YAAY,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAEpC,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,CAAC;AAEpC,OAAO,EACL,gBAAgB,EAChB,yBAAyB,EACzB,YAAY,EACZ,uBAAuB,EACvB,eAAe,EACf,SAAS,IAAI,kBAAkB,GAChC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,gBAAgB,EAAE,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAClF,OAAO,yBAAyB,MAAM,wCAAwC,CAAC;AAC/E,OAAO,SAAS,EAAE,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,YAAY,MAAM,gBAAgB,CAAC;AAC1C,OAAO,SAAS,EAAE,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAEnD,cAAc,6BAA6B,CAAC;AAE5C,OAAO,KAAK,QAAQ,MAAM,6BAA6B,CAAC;AAMxD,YAAY,EACV,kBAAkB,EAClB,uBAAuB,EACvB,QAAQ,EACR,SAAS,EACT,cAAc,EACd,iBAAiB,EACjB,IAAI,EACJ,YAAY,EACZ,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB,EACrB,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,iBAAiB,EACjB,cAAc,EACd,sBAAsB,GACvB,MAAM,OAAO,CAAC;AAEf,YAAY,EAAE,WAAW,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACvF,YAAY,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,YAAY,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAEnE,YAAY,EAAE,SAAS,EAAE,CAAC;AAC1B,YAAY,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AACpE,YAAY,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAEpC,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,CAAC;AAEpC,OAAO,EACL,gBAAgB,EAChB,yBAAyB,EACzB,YAAY,EACZ,uBAAuB,EACvB,eAAe,EACf,SAAS,IAAI,kBAAkB,GAChC,CAAC"}

package/dist/esm/index.mjs

@@ -1,4 +1,4 @@
-import { getPollingUri, TypeValidators, createSafeLogger, ServiceEndpoints, ApplicationTags, OptionMessages, NumberWithMinimum, SafeLogger, internal, deepCompact, clone, secondsToMillis, ClientContext, fastDeepEqual, defaultHeaders, Context, timedPromise, AutoEnvAttributes, LDClientError, isHttpRecoverable, httpErrorMessage, LDPollingError, DataSourceErrorKind, getStreamingUri, shouldRetry, LDStreamingError } from '@launchdarkly/js-sdk-common';
+import { getPollingUri, TypeValidators, createSafeLogger, ServiceEndpoints, ApplicationTags, OptionMessages, NumberWithMinimum, SafeLogger, internal, deepCompact, clone, secondsToMillis, ClientContext, fastDeepEqual, defaultHeaders, Context, LDTimeoutError, AutoEnvAttributes, LDClientError, isHttpRecoverable, httpErrorMessage, LDPollingError, DataSourceErrorKind, getStreamingUri, shouldRetry, LDStreamingError } from '@launchdarkly/js-sdk-common';
 export * from '@launchdarkly/js-sdk-common';
 import * as jsSdkCommon from '@launchdarkly/js-sdk-common';
 export { jsSdkCommon as platform };
@@ -80,6 +80,143 @@ function makeRequestor(plainContextString, serviceEndpoints, paths, requests, en
     return new Requestor(requests, uri, headers, method, body);
 }
 
+const duplicateExecutionError = new Error('Task has already been executed or shed. This is likely an implementation error. The task will not be executed again.');
+/**
+ * Creates a pending task.
+ * @param task The async function to execute.
+ * @param sheddable Whether the task can be shed from the queue.
+ * @returns A pending task.
+ */
+function makePending(task, _logger, sheddable = false) {
+    let resolveTask;
+    const promise = new Promise((resolve) => {
+        resolveTask = (result, beforeResult) => {
+            try {
+                task.after?.(result, beforeResult);
+            }
+            catch (error) {
+                _logger?.error(`Error in after callback: ${error}`);
+            }
+            resolve(result);
+        };
+    });
+    const beforePromise = task.before ? task.before() : Promise.resolve(undefined);
+    let executedOrShed = false;
+    return {
+        execute: () => {
+            if (executedOrShed) {
+                // This should never happen. If it does, then it represents an implementation error in the SDK.
+                _logger?.error(duplicateExecutionError);
+            }
+            executedOrShed = true;
+            beforePromise
+                .then((beforeResult) => {
+                task
+                    .execute(beforeResult)
+                    .then((result) => resolveTask({ status: 'complete', result }, beforeResult))
+                    .catch((error) => resolveTask({ status: 'error', error }, beforeResult));
+            })
+                .catch((error) => {
+                _logger?.error(error);
+                resolveTask({ status: 'error', error }, undefined);
+            });
+        },
+        shed: () => {
+            if (executedOrShed) {
+                // This should never happen. If it does, then it represents an implementation error in the SDK.
+                _logger?.error(duplicateExecutionError);
+            }
+            executedOrShed = true;
+            beforePromise.then((beforeResult) => {
+                resolveTask({ status: 'shed' }, beforeResult);
+            });
+        },
+        promise,
+        sheddable,
+    };
+}
+/**
+ * An asynchronous task queue with the ability to replace pending tasks.
+ *
+ * This is useful when you have asynchronous operations which much execute in order, and for cases where intermediate
+ * operations can be discarded.
+ *
+ * For instance, the SDK can only have one active context at a time, if you request identification of many contexts,
+ * then the ultimate state will be based on the last request. The intermediate identifies can be discarded.
+ *
+ * This queue will always begin execution of the first item added to the queue, at that point the item itself is not
+ * queued, but active. If another request is made while that item is still active, then it is added to the queue.
+ * A third request would then replace the second request if the second request had not yet become active, and it was
+ * sheddable.
+ *
+ * Once a task is active the queue will complete it. It doesn't cancel tasks that it has started, but it can shed tasks
+ * that have not started.
+ *
+ * TTaskResult Is the return type of the task to be executed. Tasks accept no parameters. So if you need parameters
+ * you should use a lambda to capture them.
+ *
+ * Exceptions from tasks are always handled and the execute method will never reject a promise.
+ *
+ * Queue management should be done synchronously. There should not be asynchronous operations between checking the queue
+ * and acting on the results of said check.
+ */
+function createAsyncTaskQueue(logger) {
+    let activeTask;
+    const queue = [];
+    function checkPending() {
+        // There is an existing active task, so we don't need to do anything.
+        if (activeTask) {
+            return;
+        }
+        // There are pending tasks, so we need to execute the next one.
+        if (queue.length > 0) {
+            const nextTask = queue.shift();
+            activeTask = nextTask.promise.finally(() => {
+                activeTask = undefined;
+                checkPending();
+            });
+            nextTask.execute();
+        }
+    }
+    return {
+        /**
+         * Execute a task using the queue.
+         *
+         * @param task The async function to execute.
+         * @param sheddable Whether the task can be shed from the queue.
+         * @returns A promise that resolves to the result of the task.
+         */
+        execute(task, sheddable = false) {
+            const pending = makePending(task, logger, sheddable);
+            if (!activeTask) {
+                activeTask = pending.promise.finally(() => {
+                    activeTask = undefined;
+                    checkPending();
+                });
+                pending.execute();
+            }
+            else {
+                // If the last pending task is sheddable, we need to shed it before adding the new task.
+                if (queue[queue.length - 1]?.sheddable) {
+                    queue.pop()?.shed();
+                }
+                queue.push(pending);
+            }
+            return pending.promise;
+        },
+        /**
+         * Returns the number of pending tasks in the queue.
+         * Intended for testing purposes only.
+         *
+         * @internal
+         * @returns The number of pending tasks in the queue.
+         */
+        pendingCount() {
+            return queue.length;
+        },
+    };
+}
+
 // eslint-disable-next-line max-classes-per-file
 const validators = {
     logger: TypeValidators.Object,
@@ -1194,6 +1331,7 @@ class LDClientImpl {
         this._eventFactoryDefault = new EventFactory(false);
         this._eventFactoryWithReasons = new EventFactory(true);
         this._eventSendingEnabled = false;
+        this._identifyQueue = createAsyncTaskQueue();
         if (!sdkKey) {
             throw new Error('You must configure the client with a client-side SDK key');
         }
@@ -1259,7 +1397,7 @@ class LDClientImpl {
     }
     getContext() {
         // The LDContext returned here may have been modified by the SDK (for example: adding auto env attributes).
-        // We are returning an LDContext here to maintain a consistent represetnation of context to the consuming
+        // We are returning an LDContext here to maintain a consistent representation of context to the consuming
         // code.  We are returned the unchecked context so that if a consumer identifies with an invalid context
         // and then calls getContext, they get back the same context they provided, without any assertion about
         // validity.
@@ -1268,28 +1406,25 @@ class LDClientImpl {
     getInternalContext() {
         return this._checkedContext;
     }
-    _createIdentifyPromise(timeout, noTimeout) {
+    _createIdentifyPromise() {
         let res;
         let rej;
         const basePromise = new Promise((resolve, reject) => {
             res = resolve;
             rej = reject;
         });
-        if (noTimeout) {
-            return { identifyPromise: basePromise, identifyResolve: res, identifyReject: rej };
-        }
-        const timed = timedPromise(timeout, 'identify');
-        const raced = Promise.race([timed, basePromise]).catch((e) => {
-            if (e.message.includes('timed out')) {
-                this.logger.error(`identify error: ${e}`);
-            }
-            throw e;
-        });
-        return { identifyPromise: raced, identifyResolve: res, identifyReject: rej };
+        return { identifyPromise: basePromise, identifyResolve: res, identifyReject: rej };
     }
     /**
      * Identifies a context to LaunchDarkly. See {@link LDClient.identify}.
      *
+     * If used with the `sheddable` option set to true, then the identify operation will be sheddable. This means that if
+     * multiple identify operations are done, without waiting for the previous one to complete, then intermediate
+     * operations may be discarded.
+     *
+     * It is recommended to use the `identifyResult` method instead when the operation is sheddable. In a future release,
+     * all identify operations will default to being sheddable.
+     *
      * @param pristineContext The LDContext object to be identified.
      * @param identifyOptions Optional configuration. See {@link LDIdentifyOptions}.
      * @returns A Promise which resolves when the flag values for the specified
@@ -1303,39 +1438,95 @@ class LDClientImpl {
      * 3. A network error is encountered during initialization.
      */
     async identify(pristineContext, identifyOptions) {
+        // In order to manage customization in the derived classes it is important that `identify` MUST be implemented in
+        // terms of `identifyResult`. So that the logic of the identification process can be extended in one place.
+        const result = await this.identifyResult(pristineContext, identifyOptions);
+        if (result.status === 'error') {
+            throw result.error;
+        }
+        else if (result.status === 'timeout') {
+            const timeoutError = new LDTimeoutError(`identify timed out after ${result.timeout} seconds.`);
+            this.logger.error(timeoutError.message);
+            throw timeoutError;
+        }
+        // If completed or shed, then we are done.
+    }
+    async identifyResult(pristineContext, identifyOptions) {
         const identifyTimeout = identifyOptions?.timeout ?? DEFAULT_IDENTIFY_TIMEOUT_SECONDS;
         const noTimeout = identifyOptions?.timeout === undefined && identifyOptions?.noTimeout === true;
-        // When noTimeout is specified, and a timeout is not secified, then this condition cannot
+        // When noTimeout is specified, and a timeout is not specified, then this condition cannot
         // be encountered. (Our default would need to be greater)
         if (identifyTimeout > this._highTimeoutThreshold) {
             this.logger.warn('The identify function was called with a timeout greater than ' +
                 `${this._highTimeoutThreshold} seconds. We recommend a timeout of less than ` +
                 `${this._highTimeoutThreshold} seconds.`);
         }
-        let context = await ensureKey(pristineContext, this.platform);
-        if (this.autoEnvAttributes === AutoEnvAttributes.Enabled) {
-            context = await addAutoEnv(context, this.platform, this._config);
-        }
-        const checkedContext = Context.fromLDContext(context);
-        if (!checkedContext.valid) {
-            const error = new Error('Context was unspecified or had no key');
-            this.emitter.emit('error', context, error);
-            return Promise.reject(error);
-        }
-        this._uncheckedContext = context;
-        this._checkedContext = checkedContext;
-        this._eventProcessor?.sendEvent(this._eventFactoryDefault.identifyEvent(this._checkedContext));
-        const { identifyPromise, identifyResolve, identifyReject } = this._createIdentifyPromise(identifyTimeout, noTimeout);
-        this.logger.debug(`Identifying ${JSON.stringify(this._checkedContext)}`);
-        const afterIdentify = this._hookRunner.identify(context, identifyOptions?.timeout);
-        await this.dataManager.identify(identifyResolve, identifyReject, checkedContext, identifyOptions);
-        return identifyPromise.then((res) => {
-            afterIdentify({ status: 'completed' });
-            return res;
-        }, (e) => {
-            afterIdentify({ status: 'error' });
-            throw e;
+        const callSitePromise = this._identifyQueue
+            .execute({
+            before: async () => {
+                let context = await ensureKey(pristineContext, this.platform);
+                if (this.autoEnvAttributes === AutoEnvAttributes.Enabled) {
+                    context = await addAutoEnv(context, this.platform, this._config);
+                }
+                const checkedContext = Context.fromLDContext(context);
+                if (checkedContext.valid) {
+                    const afterIdentify = this._hookRunner.identify(context, identifyOptions?.timeout);
+                    return {
+                        context,
+                        checkedContext,
+                        afterIdentify,
+                    };
+                }
+                return {
+                    context,
+                    checkedContext,
+                };
+            },
+            execute: async (beforeResult) => {
+                const { context, checkedContext } = beforeResult;
+                if (!checkedContext.valid) {
+                    const error = new Error('Context was unspecified or had no key');
+                    this.emitter.emit('error', context, error);
+                    return Promise.reject(error);
+                }
+                this._uncheckedContext = context;
+                this._checkedContext = checkedContext;
+                this._eventProcessor?.sendEvent(this._eventFactoryDefault.identifyEvent(this._checkedContext));
+                const { identifyPromise, identifyResolve, identifyReject } = this._createIdentifyPromise();
+                this.logger.debug(`Identifying ${JSON.stringify(this._checkedContext)}`);
+                await this.dataManager.identify(identifyResolve, identifyReject, checkedContext, identifyOptions);
+                return identifyPromise;
+            },
+            after: async (res, beforeResult) => {
+                if (res.status === 'complete') {
+                    beforeResult?.afterIdentify?.({ status: 'completed' });
+                }
+                else if (res.status === 'shed') {
+                    beforeResult?.afterIdentify?.({ status: 'shed' });
+                }
+                else if (res.status === 'error') {
+                    beforeResult?.afterIdentify?.({ status: 'error' });
+                }
+            },
+        }, identifyOptions?.sheddable ?? false)
+            .then((res) => {
+            if (res.status === 'error') {
+                return { status: 'error', error: res.error };
+            }
+            if (res.status === 'shed') {
+                return { status: 'shed' };
+            }
+            return { status: 'completed' };
+        });
+        if (noTimeout) {
+            return callSitePromise;
+        }
+        const timeoutPromise = new Promise((resolve) => {
+            setTimeout(() => {
+                resolve({ status: 'timeout', timeout: identifyTimeout });
+            }, identifyTimeout * 1000);
         });
+        return Promise.race([callSitePromise, timeoutPromise]);
     }
     on(eventName, listener) {
         this.emitter.on(eventName, listener);