@depup/launchdarkly-node-server-sdk 7.0.4-depup.0

package/contract-tests/sdkClientEntity.js

@@ -0,0 +1,110 @@
+const ld = require('launchdarkly-node-server-sdk');
+
+const { Log, sdkLogger } = require('./log');
+
+const badCommandError = new Error('unsupported command');
+
+function makeSdkConfig(options, tag) {
+  const cf = {
+    logger: sdkLogger(tag),
+  };
+  const maybeTime = seconds => (seconds === undefined || seconds === null ? undefined : seconds / 1000);
+  if (options.streaming) {
+    cf.streamUri = options.streaming.baseUri;
+    cf.streamInitialReconnectDelay = maybeTime(options.streaming.initialRetryDelayMs);
+  }
+  if (options.events) {
+    cf.allAttributesPrivate = options.events.allAttributesPrivate;
+    cf.eventsUri = options.events.baseUri;
+    cf.capacity = options.events.capacity;
+    cf.diagnosticOptOut = !options.events.enableDiagnostics;
+    cf.flushInterval = maybeTime(options.events.flushIntervalMs);
+    cf.privateAttributes = options.events.globalPrivateAttributes;
+  }
+  if (options.tags) {
+    cf.application = {
+      id: options.tags.applicationId,
+      version: options.tags.applicationVersion,
+    };
+  }
+  return cf;
+}
+
+async function newSdkClientEntity(options) {
+  const c = {};
+  const log = Log(options.tag);
+
+  log.info('Creating client with configuration: ' + JSON.stringify(options.configuration));
+  const timeout =
+    options.configuration.startWaitTimeMs !== null && options.configuration.startWaitTimeMs !== undefined
+      ? options.configuration.startWaitTimeMs
+      : 5000;
+  const client = ld.init(
+    options.configuration.credential || 'unknown-sdk-key',
+    makeSdkConfig(options.configuration, options.tag)
+  );
+  try {
+    await Promise.race([client.waitForInitialization(), new Promise(resolve => setTimeout(resolve, timeout))]);
+  } catch (_) {
+    // if waitForInitialization() rejects, the client failed to initialize, see next line
+  }
+  if (!client.initialized() && !options.configuration.initCanFail) {
+    client.close();
+    throw new Error('client initialization failed');
+  }
+
+  c.close = () => {
+    client.close();
+    log.info('Test ended');
+  };
+
+  c.doCommand = async params => {
+    log.info('Received command: ' + params.command);
+    switch (params.command) {
+      case 'evaluate': {
+        const pe = params.evaluate;
+        if (pe.detail) {
+          return await client.variationDetail(pe.flagKey, pe.context || pe.user, pe.defaultValue);
+        } else {
+          const value = await client.variation(pe.flagKey, pe.context || pe.user, pe.defaultValue);
+          return { value };
+        }
+      }
+
+      case 'evaluateAll': {
+        const pea = params.evaluateAll;
+        const eao = {
+          clientSideOnly: pea.clientSideOnly,
+          detailsOnlyForTrackedFlags: pea.detailsOnlyForTrackedFlags,
+          withReasons: pea.withReasons,
+        };
+        return { state: await client.allFlagsState(pea.context || pea.user, eao) };
+      }
+
+      case 'identifyEvent':
+        client.identify(params.identifyEvent.context || params.identifyEvent.user);
+        return undefined;
+
+      case 'customEvent': {
+        const pce = params.customEvent;
+        client.track(pce.eventKey, pce.context || pce.user, pce.data, pce.metricValue);
+        return undefined;
+      }
+
+      case 'flushEvents':
+        client.flush();
+        return undefined;
+
+      case 'getBigSegmentStoreStatus':
+        return undefined;
+
+      default:
+        throw badCommandError;
+    }
+  };
+
+  return c;
+}
+
+module.exports.newSdkClientEntity = newSdkClientEntity;
+module.exports.badCommandError = badCommandError;

