Merge branch 'ta/fdv2-temporary-holding' into ta/sdk-851/polling-synchronizer

Author: Todd Anderson

packages/shared/common/__tests__/subsystem/DataSystem/CompositeDataSource.test.ts

@@ -516,3 +516,74 @@ it('is well behaved with an initializer and no synchronizers configured', async
       'CompositeDataSource has exhausted all configured datasources (1 initializers, 0 synchronizers).',
   });
 });
+
+it('consumes cancellation tokens correctly', async () => {
+  const mockInitializer1 = {
+    start: jest
+      .fn()
+      .mockImplementation(
+        (
+          _dataCallback: (basis: boolean, data: any) => void,
+          _statusCallback: (status: DataSourceState, err?: any) => void,
+        ) => {
+          _dataCallback(true, { key: 'init1' });
+        },
+      ),
+    stop: jest.fn(),
+  };
+
+  const mockSynchronizer1 = {
+    start: jest
+      .fn()
+      .mockImplementation(
+        (
+          _dataCallback: (basis: boolean, data: any) => void,
+          _statusCallback: (status: DataSourceState, err?: any) => void,
+        ) => {
+          _statusCallback(DataSourceState.Initializing);
+          _statusCallback(DataSourceState.Interrupted); // report interrupted to schedule automatic transition and create cancellation token
+        },
+      ),
+    stop: jest.fn(),
+  };
+
+  const underTest = new CompositeDataSource(
+    [makeInitializerFactory(mockInitializer1)],
+    [makeSynchronizerFactory(mockSynchronizer1)],
+    undefined,
+    {
+      // pass in transition condition of 0 so that it will thrash, generating cancellation tokens repeatedly
+      [DataSourceState.Interrupted]: {
+        durationMS: 100,
+        transition: 'fallback',
+      },
+    },
+    makeZeroBackoff(),
+  );
+
+  let dataCallback;
+  let statusCallback;
+  let interruptedCount = 0;
+  await new Promise<void>((resolve) => {
+    dataCallback = jest.fn();
+    statusCallback = jest.fn((_1: DataSourceState, _2: any) => {
+      interruptedCount += 1;
+      if (interruptedCount > 10) {
+        // let it thrash for N iterations
+        resolve();
+      }
+    });
+
+    underTest.start(dataCallback, statusCallback);
+  });
+
+  // @ts-ignore
+  // eslint-disable-next-line no-underscore-dangle
+  expect(underTest._cancelTokens.length).toEqual(1);
+
+  underTest.stop();
+
+  // @ts-ignore
+  // eslint-disable-next-line no-underscore-dangle
+  expect(underTest._cancelTokens.length).toEqual(0);
+});

packages/shared/common/src/datasource/CompositeDataSource.ts

