@launchdarkly/js-client-sdk-common 1.9.0 → 1.9.1-beta.1

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { TypeValidators, createSafeLogger, ServiceEndpoints, ApplicationTags, OptionMessages, NumberWithMinimum, SafeLogger, internal, deepCompact, clone, secondsToMillis, ClientContext, fastDeepEqual, defaultHeaders, Context, timedPromise, AutoEnvAttributes, LDClientError, getPollingUri, 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, timedPromise, 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 };
@@ -14,6 +14,72 @@ var DataSourceState;
     // NetworkUnavailable,
 })(DataSourceState || (DataSourceState = {}));
 
+// eslint-disable-next-line max-classes-per-file
+function isOk(status) {
+    return status >= 200 && status <= 299;
+}
+class LDRequestError extends Error {
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = 'LaunchDarklyRequestError';
+    }
+}
+/**
+ * Note: The requestor is implemented independently from polling such that it can be used to
+ * make a one-off request.
+ */
+class Requestor {
+    constructor(_requests, _uri, _headers, _method, _body) {
+        this._requests = _requests;
+        this._uri = _uri;
+        this._headers = _headers;
+        this._method = _method;
+        this._body = _body;
+    }
+    async requestPayload() {
+        let status;
+        try {
+            const res = await this._requests.fetch(this._uri, {
+                method: this._method,
+                headers: this._headers,
+                body: this._body,
+            });
+            if (isOk(res.status)) {
+                return await res.text();
+            }
+            // Assigning so it can be thrown after the try/catch.
+            status = res.status;
+        }
+        catch (err) {
+            throw new LDRequestError(err?.message);
+        }
+        throw new LDRequestError(`Unexpected status code: ${status}`, status);
+    }
+}
+function makeRequestor(plainContextString, serviceEndpoints, paths, requests, encoding, baseHeaders, baseQueryParams, withReasons, useReport, secureModeHash) {
+    let body;
+    let method = 'GET';
+    const headers = { ...baseHeaders };
+    if (useReport) {
+        method = 'REPORT';
+        headers['content-type'] = 'application/json';
+        body = plainContextString; // context is in body for REPORT
+    }
+    const path = useReport
+        ? paths.pathReport(encoding, plainContextString)
+        : paths.pathGet(encoding, plainContextString);
+    const parameters = [...(baseQueryParams ?? [])];
+    if (withReasons) {
+        parameters.push({ key: 'withReasons', value: 'true' });
+    }
+    if (secureModeHash) {
+        parameters.push({ key: 'h', value: secureModeHash });
+    }
+    const uri = getPollingUri(serviceEndpoints, path, parameters);
+    return new Requestor(requests, uri, headers, method, body);
+}
+
 // eslint-disable-next-line max-classes-per-file
 const validators = {
     logger: TypeValidators.Object,
@@ -38,6 +104,7 @@ const validators = {
     wrapperVersion: TypeValidators.String,
     payloadFilterKey: TypeValidators.stringMatchingRegex(/^[a-zA-Z0-9](\w|\.|-)*$/),
     hooks: TypeValidators.createTypeArray('Hook[]', {}),
+    inspectors: TypeValidators.createTypeArray('LDInspection', {}),
 };
 
 const DEFAULT_POLLING_INTERVAL = 60 * 5;
@@ -53,8 +120,13 @@ function ensureSafeLogger(logger) {
 class ConfigurationImpl {
     constructor(pristineOptions = {}, internalOptions = {}) {
         this.logger = createSafeLogger();
+        // Naming conventions is not followed for these lines because the config validation
+        // accesses members based on the keys of the options. (sdk-763)
+        // eslint-disable-next-line @typescript-eslint/naming-convention
         this.baseUri = DEFAULT_POLLING;
+        // eslint-disable-next-line @typescript-eslint/naming-convention
         this.eventsUri = ServiceEndpoints.DEFAULT_EVENTS;
+        // eslint-disable-next-line @typescript-eslint/naming-convention
         this.streamUri = DEFAULT_STREAM;
         this.maxCachedContexts = 5;
         this.capacity = 100;
@@ -71,8 +143,9 @@ class ConfigurationImpl {
         this.privateAttributes = [];
         this.pollInterval = DEFAULT_POLLING_INTERVAL;
         this.hooks = [];
+        this.inspectors = [];
         this.logger = ensureSafeLogger(pristineOptions.logger);
-        const errors = this.validateTypesAndNames(pristineOptions);
+        const errors = this._validateTypesAndNames(pristineOptions);
         errors.forEach((e) => this.logger.warn(e));
         this.serviceEndpoints = new ServiceEndpoints(this.streamUri, this.baseUri, this.eventsUri, internalOptions.analyticsEventPath, internalOptions.diagnosticEventPath, internalOptions.includeAuthorizationHeader, pristineOptions.payloadFilterKey);
         this.useReport = pristineOptions.useReport ?? false;
@@ -80,7 +153,7 @@ class ConfigurationImpl {
         this.userAgentHeaderName = internalOptions.userAgentHeaderName ?? 'user-agent';
         this.trackEventModifier = internalOptions.trackEventModifier ?? ((event) => event);
     }
-    validateTypesAndNames(pristineOptions) {
+    _validateTypesAndNames(pristineOptions) {
         const errors = [];
         Object.entries(pristineOptions).forEach(([k, v]) => {
             const validator = validators[k];
@@ -388,11 +461,12 @@ function createErrorEvaluationDetail(errorKind, def) {
     };
 }
 function createSuccessEvaluationDetail(value, variationIndex, reason) {
-    return {
+    const res = {
         value,
         variationIndex: variationIndex ?? null,
         reason: reason ?? null,
     };
+    return res;
 }
 
 const createEventProcessor = (clientSideID, config, platform, baseHeaders, diagnosticsManager) => {
@@ -490,23 +564,23 @@ class ContextIndex {
  * then persists changes after the updater has completed.
  */
 class FlagPersistence {
-    constructor(platform, environmentNamespace, maxCachedContexts, flagStore, flagUpdater, logger, timeStamper = () => Date.now()) {
-        this.platform = platform;
-        this.environmentNamespace = environmentNamespace;
-        this.maxCachedContexts = maxCachedContexts;
-        this.flagStore = flagStore;
-        this.flagUpdater = flagUpdater;
-        this.logger = logger;
-        this.timeStamper = timeStamper;
-        this.indexKeyPromise = namespaceForContextIndex(this.environmentNamespace);
+    constructor(_platform, _environmentNamespace, _maxCachedContexts, _flagStore, _flagUpdater, _logger, _timeStamper = () => Date.now()) {
+        this._platform = _platform;
+        this._environmentNamespace = _environmentNamespace;
+        this._maxCachedContexts = _maxCachedContexts;
+        this._flagStore = _flagStore;
+        this._flagUpdater = _flagUpdater;
+        this._logger = _logger;
+        this._timeStamper = _timeStamper;
+        this._indexKeyPromise = namespaceForContextIndex(this._environmentNamespace);
     }
     /**
      * Inits flag persistence for the provided context with the provided flags.  This will result
      * in the underlying {@link FlagUpdater} switching its active context.
      */
     async init(context, newFlags) {
-        this.flagUpdater.init(context, newFlags);
-        await this.storeCache(context);
+        this._flagUpdater.init(context, newFlags);
+        await this._storeCache(context);
     }
     /**
      * Upserts a flag into the {@link FlagUpdater} and stores that to persistence if the upsert
@@ -514,8 +588,8 @@ class FlagPersistence {
      * the active context.
      */
     async upsert(context, key, item) {
-        if (this.flagUpdater.upsert(context, key, item)) {
-            await this.storeCache(context);
+        if (this._flagUpdater.upsert(context, key, item)) {
+            await this._storeCache(context);
             return true;
         }
         return false;
@@ -525,19 +599,19 @@ class FlagPersistence {
      * {@link FlagUpdater} this {@link FlagPersistence} was constructed with.
      */
     async loadCached(context) {
-        const storageKey = await namespaceForContextData(this.platform.crypto, this.environmentNamespace, context);
-        let flagsJson = await this.platform.storage?.get(storageKey);
+        const storageKey = await namespaceForContextData(this._platform.crypto, this._environmentNamespace, context);
+        let flagsJson = await this._platform.storage?.get(storageKey);
         if (flagsJson === null || flagsJson === undefined) {
             // Fallback: in version <10.3.1 flag data was stored under the canonical key, check
             // to see if data is present and migrate the data if present.
-            flagsJson = await this.platform.storage?.get(context.canonicalKey);
+            flagsJson = await this._platform.storage?.get(context.canonicalKey);
             if (flagsJson === null || flagsJson === undefined) {
                 // return false indicating cache did not load if flag json is still absent
                 return false;
             }
             // migrate data from version <10.3.1 and cleanup data that was under canonical key
-            await this.platform.storage?.set(storageKey, flagsJson);
-            await this.platform.storage?.clear(context.canonicalKey);
+            await this._platform.storage?.set(storageKey, flagsJson);
+            await this._platform.storage?.clear(context.canonicalKey);
         }
         try {
             const flags = JSON.parse(flagsJson);
@@ -546,43 +620,43 @@ class FlagPersistence {
                 acc[key] = { version: flag.version, flag };
                 return acc;
             }, {});
-            this.flagUpdater.initCached(context, descriptors);
-            this.logger.debug('Loaded cached flag evaluations from persistent storage');
+            this._flagUpdater.initCached(context, descriptors);
+            this._logger.debug('Loaded cached flag evaluations from persistent storage');
             return true;
         }
         catch (e) {
-            this.logger.warn(`Could not load cached flag evaluations from persistent storage: ${e.message}`);
+            this._logger.warn(`Could not load cached flag evaluations from persistent storage: ${e.message}`);
             return false;
         }
     }
-    async loadIndex() {
-        if (this.contextIndex !== undefined) {
-            return this.contextIndex;
+    async _loadIndex() {
+        if (this._contextIndex !== undefined) {
+            return this._contextIndex;
         }
-        const json = await this.platform.storage?.get(await this.indexKeyPromise);
+        const json = await this._platform.storage?.get(await this._indexKeyPromise);
         if (!json) {
-            this.contextIndex = new ContextIndex();
-            return this.contextIndex;
+            this._contextIndex = new ContextIndex();
+            return this._contextIndex;
         }
         try {
-            this.contextIndex = ContextIndex.fromJson(json);
-            this.logger.debug('Loaded context index from persistent storage');
+            this._contextIndex = ContextIndex.fromJson(json);
+            this._logger.debug('Loaded context index from persistent storage');
         }
         catch (e) {
-            this.logger.warn(`Could not load index from persistent storage: ${e.message}`);
-            this.contextIndex = new ContextIndex();
+            this._logger.warn(`Could not load index from persistent storage: ${e.message}`);
+            this._contextIndex = new ContextIndex();
         }
-        return this.contextIndex;
-    }
-    async storeCache(context) {
-        const index = await this.loadIndex();
-        const storageKey = await namespaceForContextData(this.platform.crypto, this.environmentNamespace, context);
-        index.notice(storageKey, this.timeStamper());
-        const pruned = index.prune(this.maxCachedContexts);
-        await Promise.all(pruned.map(async (it) => this.platform.storage?.clear(it.id)));
+        return this._contextIndex;
+    }
+    async _storeCache(context) {
+        const index = await this._loadIndex();
+        const storageKey = await namespaceForContextData(this._platform.crypto, this._environmentNamespace, context);
+        index.notice(storageKey, this._timeStamper());
+        const pruned = index.prune(this._maxCachedContexts);
+        await Promise.all(pruned.map(async (it) => this._platform.storage?.clear(it.id)));
         // store index
-        await this.platform.storage?.set(await this.indexKeyPromise, index.toJson());
-        const allFlags = this.flagStore.getAll();
+        await this._platform.storage?.set(await this._indexKeyPromise, index.toJson());
+        const allFlags = this._flagStore.getAll();
         // mapping item descriptors to flags
         const flags = Object.entries(allFlags).reduce((acc, [key, descriptor]) => {
             if (descriptor.flag !== null && descriptor.flag !== undefined) {
@@ -592,7 +666,7 @@ class FlagPersistence {
         }, {});
         const jsonAll = JSON.stringify(flags);
         // store flag data
-        await this.platform.storage?.set(storageKey, jsonAll);
+        await this._platform.storage?.set(storageKey, jsonAll);
     }
 }
 
@@ -601,25 +675,25 @@ class FlagPersistence {
  */
 class DefaultFlagStore {
     constructor() {
-        this.flags = {};
+        this._flags = {};
     }
     init(newFlags) {
-        this.flags = Object.entries(newFlags).reduce((acc, [key, flag]) => {
+        this._flags = Object.entries(newFlags).reduce((acc, [key, flag]) => {
             acc[key] = flag;
             return acc;
         }, {});
     }
     insertOrUpdate(key, update) {
-        this.flags[key] = update;
+        this._flags[key] = update;
     }
     get(key) {
-        if (Object.prototype.hasOwnProperty.call(this.flags, key)) {
-            return this.flags[key];
+        if (Object.prototype.hasOwnProperty.call(this._flags, key)) {
+            return this._flags[key];
         }
         return undefined;
     }
     getAll() {
-        return this.flags;
+        return this._flags;
     }
 }
 
@@ -648,19 +722,19 @@ function calculateChangedKeys(existingObject, newObject) {
  */
 class FlagUpdater {
     constructor(flagStore, logger) {
-        this.changeCallbacks = new Array();
-        this.flagStore = flagStore;
-        this.logger = logger;
+        this._changeCallbacks = new Array();
+        this._flagStore = flagStore;
+        this._logger = logger;
     }
     init(context, newFlags) {
-        this.activeContextKey = context.canonicalKey;
-        const oldFlags = this.flagStore.getAll();
-        this.flagStore.init(newFlags);
+        this._activeContextKey = context.canonicalKey;
+        const oldFlags = this._flagStore.getAll();
+        this._flagStore.init(newFlags);
         const changed = calculateChangedKeys(oldFlags, newFlags);
         if (changed.length > 0) {
-            this.changeCallbacks.forEach((callback) => {
+            this._changeCallbacks.forEach((callback) => {
                 try {
-                    callback(context, changed);
+                    callback(context, changed, 'init');
                 }
                 catch (err) {
                     /* intentionally empty */
@@ -669,25 +743,25 @@ class FlagUpdater {
         }
     }
     initCached(context, newFlags) {
-        if (this.activeContextKey === context.canonicalKey) {
+        if (this._activeContextKey === context.canonicalKey) {
             return;
         }
         this.init(context, newFlags);
     }
     upsert(context, key, item) {
-        if (this.activeContextKey !== context.canonicalKey) {
-            this.logger.warn('Received an update for an inactive context.');
+        if (this._activeContextKey !== context.canonicalKey) {
+            this._logger.warn('Received an update for an inactive context.');
             return false;
         }
-        const currentValue = this.flagStore.get(key);
+        const currentValue = this._flagStore.get(key);
         if (currentValue !== undefined && currentValue.version >= item.version) {
             // this is an out of order update that can be ignored
             return false;
         }
-        this.flagStore.insertOrUpdate(key, item);
-        this.changeCallbacks.forEach((callback) => {
+        this._flagStore.insertOrUpdate(key, item);
+        this._changeCallbacks.forEach((callback) => {
             try {
-                callback(context, [key]);
+                callback(context, [key], 'patch');
             }
             catch (err) {
                 /* intentionally empty */
@@ -696,12 +770,12 @@ class FlagUpdater {
         return true;
     }
     on(callback) {
-        this.changeCallbacks.push(callback);
+        this._changeCallbacks.push(callback);
     }
     off(callback) {
-        const index = this.changeCallbacks.indexOf(callback);
+        const index = this._changeCallbacks.indexOf(callback);
         if (index > -1) {
-            this.changeCallbacks.splice(index, 1);
+            this._changeCallbacks.splice(index, 1);
         }
     }
 }
@@ -715,40 +789,39 @@ class DefaultFlagManager {
      * @param timeStamper exists for testing purposes
      */
     constructor(platform, sdkKey, maxCachedContexts, logger, timeStamper = () => Date.now()) {
-        this.timeStamper = timeStamper;
-        this.flagStore = new DefaultFlagStore();
-        this.flagUpdater = new FlagUpdater(this.flagStore, logger);
-        this.flagPersistencePromise = this.initPersistence(platform, sdkKey, maxCachedContexts, logger, timeStamper);
+        this._flagStore = new DefaultFlagStore();
+        this._flagUpdater = new FlagUpdater(this._flagStore, logger);
+        this._flagPersistencePromise = this._initPersistence(platform, sdkKey, maxCachedContexts, logger, timeStamper);
     }
-    async initPersistence(platform, sdkKey, maxCachedContexts, logger, timeStamper = () => Date.now()) {
+    async _initPersistence(platform, sdkKey, maxCachedContexts, logger, timeStamper = () => Date.now()) {
         const environmentNamespace = await namespaceForEnvironment(platform.crypto, sdkKey);
-        return new FlagPersistence(platform, environmentNamespace, maxCachedContexts, this.flagStore, this.flagUpdater, logger, timeStamper);
+        return new FlagPersistence(platform, environmentNamespace, maxCachedContexts, this._flagStore, this._flagUpdater, logger, timeStamper);
     }
     get(key) {
-        return this.flagStore.get(key);
+        return this._flagStore.get(key);
     }
     getAll() {
-        return this.flagStore.getAll();
+        return this._flagStore.getAll();
     }
     setBootstrap(context, newFlags) {
         // Bypasses the persistence as we do not want to put these flags into any cache.
         // Generally speaking persistence likely *SHOULD* be disabled when using bootstrap.
-        this.flagUpdater.init(context, newFlags);
+        this._flagUpdater.init(context, newFlags);
     }
     async init(context, newFlags) {
-        return (await this.flagPersistencePromise).init(context, newFlags);
+        return (await this._flagPersistencePromise).init(context, newFlags);
     }
     async upsert(context, key, item) {
-        return (await this.flagPersistencePromise).upsert(context, key, item);
+        return (await this._flagPersistencePromise).upsert(context, key, item);
     }
     async loadCached(context) {
-        return (await this.flagPersistencePromise).loadCached(context);
+        return (await this._flagPersistencePromise).loadCached(context);
     }
     on(callback) {
-        this.flagUpdater.on(callback);
+        this._flagUpdater.on(callback);
     }
     off(callback) {
-        this.flagUpdater.off(callback);
+        this._flagUpdater.off(callback);
     }
 }
 
@@ -798,39 +871,186 @@ function executeAfterIdentify(logger, hooks, hookContext, updatedData, result) {
     }
 }
 class HookRunner {
-    constructor(logger, initialHooks) {
-        this.logger = logger;
-        this.hooks = [];
-        this.hooks.push(...initialHooks);
+    constructor(_logger, initialHooks) {
+        this._logger = _logger;
+        this._hooks = [];
+        this._hooks.push(...initialHooks);
     }
     withEvaluation(key, context, defaultValue, method) {
-        if (this.hooks.length === 0) {
+        if (this._hooks.length === 0) {
             return method();
         }
-        const hooks = [...this.hooks];
+        const hooks = [...this._hooks];
         const hookContext = {
             flagKey: key,
             context,
             defaultValue,
         };
-        const hookData = executeBeforeEvaluation(this.logger, hooks, hookContext);
+        const hookData = executeBeforeEvaluation(this._logger, hooks, hookContext);
         const result = method();
-        executeAfterEvaluation(this.logger, hooks, hookContext, hookData, result);
+        executeAfterEvaluation(this._logger, hooks, hookContext, hookData, result);
         return result;
     }
     identify(context, timeout) {
-        const hooks = [...this.hooks];
+        const hooks = [...this._hooks];
         const hookContext = {
             context,
             timeout,
         };
-        const hookData = executeBeforeIdentify(this.logger, hooks, hookContext);
+        const hookData = executeBeforeIdentify(this._logger, hooks, hookContext);
         return (result) => {
-            executeAfterIdentify(this.logger, hooks, hookContext, hookData, result);
+            executeAfterIdentify(this._logger, hooks, hookContext, hookData, result);
         };
     }
     addHook(hook) {
-        this.hooks.push(hook);
+        this._hooks.push(hook);
+    }
+}
+
+function getInspectorHook(inspectorManager) {
+    return {
+        getMetadata() {
+            return {
+                name: 'LaunchDarkly-Inspector-Adapter',
+            };
+        },
+        afterEvaluation: (hookContext, data, detail) => {
+            inspectorManager.onFlagUsed(hookContext.flagKey, detail, hookContext.context);
+            return data;
+        },
+        afterIdentify(hookContext, data, _result) {
+            inspectorManager.onIdentityChanged(hookContext.context);
+            return data;
+        },
+    };
+}
+
+function invalidInspector(type, name) {
+    return `an inspector: "${name}" of an invalid type (${type}) was configured`;
+}
+function inspectorMethodError(type, name) {
+    return `an inspector: "${name}" of type: "${type}" generated an exception`;
+}
+
+/**
+ * Wrap an inspector ensuring that calling its methods are safe.
+ * @param inspector Inspector to wrap.
+ */
+function createSafeInspector(inspector, logger) {
+    let errorLogged = false;
+    const wrapper = {
+        method: (...args) => {
+            try {
+                // We are proxying arguments here to the underlying method. Typescript doesn't care
+                // for this as it cannot validate the parameters are correct, but we are also the caller
+                // in this case and will dispatch things with the correct arguments. The dispatch to this
+                // will itself happen with a type guard.
+                // @ts-ignore
+                inspector.method(...args);
+            }
+            catch {
+                // If something goes wrong in an inspector we want to log that something
+                // went wrong. We don't want to flood the logs, so we only log something
+                // the first time that something goes wrong.
+                // We do not include the exception in the log, because we do not know what
+                // kind of data it may contain.
+                if (!errorLogged) {
+                    errorLogged = true;
+                    logger.warn(inspectorMethodError(wrapper.type, wrapper.name));
+                }
+                // Prevent errors.
+            }
+        },
+        type: inspector.type,
+        name: inspector.name,
+        synchronous: inspector.synchronous,
+    };
+    return wrapper;
+}
+
+const FLAG_USED_TYPE = 'flag-used';
+const FLAG_DETAILS_CHANGED_TYPE = 'flag-details-changed';
+const FLAG_DETAIL_CHANGED_TYPE = 'flag-detail-changed';
+const IDENTITY_CHANGED_TYPE = 'client-identity-changed';
+const VALID__TYPES = [
+    FLAG_USED_TYPE,
+    FLAG_DETAILS_CHANGED_TYPE,
+    FLAG_DETAIL_CHANGED_TYPE,
+    IDENTITY_CHANGED_TYPE,
+];
+function validateInspector(inspector, logger) {
+    const valid = VALID__TYPES.includes(inspector.type) &&
+        inspector.method &&
+        typeof inspector.method === 'function';
+    if (!valid) {
+        logger.warn(invalidInspector(inspector.type, inspector.name));
+    }
+    return valid;
+}
+/**
+ * Manages dispatching of inspection data to registered inspectors.
+ */
+class InspectorManager {
+    constructor(inspectors, logger) {
+        this._safeInspectors = [];
+        const validInspectors = inspectors.filter((inspector) => validateInspector(inspector, logger));
+        this._safeInspectors = validInspectors.map((inspector) => createSafeInspector(inspector, logger));
+    }
+    hasInspectors() {
+        return this._safeInspectors.length !== 0;
+    }
+    /**
+     * Notify registered inspectors of a flag being used.
+     *
+     * @param flagKey The key for the flag.
+     * @param detail The LDEvaluationDetail for the flag.
+     * @param context The LDContext for the flag.
+     */
+    onFlagUsed(flagKey, detail, context) {
+        this._safeInspectors.forEach((inspector) => {
+            if (inspector.type === FLAG_USED_TYPE) {
+                inspector.method(flagKey, detail, context);
+            }
+        });
+    }
+    /**
+     * Notify registered inspectors that the flags have been replaced.
+     *
+     * @param flags The current flags as a Record<string, LDEvaluationDetail>.
+     */
+    onFlagsChanged(flags) {
+        this._safeInspectors.forEach((inspector) => {
+            if (inspector.type === FLAG_DETAILS_CHANGED_TYPE) {
+                inspector.method(flags);
+            }
+        });
+    }
+    /**
+     * Notify registered inspectors that a flag value has changed.
+     *
+     * @param flagKey The key for the flag that changed.
+     * @param flag An `LDEvaluationDetail` for the flag.
+     */
+    onFlagChanged(flagKey, flag) {
+        this._safeInspectors.forEach((inspector) => {
+            if (inspector.type === FLAG_DETAIL_CHANGED_TYPE) {
+                inspector.method(flagKey, flag);
+            }
+        });
+    }
+    /**
+     * Notify the registered inspectors that the context identity has changed.
+     *
+     * The notification itself will be dispatched asynchronously.
+     *
+     * @param context The `LDContext` which is now identified.
+     */
+    onIdentityChanged(context) {
+        this._safeInspectors.forEach((inspector) => {
+            if (inspector.type === IDENTITY_CHANGED_TYPE) {
+                inspector.method(context);
+            }
+        });
     }
 }
 
@@ -841,16 +1061,16 @@ class HookRunner {
  * a system to allow listeners which have counts independent of the primary listener counts.
  */
 class LDEmitter {
-    constructor(logger) {
-        this.logger = logger;
-        this.listeners = new Map();
+    constructor(_logger) {
+        this._logger = _logger;
+        this._listeners = new Map();
     }
     on(name, listener) {
-        if (!this.listeners.has(name)) {
-            this.listeners.set(name, [listener]);
+        if (!this._listeners.has(name)) {
+            this._listeners.set(name, [listener]);
         }
         else {
-            this.listeners.get(name)?.push(listener);
+            this._listeners.get(name)?.push(listener);
         }
     }
     /**
@@ -860,7 +1080,7 @@ class LDEmitter {
      * @param listener Optional. If unspecified, all listeners for the event will be removed.
      */
     off(name, listener) {
-        const existingListeners = this.listeners.get(name);
+        const existingListeners = this._listeners.get(name);
         if (!existingListeners) {
             return;
         }
@@ -868,33 +1088,33 @@ class LDEmitter {
             // remove from internal cache
             const updated = existingListeners.filter((fn) => fn !== listener);
             if (updated.length === 0) {
-                this.listeners.delete(name);
+                this._listeners.delete(name);
             }
             else {
-                this.listeners.set(name, updated);
+                this._listeners.set(name, updated);
             }
             return;
         }
         // listener was not specified, so remove them all for that event
-        this.listeners.delete(name);
+        this._listeners.delete(name);
     }
-    invokeListener(listener, name, ...detail) {
+    _invokeListener(listener, name, ...detail) {
         try {
             listener(...detail);
         }
         catch (err) {
-            this.logger?.error(`Encountered error invoking handler for "${name}", detail: "${err}"`);
+            this._logger?.error(`Encountered error invoking handler for "${name}", detail: "${err}"`);
         }
     }
     emit(name, ...detail) {
-        const listeners = this.listeners.get(name);
-        listeners?.forEach((listener) => this.invokeListener(listener, name, ...detail));
+        const listeners = this._listeners.get(name);
+        listeners?.forEach((listener) => this._invokeListener(listener, name, ...detail));
     }
     eventNames() {
-        return [...this.listeners.keys()];
+        return [...this._listeners.keys()];
     }
     listenerCount(name) {
-        return this.listeners.get(name)?.length ?? 0;
+        return this._listeners.get(name)?.length ?? 0;
     }
 }
 
@@ -907,40 +1127,45 @@ class LDClientImpl {
         this.sdkKey = sdkKey;
         this.autoEnvAttributes = autoEnvAttributes;
         this.platform = platform;
-        this.identifyTimeout = 5;
-        this.highTimeoutThreshold = 15;
-        this.eventFactoryDefault = new EventFactory(false);
-        this.eventFactoryWithReasons = new EventFactory(true);
-        this.eventSendingEnabled = false;
+        this._identifyTimeout = 5;
+        this._highTimeoutThreshold = 15;
+        this._eventFactoryDefault = new EventFactory(false);
+        this._eventFactoryWithReasons = new EventFactory(true);
+        this._eventSendingEnabled = false;
         if (!sdkKey) {
             throw new Error('You must configure the client with a client-side SDK key');
         }
         if (!platform.encoding) {
             throw new Error('Platform must implement Encoding because btoa is required.');
         }
-        this.config = new ConfigurationImpl(options, internalOptions);
-        this.logger = this.config.logger;
-        this.baseHeaders = defaultHeaders(this.sdkKey, this.platform.info, this.config.tags, this.config.serviceEndpoints.includeAuthorizationHeader, this.config.userAgentHeaderName);
-        this.flagManager = new DefaultFlagManager(this.platform, sdkKey, this.config.maxCachedContexts, this.config.logger);
-        this.diagnosticsManager = createDiagnosticsManager(sdkKey, this.config, platform);
-        this.eventProcessor = createEventProcessor(sdkKey, this.config, platform, this.baseHeaders, this.diagnosticsManager);
+        this._config = new ConfigurationImpl(options, internalOptions);
+        this.logger = this._config.logger;
+        this._baseHeaders = defaultHeaders(this.sdkKey, this.platform.info, this._config.tags, this._config.serviceEndpoints.includeAuthorizationHeader, this._config.userAgentHeaderName);
+        this._flagManager = new DefaultFlagManager(this.platform, sdkKey, this._config.maxCachedContexts, this._config.logger);
+        this._diagnosticsManager = createDiagnosticsManager(sdkKey, this._config, platform);
+        this._eventProcessor = createEventProcessor(sdkKey, this._config, platform, this._baseHeaders, this._diagnosticsManager);
         this.emitter = new LDEmitter();
         this.emitter.on('error', (c, err) => {
             this.logger.error(`error: ${err}, context: ${JSON.stringify(c)}`);
         });
-        this.flagManager.on((context, flagKeys) => {
+        this._flagManager.on((context, flagKeys, type) => {
+            this._handleInspectionChanged(flagKeys, type);
             const ldContext = Context.toLDContext(context);
             this.emitter.emit('change', ldContext, flagKeys);
             flagKeys.forEach((it) => {
                 this.emitter.emit(`change:${it}`, ldContext);
             });
         });
-        this.dataManager = dataManagerFactory(this.flagManager, this.config, this.baseHeaders, this.emitter, this.diagnosticsManager);
-        this.hookRunner = new HookRunner(this.logger, this.config.hooks);
+        this.dataManager = dataManagerFactory(this._flagManager, this._config, this._baseHeaders, this.emitter, this._diagnosticsManager);
+        this._hookRunner = new HookRunner(this.logger, this._config.hooks);
+        this._inspectorManager = new InspectorManager(this._config.inspectors, this.logger);
+        if (this._inspectorManager.hasInspectors()) {
+            this._hookRunner.addHook(getInspectorHook(this._inspectorManager));
+        }
     }
     allFlags() {
         // extracting all flag values
-        const result = Object.entries(this.flagManager.getAll()).reduce((acc, [key, descriptor]) => {
+        const result = Object.entries(this._flagManager.getAll()).reduce((acc, [key, descriptor]) => {
             if (descriptor.flag !== null && descriptor.flag !== undefined && !descriptor.flag.deleted) {
                 acc[key] = descriptor.flag.value;
             }
@@ -950,13 +1175,13 @@ class LDClientImpl {
     }
     async close() {
         await this.flush();
-        this.eventProcessor?.close();
-        this.updateProcessor?.close();
+        this._eventProcessor?.close();
+        this._updateProcessor?.close();
         this.logger.debug('Closed event processor and data source.');
     }
     async flush() {
         try {
-            await this.eventProcessor?.flush();
+            await this._eventProcessor?.flush();
             this.logger.debug('Successfully flushed event processor.');
         }
         catch (e) {
@@ -971,12 +1196,12 @@ class LDClientImpl {
         // 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.
-        return this.uncheckedContext ? clone(this.uncheckedContext) : undefined;
+        return this._uncheckedContext ? clone(this._uncheckedContext) : undefined;
     }
     getInternalContext() {
-        return this.checkedContext;
+        return this._checkedContext;
     }
-    createIdentifyPromise(timeout) {
+    _createIdentifyPromise(timeout) {
         let res;
         let rej;
         const slow = new Promise((resolve, reject) => {
@@ -1009,16 +1234,16 @@ class LDClientImpl {
      */
     async identify(pristineContext, identifyOptions) {
         if (identifyOptions?.timeout) {
-            this.identifyTimeout = identifyOptions.timeout;
+            this._identifyTimeout = identifyOptions.timeout;
         }
-        if (this.identifyTimeout > this.highTimeoutThreshold) {
+        if (this._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.`);
+                `${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);
+            context = await addAutoEnv(context, this.platform, this._config);
         }
         const checkedContext = Context.fromLDContext(context);
         if (!checkedContext.valid) {
@@ -1026,12 +1251,12 @@ class LDClientImpl {
             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.identifyTimeout);
-        this.logger.debug(`Identifying ${JSON.stringify(this.checkedContext)}`);
-        const afterIdentify = this.hookRunner.identify(context, identifyOptions?.timeout);
+        this._uncheckedContext = context;
+        this._checkedContext = checkedContext;
+        this._eventProcessor?.sendEvent(this._eventFactoryDefault.identifyEvent(this._checkedContext));
+        const { identifyPromise, identifyResolve, identifyReject } = this._createIdentifyPromise(this._identifyTimeout);
+        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' });
@@ -1048,38 +1273,38 @@ class LDClientImpl {
         this.emitter.off(eventName, listener);
     }
     track(key, data, metricValue) {
-        if (!this.checkedContext || !this.checkedContext.valid) {
-            this.logger.warn(ClientMessages.missingContextKeyNoEvent);
+        if (!this._checkedContext || !this._checkedContext.valid) {
+            this.logger.warn(ClientMessages.MissingContextKeyNoEvent);
             return;
         }
         // 0 is valid, so do not truthy check the metric value
         if (metricValue !== undefined && !TypeValidators.Number.is(metricValue)) {
             this.logger?.warn(ClientMessages.invalidMetricValue(typeof metricValue));
         }
-        this.eventProcessor?.sendEvent(this.config.trackEventModifier(this.eventFactoryDefault.customEvent(key, this.checkedContext, data, metricValue)));
+        this._eventProcessor?.sendEvent(this._config.trackEventModifier(this._eventFactoryDefault.customEvent(key, this._checkedContext, data, metricValue)));
     }
-    variationInternal(flagKey, defaultValue, eventFactory, typeChecker) {
-        if (!this.uncheckedContext) {
-            this.logger.debug(ClientMessages.missingContextKeyNoEvent);
+    _variationInternal(flagKey, defaultValue, eventFactory, typeChecker) {
+        if (!this._uncheckedContext) {
+            this.logger.debug(ClientMessages.MissingContextKeyNoEvent);
             return createErrorEvaluationDetail(ErrorKinds.UserNotSpecified, defaultValue);
         }
-        const evalContext = Context.fromLDContext(this.uncheckedContext);
-        const foundItem = this.flagManager.get(flagKey);
+        const evalContext = Context.fromLDContext(this._uncheckedContext);
+        const foundItem = this._flagManager.get(flagKey);
         if (foundItem === undefined || foundItem.flag.deleted) {
             const defVal = defaultValue ?? null;
             const error = new LDClientError(`Unknown feature flag "${flagKey}"; returning default value ${defVal}.`);
-            this.emitter.emit('error', this.uncheckedContext, error);
-            this.eventProcessor?.sendEvent(this.eventFactoryDefault.unknownFlagEvent(flagKey, defVal, evalContext));
+            this.emitter.emit('error', this._uncheckedContext, error);
+            this._eventProcessor?.sendEvent(this._eventFactoryDefault.unknownFlagEvent(flagKey, defVal, evalContext));
             return createErrorEvaluationDetail(ErrorKinds.FlagNotFound, defaultValue);
         }
-        const { reason, value, variation } = foundItem.flag;
+        const { reason, value, variation, prerequisites } = foundItem.flag;
         if (typeChecker) {
             const [matched, type] = typeChecker(value);
             if (!matched) {
-                this.eventProcessor?.sendEvent(eventFactory.evalEventClient(flagKey, defaultValue, // track default value on type errors
+                this._eventProcessor?.sendEvent(eventFactory.evalEventClient(flagKey, defaultValue, // track default value on type errors
                 defaultValue, foundItem.flag, evalContext, reason));
                 const error = new LDClientError(`Wrong type "${type}" for feature flag "${flagKey}"; returning default value`);
-                this.emitter.emit('error', this.uncheckedContext, error);
+                this.emitter.emit('error', this._uncheckedContext, error);
                 return createErrorEvaluationDetail(ErrorKinds.WrongType, defaultValue);
             }
         }
@@ -1088,21 +1313,24 @@ class LDClientImpl {
             this.logger.debug('Result value is null. Providing default value.');
             successDetail.value = defaultValue;
         }
-        this.eventProcessor?.sendEvent(eventFactory.evalEventClient(flagKey, value, defaultValue, foundItem.flag, evalContext, reason));
+        prerequisites?.forEach((prereqKey) => {
+            this.variation(prereqKey, undefined);
+        });
+        this._eventProcessor?.sendEvent(eventFactory.evalEventClient(flagKey, value, defaultValue, foundItem.flag, evalContext, reason));
         return successDetail;
     }
     variation(flagKey, defaultValue) {
-        const { value } = this.hookRunner.withEvaluation(flagKey, this.uncheckedContext, defaultValue, () => this.variationInternal(flagKey, defaultValue, this.eventFactoryDefault));
+        const { value } = this._hookRunner.withEvaluation(flagKey, this._uncheckedContext, defaultValue, () => this._variationInternal(flagKey, defaultValue, this._eventFactoryDefault));
         return value;
     }
     variationDetail(flagKey, defaultValue) {
-        return this.hookRunner.withEvaluation(flagKey, this.uncheckedContext, defaultValue, () => this.variationInternal(flagKey, defaultValue, this.eventFactoryWithReasons));
+        return this._hookRunner.withEvaluation(flagKey, this._uncheckedContext, defaultValue, () => this._variationInternal(flagKey, defaultValue, this._eventFactoryWithReasons));
     }
-    typedEval(key, defaultValue, eventFactory, typeChecker) {
-        return this.hookRunner.withEvaluation(key, this.uncheckedContext, defaultValue, () => this.variationInternal(key, defaultValue, eventFactory, typeChecker));
+    _typedEval(key, defaultValue, eventFactory, typeChecker) {
+        return this._hookRunner.withEvaluation(key, this._uncheckedContext, defaultValue, () => this._variationInternal(key, defaultValue, eventFactory, typeChecker));
     }
     boolVariation(key, defaultValue) {
-        return this.typedEval(key, defaultValue, this.eventFactoryDefault, (value) => [
+        return this._typedEval(key, defaultValue, this._eventFactoryDefault, (value) => [
             TypeValidators.Boolean.is(value),
             TypeValidators.Boolean.getType(),
         ]).value;
@@ -1111,31 +1339,31 @@ class LDClientImpl {
         return this.variation(key, defaultValue);
     }
     numberVariation(key, defaultValue) {
-        return this.typedEval(key, defaultValue, this.eventFactoryDefault, (value) => [
+        return this._typedEval(key, defaultValue, this._eventFactoryDefault, (value) => [
             TypeValidators.Number.is(value),
             TypeValidators.Number.getType(),
         ]).value;
     }
     stringVariation(key, defaultValue) {
-        return this.typedEval(key, defaultValue, this.eventFactoryDefault, (value) => [
+        return this._typedEval(key, defaultValue, this._eventFactoryDefault, (value) => [
             TypeValidators.String.is(value),
             TypeValidators.String.getType(),
         ]).value;
     }
     boolVariationDetail(key, defaultValue) {
-        return this.typedEval(key, defaultValue, this.eventFactoryWithReasons, (value) => [
+        return this._typedEval(key, defaultValue, this._eventFactoryWithReasons, (value) => [
             TypeValidators.Boolean.is(value),
             TypeValidators.Boolean.getType(),
         ]);
     }
     numberVariationDetail(key, defaultValue) {
-        return this.typedEval(key, defaultValue, this.eventFactoryWithReasons, (value) => [
+        return this._typedEval(key, defaultValue, this._eventFactoryWithReasons, (value) => [
             TypeValidators.Number.is(value),
             TypeValidators.Number.getType(),
         ]);
     }
     stringVariationDetail(key, defaultValue) {
-        return this.typedEval(key, defaultValue, this.eventFactoryWithReasons, (value) => [
+        return this._typedEval(key, defaultValue, this._eventFactoryWithReasons, (value) => [
             TypeValidators.String.is(value),
             TypeValidators.String.getType(),
         ]);
@@ -1144,7 +1372,7 @@ class LDClientImpl {
         return this.variationDetail(key, defaultValue);
     }
     addHook(hook) {
-        this.hookRunner.addHook(hook);
+        this._hookRunner.addHook(hook);
     }
     /**
      * Enable/Disable event sending.
@@ -1152,13 +1380,13 @@ class LDClientImpl {
      * @param flush True to flush while disabling. Useful to flush on certain state transitions.
      */
     setEventSendingEnabled(enabled, flush) {
-        if (this.eventSendingEnabled === enabled) {
+        if (this._eventSendingEnabled === enabled) {
             return;
         }
-        this.eventSendingEnabled = enabled;
+        this._eventSendingEnabled = enabled;
         if (enabled) {
             this.logger.debug('Starting event processor');
-            this.eventProcessor?.start();
+            this._eventProcessor?.start();
         }
         else if (flush) {
             this.logger?.debug('Flushing event processor before disabling.');
@@ -1166,92 +1394,70 @@ class LDClientImpl {
             this.flush().then(() => {
                 // While waiting for the flush event sending could be re-enabled, in which case
                 // we do not want to close the event processor.
-                if (!this.eventSendingEnabled) {
+                if (!this._eventSendingEnabled) {
                     this.logger?.debug('Stopping event processor.');
-                    this.eventProcessor?.close();
+                    this._eventProcessor?.close();
                 }
             });
         }
         else {
             // Just disabled.
             this.logger?.debug('Stopping event processor.');
-            this.eventProcessor?.close();
+            this._eventProcessor?.close();
         }
     }
     sendEvent(event) {
-        this.eventProcessor?.sendEvent(event);
-    }
-}
-
-function isOk(status) {
-    return status >= 200 && status <= 299;
-}
-class LDRequestError extends Error {
-    constructor(message, status) {
-        super(message);
-        this.status = status;
-        this.name = 'LaunchDarklyRequestError';
+        this._eventProcessor?.sendEvent(event);
     }
-}
-/**
- * Note: The requestor is implemented independently from polling such that it can be used to
- * make a one-off request.
- */
-class Requestor {
-    constructor(requests, uri, headers, method, body) {
-        this.requests = requests;
-        this.uri = uri;
-        this.headers = headers;
-        this.method = method;
-        this.body = body;
-    }
-    async requestPayload() {
-        let status;
-        try {
-            const res = await this.requests.fetch(this.uri, {
-                method: this.method,
-                headers: this.headers,
-                body: this.body,
-            });
-            if (isOk(res.status)) {
-                return await res.text();
+    _handleInspectionChanged(flagKeys, type) {
+        if (!this._inspectorManager.hasInspectors()) {
+            return;
+        }
+        const details = {};
+        flagKeys.forEach((flagKey) => {
+            const item = this._flagManager.get(flagKey);
+            if (item?.flag && !item.flag.deleted) {
+                const { reason, value, variation } = item.flag;
+                details[flagKey] = createSuccessEvaluationDetail(value, variation, reason);
             }
-            // Assigning so it can be thrown after the try/catch.
-            status = res.status;
+        });
+        if (type === 'init') {
+            this._inspectorManager.onFlagsChanged(details);
         }
-        catch (err) {
-            throw new LDRequestError(err?.message);
+        else if (type === 'patch') {
+            Object.entries(details).forEach(([flagKey, detail]) => {
+                this._inspectorManager.onFlagChanged(flagKey, detail);
+            });
         }
-        throw new LDRequestError(`Unexpected status code: ${status}`, status);
     }
 }
 
 class DataSourceEventHandler {
-    constructor(flagManager, statusManager, logger) {
-        this.flagManager = flagManager;
-        this.statusManager = statusManager;
-        this.logger = logger;
+    constructor(_flagManager, _statusManager, _logger) {
+        this._flagManager = _flagManager;
+        this._statusManager = _statusManager;
+        this._logger = _logger;
     }
     async handlePut(context, flags) {
-        this.logger.debug(`Got PUT: ${Object.keys(flags)}`);
+        this._logger.debug(`Got PUT: ${Object.keys(flags)}`);
         // mapping flags to item descriptors
         const descriptors = Object.entries(flags).reduce((acc, [key, flag]) => {
             acc[key] = { version: flag.version, flag };
             return acc;
         }, {});
-        await this.flagManager.init(context, descriptors);
-        this.statusManager.requestStateUpdate(DataSourceState.Valid);
+        await this._flagManager.init(context, descriptors);
+        this._statusManager.requestStateUpdate(DataSourceState.Valid);
     }
     async handlePatch(context, patchFlag) {
-        this.logger.debug(`Got PATCH ${JSON.stringify(patchFlag, null, 2)}`);
-        this.flagManager.upsert(context, patchFlag.key, {
+        this._logger.debug(`Got PATCH ${JSON.stringify(patchFlag, null, 2)}`);
+        this._flagManager.upsert(context, patchFlag.key, {
             version: patchFlag.version,
             flag: patchFlag,
         });
     }
     async handleDelete(context, deleteFlag) {
-        this.logger.debug(`Got DELETE ${JSON.stringify(deleteFlag, null, 2)}`);
-        this.flagManager.upsert(context, deleteFlag.key, {
+        this._logger.debug(`Got DELETE ${JSON.stringify(deleteFlag, null, 2)}`);
+        this._flagManager.upsert(context, deleteFlag.key, {
             version: deleteFlag.version,
             flag: {
                 ...deleteFlag,
@@ -1266,10 +1472,10 @@ class DataSourceEventHandler {
         });
     }
     handleStreamingError(error) {
-        this.statusManager.reportError(error.kind, error.message, error.code, error.recoverable);
+        this._statusManager.reportError(error.kind, error.message, error.code, error.recoverable);
     }
     handlePollingError(error) {
-        this.statusManager.reportError(error.kind, error.message, error.status, error.recoverable);
+        this._statusManager.reportError(error.kind, error.message, error.status, error.recoverable);
     }
 }
 
@@ -1277,17 +1483,17 @@ class DataSourceEventHandler {
  * Tracks the current data source status and emits updates when the status changes.
  */
 class DataSourceStatusManager {
-    constructor(emitter, timeStamper = () => Date.now()) {
-        this.emitter = emitter;
-        this.state = DataSourceState.Closed;
-        this.stateSinceMillis = timeStamper();
-        this.timeStamper = timeStamper;
+    constructor(_emitter, timeStamper = () => Date.now()) {
+        this._emitter = _emitter;
+        this._state = DataSourceState.Closed;
+        this._stateSinceMillis = timeStamper();
+        this._timeStamper = timeStamper;
     }
     get status() {
         return {
-            state: this.state,
-            stateSince: this.stateSinceMillis,
-            lastError: this.errorInfo,
+            state: this._state,
+            stateSince: this._stateSinceMillis,
+            lastError: this._errorInfo,
         };
     }
     /**
@@ -1296,17 +1502,17 @@ class DataSourceStatusManager {
      * @param requestedState to track
      * @param isError to indicate that the state update is a result of an error occurring.
      */
-    updateState(requestedState, isError = false) {
-        const newState = requestedState === DataSourceState.Interrupted && this.state === DataSourceState.Initializing // don't go to interrupted from initializing (recoverable errors when initializing are not noteworthy)
+    _updateState(requestedState, isError = false) {
+        const newState = requestedState === DataSourceState.Interrupted && this._state === DataSourceState.Initializing // don't go to interrupted from initializing (recoverable errors when initializing are not noteworthy)
             ? DataSourceState.Initializing
             : requestedState;
-        const changedState = this.state !== newState;
+        const changedState = this._state !== newState;
         if (changedState) {
-            this.state = newState;
-            this.stateSinceMillis = this.timeStamper();
+            this._state = newState;
+            this._stateSinceMillis = this._timeStamper();
         }
         if (changedState || isError) {
-            this.emitter.emit('dataSourceStatus', this.status);
+            this._emitter.emit('dataSourceStatus', this.status);
         }
     }
     /**
@@ -1315,7 +1521,7 @@ class DataSourceStatusManager {
      * @param state that is requested
      */
     requestStateUpdate(state) {
-        this.updateState(state);
+        this._updateState(state);
     }
     /**
      * Reports a datasource error to this manager. Since the {@link DataSourceStatus} includes error
@@ -1332,10 +1538,10 @@ class DataSourceStatusManager {
             kind,
             message,
             statusCode,
-            time: this.timeStamper(),
+            time: this._timeStamper(),
         };
-        this.errorInfo = errorInfo;
-        this.updateState(recoverable ? DataSourceState.Interrupted : DataSourceState.Closed, true);
+        this._errorInfo = errorInfo;
+        this._updateState(recoverable ? DataSourceState.Interrupted : DataSourceState.Closed, true);
     }
 }
 
@@ -1343,54 +1549,34 @@ class DataSourceStatusManager {
  * @internal
  */
 class PollingProcessor {
-    constructor(plainContextString, dataSourceConfig, requests, encoding, dataHandler, errorHandler, logger) {
-        this.plainContextString = plainContextString;
-        this.dataSourceConfig = dataSourceConfig;
-        this.dataHandler = dataHandler;
-        this.errorHandler = errorHandler;
-        this.logger = logger;
-        this.stopped = false;
-        const path = dataSourceConfig.useReport
-            ? dataSourceConfig.paths.pathReport(encoding, plainContextString)
-            : dataSourceConfig.paths.pathGet(encoding, plainContextString);
-        const parameters = [
-            ...(dataSourceConfig.queryParameters ?? []),
-        ];
-        if (this.dataSourceConfig.withReasons) {
-            parameters.push({ key: 'withReasons', value: 'true' });
-        }
-        const uri = getPollingUri(dataSourceConfig.serviceEndpoints, path, parameters);
-        this.pollInterval = dataSourceConfig.pollInterval;
-        let method = 'GET';
-        const headers = { ...dataSourceConfig.baseHeaders };
-        let body;
-        if (dataSourceConfig.useReport) {
-            method = 'REPORT';
-            headers['content-type'] = 'application/json';
-            body = plainContextString; // context is in body for REPORT
-        }
-        this.requestor = new Requestor(requests, uri, headers, method, body);
-    }
-    async poll() {
-        if (this.stopped) {
+    constructor(_requestor, _pollIntervalSeconds, _dataHandler, _errorHandler, _logger) {
+        this._requestor = _requestor;
+        this._pollIntervalSeconds = _pollIntervalSeconds;
+        this._dataHandler = _dataHandler;
+        this._errorHandler = _errorHandler;
+        this._logger = _logger;
+        this._stopped = false;
+    }
+    async _poll() {
+        if (this._stopped) {
             return;
         }
         const reportJsonError = (data) => {
-            this.logger?.error('Polling received invalid data');
-            this.logger?.debug(`Invalid JSON follows: ${data}`);
-            this.errorHandler?.(new LDPollingError(DataSourceErrorKind.InvalidData, 'Malformed JSON data in polling response'));
+            this._logger?.error('Polling received invalid data');
+            this._logger?.debug(`Invalid JSON follows: ${data}`);
+            this._errorHandler?.(new LDPollingError(DataSourceErrorKind.InvalidData, 'Malformed JSON data in polling response'));
         };
-        this.logger?.debug('Polling LaunchDarkly for feature flag updates');
+        this._logger?.debug('Polling LaunchDarkly for feature flag updates');
         const startTime = Date.now();
         try {
-            const res = await this.requestor.requestPayload();
+            const res = await this._requestor.requestPayload();
             try {
                 const flags = JSON.parse(res);
                 try {
-                    this.dataHandler?.(flags);
+                    this._dataHandler?.(flags);
                 }
                 catch (err) {
-                    this.logger?.error(`Exception from data handler: ${err}`);
+                    this._logger?.error(`Exception from data handler: ${err}`);
                 }
             }
             catch {
@@ -1401,29 +1587,29 @@ class PollingProcessor {
             const requestError = err;
             if (requestError.status !== undefined) {
                 if (!isHttpRecoverable(requestError.status)) {
-                    this.logger?.error(httpErrorMessage(err, 'polling request'));
-                    this.errorHandler?.(new LDPollingError(DataSourceErrorKind.ErrorResponse, requestError.message, requestError.status));
+                    this._logger?.error(httpErrorMessage(err, 'polling request'));
+                    this._errorHandler?.(new LDPollingError(DataSourceErrorKind.ErrorResponse, requestError.message, requestError.status));
                     return;
                 }
             }
-            this.logger?.error(httpErrorMessage(err, 'polling request', 'will retry'));
+            this._logger?.error(httpErrorMessage(err, 'polling request', 'will retry'));
         }
         const elapsed = Date.now() - startTime;
-        const sleepFor = Math.max(this.pollInterval * 1000 - elapsed, 0);
-        this.logger?.debug('Elapsed: %d ms, sleeping for %d ms', elapsed, sleepFor);
-        this.timeoutHandle = setTimeout(() => {
-            this.poll();
+        const sleepFor = Math.max(this._pollIntervalSeconds * 1000 - elapsed, 0);
+        this._logger?.debug('Elapsed: %d ms, sleeping for %d ms', elapsed, sleepFor);
+        this._timeoutHandle = setTimeout(() => {
+            this._poll();
         }, sleepFor);
     }
     start() {
-        this.poll();
+        this._poll();
     }
     stop() {
-        if (this.timeoutHandle) {
-            clearTimeout(this.timeoutHandle);
-            this.timeoutHandle = undefined;
+        if (this._timeoutHandle) {
+            clearTimeout(this._timeoutHandle);
+            this._timeoutHandle = undefined;
         }
-        this.stopped = true;
+        this._stopped = true;
     }
     close() {
         this.stop();
@@ -1436,40 +1622,43 @@ const reportJsonError = (type, data, logger, errorHandler) => {
     errorHandler?.(new LDStreamingError(DataSourceErrorKind.InvalidData, 'Malformed JSON data in event stream'));
 };
 class StreamingProcessor {
-    constructor(plainContextString, dataSourceConfig, listeners, requests, encoding, diagnosticsManager, errorHandler, logger) {
-        this.plainContextString = plainContextString;
-        this.dataSourceConfig = dataSourceConfig;
-        this.listeners = listeners;
-        this.requests = requests;
-        this.diagnosticsManager = diagnosticsManager;
-        this.errorHandler = errorHandler;
-        this.logger = logger;
-        // TODO: SC-255969 Implement better REPORT fallback logic
-        if (dataSourceConfig.useReport && !requests.getEventSourceCapabilities().customMethod) {
-            logger?.error("Configuration option useReport is true, but platform's EventSource does not support custom HTTP methods. Streaming may not work.");
-        }
-        const path = dataSourceConfig.useReport
-            ? dataSourceConfig.paths.pathReport(encoding, plainContextString)
-            : dataSourceConfig.paths.pathGet(encoding, plainContextString);
+    constructor(_plainContextString, _dataSourceConfig, _listeners, _requests, encoding, _pollingRequestor, _diagnosticsManager, _errorHandler, _logger) {
+        this._plainContextString = _plainContextString;
+        this._dataSourceConfig = _dataSourceConfig;
+        this._listeners = _listeners;
+        this._requests = _requests;
+        this._pollingRequestor = _pollingRequestor;
+        this._diagnosticsManager = _diagnosticsManager;
+        this._errorHandler = _errorHandler;
+        this._logger = _logger;
+        let path;
+        if (_dataSourceConfig.useReport && !_requests.getEventSourceCapabilities().customMethod) {
+            path = _dataSourceConfig.paths.pathPing(encoding, _plainContextString);
+        }
+        else {
+            path = _dataSourceConfig.useReport
+                ? _dataSourceConfig.paths.pathReport(encoding, _plainContextString)
+                : _dataSourceConfig.paths.pathGet(encoding, _plainContextString);
+        }
         const parameters = [
-            ...(dataSourceConfig.queryParameters ?? []),
+            ...(_dataSourceConfig.queryParameters ?? []),
         ];
-        if (this.dataSourceConfig.withReasons) {
+        if (this._dataSourceConfig.withReasons) {
             parameters.push({ key: 'withReasons', value: 'true' });
         }
-        this.requests = requests;
-        this.headers = { ...dataSourceConfig.baseHeaders };
-        this.logger = logger;
-        this.streamUri = getStreamingUri(dataSourceConfig.serviceEndpoints, path, parameters);
+        this._requests = _requests;
+        this._headers = { ..._dataSourceConfig.baseHeaders };
+        this._logger = _logger;
+        this._streamUri = getStreamingUri(_dataSourceConfig.serviceEndpoints, path, parameters);
     }
-    logConnectionStarted() {
-        this.connectionAttemptStartTime = Date.now();
+    _logConnectionStarted() {
+        this._connectionAttemptStartTime = Date.now();
     }
-    logConnectionResult(success) {
-        if (this.connectionAttemptStartTime && this.diagnosticsManager) {
-            this.diagnosticsManager.recordStreamInit(this.connectionAttemptStartTime, !success, Date.now() - this.connectionAttemptStartTime);
+    _logConnectionResult(success) {
+        if (this._connectionAttemptStartTime && this._diagnosticsManager) {
+            this._diagnosticsManager.recordStreamInit(this._connectionAttemptStartTime, !success, Date.now() - this._connectionAttemptStartTime);
         }
-        this.connectionAttemptStartTime = undefined;
+        this._connectionAttemptStartTime = undefined;
     }
     /**
      * This is a wrapper around the passed errorHandler which adds additional
@@ -1480,75 +1669,101 @@ class StreamingProcessor {
      *
      * @private
      */
-    retryAndHandleError(err) {
+    _retryAndHandleError(err) {
         if (!shouldRetry(err)) {
-            this.logConnectionResult(false);
-            this.errorHandler?.(new LDStreamingError(DataSourceErrorKind.ErrorResponse, err.message, err.status, false));
-            this.logger?.error(httpErrorMessage(err, 'streaming request'));
+            this._logConnectionResult(false);
+            this._errorHandler?.(new LDStreamingError(DataSourceErrorKind.ErrorResponse, err.message, err.status, false));
+            this._logger?.error(httpErrorMessage(err, 'streaming request'));
             return false;
         }
-        this.logger?.warn(httpErrorMessage(err, 'streaming request', 'will retry'));
-        this.logConnectionResult(false);
-        this.logConnectionStarted();
+        this._logger?.warn(httpErrorMessage(err, 'streaming request', 'will retry'));
+        this._logConnectionResult(false);
+        this._logConnectionStarted();
         return true;
     }
     start() {
-        this.logConnectionStarted();
+        this._logConnectionStarted();
         let methodAndBodyOverrides;
-        if (this.dataSourceConfig.useReport) {
+        if (this._dataSourceConfig.useReport) {
             // REPORT will include a body, so content type is required.
-            this.headers['content-type'] = 'application/json';
+            this._headers['content-type'] = 'application/json';
             // orverrides default method with REPORT and adds body.
-            methodAndBodyOverrides = { method: 'REPORT', body: this.plainContextString };
+            methodAndBodyOverrides = { method: 'REPORT', body: this._plainContextString };
         }
         else {
             // no method or body override
             methodAndBodyOverrides = {};
         }
         // TLS is handled by the platform implementation.
-        const eventSource = this.requests.createEventSource(this.streamUri, {
-            headers: this.headers,
+        const eventSource = this._requests.createEventSource(this._streamUri, {
+            headers: this._headers,
             ...methodAndBodyOverrides,
-            errorFilter: (error) => this.retryAndHandleError(error),
-            initialRetryDelayMillis: this.dataSourceConfig.initialRetryDelayMillis,
+            errorFilter: (error) => this._retryAndHandleError(error),
+            initialRetryDelayMillis: this._dataSourceConfig.initialRetryDelayMillis,
             readTimeoutMillis: 5 * 60 * 1000,
             retryResetIntervalMillis: 60 * 1000,
         });
-        this.eventSource = eventSource;
+        this._eventSource = eventSource;
         eventSource.onclose = () => {
-            this.logger?.info('Closed LaunchDarkly stream connection');
+            this._logger?.info('Closed LaunchDarkly stream connection');
         };
         eventSource.onerror = () => {
             // The work is done by `errorFilter`.
         };
         eventSource.onopen = () => {
-            this.logger?.info('Opened LaunchDarkly stream connection');
+            this._logger?.info('Opened LaunchDarkly stream connection');
         };
         eventSource.onretrying = (e) => {
-            this.logger?.info(`Will retry stream connection in ${e.delayMillis} milliseconds`);
+            this._logger?.info(`Will retry stream connection in ${e.delayMillis} milliseconds`);
         };
-        this.listeners.forEach(({ deserializeData, processJson }, eventName) => {
+        this._listeners.forEach(({ deserializeData, processJson }, eventName) => {
             eventSource.addEventListener(eventName, (event) => {
-                this.logger?.debug(`Received ${eventName} event`);
+                this._logger?.debug(`Received ${eventName} event`);
                 if (event?.data) {
-                    this.logConnectionResult(true);
+                    this._logConnectionResult(true);
                     const { data } = event;
                     const dataJson = deserializeData(data);
                     if (!dataJson) {
-                        reportJsonError(eventName, data, this.logger, this.errorHandler);
+                        reportJsonError(eventName, data, this._logger, this._errorHandler);
                         return;
                     }
                     processJson(dataJson);
                 }
                 else {
-                    this.errorHandler?.(new LDStreamingError(DataSourceErrorKind.InvalidData, 'Unexpected payload from event stream'));
+                    this._errorHandler?.(new LDStreamingError(DataSourceErrorKind.InvalidData, 'Unexpected payload from event stream'));
                 }
             });
         });
+        // here we set up a listener that will poll when ping is received
+        eventSource.addEventListener('ping', async () => {
+            this._logger?.debug('Got PING, going to poll LaunchDarkly for feature flag updates');
+            try {
+                const res = await this._pollingRequestor.requestPayload();
+                try {
+                    const payload = JSON.parse(res);
+                    try {
+                        // forward the payload on to the PUT listener
+                        this._listeners.get('put')?.processJson(payload);
+                    }
+                    catch (err) {
+                        this._logger?.error(`Exception from data handler: ${err}`);
+                    }
+                }
+                catch {
+                    this._logger?.error('Polling after ping received invalid data');
+                    this._logger?.debug(`Invalid JSON follows: ${res}`);
+                    this._errorHandler?.(new LDPollingError(DataSourceErrorKind.InvalidData, 'Malformed JSON data in ping polling response'));
+                }
+            }
+            catch (err) {
+                const requestError = err;
+                this._errorHandler?.(new LDPollingError(DataSourceErrorKind.ErrorResponse, requestError.message, requestError.status));
+            }
+        });
     }
     stop() {
-        this.eventSource?.close();
-        this.eventSource = undefined;
+        this._eventSource?.close();
+        this._eventSource = undefined;
     }
     close() {
         this.stop();
@@ -1568,35 +1783,26 @@ class BaseDataManager {
         this.diagnosticsManager = diagnosticsManager;
         this.logger = config.logger;
         this.dataSourceStatusManager = new DataSourceStatusManager(emitter);
-        this.dataSourceEventHandler = new DataSourceEventHandler(flagManager, this.dataSourceStatusManager, this.config.logger);
+        this._dataSourceEventHandler = new DataSourceEventHandler(flagManager, this.dataSourceStatusManager, this.config.logger);
     }
     /**
      * Set additional connection parameters for requests polling/streaming.
      */
     setConnectionParams(connectionParams) {
-        this.connectionParams = connectionParams;
+        this._connectionParams = connectionParams;
     }
-    createPollingProcessor(context, checkedContext, identifyResolve, identifyReject) {
-        const processor = new PollingProcessor(JSON.stringify(context), {
-            credential: this.credential,
-            serviceEndpoints: this.config.serviceEndpoints,
-            paths: this.getPollingPaths(),
-            baseHeaders: this.baseHeaders,
-            pollInterval: this.config.pollInterval,
-            withReasons: this.config.withReasons,
-            useReport: this.config.useReport,
-            queryParameters: this.connectionParams?.queryParameters,
-        }, this.platform.requests, this.platform.encoding, async (flags) => {
-            await this.dataSourceEventHandler.handlePut(checkedContext, flags);
+    createPollingProcessor(context, checkedContext, requestor, identifyResolve, identifyReject) {
+        const processor = new PollingProcessor(requestor, this.config.pollInterval, async (flags) => {
+            await this._dataSourceEventHandler.handlePut(checkedContext, flags);
             identifyResolve?.();
         }, (err) => {
             this.emitter.emit('error', context, err);
-            this.dataSourceEventHandler.handlePollingError(err);
+            this._dataSourceEventHandler.handlePollingError(err);
             identifyReject?.(err);
-        });
-        this.updateProcessor = this.decorateProcessorWithStatusReporting(processor, this.dataSourceStatusManager);
+        }, this.logger);
+        this.updateProcessor = this._decorateProcessorWithStatusReporting(processor, this.dataSourceStatusManager);
     }
-    createStreamingProcessor(context, checkedContext, identifyResolve, identifyReject) {
+    createStreamingProcessor(context, checkedContext, pollingRequestor, identifyResolve, identifyReject) {
         const processor = new StreamingProcessor(JSON.stringify(context), {
             credential: this.credential,
             serviceEndpoints: this.config.serviceEndpoints,
@@ -1605,38 +1811,38 @@ class BaseDataManager {
             initialRetryDelayMillis: this.config.streamInitialReconnectDelay * 1000,
             withReasons: this.config.withReasons,
             useReport: this.config.useReport,
-            queryParameters: this.connectionParams?.queryParameters,
-        }, this.createStreamListeners(checkedContext, identifyResolve), this.platform.requests, this.platform.encoding, this.diagnosticsManager, (e) => {
+            queryParameters: this._connectionParams?.queryParameters,
+        }, this.createStreamListeners(checkedContext, identifyResolve), this.platform.requests, this.platform.encoding, pollingRequestor, this.diagnosticsManager, (e) => {
             this.emitter.emit('error', context, e);
-            this.dataSourceEventHandler.handleStreamingError(e);
+            this._dataSourceEventHandler.handleStreamingError(e);
             identifyReject?.(e);
-        });
-        this.updateProcessor = this.decorateProcessorWithStatusReporting(processor, this.dataSourceStatusManager);
+        }, this.logger);
+        this.updateProcessor = this._decorateProcessorWithStatusReporting(processor, this.dataSourceStatusManager);
     }
     createStreamListeners(context, identifyResolve) {
         const listeners = new Map();
         listeners.set('put', {
             deserializeData: JSON.parse,
             processJson: async (flags) => {
-                await this.dataSourceEventHandler.handlePut(context, flags);
+                await this._dataSourceEventHandler.handlePut(context, flags);
                 identifyResolve?.();
             },
         });
         listeners.set('patch', {
             deserializeData: JSON.parse,
             processJson: async (patchFlag) => {
-                this.dataSourceEventHandler.handlePatch(context, patchFlag);
+                this._dataSourceEventHandler.handlePatch(context, patchFlag);
             },
         });
         listeners.set('delete', {
             deserializeData: JSON.parse,
             processJson: async (deleteFlag) => {
-                this.dataSourceEventHandler.handleDelete(context, deleteFlag);
+                this._dataSourceEventHandler.handleDelete(context, deleteFlag);
             },
         });
         return listeners;
     }
-    decorateProcessorWithStatusReporting(processor, statusManager) {
+    _decorateProcessorWithStatusReporting(processor, statusManager) {
         return {
             start: () => {
                 // update status before starting processor to ensure potential errors are reported after initializing
@@ -1655,5 +1861,5 @@ class BaseDataManager {
     }
 }
 
-export { BaseDataManager, DataSourceState, LDClientImpl, Requestor };
+export { BaseDataManager, DataSourceState, LDClientImpl, Requestor, makeRequestor };
 //# sourceMappingURL=index.mjs.map