package/contract-tests/testharness-suppressions.txt

@@ -0,0 +1,2 @@
+streaming/validation/drop and reconnect if stream event has malformed JSON
+streaming/validation/drop and reconnect if stream event has well-formed JSON not matching schema

package/diagnostic_events.js

@@ -0,0 +1,151 @@
+const os = require('os');
+const { v4: uuidv4 } = require('uuid');
+const configuration = require('./configuration');
+const packageJson = require('./package.json');
+
+// An object that maintains information that will go into diagnostic events, and knows how to format
+// those events. It is instantiated by the SDK client, and shared with the event processor.
+function DiagnosticsManager(config, diagnosticId, startTime) {
+  let dataSinceDate = startTime;
+  let streamInits = [];
+  const acc = {};
+
+  // Creates the initial event that is sent by the event processor when the SDK starts up. This will not
+  // be repeated during the lifetime of the SDK client.
+  acc.createInitEvent = () => ({
+    kind: 'diagnostic-init',
+    id: diagnosticId,
+    creationDate: startTime,
+    sdk: makeSdkData(config),
+    configuration: makeConfigData(config),
+    platform: makePlatformData(),
+  });
+
+  // Records a stream connection attempt (called by the stream processor).
+  // timestamp: Time of the *beginning* of the connection attempt.
+  // failed: True if the connection failed, or we got a read timeout before receiving a "put".
+  // durationMillis: Elapsed time between starting timestamp and when we either gave up/lost the
+  //   connection or received a successful "put".
+  acc.recordStreamInit = (timestamp, failed, durationMillis) => {
+    const item = { timestamp, failed, durationMillis };
+    streamInits.push(item);
+  };
+
+  // Creates a periodic event containing time-dependent stats, and resets the state of the manager with
+  // regard to those stats.
+  // Note: the reason droppedEvents, deduplicatedUsers, and eventsInLastBatch are passed into this function,
+  // instead of being properties of the DiagnosticsManager, is that the event processor is the one who's
+  // calling this function and is also the one who's tracking those stats.
+  acc.createStatsEventAndReset = (droppedEvents, deduplicatedUsers, eventsInLastBatch) => {
+    const currentTime = new Date().getTime();
+    const ret = {
+      kind: 'diagnostic',
+      id: diagnosticId,
+      creationDate: currentTime,
+      dataSinceDate,
+      droppedEvents,
+      deduplicatedUsers,
+      eventsInLastBatch,
+      streamInits,
+    };
+    dataSinceDate = currentTime;
+    streamInits = [];
+    return ret;
+  };
+
+  return acc;
+}
+
+function DiagnosticId(sdkKey) {
+  const ret = {
+    diagnosticId: uuidv4(),
+  };
+  if (sdkKey) {
+    ret.sdkKeySuffix = sdkKey.length > 6 ? sdkKey.substring(sdkKey.length - 6) : sdkKey;
+  }
+  return ret;
+}
+
+function makeSdkData(config) {
+  const sdkData = {
+    name: 'node-server-sdk',
+    version: packageJson.version,
+  };
+  if (config.wrapperName) {
+    sdkData.wrapperName = config.wrapperName;
+  }
+  if (config.wrapperVersion) {
+    sdkData.wrapperVersion = config.wrapperVersion;
+  }
+  return sdkData;
+}
+
+function makeConfigData(config) {
+  const defaults = configuration.defaults();
+  const secondsToMillis = sec => Math.trunc(sec * 1000);
+
+  function getComponentDescription(component, defaultName) {
+    if (component) {
+      return component.description || 'custom';
+    }
+    return defaultName;
+  }
+
+  const configData = {
+    customBaseURI: config.baseUri !== defaults.baseUri,
+    customStreamURI: config.streamUri !== defaults.streamUri,
+    customEventsURI: config.eventsUri !== defaults.eventsUri,
+    eventsCapacity: config.capacity,
+    connectTimeoutMillis: secondsToMillis(config.timeout),
+    socketTimeoutMillis: secondsToMillis(config.timeout), // Node doesn't distinguish between these two kinds of timeouts
+    eventsFlushIntervalMillis: secondsToMillis(config.flushInterval),
+    pollingIntervalMillis: secondsToMillis(config.pollInterval),
+    // startWaitMillis: n/a (Node SDK does not have this feature)
+    // samplingInterval: n/a (Node SDK does not have this feature)
+    reconnectTimeMillis: secondsToMillis(config.streamInitialReconnectDelay),
+    streamingDisabled: !config.stream,
+    usingRelayDaemon: !!config.useLdd,
+    offline: !!config.offline,
+    allAttributesPrivate: !!config.allAttributesPrivate,
+    contextKeysCapacity: config.contextKeysCapacity,
+    contextKeysFlushIntervalMillis: secondsToMillis(config.contextKeysFlushInterval),
+    usingProxy: !!(config.proxyAgent || config.proxyHost),
+    usingProxyAuthenticator: !!config.proxyAuth,
+    diagnosticRecordingIntervalMillis: secondsToMillis(config.diagnosticRecordingInterval),
+    dataStoreType: getComponentDescription(config.featureStore, 'memory'),
+  };
+
+  return configData;
+}
+
+function makePlatformData() {
+  return {
+    name: 'Node',
+    osArch: os.arch(),
+    osName: normalizePlatformName(os.platform()),
+    osVersion: os.release(),
+    // Note that os.release() is not the same OS version string that would be reported by other languages.
+    // It's defined as being the value returned by "uname -r" (e.g. on Mac OS 10.14, this is "18.7.0"; on
+    // Ubuntu 16.04, it is "4.4.0-1095-aws"), or GetVersionExW in Windows.
+    nodeVersion: process.versions.node,
+  };
+}
+
+function normalizePlatformName(platformName) {
+  // The following logic is based on how Node.js reports the platform name
+  switch (platformName) {
+    case 'darwin':
+      return 'MacOS';
+    case 'win32':
+      return 'Windows';
+    case 'linux':
+      return 'Linux';
+    default:
+      return platformName;
+  }
+}
+
+module.exports = {
+  DiagnosticsManager,
+  DiagnosticId,
+};

