chore: Adds LDDataSystemOptions for configuring the Data System.

Author: tanderson-ld

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

@@ -29,6 +29,7 @@ interface TransitionRequest {
   err?: Error;
 }
 
+// TODO SDK-858: move this out of API directory to neighbor datasource folder
 /**
  * The {@link CompositeDataSource} can combine a number of {@link DataSystemInitializer}s and {@link DataSystemSynchronizer}s
  * into a single {@link DataSource}, implementing fallback and recovery logic internally to choose where data is sourced from.

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

@@ -408,4 +408,8 @@ describe('when setting different options', () => {
       },
     ]);
   });
+
+  it('drop', () => {
+
+  }
 });

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

@@ -30,6 +30,11 @@ import {
 import { Hook } from './api/integrations/Hook';
 import { BigSegmentStoreMembership } from './api/interfaces';
 import { LDWaitForInitializationOptions } from './api/LDWaitForInitializationOptions';
+import {
+  isPollingOptions,
+  isStandardOptions,
+  isStreamingOptions,
+} from './api/options/LDDataSystemOptions';
 import BigSegmentsManager from './BigSegmentsManager';
 import BigSegmentStoreStatusProvider from './BigSegmentStatusProviderImpl';
 import { createStreamListeners } from './data_sources/createStreamListeners';
@@ -219,25 +224,34 @@ export default class LDClientImpl implements LDClient {
     const listeners = createStreamListeners(dataSourceUpdates, this._logger, {
       put: () => this._initSuccess(),
     });
-    const makeDefaultProcessor = () =>
-      config.stream
-        ? new StreamingProcessor(
-            clientContext,
-            '/all',
-            [],
-            listeners,
-            baseHeaders,
-            this._diagnosticsManager,
-            (e) => this._dataSourceErrorHandler(e),
-            this._config.streamInitialReconnectDelay,
-          )
-        : new PollingProcessor(
-            config,
-            new Requestor(config, this._platform.requests, baseHeaders),
-            dataSourceUpdates,
-            () => this._initSuccess(),
-            (e) => this._dataSourceErrorHandler(e),
-          );
+    const makeDefaultProcessor = () => {
+      if (isPollingOptions(config.dataSystem.dataSource)) {
+        return new PollingProcessor(
+          new Requestor(config, this._platform.requests, baseHeaders),
+          config.dataSystem.dataSource.pollInterval ?? 30,
+          dataSourceUpdates,
+          config.logger,
+          () => this._initSuccess(),
+          (e) => this._dataSourceErrorHandler(e),
+        );
+      }
+      // TODO: SDK-858 Hook up composite data source and config
+      const reconnectDelay =
+        isStandardOptions(config.dataSystem.dataSource) ||
+        isStreamingOptions(config.dataSystem.dataSource)
+          ? config.dataSystem.dataSource.streamInitialReconnectDelay
+          : 1;
+      return new StreamingProcessor(
+        clientContext,
+        '/all',
+        [],
+        listeners,
+        baseHeaders,
+        this._diagnosticsManager,
+        (e) => this._dataSourceErrorHandler(e),
+        reconnectDelay,
+      );
+    };
 
     if (!(config.offline || config.useLdd)) {
       this._updateProcessor =

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

@@ -0,0 +1,137 @@
+import { LDClientContext, subsystem } from '@launchdarkly/js-sdk-common';
+
+import { LDDataSourceUpdates, LDFeatureStore } from '../subsystems';
+
+/**
+ * Configuration options for the Data System that the SDK uses to get and maintain flags and other
+ * data from LaunchDarkly and other sources.
+ *
+ * Example (Recommended):
+ * ```typescript
+ * let dataSystemOptions = {
+ *     dataSource: {
+ *         type: 'standard';
+ *     },
+ * }
+ *
+ * Example (Polling with DynamoDB Persistent Store):
+ * ```typescript
+ * import { DynamoDBFeatureStore } from '@launchdarkly/node-server-sdk-dynamodb';
+ *
+ * let dataSystemOptions = {
+ *     dataSource: {
+ *         type: 'polling';
+ *         pollInterval: 300;
+ *     },
+ *     persistentStore: DynamoDBFeatureStore('your-table', { cacheTTL: 30 });
+ * }
+ * const client = init('my-sdk-key', { hooks: [new TracingHook()] });
+ * ```
+ */
+export interface LDDataSystemOptions {
+  /**
+   * Configuration options for the Data Source that the SDK uses to get flags and other
+   * data from the LaunchDarkly servers. Choose one of {@link StandardDataSourceOptions},
+   * {@link StreamingDataSourceOptions}, or {@link PollingDataSourceOptions}; setting the
+   * 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.
+   *
+   * See {@link LDDataSystemOptions} decoumentation for exmaples.
+   */
+  dataSource?: DataSourceOptions;
+
+  /**
+   * A component that obtains feature flag data and puts it in the feature store. Setting
+   * this supercedes {@link LDDataSystemOptions#dataSource}.
+   */
+  updateProcessor?:
+    | object
+    | ((
+        clientContext: LDClientContext,
+        dataSourceUpdates: LDDataSourceUpdates,
+        initSuccessHandler: VoidFunction,
+        errorHandler?: (e: Error) => void,
+      ) => subsystem.LDStreamProcessor);
+
+  /**
+   * Before data has arrived from LaunchDarkly, the SDK is able to evaluate flags using
+   * data from the persistent store. Once fresh data is available, the SDK will no longer
+   * read from the persistent store, although it will keep it up-to-date for future startups.
+   */
+  persistentStore?: LDFeatureStore | ((clientContext: LDClientContext) => LDFeatureStore);
+}
+
+export type DataSourceOptions =
+  | StandardDataSourceOptions
+  | StreamingDataSourceOptions
+  | PollingDataSourceOptions;
+
+/**
+ * This standard data source is the recommended datasource for most customers. It will use
+ * a combination of streaming and polling to initialize the SDK, provide real time updates,
+ * and can switch between streaming and polling automatically to provide redundancy.
+ */
+export interface StandardDataSourceOptions {
+  type: 'standard';
+
+  /**
+   * Sets the initial reconnect delay for the streaming connection, in seconds. Default if omitted.
+   *
+   * The streaming service uses a backoff algorithm (with jitter) every time the connection needs
+   * to be reestablished. The delay for the first reconnection will start near this value, and then
+   * increase exponentially for any subsequent connection failures.
+   *
+   * The default value is 1.
+   */
+  streamInitialReconnectDelay?: number;
+
+  /**
+   * The time between polling requests, in seconds. Default if omitted.
+   */
+  pollInterval?: number;
+}
+
+/**
+ * This data source will make best effort to maintain a streaming connection to LaunchDarkly services
+ * to provide real time data updates.
+ */
+export interface StreamingDataSourceOptions {
+  type: 'streaming';
+
+  /**
+   * Sets the initial reconnect delay for the streaming connection, in seconds. Default if omitted.
+   *
+   * The streaming service uses a backoff algorithm (with jitter) every time the connection needs
+   * to be reestablished. The delay for the first reconnection will start near this value, and then
+   * increase exponentially up to a maximum for any subsequent connection failures.
+   *
+   * The default value is 1.
+   */
+  streamInitialReconnectDelay?: number;
+}
+
+/**
+ * This data source will periodically make a request to LaunchDarkly services to retrieve updated data.
+ */
+export interface PollingDataSourceOptions {
+  type: 'polling';
+
+  /**
+   * The time between polling requests, in seconds. Default if omitted.
+   */
+  pollInterval?: number;
+}
+
+export function isStandardOptions(u: any): u is StandardDataSourceOptions {
+  return u.kind === 'standard';
+}
+
+export function isStreamingOptions(u: any): u is StreamingDataSourceOptions {
+  return u.kind === 'streaming';
+}
+
+export function isPollingOptions(u: any): u is PollingDataSourceOptions {
+  return u.kind === 'polling';
+}

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

