updated datasource states. shutdown to be closed and now closed and initializing can occur more than once

Author: tanderson-ld

packages/shared/sdk-client/__tests__/LDClientImpl.test.ts

@@ -33,12 +33,18 @@ describe('sdk-client object', () => {
   let mockPlatform: ReturnType<typeof createBasicPlatform>;
   let logger: ReturnType<typeof createLogger>;
 
-  const onDataSourceChangePromise = () =>
-    new Promise<string[]>((res) => {
-      ldc.on('dataSourceStatus', (_context: LDContext, changes: string[]) => {
-        res(changes);
+  function onDataSourceChangePromise(numToAwait: number) {
+    let countdown = numToAwait;
+    // eslint-disable-next-line no-new
+    return new Promise<void>((res) => {
+      ldc.on('dataSourceStatus', () => {
+        countdown -= 1;
+        if (countdown === 0) {
+          res();
+        }
       });
     });
+  }
 
   beforeEach(() => {
     mockPlatform = createBasicPlatform();
@@ -321,12 +327,21 @@ describe('sdk-client object', () => {
 
     const spyListener = jest.fn();
     ldc.on('dataSourceStatus', spyListener);
-    const changePromise = onDataSourceChangePromise();
+    const changePromise = onDataSourceChangePromise(2);
     await ldc.identify(carContext);
     await changePromise;
 
+    expect(spyListener).toHaveBeenCalledTimes(2);
     expect(spyListener).toHaveBeenNthCalledWith(
       1,
+      expect.objectContaining({
+        state: DataSourceState.Initializing,
+        stateSince: expect.any(Number),
+        lastError: undefined,
+      }),
+    );
+    expect(spyListener).toHaveBeenNthCalledWith(
+      2,
       expect.objectContaining({
         state: DataSourceState.Valid,
         stateSince: expect.any(Number),
@@ -335,7 +350,7 @@ describe('sdk-client object', () => {
     );
   });
 
-  test('data source status emits shutdown when initialization encounters unrecoverable error', async () => {
+  test('data source status emits closed when initialization encounters unrecoverable error', async () => {
     const carContext: LDContext = { kind: 'car', key: 'test-car' };
 
     mockPlatform.crypto.randomUUID.mockReturnValue('random1');
@@ -350,16 +365,23 @@ describe('sdk-client object', () => {
 
     const spyListener = jest.fn();
     ldc.on('dataSourceStatus', spyListener);
-    const changePromise = onDataSourceChangePromise();
-
+    const changePromise = onDataSourceChangePromise(2);
     await expect(ldc.identify(carContext)).rejects.toThrow('test-error');
     await changePromise;
 
-    expect(spyListener).toHaveBeenCalledTimes(1);
+    expect(spyListener).toHaveBeenCalledTimes(2);
     expect(spyListener).toHaveBeenNthCalledWith(
       1,
       expect.objectContaining({
-        state: DataSourceState.Shutdown,
+        state: DataSourceState.Initializing,
+        stateSince: expect.any(Number),
+        lastError: undefined,
+      }),
+    );
+    expect(spyListener).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({
+        state: DataSourceState.Closed,
         stateSince: expect.any(Number),
         lastError: expect.anything(),
       }),

packages/shared/sdk-client/__tests__/datasource/DataSourceStatusManager.test.ts

@@ -4,39 +4,40 @@ import { DataSourceState } from '../../src/datasource/DataSourceStatus';
 import DataSourceStatusManager from '../../src/datasource/DataSourceStatusManager';
 
 describe('DataSourceStatusManager', () => {
-  test('its first state is initializing', async () => {
+  test('its first state is closed', async () => {
     const underTest = new DataSourceStatusManager();
-    expect(underTest.status.state).toEqual(DataSourceState.Initializing);
+    expect(underTest.status.state).toEqual(DataSourceState.Closed);
   });
 
-  test('it stays at initializing if receives non shutdown error', async () => {
+  test('it stays at initializing if receives recoverable error', async () => {
     const underTest = new DataSourceStatusManager();
-    underTest.setError(DataSourceErrorKind.ErrorResponse, 'womp', 404, true);
+    underTest.requestStateUpdate(DataSourceState.Initializing);
+    underTest.reportError(DataSourceErrorKind.ErrorResponse, 'womp', 404, true);
     expect(underTest.status.state).toEqual(DataSourceState.Initializing);
   });
 
-  test('it moves to shutdown if receives shutdown error', async () => {
+  test('it moves to closed if receives unrecoverable error', async () => {
     const underTest = new DataSourceStatusManager();
-    underTest.setError(DataSourceErrorKind.ErrorResponse, 'womp', 404, false);
-    expect(underTest.status.state).toEqual(DataSourceState.Shutdown);
+    underTest.requestStateUpdate(DataSourceState.Initializing);
+    underTest.reportError(DataSourceErrorKind.ErrorResponse, 'womp', 404, false);
+    expect(underTest.status.state).toEqual(DataSourceState.Closed);
   });
 
   test('it updates last error time with each error, but not stateSince', async () => {
     let time = 0;
     const stamper: () => number = () => time;
     const underTest = new DataSourceStatusManager(stamper);
-
-    underTest.setError(DataSourceErrorKind.ErrorResponse, 'womp', 404, true);
+    underTest.reportError(DataSourceErrorKind.ErrorResponse, 'womp', 404, true);
     expect(underTest.status.stateSince).toEqual(0);
     expect(underTest.status.lastError?.time).toEqual(0);
 
     time += 1;
-    underTest.setError(DataSourceErrorKind.ErrorResponse, 'womp', 404, true);
+    underTest.reportError(DataSourceErrorKind.ErrorResponse, 'womp', 404, true);
     expect(underTest.status.stateSince).toEqual(0);
     expect(underTest.status.lastError?.time).toEqual(1);
 
     time += 1;
-    underTest.setError(DataSourceErrorKind.ErrorResponse, 'womp', 404, true);
+    underTest.reportError(DataSourceErrorKind.ErrorResponse, 'womp', 404, true);
     expect(underTest.status.stateSince).toEqual(0);
     expect(underTest.status.lastError?.time).toEqual(2);
   });
@@ -46,15 +47,15 @@ describe('DataSourceStatusManager', () => {
     const stamper: () => number = () => time;
 
     const underTest = new DataSourceStatusManager(stamper);
-    expect(underTest.status.state).toEqual(DataSourceState.Initializing);
+    expect(underTest.status.state).toEqual(DataSourceState.Closed);
     expect(underTest.status.stateSince).toEqual(0);
 
     time += 1;
-    underTest.setValid();
+    underTest.requestStateUpdate(DataSourceState.Valid);
     expect(underTest.status.stateSince).toEqual(1);
 
     time += 1;
-    underTest.setShutdown();
+    underTest.requestStateUpdate(DataSourceState.Closed);
     expect(underTest.status.stateSince).toEqual(2);
   });
 
@@ -65,13 +66,13 @@ describe('DataSourceStatusManager', () => {
     const spyListener = jest.fn();
     underTest.on(spyListener);
 
-    underTest.setOffline();
+    underTest.requestStateUpdate(DataSourceState.SetOffline);
     time += 1;
-    underTest.setError(DataSourceErrorKind.ErrorResponse, 'womp', 400, true);
+    underTest.reportError(DataSourceErrorKind.ErrorResponse, 'womp', 400, true);
     time += 1;
-    underTest.setError(DataSourceErrorKind.ErrorResponse, 'womp', 400, true);
+    underTest.reportError(DataSourceErrorKind.ErrorResponse, 'womp', 400, true);
     time += 1;
-    underTest.setShutdown();
+    underTest.requestStateUpdate(DataSourceState.Closed);
     expect(spyListener).toHaveBeenCalledTimes(4);
     expect(spyListener).toHaveBeenNthCalledWith(
       1,
@@ -100,7 +101,7 @@ describe('DataSourceStatusManager', () => {
     expect(spyListener).toHaveBeenNthCalledWith(
       4,
       expect.objectContaining({
-        state: DataSourceState.Shutdown,
+        state: DataSourceState.Closed,
         stateSince: 3,
         lastError: expect.anything(),
       }),

packages/shared/sdk-client/src/LDClientImpl.ts

@@ -27,7 +27,7 @@ import { LDClientInternalOptions } from './configuration/Configuration';
 import { addAutoEnv } from './context/addAutoEnv';
 import { ensureKey } from './context/ensureKey';
 import DataSourceEventHandler from './datasource/DataSourceEventHandler';
-import DataSourceStatus from './datasource/DataSourceStatus';
+import DataSourceStatus, { DataSourceState } from './datasource/DataSourceStatus';
 import DataSourceStatusManager from './datasource/DataSourceStatusManager';
 import createDiagnosticsManager from './diagnostics/createDiagnosticsManager';
 import {
@@ -155,7 +155,7 @@ export default class LDClientImpl implements LDClient {
     switch (mode) {
       case 'offline':
         this.updateProcessor?.close();
-        this.dataSourceStatusManager.setOffline();
+        this.dataSourceStatusManager.requestStateUpdate(DataSourceState.SetOffline);
         break;
       case 'polling':
       case 'streaming':
@@ -204,7 +204,7 @@ export default class LDClientImpl implements LDClient {
     await this.flush();
     this.eventProcessor?.close();
     this.updateProcessor?.close();
-    this.dataSourceStatusManager.setShutdown();
+    this.dataSourceStatusManager.requestStateUpdate(DataSourceState.Closed);
     this.logger.debug('Closed event processor and data source.');
   }
 
@@ -387,7 +387,10 @@ export default class LDClientImpl implements LDClient {
       }
     } else {
       // we don't update data source status in this path because we are about to start again
-      this.updateProcessor?.close();
+      if (this.updateProcessor) {
+        this.updateProcessor.close();
+        this.dataSourceStatusManager.requestStateUpdate(DataSourceState.Closed);
+      }
 
       switch (this.getConnectionMode()) {
         case 'streaming':
@@ -399,6 +402,8 @@ export default class LDClientImpl implements LDClient {
         default:
           break;
       }
+      // update status before starting processor to ensure potential errors are reported after initializing
+      this.dataSourceStatusManager.requestStateUpdate(DataSourceState.Initializing);
       this.updateProcessor!.start();
     }
 

packages/shared/sdk-client/src/datasource/DataSourceEventHandler.ts

@@ -3,6 +3,7 @@ import { Context, internal, LDLogger } from '@launchdarkly/js-sdk-common';
 import FlagManager from '../flag-manager/FlagManager';
 import { ItemDescriptor } from '../flag-manager/ItemDescriptor';
 import { DeleteFlag, Flags, PatchFlag } from '../types';
+import { DataSourceState } from './DataSourceStatus';
 import DataSourceStatusManager from './DataSourceStatusManager';
 
 type LDStreamingError = internal.LDStreamingError;
@@ -27,7 +28,7 @@ export default class DataSourceEventHandler {
       {},
     );
     await this.flagManager.init(context, descriptors);
-    this.statusManager.setValid();
+    this.statusManager.requestStateUpdate(DataSourceState.Valid);
   }
 
   async handlePatch(context: Context, patchFlag: PatchFlag) {
@@ -57,10 +58,10 @@ export default class DataSourceEventHandler {
   }
 
   handleStreamingError(error: LDStreamingError) {
-    this.statusManager.setError(error.kind, error.message, error.code, error.recoverable);
+    this.statusManager.reportError(error.kind, error.message, error.code, error.recoverable);
   }
 
   handlePollingError(error: LDPollingError) {
-    this.statusManager.setError(error.kind, error.message, error.status, error.recoverable);
+    this.statusManager.reportError(error.kind, error.message, error.status, error.recoverable);
   }
 }

packages/shared/sdk-client/src/datasource/DataSourceStatus.ts

@@ -5,7 +5,7 @@ export enum DataSourceState {
   Valid,
   Interrupted,
   SetOffline,
-  Shutdown,
+  Closed,
   // TODO: SDK-702 - Implement network availability behaviors
   // NetworkUnavailable,
 }
@@ -20,8 +20,8 @@ export default interface DataSourceStatus {
    * The UNIX epoch timestamp in milliseconds that the value of State most recently changed.
    *
    * The meaning of this depends on the current state:
-   * For {@link DataSourceState.Initializing}, it is the time that the SDK started
-   * initializing.
+   * For {@link DataSourceState.Initializing}, it is the time that the datasource started
+   * attempting to retrieve data.
    *
    * For {@link DataSourceState.Valid}, it is the time that the data source most
    * recently entered a valid state, after previously having been
@@ -32,8 +32,8 @@ export default interface DataSourceStatus {
    * most recently entered an error state, after previously having been
    * {@link DataSourceState.valid}.
    *
-   * For {@link DataSourceState.Shutdown}, it is the time that the data source
-   * encountered an unrecoverable error or that the datasource was explicitly shut down.
+   * For {@link DataSourceState.Closed}, it is the time that the data source
+   * encountered an unrecoverable error or that the datasource was explicitly closed.
    */
   readonly stateSince: number;
 

packages/shared/sdk-client/src/datasource/DataSourceStatusManager.ts

@@ -22,7 +22,7 @@ export default class DataSourceStatusManager {
   private emitter: LDEmitter;
 
   constructor(timeStamper: () => number = () => Date.now()) {
-    this.state = DataSourceState.Initializing;
+    this.state = DataSourceState.Closed;
     this.stateSinceMillis = timeStamper();
     this.emitter = new LDEmitter();
     this.timeStamper = timeStamper;
@@ -74,24 +74,12 @@ export default class DataSourceStatusManager {
   }
 
   /**
-   * Sets the state to {@link DataSourceState.Valid}
+   * Requests the manager move to the provided state.  This request may be ignored
+   * if the current state cannot transition to the requested state.
+   * @param state that is requested
    */
-  setValid() {
-    this.updateState(DataSourceState.Valid);
-  }
-
-  /**
-   * Sets the state to {@link DataSourceState.SetOffline}
-   */
-  setOffline() {
-    this.updateState(DataSourceState.SetOffline);
-  }
-
-  /**
-   * Sets the state to {@link DataSourceState.Shutdown}
-   */
-  setShutdown() {
-    this.updateState(DataSourceState.Shutdown);
+  requestStateUpdate(state: DataSourceState) {
+    this.updateState(state);
   }
 
   /**
@@ -104,7 +92,7 @@ export default class DataSourceStatusManager {
    * @param statusCode of the error if there was one
    * @param recoverable to indicate that the error is anticipated to be recoverable
    */
-  setError(
+  reportError(
     kind: DataSourceErrorKind,
     message: string,
     statusCode?: number,
@@ -117,7 +105,7 @@ export default class DataSourceStatusManager {
       time: this.timeStamper(),
     };
     this.errorInfo = errorInfo;
-    this.updateState(recoverable ? DataSourceState.Interrupted : DataSourceState.Shutdown, true);
+    this.updateState(recoverable ? DataSourceState.Interrupted : DataSourceState.Closed, true);
   }
 
   // TODO: SDK-702 - Implement network availability behaviors

packages/shared/sdk-client/src/index.ts

@@ -1,4 +1,5 @@
 import { LDClientInternalOptions } from './configuration/Configuration';
+import DataSourceStatus from './datasource/DataSourceStatus';
 import LDClientImpl from './LDClientImpl';
 
 export * from '@launchdarkly/js-sdk-common';
@@ -19,4 +20,4 @@ export type {
 
 export { DataSourcePaths } from './streaming';
 
-export { LDClientImpl, LDClientInternalOptions };
+export { DataSourceStatus, LDClientImpl, LDClientInternalOptions };