Common configuration requestor/poller (#35)

* move poller over

* poller worked into init

* bump version number

* use yarn with the makefile prepare commands

* test for happy path client fetch

* initial rery function working

* selective jest mocking

* better test case

* better logging and improved poller test

* make compatible with node sdk

* changes for node sdk server to work

* clear timeout when stopped

* remove dummy test

* remove unused import

Author: aarsilv

Makefile

@@ -45,5 +45,5 @@ test-data:
 .PHONY: prepare
 prepare: test-data
 	 rm -rf dist/
-	 tsc
-	 webpack
+	 yarn tsc
+	 yarn webpack

jest.config.js renamed to jest.config.ts

@@ -1,4 +1,4 @@
-module.exports = {
+const jestConfig = {
   moduleFileExtensions: ['js', 'json', 'ts'],
   rootDir: './',
   moduleNameMapper: {
@@ -12,9 +12,6 @@ module.exports = {
   collectCoverageFrom: ['**/*.(t|j)s'],
   coverageDirectory: 'coverage/',
   testEnvironment: 'node',
-  globals: {
-    'ts-jest': {
-      isolatedModules: true,
-    },
-  },
 };
+
+export default jestConfig;

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eppo/js-client-sdk-common",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Eppo SDK for client-side JavaScript applications (base for both web and react native)",
   "main": "dist/index.js",
   "files": [
@@ -39,7 +39,7 @@
   },
   "homepage": "https://github.com/Eppo-exp/js-client-sdk-common#readme",
   "devDependencies": {
-    "@types/jest": "^28.1.1",
+    "@types/jest": "^29.5.11",
     "@types/md5": "^2.3.2",
     "@typescript-eslint/eslint-plugin": "^5.13.0",
     "@typescript-eslint/parser": "^5.13.0",
@@ -49,12 +49,12 @@
     "eslint-plugin-import": "^2.25.4",
     "eslint-plugin-prettier": "^4.0.0",
     "eslint-plugin-promise": "^6.0.0",
-    "jest": "^28.1.1",
-    "jest-environment-jsdom": "^28.1.1",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
     "prettier": "^2.7.1",
     "terser-webpack-plugin": "^5.3.3",
-    "testdouble": "^3.16.6",
-    "ts-jest": "^28.0.5",
+    "testdouble": "^3.20.1",
+    "ts-jest": "^29.1.1",
     "ts-loader": "^9.3.1",
     "ts-node": "^10.9.1",
     "typescript": "^4.7.4",

src/client/eppo-client.spec.ts

@@ -3,7 +3,7 @@
  */
 import axios from 'axios';
 import * as td from 'testdouble';
-import mock from 'xhr-mock';
+import mock, { MockResponse } from 'xhr-mock';
 
 import {
   IAssignmentTestCase,
@@ -16,19 +16,19 @@ import {
 import { IAssignmentHooks } from '../assignment-hooks';
 import { IAssignmentLogger } from '../assignment-logger';
 import { IConfigurationStore } from '../configuration-store';
-import { MAX_EVENT_QUEUE_SIZE } from '../constants';
+import { MAX_EVENT_QUEUE_SIZE, POLL_INTERVAL_MS, POLL_JITTER_PCT } from '../constants';
 import { OperatorType } from '../dto/rule-dto';
 import { EppoValue } from '../eppo_value';
 import ExperimentConfigurationRequestor from '../experiment-configuration-requestor';
 import HttpClient from '../http-client';
 
-import EppoClient from './eppo-client';
+import EppoClient, { ExperimentConfigurationRequestParameters } from './eppo-client';
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const packageJson = require('../../package.json');
 
 class TestConfigurationStore implements IConfigurationStore {
-  private store = {};
+  private store: Record<string, string> = {};
 
   public get<T>(key: string): T {
     const rval = this.store[key];
@@ -1101,3 +1101,172 @@ describe(' EppoClient getAssignment From Obfuscated RAC', () => {
     });
   }
 });
+
+describe('Eppo Client constructed with configuration request parameters', () => {
+  let client: EppoClient;
+  let storage: IConfigurationStore;
+  let requestConfiguration: ExperimentConfigurationRequestParameters;
+  let mockServerResponseFunc: (res: MockResponse) => MockResponse;
+
+  const racBody = JSON.stringify(readMockRacResponse(MOCK_RAC_RESPONSE_FILE));
+  const flagKey = 'randomization_algo';
+  const subjectForGreenVariation = 'subject-identiferA';
+
+  const maxRetryDelay = POLL_INTERVAL_MS * POLL_JITTER_PCT;
+
+  beforeAll(() => {
+    mock.setup();
+    mock.get(/randomized_assignment\/v3\/config*/, (_req, res) => {
+      return mockServerResponseFunc(res);
+    });
+  });
+
+  beforeEach(() => {
+    storage = new TestConfigurationStore();
+    requestConfiguration = {
+      apiKey: 'dummy key',
+      sdkName: 'js-client-sdk-common',
+      sdkVersion: packageJson.version,
+    };
+    mockServerResponseFunc = (res) => res.status(200).body(racBody);
+
+    // We only want to fake setTimeout() and clearTimeout()
+    jest.useFakeTimers({
+      advanceTimers: true,
+      doNotFake: [
+        'Date',
+        'hrtime',
+        'nextTick',
+        'performance',
+        'queueMicrotask',
+        'requestAnimationFrame',
+        'cancelAnimationFrame',
+        'requestIdleCallback',
+        'cancelIdleCallback',
+        'setImmediate',
+        'clearImmediate',
+        'setInterval',
+        'clearInterval',
+      ],
+    });
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+    jest.useRealTimers();
+  });
+
+  afterAll(() => {
+    mock.teardown();
+  });
+
+  it('Fetches initial configuration', async () => {
+    client = new EppoClient(storage, requestConfiguration);
+    client.setIsGracefulFailureMode(false);
+    // no configuration loaded
+    let variation = client.getAssignment(subjectForGreenVariation, flagKey);
+    expect(variation).toBeNull();
+    // have client fetch configurations
+    await client.fetchFlagConfigurations();
+    variation = client.getAssignment(subjectForGreenVariation, flagKey);
+    expect(variation).toBe('green');
+  });
+
+  it.each([
+    { pollAfterSuccessfulInitialization: false },
+    { pollAfterSuccessfulInitialization: true },
+  ])('retries initial configuration request with config %p', async (configModification) => {
+    let callCount = 0;
+    mockServerResponseFunc = (res) => {
+      if (++callCount === 1) {
+        // Throw an error for the first call
+        return res.status(500);
+      } else {
+        // Return a mock object for subsequent calls
+        return res.status(200).body(racBody);
+      }
+    };
+
+    const { pollAfterSuccessfulInitialization } = configModification;
+    requestConfiguration = {
+      ...requestConfiguration,
+      pollAfterSuccessfulInitialization,
+    };
+    client = new EppoClient(storage, requestConfiguration);
+    client.setIsGracefulFailureMode(false);
+    // no configuration loaded
+    let variation = client.getAssignment(subjectForGreenVariation, flagKey);
+    expect(variation).toBeNull();
+
+    // By not awaiting (yet) only the first attempt should be fired off before test execution below resumes
+    const fetchPromise = client.fetchFlagConfigurations();
+
+    // Advance timers mid-init to allow retrying
+    await jest.advanceTimersByTimeAsync(maxRetryDelay);
+
+    // Await so it can finish its initialization before this test proceeds
+    await fetchPromise;
+
+    variation = client.getAssignment(subjectForGreenVariation, flagKey);
+    expect(variation).toBe('green');
+    expect(callCount).toBe(2);
+
+    await jest.advanceTimersByTimeAsync(POLL_INTERVAL_MS);
+    // By default, no more polling
+    expect(callCount).toBe(pollAfterSuccessfulInitialization ? 3 : 2);
+  });
+
+  it.each([
+    { pollAfterFailedInitialization: false, throwOnFailedInitialization: false },
+    { pollAfterFailedInitialization: false, throwOnFailedInitialization: true },
+    { pollAfterFailedInitialization: true, throwOnFailedInitialization: false },
+    { pollAfterFailedInitialization: true, throwOnFailedInitialization: true },
+  ])('initial configuration request fails with config %p', async (configModification) => {
+    let callCount = 0;
+    mockServerResponseFunc = (res) => {
+      if (++callCount === 1) {
+        // Throw an error for initialization call
+        return res.status(500);
+      } else {
+        // Return a mock object for subsequent calls
+        return res.status(200).body(racBody);
+      }
+    };
+
+    const { pollAfterFailedInitialization, throwOnFailedInitialization } = configModification;
+
+    // Note: fake time does not play well with errors bubbled up after setTimeout (event loop,
+    // timeout queue, message queue stuff) so we don't allow retries when rethrowing.
+    const numInitialRequestRetries = 0;
+
+    requestConfiguration = {
+      ...requestConfiguration,
+      numInitialRequestRetries,
+      throwOnFailedInitialization,
+      pollAfterFailedInitialization,
+    };
+    client = new EppoClient(storage, requestConfiguration);
+    client.setIsGracefulFailureMode(false);
+    // no configuration loaded
+    expect(client.getAssignment(subjectForGreenVariation, flagKey)).toBeNull();
+
+    // By not awaiting (yet) only the first attempt should be fired off before test execution below resumes
+    if (throwOnFailedInitialization) {
+      await expect(client.fetchFlagConfigurations()).rejects.toThrow();
+    } else {
+      await expect(client.fetchFlagConfigurations()).resolves.toBeUndefined();
+    }
+    expect(callCount).toBe(1);
+    // still no configuration loaded
+    expect(client.getAssignment(subjectForGreenVariation, flagKey)).toBeNull();
+
+    // Advance timers so a post-init poll can take place
+    await jest.advanceTimersByTimeAsync(POLL_INTERVAL_MS * 1.5);
+
+    // if pollAfterFailedInitialization = true, we will poll later and get a config, otherwise not
+    expect(callCount).toBe(pollAfterFailedInitialization ? 2 : 1);
+    expect(client.getAssignment(subjectForGreenVariation, flagKey)).toBe(
+      pollAfterFailedInitialization ? 'green' : null,
+    );
+  });
+});

src/client/eppo-client.ts

@@ -1,3 +1,4 @@
+import axios from 'axios';
 import * as md5 from 'md5';
 
 import {
@@ -14,12 +15,22 @@ import {
   NullableHoldoutVariationType,
 } from '../assignment-logger';
 import { IConfigurationStore } from '../configuration-store';
-import { MAX_EVENT_QUEUE_SIZE } from '../constants';
+import {
+  BASE_URL as DEFAULT_BASE_URL,
+  DEFAULT_INITIAL_CONFIG_REQUEST_RETRIES,
+  DEFAULT_POLL_CONFIG_REQUEST_RETRIES,
+  DEFAULT_REQUEST_TIMEOUT_MS as DEFAULT_REQUEST_TIMEOUT_MS,
+  MAX_EVENT_QUEUE_SIZE,
+  POLL_INTERVAL_MS,
+} from '../constants';
 import { IAllocation } from '../dto/allocation-dto';
 import { IExperimentConfiguration } from '../dto/experiment-configuration-dto';
 import { IVariation } from '../dto/variation-dto';
 import { EppoValue, ValueType } from '../eppo_value';
+import ExperimentConfigurationRequestor from '../experiment-configuration-requestor';
+import HttpClient from '../http-client';
 import { getMD5Hash } from '../obfuscation';
+import initPoller, { IPoller } from '../poller';
 import { findMatchingRule } from '../rule_evaluator';
 import { getShard, isShardInRange } from '../shard';
 import { validateNotBlank } from '../validation';
@@ -97,15 +108,102 @@ export interface IEppoClient {
     subjectAttributes?: Record<string, any>,
     assignmentHooks?: IAssignmentHooks,
   ): object | null;
+
+  setLogger(logger: IAssignmentLogger): void;
+
+  useLRUInMemoryAssignmentCache(maxSize: number): void;
+
+  useCustomAssignmentCache(cache: AssignmentCache<Cacheable>): void;
+
+  fetchFlagConfigurations(): void;
+
+  stopPolling(): void;
+
+  setIsGracefulFailureMode(gracefulFailureMode: boolean): void;
 }
 
+export type ExperimentConfigurationRequestParameters = {
+  apiKey: string;
+  sdkVersion: string;
+  sdkName: string;
+  baseUrl?: string;
+  requestTimeoutMs?: number;
+  numInitialRequestRetries?: number;
+  numPollRequestRetries?: number;
+  pollAfterSuccessfulInitialization?: boolean;
+  pollAfterFailedInitialization?: boolean;
+  throwOnFailedInitialization?: boolean;
+};
+
 export default class EppoClient implements IEppoClient {
   private queuedEvents: IAssignmentEvent[] = [];
   private assignmentLogger: IAssignmentLogger | undefined;
   private isGracefulFailureMode = true;
   private assignmentCache: AssignmentCache<Cacheable> | undefined;
+  private configurationStore: IConfigurationStore;
+  private configurationRequestConfig: ExperimentConfigurationRequestParameters | undefined;
+  private requestPoller: IPoller | undefined;
+
+  constructor(
+    configurationStore: IConfigurationStore,
+    configurationRequestConfig?: ExperimentConfigurationRequestParameters,
+  ) {
+    this.configurationStore = configurationStore;
+    this.configurationRequestConfig = configurationRequestConfig;
+  }
+
+  public async fetchFlagConfigurations() {
+    if (!this.configurationRequestConfig) {
+      throw new Error(
+        'Eppo SDK unable to fetch flag configurations without a request configuration',
+      );
+    }
+
+    if (this.requestPoller) {
+      // if fetchFlagConfigurations() was previously called, stop any polling process from that call
+      this.requestPoller.stop();
+    }
+
+    const axiosInstance = axios.create({
+      baseURL: this.configurationRequestConfig.baseUrl || DEFAULT_BASE_URL,
+      timeout: this.configurationRequestConfig.requestTimeoutMs || DEFAULT_REQUEST_TIMEOUT_MS,
+    });
+    const httpClient = new HttpClient(axiosInstance, {
+      apiKey: this.configurationRequestConfig.apiKey,
+      sdkName: this.configurationRequestConfig.sdkName,
+      sdkVersion: this.configurationRequestConfig.sdkVersion,
+    });
+    const configurationRequestor = new ExperimentConfigurationRequestor(
+      this.configurationStore,
+      httpClient,
+    );
 
-  constructor(private configurationStore: IConfigurationStore) {}
+    this.requestPoller = initPoller(
+      POLL_INTERVAL_MS,
+      configurationRequestor.fetchAndStoreConfigurations.bind(configurationRequestor),
+      {
+        maxStartRetries:
+          this.configurationRequestConfig.numInitialRequestRetries ??
+          DEFAULT_INITIAL_CONFIG_REQUEST_RETRIES,
+        maxPollRetries:
+          this.configurationRequestConfig.numPollRequestRetries ??
+          DEFAULT_POLL_CONFIG_REQUEST_RETRIES,
+        pollAfterSuccessfulStart:
+          this.configurationRequestConfig.pollAfterSuccessfulInitialization ?? false,
+        pollAfterFailedStart:
+          this.configurationRequestConfig.pollAfterFailedInitialization ?? false,
+        errorOnFailedStart: this.configurationRequestConfig.throwOnFailedInitialization ?? false,
+      },
+    );
+
+    await this.requestPoller.start();
+  }
+
+  public stopPolling() {
+    if (this.requestPoller) {
+      this.requestPoller.stop();
+    }
+  }
 
   // @deprecated getAssignment is deprecated in favor of the typed get<Type>Assignment methods
   public getAssignment(