@@ -3,6 +3,7 @@ import { LDClientContext, LDLogger, subsystem, VoidFunction } from '@launchdarkl
 import { Hook } from '../integrations/Hook';
 import { LDDataSourceUpdates, LDFeatureStore } from '../subsystems';
 import { LDBigSegmentsOptions } from './LDBigSegmentsOptions';
+import { LDDataSystemOptions } from './LDDataSystemOptions';
 import { LDProxyOptions } from './LDProxyOptions';
 import { LDTLSOptions } from './LDTLSOptions';
 
@@ -67,9 +68,48 @@ export interface LDOptions {
    * 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.
+   *
+   * If you specify the {@link LDOptions#dataSystem}, this setting will be ignored.
+   *
+   * @deprecated This is now superceded by {@link LDOptions#dataSystem} using property
+   * {@link LDDataSystemOptions#persistentStore}. The scope of the {@link LDFeatureStore}
+   * that you provide is being reduced in the next major version to only being responsible
+   * for persistence. See documention on {@link LDDataSystemOptions#persistentStore} for
+   * more information.
    */
   featureStore?: LDFeatureStore | ((clientContext: LDClientContext) => LDFeatureStore);
 
+  /**
+   * 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
+   *
+   * Example (Recommended):
+   * ```typescript
+   * let dataSystemOptions = {
+   *     dataSource: {
+   *         type: 'standard';
+   *         // options can be customized here, though defaults are recommended
+   *     },
+   * }
+   *
+   * Example (Polling with DynamoDB Persistent Store):
+   * ```typescript
+   * import { DynamoDBFeatureStore } from '@launchdarkly/node-server-sdk-dynamodb';
+   *
+   * let dataSystemOptions = {
+   *     dataSource: {
+   *         type: 'polling';
+   *         pollInterval: 300;
+   *     },
+   *     persistentStore: DynamoDBFeatureStore('your-table', { cacheTTL: 30 });
+   * }
+   * const client = init('my-sdk-key', { hooks: [new TracingHook()] });
+   * ```
+   */
+  dataSystem?: LDDataSystemOptions;
+
   /**
    * Additional parameters for configuring the SDK's Big Segments behavior.
    *
@@ -86,7 +126,10 @@ export interface LDOptions {
   /**
    * A component that obtains feature flag data and puts it in the feature store.
    *
-   * By default, this is the client's default streaming or polling component.
+   * 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
@@ -104,6 +147,12 @@ 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;
 
@@ -122,6 +171,13 @@ export interface LDOptions {
    *
    * This is true by default. If you set it to false, the client will use polling.
    * Streaming should only be disabled on the advice of LaunchDarkly support.
+   *
+   * If you specify the {@link LDOptions#dataSystem}, this setting will be ignored.
+   *
+   * @deprecated This functionality is now controlled by {@link LDOptions#dataSystem}
+   * by specifying {@link LDDataSystemOptions#dataSource} options. To opt out of
+   * streaming, you can use the {@link PollingDataSourceOptions}.  Streaming should
+   * only be disabled on the advice of LaunchDarkly support.
    */
   stream?: boolean;
 
@@ -133,6 +189,13 @@ export interface LDOptions {
    * increase exponentially for any subsequent connection failures.
    *
    * The default value is 1.
+   *
+   * If you specify the {@link LDOptions#dataSystem}, this setting will be ignored.
+   *
+   * @deprecated This functionality is now controlled by {@link LDOptions#dataSystem}
+   * by specifying {@link LDDataSystemOptions#dataSource} options. Specifying the reconnect
+   * delay is still available when using {@link StandardDataSourceOptions} or
+   * {@link StreamingDataSourceOptions}.
    */
   streamInitialReconnectDelay?: number;
 

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

@@ -3,3 +3,4 @@ export * from './LDOptions';
 export * from './LDProxyOptions';
 export * from './LDTLSOptions';
 export * from './LDMigrationOptions';
+export * from './LDDataSystemOptions';

packages/shared/sdk-server/src/data_sources/PollingProcessor.ts

@@ -13,6 +13,7 @@ import Configuration from '../options/Configuration';
 import { deserializePoll } from '../store';
 import VersionedDataKinds from '../store/VersionedDataKinds';
 import Requestor from './Requestor';
+import { isPollingOptions, isStandardOptions } from '../api/options/LDDataSystemOptions';
 
 export type PollingErrorHandler = (err: LDPollingError) => void;
 
@@ -22,22 +23,16 @@ export type PollingErrorHandler = (err: LDPollingError) => void;
 export default class PollingProcessor implements subsystem.LDStreamProcessor {
   private _stopped = false;
 
-  private _logger?: LDLogger;
-
-  private _pollInterval: number;
-
   private _timeoutHandle: any;
 
   constructor(
-    config: Configuration,
     private readonly _requestor: Requestor,
+    private readonly _pollInterval: number,
     private readonly _featureStore: LDDataSourceUpdates,
+    private readonly _logger?: LDLogger,
     private readonly _initSuccessHandler: VoidFunction = () => {},
     private readonly _errorHandler?: PollingErrorHandler,
-  ) {
-    this._logger = config.logger;
-    this._pollInterval = config.pollInterval;
-  }
+  ) {}
 
   private _poll() {
     if (this._stopped) {