@@ -136,6 +136,7 @@ export class CompositeDataSource implements DataSource {
                     cancelScheduledTransition = cancel;
                     this._cancelTokens.push(cancelScheduledTransition);
                     promise.then(() => {
+                      this._consumeCancelToken(cancel);
                       callbackHandler.disable();
                       transitionResolve({ transition: condition.transition });
                     });
@@ -176,7 +177,10 @@ export class CompositeDataSource implements DataSource {
         const delay = this._backoff.fail();
         const { promise, cancel: cancelDelay } = this._cancellableDelay(delay);
         this._cancelTokens.push(cancelDelay);
-        const delayedTransition = promise.then(() => transitionRequest);
+        const delayedTransition = promise.then(() => {
+          this._consumeCancelToken(cancelDelay);
+          return transitionRequest;
+        });
 
         // race the delayed transition and external transition requests to be responsive
         transitionRequest = await Promise.race([

packages/shared/sdk-server/__tests__/options/Configuration.test.ts

@@ -22,7 +22,7 @@ function logger(options: LDOptions): TestLogger {
 describe.each([undefined, null, 'potat0', 17, [], {}])('constructed without options', (input) => {
   it('should have default options', () => {
     // JavaScript is not going to stop you from calling this with whatever
-    // you want. So we need to tell TS to ingore our bad behavior.
+    // you want. So we need to tell TS to ignore our bad behavior.
     // @ts-ignore
     const config = new Configuration(input);
 
@@ -47,7 +47,7 @@ describe.each([undefined, null, 'potat0', 17, [], {}])('constructed without opti
     expect(config.tags.value).toBeUndefined();
     expect(config.timeout).toEqual(5);
     expect(config.tlsParams).toBeUndefined();
-    expect(config.useLdd).toBe(false);
+    expect(config.dataSystem.useLdd).toBe(false);
     expect(config.wrapperName).toBeUndefined();
     expect(config.wrapperVersion).toBeUndefined();
     expect(config.hooks).toBeUndefined();
@@ -233,7 +233,7 @@ describe('when setting different options', () => {
   ])('allows setting stream and validates useLdd', (value, expected, warnings) => {
     // @ts-ignore
     const config = new Configuration(withLogger({ useLdd: value }));
-    expect(config.useLdd).toEqual(expected);
+    expect(config.dataSystem.useLdd).toEqual(expected);
     expect(logger(config).getCount()).toEqual(warnings);
   });
 
@@ -421,7 +421,7 @@ describe('when setting different options', () => {
     ]);
   });
 
-  it('drops invalid dataystem data source options and replaces with defaults', () => {
+  it('drops invalid datasystem data source options and replaces with defaults', () => {
     const config = new Configuration(
       withLogger({
         dataSystem: { dataSource: { bogus: 'myBogusOptions' } as unknown as DataSourceOptions },
@@ -436,7 +436,7 @@ describe('when setting different options', () => {
     ]);
   });
 
-  it('validates the datasystem persitent store is a factory or object', () => {
+  it('validates the datasystem persistent store is a factory or object', () => {
     const config1 = new Configuration(
       withLogger({
         dataSystem: {
@@ -501,7 +501,7 @@ describe('when setting different options', () => {
     expect(logger(config).getCount()).toEqual(0);
   });
 
-  it('ignores top level featureStore in favor of the datasystem persitent store', () => {
+  it('ignores top level featureStore in favor of the datasystem persistent store', () => {
     const shouldNotBeUsed = new InMemoryFeatureStore();
     const shouldBeUsed = new InMemoryFeatureStore();
     const config = new Configuration(
@@ -516,4 +516,29 @@ describe('when setting different options', () => {
     const result = config.dataSystem.featureStoreFactory(null);
     expect(result).toEqual(shouldBeUsed);
   });
+
+  it('ignores top level useLdd option if datasystem is specified', () => {
+    const config = new Configuration(
+      withLogger({
+        dataSystem: {
+          persistentStore: new InMemoryFeatureStore(),
+        },
+        useLdd: true,
+      }),
+    );
+    const result = config.dataSystem.useLdd;
+    expect(result).toEqual(undefined);
+
+    const config2 = new Configuration(
+      withLogger({
+        dataSystem: {
+          persistentStore: new InMemoryFeatureStore(),
+          useLdd: true,
+        },
+        useLdd: false,
+      }),
+    );
+    const result2 = config2.dataSystem.useLdd;
+    expect(result2).toEqual(true);
+  });
 });

packages/shared/sdk-server/src/api/options/LDDataSystemOptions.ts

@@ -37,9 +37,9 @@ export interface LDDataSystemOptions {
    * type and the optional fields you want to customize.
    *
    * If not specified, this defaults to using the {@link StandardDataSourceOptions} which
-   * pefroms a combination of streaming and polling.
+   * performs a combination of streaming and polling.
    *
-   * See {@link LDDataSystemOptions} decoumentation for exmaples.
+   * See {@link LDDataSystemOptions} documentation for examples.
    */
   dataSource?: DataSourceOptions;
 
@@ -48,11 +48,11 @@ export interface LDDataSystemOptions {
    * data from the persistent store. Once fresh data has arrived from LaunchDarkly, the
    * SDK will no longer read from the persistent store, although it will keep it up-to-date
    * for future startups.
-   * 
+   *
    * Some implementations provide the store implementation object itself, while others
    * provide a factory function that creates the store implementation based on the SDK
    * configuration; this property accepts either.
-   * 
+   *
    * @param clientContext whose properties may be used to influence creation of the persistent store.
    */
   persistentStore?: LDFeatureStore | ((clientContext: LDClientContext) => LDFeatureStore);
@@ -68,7 +68,7 @@ export interface LDDataSystemOptions {
 
   /**
    * A component that obtains feature flag data and puts it in the feature store. Setting
-   * this supercedes {@link LDDataSystemOptions#dataSource}.
+   * this supersedes {@link LDDataSystemOptions#dataSource}.
    */
   updateProcessor?:
     | object

packages/shared/sdk-server/src/api/options/LDOptions.ts

@@ -83,7 +83,7 @@ export interface LDOptions {
    * Configuration options for the Data System that the SDK uses to get and maintain flags and other
    * data from LaunchDarkly and other sources.
    *
-   * Setting this option supercedes
+   * Setting this option supersedes
    *
    * Example (Recommended):
    * ```typescript
@@ -127,9 +127,6 @@ export interface LDOptions {
    * A component that obtains feature flag data and puts it in the feature store.
    *
    * If you specify the {@link LDOptions#dataSystem}, this setting will be ignored.
-   *
-   * @deprecated This has moved to {@link LDOptions#dataSystem}. Use property
-   * {@link LDDataSystemOptions#updateProcessor} instead.
    */
   updateProcessor?:
     | object
@@ -149,10 +146,6 @@ export interface LDOptions {
    * The time between polling requests, in seconds. Ignored in streaming mode.
    *
    * If you specify the {@link LDOptions#dataSystem}, this setting will be ignored.
-   *
-   * @deprecated This functionality is now controlled by {@link LDOptions#dataSystem} by
-   * specifying the {@link LDDataSystemOptions#dataSource}. Specifying the polling interval is still
-   * available when using {@link StandardDataSourceOptions} or {@link PollingDataSourceOptions}.
    */
   pollInterval?: number;
 
@@ -220,7 +213,7 @@ export interface LDOptions {
   sendEvents?: boolean;
 
   /**
-   * Whether all context attributes (except the contexy key) should be marked as private, and
+   * Whether all context attributes (except the context key) should be marked as private, and
    * not sent to LaunchDarkly.
    *
    * By default, this is false.

packages/shared/sdk-server/src/diagnostics/createDiagnosticsInitConfig.ts

@@ -43,7 +43,7 @@ const createDiagnosticsInitConfig = (
   diagnosticRecordingIntervalMillis: secondsToMillis(config.diagnosticRecordingInterval),
 
   streamingDisabled: isPollingOnlyOptions(config.dataSystem.dataSource),
-  usingRelayDaemon: config.useLdd,
+  usingRelayDaemon: config.dataSystem.useLdd,
   offline: config.offline,
   allAttributesPrivate: config.allAttributesPrivate,
   contextKeysCapacity: config.contextKeysCapacity,

packages/shared/sdk-server/src/options/Configuration.ts

@@ -299,8 +299,6 @@ export default class Configuration {
 
   public readonly offline: boolean;
 
-  public readonly useLdd: boolean;
-
   public readonly sendEvents: boolean;
 
   public readonly allAttributesPrivate: boolean;
@@ -447,6 +445,5 @@ Type '((LDFeatureStore | ((options: LDOptions) => LDFeatureStore)) & ((...args:
     this.hooks = validatedOptions.hooks;
 
     this.offline = validatedOptions.offline;
-    this.useLdd = validatedOptions.useLdd;
   }
 }

packages/shared/sdk-server/src/options/ValidatedOptions.ts

@@ -23,7 +23,6 @@ export interface ValidatedOptions {
   flushInterval: number;
   pollInterval: number;
   offline: boolean;
-  useLdd: boolean;
   allAttributesPrivate: false;
   privateAttributes: string[];
   contextKeysCapacity: number;