package/docs/typedoc.js

@@ -0,0 +1,10 @@
+module.exports = {
+  out: '/tmp/project-releaser/project/docs/build/html',
+  exclude: [
+    '**/node_modules/**',
+    'test-types.ts'
+  ],
+  name: "LaunchDarkly Server-Side Node SDK (7.0.0)",
+  readme: 'none',                // don't add a home page with a copy of README.md
+  entryPoints: "/tmp/project-releaser/project/index.d.ts"
+};

package/errors.js

@@ -0,0 +1,26 @@
+function createCustomError(name) {
+  function CustomError(message, code) {
+    Error.captureStackTrace && Error.captureStackTrace(this, this.constructor);
+    this.message = message;
+    this.code = code;
+  }
+
+  CustomError.prototype = new Error();
+  CustomError.prototype.name = name;
+  CustomError.prototype.constructor = CustomError;
+
+  return CustomError;
+}
+
+exports.LDPollingError = createCustomError('LaunchDarklyPollingError');
+exports.LDStreamingError = createCustomError('LaunchDarklyStreamingError');
+exports.LDUnexpectedResponseError = createCustomError('LaunchDarklyUnexpectedResponseError');
+exports.LDInvalidSDKKeyError = createCustomError('LaunchDarklyInvalidSDKKeyError');
+exports.LDClientError = createCustomError('LaunchDarklyClientError');
+
+exports.isHttpErrorRecoverable = function (status) {
+  if (status >= 400 && status < 500) {
+    return status === 400 || status === 408 || status === 429;
+  }
+  return true;
+};