polling interval param, keep polling and check cache expiration in callback

Author: typotter

src/client/eppo-client.spec.ts

@@ -17,7 +17,7 @@ import { IAssignmentLogger } from '../assignment-logger';
 import ConfigurationRequestor from '../configuration-requestor';
 import { IConfigurationStore } from '../configuration-store/configuration-store';
 import { MemoryOnlyConfigurationStore } from '../configuration-store/memory.store';
-import { MAX_EVENT_QUEUE_SIZE, POLL_INTERVAL_MS, POLL_JITTER_PCT } from '../constants';
+import { MAX_EVENT_QUEUE_SIZE, DEFAULT_POLL_INTERVAL_MS, POLL_JITTER_PCT } from '../constants';
 import FetchHttpClient from '../http-client';
 import { Flag, ObfuscatedFlag, VariationType } from '../interfaces';
 
@@ -576,7 +576,7 @@ describe('EppoClient E2E test', () => {
     const subject = 'alice';
     const pi = 3.1415926;
 
-    const maxRetryDelay = POLL_INTERVAL_MS * POLL_JITTER_PCT;
+    const maxRetryDelay = DEFAULT_POLL_INTERVAL_MS * POLL_JITTER_PCT;
 
     beforeAll(async () => {
       global.fetch = jest.fn(() => {
@@ -652,6 +652,38 @@ describe('EppoClient E2E test', () => {
       expect(variation).toBe(pi);
     });
 
+    describe('Poll after successful start', () => {
+      it('Continues to poll when cache has not expired', async () => {
+        class MockStore<T> extends MemoryOnlyConfigurationStore<T> {
+          public static expired = false;
+
+          async isExpired(): Promise<boolean> {
+            return MockStore.expired;
+          }
+        }
+
+        client = new EppoClient(new MockStore(), undefined, undefined, {
+          ...requestConfiguration,
+          pollAfterSuccessfulInitialization: true,
+        });
+        client.setIsGracefulFailureMode(false);
+        // no configuration loaded
+        let variation = client.getNumericAssignment(flagKey, subject, {}, 0.0);
+        expect(variation).toBe(0.0);
+
+        // have client fetch configurations; cache is not expired so assignment stays
+        await client.fetchFlagConfigurations();
+        variation = client.getNumericAssignment(flagKey, subject, {}, 0.0);
+        expect(variation).toBe(0.0);
+
+        // Expire the cache and advance time until a reload should happen
+        MockStore.expired = true;
+        await jest.advanceTimersByTimeAsync(DEFAULT_POLL_INTERVAL_MS * 1.5);
+
+        variation = client.getNumericAssignment(flagKey, subject, {}, 0.0);
+        expect(variation).toBe(pi);
+      });
+    });
     it('Does not fetch configurations if the configuration store is unexpired', async () => {
       class MockStore<T> extends MemoryOnlyConfigurationStore<T> {
         async isExpired(): Promise<boolean> {
@@ -720,7 +752,7 @@ describe('EppoClient E2E test', () => {
       expect(variation).toBe(pi);
       expect(callCount).toBe(2);
 
-      await jest.advanceTimersByTimeAsync(POLL_INTERVAL_MS);
+      await jest.advanceTimersByTimeAsync(DEFAULT_POLL_INTERVAL_MS);
       // By default, no more polling
       expect(callCount).toBe(pollAfterSuccessfulInitialization ? 3 : 2);
     });
@@ -782,7 +814,7 @@ describe('EppoClient E2E test', () => {
       expect(client.getNumericAssignment(flagKey, subject, {}, 10.0)).toBe(10.0);
 
       // Advance timers so a post-init poll can take place
-      await jest.advanceTimersByTimeAsync(POLL_INTERVAL_MS * 1.5);
+      await jest.advanceTimersByTimeAsync(DEFAULT_POLL_INTERVAL_MS * 1.5);
 
       // if pollAfterFailedInitialization = true, we will poll later and get a config, otherwise not
       expect(callCount).toBe(pollAfterFailedInitialization ? 2 : 1);

src/client/eppo-client.ts

@@ -15,7 +15,7 @@ import {
   DEFAULT_POLL_CONFIG_REQUEST_RETRIES,
   DEFAULT_REQUEST_TIMEOUT_MS,
   MAX_EVENT_QUEUE_SIZE,
-  POLL_INTERVAL_MS,
+  DEFAULT_POLL_INTERVAL_MS,
 } from '../constants';
 import { decodeFlag } from '../decoding';
 import { EppoValue } from '../eppo_value';
@@ -60,6 +60,7 @@ export type FlagConfigurationRequestParameters = {
   sdkName: string;
   baseUrl?: string;
   requestTimeoutMs?: number;
+  pollingIntervalMs?: number;
   numInitialRequestRetries?: number;
   numPollRequestRetries?: number;
   pollAfterSuccessfulInitialization?: boolean;
@@ -121,32 +122,27 @@ export default class EppoClient {
         'Eppo SDK unable to fetch flag configurations without configuration request parameters',
       );
     }
+    // if fetchFlagConfigurations() was previously called, stop any polling process from that call
+    this.requestPoller?.stop();
 
-    if (this.requestPoller) {
-      // if fetchFlagConfigurations() was previously called, stop any polling process from that call
-      this.requestPoller.stop();
-    }
-
-    const isExpired = await this.flagConfigurationStore.isExpired();
-    if (!isExpired) {
-      logger.info(
-        '[Eppo SDK] Configuration store is not expired. Skipping fetching flag configurations',
-      );
-      return;
-    }
     const {
       apiKey,
       sdkName,
       sdkVersion,
       baseUrl, // Default is set in ApiEndpoints constructor if undefined
       requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS,
+      pollingIntervalMs = DEFAULT_POLL_INTERVAL_MS,
       numInitialRequestRetries = DEFAULT_INITIAL_CONFIG_REQUEST_RETRIES,
       numPollRequestRetries = DEFAULT_POLL_CONFIG_REQUEST_RETRIES,
       pollAfterSuccessfulInitialization = false,
       pollAfterFailedInitialization = false,
       throwOnFailedInitialization = false,
       skipInitialPoll = false,
     } = this.configurationRequestParameters;
+    if (pollingIntervalMs <= 0) {
+      logger.error('PollingIntervalMs must be greater than 0');
+    }
+
     // todo: Inject the chain of dependencies below
     const apiEndpoints = new ApiEndpoints({
       baseUrl,
@@ -160,18 +156,20 @@ export default class EppoClient {
       this.banditModelConfigurationStore ?? null,
     );
 
-    this.requestPoller = initPoller(
-      POLL_INTERVAL_MS,
-      configurationRequestor.fetchAndStoreConfigurations.bind(configurationRequestor),
-      {
-        maxStartRetries: numInitialRequestRetries,
-        maxPollRetries: numPollRequestRetries,
-        pollAfterSuccessfulStart: pollAfterSuccessfulInitialization,
-        pollAfterFailedStart: pollAfterFailedInitialization,
-        errorOnFailedStart: throwOnFailedInitialization,
-        skipInitialPoll: skipInitialPoll,
-      },
-    );
+    const pollingCallback = async () => {
+      if (await this.flagConfigurationStore.isExpired()) {
+        return configurationRequestor.fetchAndStoreConfigurations();
+      }
+    };
+
+    this.requestPoller = initPoller(pollingIntervalMs, pollingCallback, {
+      maxStartRetries: numInitialRequestRetries,
+      maxPollRetries: numPollRequestRetries,
+      pollAfterSuccessfulStart: pollAfterSuccessfulInitialization,
+      pollAfterFailedStart: pollAfterFailedInitialization,
+      errorOnFailedStart: throwOnFailedInitialization,
+      skipInitialPoll: skipInitialPoll,
+    });
 
     await this.requestPoller.start();
   }

src/constants.ts

@@ -1,6 +1,6 @@
 export const DEFAULT_REQUEST_TIMEOUT_MS = 5000;
 export const REQUEST_TIMEOUT_MILLIS = DEFAULT_REQUEST_TIMEOUT_MS; // for backwards compatibility
-export const POLL_INTERVAL_MS = 30000;
+export const DEFAULT_POLL_INTERVAL_MS = 30000;
 export const POLL_JITTER_PCT = 0.1;
 export const DEFAULT_INITIAL_CONFIG_REQUEST_RETRIES = 1;
 export const DEFAULT_POLL_CONFIG_REQUEST_RETRIES = 7;

src/poller.spec.ts

@@ -1,10 +1,10 @@
 import * as td from 'testdouble';
 
-import { POLL_INTERVAL_MS, POLL_JITTER_PCT } from './constants';
+import { DEFAULT_POLL_INTERVAL_MS, POLL_JITTER_PCT } from './constants';
 import initPoller from './poller';
 
 describe('poller', () => {
-  const testIntervalMs = POLL_INTERVAL_MS;
+  const testIntervalMs = DEFAULT_POLL_INTERVAL_MS;
   const maxRetryDelay = testIntervalMs * POLL_JITTER_PCT;
   const noOpCallback = td.func<() => Promise<void>>();