react-native-nitro-amplitude 0.1.0

package/lib/module/experiment/experimentClient.js

@@ -0,0 +1,788 @@
+"use strict";
+
+/**
+ * @packageDocumentation
+ * @module experiment-react-native-client
+ */
+
+import { topologicalSort, EvaluationEngine, FetchError, Poller, SdkFlagApi, SdkEvaluationApi } from "@amplitude/experiment-core";
+import { version as PACKAGE_VERSION } from "./gen/version";
+import { ConnectorUserProvider } from "./integration/connector";
+import { DefaultUserProvider } from "./integration/default";
+import { AmpLogger } from "./logger/ampLogger";
+import { ConsoleLogger } from "./logger/consoleLogger";
+import { getFlagStorage, getVariantsOptionsStorage, getVariantStorage } from "./storage/cache";
+import { MemoryStorage } from "./storage/local-storage";
+import { FetchHttpClient, WrapperClient } from "./transport/http";
+import { Defaults } from "./types/config";
+import { LogLevel } from "./types/logger";
+import { isFallback, Source, VariantSource } from "./types/source";
+import { isLocalEvaluationMode, isNullOrUndefined, isNullUndefinedOrEmpty } from "./util";
+import { Backoff } from "./util/backoff";
+import { convertEvaluationVariantToVariant, convertUserToContext, convertVariant } from "./util/convert";
+import { UserSessionExposureTracker } from "./util/userSessionExposureTracker";
+
+// Configs which have been removed from the public API.
+// May be added back in the future.
+const fetchBackoffTimeout = 10000;
+const fetchBackoffAttempts = 8;
+const fetchBackoffMinMillis = 500;
+const fetchBackoffMaxMillis = 10000;
+const fetchBackoffScalar = 1.5;
+const flagPollerIntervalMillis = 60000;
+const euServerUrl = "https://api.lab.eu.amplitude.com";
+const euFlagsServerUrl = "https://flag.lab.eu.amplitude.com";
+/**
+ * The default {@link Client} used to fetch variations from Experiment's
+ * servers.
+ *
+ * @category Core Usage
+ */
+export class ExperimentClient {
+  engine = new EvaluationEngine();
+  user = {};
+  poller = new Poller(() => this.pollFlags(), flagPollerIntervalMillis);
+  isRunning = false;
+  fetchSequenceNumber = 0;
+  storedFetchSequenceNumber = 0;
+  stopCallbacks = new Set();
+
+  /**
+   * Creates a new ExperimentClient instance.
+   *
+   * In most cases you will want to use the `initialize` factory method in
+   * {@link Experiment}.
+   *
+   * @param apiKey The Client key for the Experiment project
+   * @param config See {@link ExperimentConfig} for config options
+   */
+  constructor(apiKey, config) {
+    this.apiKey = apiKey;
+    const serverZone = config?.serverZone ?? Defaults.serverZone ?? "US";
+    this.config = {
+      ...Defaults,
+      ...config,
+      debug: config?.debug ?? Defaults.debug ?? false,
+      logLevel: config?.logLevel ?? Defaults.logLevel ?? LogLevel.Error,
+      loggerProvider: config?.loggerProvider ?? Defaults.loggerProvider ?? null,
+      instanceName: config?.instanceName ?? Defaults.instanceName ?? "$default_instance",
+      fallbackVariant: config?.fallbackVariant ?? Defaults.fallbackVariant ?? {},
+      initialVariants: config?.initialVariants ?? Defaults.initialVariants ?? {},
+      source: config?.source ?? Defaults.source ?? Source.LocalStorage,
+      serverZone,
+      serverUrl: config?.serverUrl ?? (serverZone === "EU" ? euServerUrl : Defaults.serverUrl ?? "https://api.lab.amplitude.com"),
+      flagsServerUrl: config?.flagsServerUrl ?? (serverZone === "EU" ? euFlagsServerUrl : Defaults.flagsServerUrl ?? "https://flag.lab.amplitude.com"),
+      fetchTimeoutMillis: config?.fetchTimeoutMillis ?? Defaults.fetchTimeoutMillis ?? 10000,
+      retryFetchOnFailure: config?.retryFetchOnFailure ?? Defaults.retryFetchOnFailure ?? true,
+      automaticExposureTracking: config?.automaticExposureTracking ?? Defaults.automaticExposureTracking ?? true,
+      pollOnStart: config?.pollOnStart ?? Defaults.pollOnStart ?? true,
+      fetchOnStart: config?.fetchOnStart ?? Defaults.fetchOnStart ?? true,
+      automaticFetchOnAmplitudeIdentityChange: config?.automaticFetchOnAmplitudeIdentityChange ?? Defaults.automaticFetchOnAmplitudeIdentityChange ?? false,
+      userProvider: config?.userProvider ?? Defaults.userProvider ?? null,
+      exposureTrackingProvider: config?.exposureTrackingProvider ?? Defaults.exposureTrackingProvider ?? null,
+      httpClient: config?.httpClient ?? Defaults.httpClient ?? FetchHttpClient,
+      storage: config?.storage ?? Defaults.storage ?? null
+    };
+    this.logger = new AmpLogger(this.config.loggerProvider || new ConsoleLogger(), ExperimentClient.getLogLevel(this.config));
+    this.defaultUserProvider = new DefaultUserProvider(this.config.userProvider);
+    if (this.config.exposureTrackingProvider) {
+      this.userSessionExposureTracker = new UserSessionExposureTracker(this.config.exposureTrackingProvider);
+    }
+    // Setup Remote APIs
+    const httpClient = new WrapperClient(this.config.httpClient || FetchHttpClient);
+    this.flagApi = new SdkFlagApi(this.apiKey, this.config.flagsServerUrl, httpClient);
+    this.evaluationApi = new SdkEvaluationApi(this.apiKey, this.config.serverUrl, httpClient);
+    // Storage & Caching
+    const storage = this.config.storage || new MemoryStorage();
+    this.variants = getVariantStorage(this.apiKey, this.config.instanceName, storage);
+    this.flags = getFlagStorage(this.apiKey, this.config.instanceName, storage);
+    if (this.config.initialFlags) {
+      try {
+        this.initialFlags = JSON.parse(this.config.initialFlags);
+      } catch (error) {
+        this.logger.warn(error);
+      }
+    }
+    this.fetchVariantsOptions = getVariantsOptionsStorage(this.apiKey, this.config.instanceName, storage);
+    this.flagsAndVariantsLoadedPromise = [this.flags.load(this.convertInitialFlagsForStorage()), this.variants.load(), this.fetchVariantsOptions.load()];
+  }
+
+  /**
+   * Call to ensure the completion of the loading variants and flags from localStorage upon initialization.
+   */
+  async cacheReady() {
+    await Promise.all(this.flagsAndVariantsLoadedPromise);
+    return this;
+  }
+
+  /**
+   * Start the SDK by getting flag configurations from the server and fetching
+   * variants for the user. The promise returned by this function resolves when
+   * local flag configurations have been updated, and the {@link fetch()}
+   * result has been received (if the request was made).
+   *
+   * To force this function not to fetch variants, set the {@link fetchOnStart}
+   * configuration option to `false` when initializing the SDK.
+   *
+   * Finally, this function will start polling for flag configurations at a
+   * fixed interval. To disable polling, set the {@link pollOnStart}
+   * configuration option to `false` on initialization.
+   *
+   * @param user The user to set in the SDK.
+   * @see fetchOnStart
+   * @see pollOnStart
+   * @see fetch
+   * @see variant
+   */
+  async start(user) {
+    if (this.isRunning) {
+      return;
+    } else {
+      this.isRunning = true;
+    }
+    try {
+      this.defaultUserProvider.start();
+      this.setUser(user ?? {});
+      const flagsReadyPromise = this.doFlags();
+      const fetchOnStart = this.config.fetchOnStart ?? true;
+      if (fetchOnStart) {
+        await Promise.all([this.fetch(user), flagsReadyPromise]);
+      } else {
+        await flagsReadyPromise;
+      }
+      if (this.config.pollOnStart) {
+        this.poller.start();
+      }
+    } catch (e) {
+      this.stop();
+      throw e;
+    }
+  }
+
+  /**
+   * Stop background polling and retry work started by the client.
+   */
+  stop() {
+    this.stopRetries();
+    this.defaultUserProvider.stop();
+    for (const callback of this.stopCallbacks) {
+      try {
+        callback();
+      } catch (e) {
+        this.logger.warn(e);
+      }
+    }
+    this.stopCallbacks.clear();
+    if (!this.isRunning) {
+      return;
+    }
+    this.poller.stop();
+    this.isRunning = false;
+  }
+
+  /**
+   * Assign the given user to the SDK and asynchronously fetch all variants
+   * from the server. Subsequent calls may omit the user from the argument to
+   * use the user from the previous call.
+   *
+   * If an {@link ExperimentUserProvider} has been set, the argument user will
+   * be merged with the provider user, preferring user fields from the argument
+   * user and falling back on the provider for fields which are null or
+   * undefined.
+   *
+   * If configured, fetch retries the request in the background on failure.
+   * Variants received from a successful retry are stored in local storage for
+   * access.
+   *
+   * If you are using the `initialVariants` config option to preload this SDK
+   * from the server, you generally do not need to call `fetch`.
+   *
+   * @param user The user to fetch variants for.
+   * @param options Options for this specific fetch call.
+   * @returns Promise that resolves when the request for variants completes.
+   * @see ExperimentUser
+   * @see ExperimentUserProvider
+   */
+  async fetch(user = this.user, options) {
+    const fetchUser = user ?? this.user;
+    this.setUser(fetchUser);
+    try {
+      await this.fetchWithRetries(fetchUser, options);
+    } catch (e) {
+      this.logger.warn(e);
+    }
+    return this;
+  }
+  async fetchOrThrow(user = this.user, options) {
+    const fetchUser = user ?? this.user;
+    this.setUser(fetchUser);
+    await this.fetchWithRetries(fetchUser, options);
+    return this;
+  }
+
+  /**
+   * Returns the variant for the provided key.
+   *
+   * Access the variant from {@link Source}, falling back  on the given
+   * fallback, then the configured fallbackVariant.
+   *
+   * If an {@link ExposureTrackingProvider} is configured and trackExposure is
+   * true, this function will call the provider with an {@link Exposure}.
+   * The exposure event does not count towards your event volume within Amplitude.
+   *
+   * @param key The key to get the variant for.
+   * @param fallback The highest priority fallback.
+   * @see ExperimentConfig
+   * @see ExposureTrackingProvider
+   */
+  variant(key, fallback) {
+    if (!this.apiKey) {
+      return {
+        value: undefined
+      };
+    }
+    const sourceVariant = this.variantAndSource(key, fallback);
+    if (this.config.automaticExposureTracking) {
+      this.exposureInternal(key, sourceVariant);
+    }
+    this.logger.debug(`[Experiment] variant for ${key} is ${sourceVariant.variant?.value}`);
+    return sourceVariant.variant || {};
+  }
+
+  /**
+   * Track an exposure event for the variant associated with the flag/experiment
+   * {@link key}.
+   *
+   * This method requires that an {@link ExposureTrackingProvider} be
+   * configured when this client is initialized, either manually, or through the
+   * Amplitude Analytics SDK integration from set up using
+   * {@link Experiment.initializeWithAmplitudeAnalytics}.
+   *
+   * @param key The flag/experiment key to track an exposure for.
+   */
+  exposure(key) {
+    const sourceVariant = this.variantAndSource(key);
+    this.exposureInternal(key, sourceVariant);
+  }
+
+  /**
+   * Returns all variants for the user.
+   *
+   * The primary source of variants is based on the
+   * {@link Source} configured in the {@link ExperimentConfig}.
+   *
+   * @see Source
+   * @see ExperimentConfig
+   */
+  all() {
+    if (!this.apiKey) {
+      return {};
+    }
+    const evaluatedVariants = this.evaluate();
+    for (const flagKey in evaluatedVariants) {
+      const flag = this.flags.get(flagKey);
+      if (!isLocalEvaluationMode(flag)) {
+        delete evaluatedVariants[flagKey];
+      }
+    }
+    return {
+      ...this.secondaryVariants(),
+      ...this.sourceVariants(),
+      ...evaluatedVariants
+    };
+  }
+
+  /**
+   * Clear all variants in the cache and storage.
+   */
+  clear() {
+    this.variants.clear();
+    void this.variants.store().catch(e => this.logger.warn(e));
+  }
+
+  /**
+   * Get a copy of the internal {@link ExperimentUser} object if it is set.
+   *
+   * @returns a copy of the internal user object if set.
+   */
+  getUser() {
+    if (!this.user) {
+      return {};
+    }
+    if (this.user?.user_properties) {
+      const userPropertiesCopy = {
+        ...this.user.user_properties
+      };
+      return {
+        ...this.user,
+        user_properties: userPropertiesCopy
+      };
+    } else {
+      return {
+        ...this.user
+      };
+    }
+  }
+
+  /**
+   * Copy in and set the user within the experiment client.
+   *
+   * @param user the user to set within the experiment client.
+   */
+  setUser(user) {
+    if (!user) {
+      this.user = {};
+      return;
+    }
+    if (this.user?.user_properties) {
+      const userPropertiesCopy = {
+        ...user.user_properties
+      };
+      this.user = {
+        ...user,
+        user_properties: userPropertiesCopy
+      };
+    } else {
+      this.user = {
+        ...user
+      };
+    }
+  }
+
+  /**
+   * Get the user provider set by {@link setUserProvider} or null if the user
+   * provider has not been set.
+   *
+   * @returns The user provider set by {@link setUserProvider} or null.
+   * @deprecated use ExperimentConfig.userProvider instead
+   */
+  getUserProvider() {
+    return this.defaultUserProvider;
+  }
+
+  /**
+   * Sets a user provider that will inject identity information into the user
+   * for {@link fetch()} requests. The user provider will only set user fields
+   * in outgoing requests which are null or undefined.
+   *
+   * See {@link ExperimentUserProvider} for more details
+   * @param userProvider
+   * @deprecated use ExperimentConfig.userProvider instead
+   */
+  setUserProvider(userProvider) {
+    this.defaultUserProvider.baseProvider = userProvider;
+    return this;
+  }
+
+  /**
+   * Enables or disables tracking of assignment events when fetching variants.
+   * @param doTrack Whether to track assignment events.
+   */
+  async setTracksAssignment(doTrack) {
+    this.fetchVariantsOptions.put({
+      ...this.fetchVariantsOptions.get(),
+      trackingOption: doTrack ? "track" : "no-track"
+    });
+    await this.fetchVariantsOptions.store();
+  }
+  addStopCallback(callback) {
+    this.stopCallbacks.add(callback);
+  }
+  fetchOnIdentityChange() {
+    void this.fetch().catch(e => this.logger.warn(e));
+  }
+  convertInitialFlagsForStorage() {
+    if (this.initialFlags) {
+      const flagsMap = {};
+      this.initialFlags.forEach(flag => {
+        flagsMap[flag.key] = flag;
+      });
+      return flagsMap;
+    }
+    return {};
+  }
+  mergeInitialFlagsWithStorage() {
+    if (this.initialFlags) {
+      this.initialFlags.forEach(flag => {
+        if (!this.flags.get(flag.key)) {
+          this.flags.put(flag.key, flag);
+        }
+      });
+    }
+  }
+  evaluate(flagKeys) {
+    const user = this.addContextSync(this.user);
+    const flags = topologicalSort(this.flags.getAll(), flagKeys);
+    const context = convertUserToContext(user);
+    const evaluationVariants = this.engine.evaluate(context, flags);
+    const variants = {};
+    for (const flagKey of Object.keys(evaluationVariants)) {
+      variants[flagKey] = convertEvaluationVariantToVariant(evaluationVariants[flagKey]);
+    }
+    return variants;
+  }
+  variantAndSource(key, fallback) {
+    let sourceVariant = {};
+    if (this.config.source === Source.LocalStorage) {
+      sourceVariant = this.localStorageVariantAndSource(key, fallback);
+    } else if (this.config.source === Source.InitialVariants) {
+      sourceVariant = this.initialVariantsVariantAndSource(key, fallback);
+    }
+    const flag = this.flags.get(key);
+    if (flag && (isLocalEvaluationMode(flag) || !sourceVariant.variant)) {
+      sourceVariant = this.localEvaluationVariantAndSource(key, flag, fallback);
+    }
+    return sourceVariant;
+  }
+
+  /**
+   * This function assumes the flag exists and is local evaluation mode. For
+   * local evaluation, fallback order goes:
+   *
+   *  1. Local evaluation
+   *  2. Inline function fallback
+   *  3. Initial variants
+   *  4. Config fallback
+   *
+   * If there is a default variant and no fallback, return the default variant.
+   */
+  localEvaluationVariantAndSource(key, flag, fallback) {
+    let defaultSourceVariant = {};
+    // Local evaluation
+    const variant = this.evaluate([flag.key])[key];
+    const source = VariantSource.LocalEvaluation;
+    const isLocalEvaluationDefault = variant?.metadata?.default;
+    if (!isNullOrUndefined(variant) && !isLocalEvaluationDefault) {
+      return {
+        variant: convertVariant(variant),
+        source: source,
+        hasDefaultVariant: false
+      };
+    } else if (isLocalEvaluationDefault) {
+      defaultSourceVariant = {
+        variant: convertVariant(variant),
+        source: source,
+        hasDefaultVariant: true
+      };
+    }
+    // Inline fallback
+    if (!isNullOrUndefined(fallback)) {
+      return {
+        variant: convertVariant(fallback),
+        source: VariantSource.FallbackInline,
+        hasDefaultVariant: defaultSourceVariant.hasDefaultVariant
+      };
+    }
+    // Initial variants
+    const initialVariant = this.config.initialVariants[key];
+    if (!isNullOrUndefined(initialVariant)) {
+      return {
+        variant: convertVariant(initialVariant),
+        source: VariantSource.SecondaryInitialVariants,
+        hasDefaultVariant: defaultSourceVariant.hasDefaultVariant
+      };
+    }
+    // Configured fallback, or default variant
+    const fallbackVariant = convertVariant(this.config.fallbackVariant);
+    const fallbackSourceVariant = {
+      variant: fallbackVariant,
+      source: VariantSource.FallbackConfig,
+      hasDefaultVariant: defaultSourceVariant.hasDefaultVariant
+    };
+    if (!isNullUndefinedOrEmpty(fallbackVariant)) {
+      return fallbackSourceVariant;
+    }
+    return defaultSourceVariant;
+  }
+
+  /**
+   * For Source.LocalStorage, fallback order goes:
+   *
+   *  1. Local Storage
+   *  2. Inline function fallback
+   *  3. InitialFlags
+   *  4. Config fallback
+   *
+   * If there is a default variant and no fallback, return the default variant.
+   */
+  localStorageVariantAndSource(key, fallback) {
+    let defaultSourceVariant = {};
+    // Local storage
+    const localStorageVariant = this.variants.get(key);
+    const isLocalStorageDefault = localStorageVariant?.metadata?.default;
+    if (!isNullOrUndefined(localStorageVariant) && !isLocalStorageDefault) {
+      return {
+        variant: convertVariant(localStorageVariant),
+        source: VariantSource.LocalStorage,
+        hasDefaultVariant: false
+      };
+    } else if (isLocalStorageDefault) {
+      defaultSourceVariant = {
+        variant: convertVariant(localStorageVariant),
+        source: VariantSource.LocalStorage,
+        hasDefaultVariant: true
+      };
+    }
+    // Inline fallback
+    if (!isNullOrUndefined(fallback)) {
+      return {
+        variant: convertVariant(fallback),
+        source: VariantSource.FallbackInline,
+        hasDefaultVariant: defaultSourceVariant.hasDefaultVariant
+      };
+    }
+    // Initial variants
+    const initialVariant = this.config.initialVariants[key];
+    if (!isNullOrUndefined(initialVariant)) {
+      return {
+        variant: convertVariant(initialVariant),
+        source: VariantSource.SecondaryInitialVariants,
+        hasDefaultVariant: defaultSourceVariant.hasDefaultVariant
+      };
+    }
+    // Configured fallback, or default variant
+    const fallbackVariant = convertVariant(this.config.fallbackVariant);
+    const fallbackSourceVariant = {
+      variant: fallbackVariant,
+      source: VariantSource.FallbackConfig,
+      hasDefaultVariant: defaultSourceVariant.hasDefaultVariant
+    };
+    if (!isNullUndefinedOrEmpty(fallbackVariant)) {
+      return fallbackSourceVariant;
+    }
+    return defaultSourceVariant;
+  }
+
+  /**
+   * For Source.InitialVariants, fallback order goes:
+   *
+   *  1. Initial variants
+   *  2. Local storage
+   *  3. Inline function fallback
+   *  4. Config fallback
+   *
+   * If there is a default variant and no fallback, return the default variant.
+   */
+  initialVariantsVariantAndSource(key, fallback) {
+    let defaultSourceVariant = {};
+    // Initial variants
+    const initialVariantsVariant = this.config.initialVariants[key];
+    if (!isNullOrUndefined(initialVariantsVariant)) {
+      return {
+        variant: convertVariant(initialVariantsVariant),
+        source: VariantSource.InitialVariants,
+        hasDefaultVariant: false
+      };
+    }
+    // Local storage
+    const localStorageVariant = this.variants.get(key);
+    const isLocalStorageDefault = localStorageVariant?.metadata?.default;
+    if (!isNullOrUndefined(localStorageVariant) && !isLocalStorageDefault) {
+      return {
+        variant: convertVariant(localStorageVariant),
+        source: VariantSource.LocalStorage,
+        hasDefaultVariant: false
+      };
+    } else if (isLocalStorageDefault) {
+      defaultSourceVariant = {
+        variant: convertVariant(localStorageVariant),
+        source: VariantSource.LocalStorage,
+        hasDefaultVariant: true
+      };
+    }
+    // Inline fallback
+    if (!isNullOrUndefined(fallback)) {
+      return {
+        variant: convertVariant(fallback),
+        source: VariantSource.FallbackInline,
+        hasDefaultVariant: defaultSourceVariant.hasDefaultVariant
+      };
+    }
+    // Configured fallback, or default variant
+    const fallbackVariant = convertVariant(this.config.fallbackVariant);
+    const fallbackSourceVariant = {
+      variant: fallbackVariant,
+      source: VariantSource.FallbackConfig,
+      hasDefaultVariant: defaultSourceVariant.hasDefaultVariant
+    };
+    if (!isNullUndefinedOrEmpty(fallbackVariant)) {
+      return fallbackSourceVariant;
+    }
+    return defaultSourceVariant;
+  }
+  async fetchInternal(user, timeoutMillis, retry, options) {
+    // Don't even try to fetch variants if API key is not set
+    if (!this.apiKey) {
+      throw Error("Experiment API key is empty");
+    }
+    this.logger.debug(`[Experiment] Fetch all: retry=${retry}`);
+
+    // Proactively cancel retries if active in order to avoid unnecessary API
+    // requests. A new failure will restart the retries.
+    if (retry) {
+      this.stopRetries();
+    }
+    const sequenceNumber = ++this.fetchSequenceNumber;
+    try {
+      const variants = await this.doFetch(user, timeoutMillis, options);
+      await this.storeVariants(variants, sequenceNumber, options);
+      return variants;
+    } catch (e) {
+      if (retry && this.shouldRetryFetch(e)) {
+        this.startRetries(user, options);
+      }
+      throw e;
+    }
+  }
+  async fetchWithRetries(user, options) {
+    return await this.fetchInternal(user, this.config.fetchTimeoutMillis, this.config.retryFetchOnFailure, options);
+  }
+  async doFetch(user, timeoutMillis, options) {
+    user = await this.addContextOrWait(user, 10000);
+    this.logger.debug("[Experiment] Fetch variants for user: ", user);
+    const results = await this.evaluationApi.getVariants(user, {
+      ...this.fetchVariantsOptions.get(),
+      timeoutMillis: timeoutMillis,
+      flagKeys: options?.flagKeys
+    });
+    const variants = {};
+    for (const key of Object.keys(results)) {
+      variants[key] = convertEvaluationVariantToVariant(results[key]);
+    }
+    this.logger.debug("[Experiment] Received variants: ", variants);
+    return variants;
+  }
+  async doFlags() {
+    const flags = await this.flagApi.getFlags({
+      libraryName: "experiment-js-client",
+      libraryVersion: PACKAGE_VERSION,
+      timeoutMillis: this.config.fetchTimeoutMillis
+    });
+    this.flags.clear();
+    this.flags.putAll(flags);
+    await this.flags.store();
+    this.mergeInitialFlagsWithStorage();
+  }
+  async pollFlags() {
+    try {
+      await this.doFlags();
+    } catch (e) {
+      this.logger.warn(e);
+    }
+  }
+  async storeVariants(variants, sequenceNumber, options) {
+    if (sequenceNumber <= this.storedFetchSequenceNumber) {
+      this.logger.debug(`[Experiment] Ignoring stale fetch response (sequence ${sequenceNumber} <= ${this.storedFetchSequenceNumber})`);
+      return;
+    }
+    let failedFlagKeys = options?.flagKeys ? options.flagKeys : [];
+    if (failedFlagKeys.length === 0) {
+      this.variants.clear();
+    }
+    for (const key in variants) {
+      failedFlagKeys = failedFlagKeys.filter(flagKey => flagKey !== key);
+      this.variants.put(key, variants[key]);
+    }
+    for (const key in failedFlagKeys) {
+      this.variants.remove(key);
+    }
+    await this.variants.store();
+    this.storedFetchSequenceNumber = sequenceNumber;
+    this.logger.debug("[Experiment] Stored variants: ", variants);
+  }
+  startRetries(user, options) {
+    this.logger.debug("[Experiment] Retry fetch");
+    this.retriesBackoff = new Backoff(fetchBackoffAttempts, fetchBackoffMinMillis, fetchBackoffMaxMillis, fetchBackoffScalar);
+    this.retriesBackoff.start(async () => {
+      await this.fetchInternal(user, fetchBackoffTimeout, false, options);
+    });
+  }
+  stopRetries() {
+    if (this.retriesBackoff != null) {
+      this.retriesBackoff.cancel();
+    }
+  }
+  addContextSync(user) {
+    const providedUser = this.defaultUserProvider.getUserSync();
+    return this.mergeContext(user, providedUser);
+  }
+  async addContext(user) {
+    const providedUser = await this.defaultUserProvider.getUser();
+    return this.mergeContext(user, providedUser);
+  }
+  async addContextOrWait(user, ms) {
+    const baseProvider = this.defaultUserProvider.baseProvider;
+    if (baseProvider instanceof ConnectorUserProvider) {
+      await baseProvider.identityReady(ms);
+    }
+    return this.addContext(user);
+  }
+  mergeContext(user, providedUser) {
+    const mergedUserProperties = {
+      ...user?.user_properties,
+      ...providedUser?.user_properties
+    };
+    return {
+      library: `experiment-react-native-client/${PACKAGE_VERSION}`,
+      ...providedUser,
+      ...user,
+      user_properties: mergedUserProperties
+    };
+  }
+  sourceVariants() {
+    if (this.config.source === Source.LocalStorage) {
+      return this.variants.getAll();
+    } else if (this.config.source === Source.InitialVariants) {
+      return this.config.initialVariants;
+    }
+    return {};
+  }
+  secondaryVariants() {
+    if (this.config.source === Source.LocalStorage) {
+      return this.config.initialVariants;
+    } else if (this.config.source === Source.InitialVariants) {
+      return this.variants.getAll();
+    }
+    return {};
+  }
+  exposureInternal(key, sourceVariant) {
+    const exposure = {
+      flag_key: key
+    };
+    // Do not track exposure for fallback variants that are not associated with
+    // a default variant.
+    const fallback = isFallback(sourceVariant.source);
+    if (fallback && !sourceVariant.hasDefaultVariant) {
+      return;
+    }
+    if (sourceVariant.variant?.expKey) {
+      exposure.experiment_key = sourceVariant.variant?.expKey;
+    }
+    const metadata = sourceVariant.variant?.metadata;
+    if (!fallback && !metadata?.default) {
+      if (sourceVariant.variant?.key) {
+        exposure.variant = sourceVariant.variant.key;
+      } else if (sourceVariant.variant?.value) {
+        exposure.variant = sourceVariant.variant.value;
+      }
+    }
+    if (metadata) exposure.metadata = metadata;
+    const user = this.addContextSync(this.getUser());
+    this.userSessionExposureTracker?.track(exposure, user);
+  }
+  static getLogLevel(config) {
+    // Backwards compatibility: if debug flag is set to true, use Debug level
+    if (config.debug === true) {
+      return LogLevel.Debug;
+    }
+    // Otherwise use the configured logLevel or default to Warn
+    return config.logLevel ?? LogLevel.Warn;
+  }
+  shouldRetryFetch(e) {
+    if (e instanceof FetchError) {
+      return e.statusCode < 400 || e.statusCode >= 500 || e.statusCode === 429;
+    }
+    return true;
+  }
+}
+//# sourceMappingURL=experimentClient.js.map