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

package/event_factory.js

@@ -0,0 +1,121 @@
+function isExperiment(flag, reason) {
+  if (reason) {
+    // If the reason says we're in an experiment, we are. Otherwise, apply
+    // the legacy rule exclusion logic.
+    if (reason.inExperiment) {
+      return true;
+    }
+    switch (reason.kind) {
+      case 'RULE_MATCH': {
+        const index = reason.ruleIndex;
+        if (index !== undefined) {
+          const rules = flag.rules || [];
+          return index >= 0 && index < rules.length && !!rules[index].trackEvents;
+        }
+        break;
+      }
+      case 'FALLTHROUGH':
+        return !!flag.trackEventsFallthrough;
+    }
+  }
+  return false;
+}
+
+function EventFactory(withReasons) {
+  const ef = {};
+
+  ef.newEvalEvent = (flag, context, detail, defaultVal, prereqOfFlag) => {
+    const addExperimentData = isExperiment(flag, detail.reason);
+    const e = {
+      kind: 'feature',
+      creationDate: new Date().getTime(),
+      key: flag.key,
+      context,
+      value: detail.value,
+      variation: detail.variationIndex,
+      default: defaultVal,
+      version: flag.version,
+    };
+    // the following properties are handled separately so we don't waste bandwidth on unused keys
+    if (addExperimentData || flag.trackEvents) {
+      e.trackEvents = true;
+    }
+    if (flag.debugEventsUntilDate) {
+      e.debugEventsUntilDate = flag.debugEventsUntilDate;
+    }
+    if (prereqOfFlag) {
+      e.prereqOf = prereqOfFlag.key;
+    }
+    if (addExperimentData || withReasons) {
+      e.reason = detail.reason;
+    }
+    return e;
+  };
+
+  ef.newDefaultEvent = (flag, context, detail) => {
+    const e = {
+      kind: 'feature',
+      creationDate: new Date().getTime(),
+      key: flag.key,
+      context,
+      value: detail.value,
+      default: detail.value,
+      version: flag.version,
+    };
+    // the following properties are handled separately so we don't waste bandwidth on unused keys
+    if (flag.trackEvents) {
+      e.trackEvents = true;
+    }
+    if (flag.debugEventsUntilDate) {
+      e.debugEventsUntilDate = flag.debugEventsUntilDate;
+    }
+    if (withReasons) {
+      e.reason = detail.reason;
+    }
+    return e;
+  };
+
+  ef.newUnknownFlagEvent = (key, context, detail) => {
+    const e = {
+      kind: 'feature',
+      creationDate: new Date().getTime(),
+      key: key,
+      context,
+      value: detail.value,
+      default: detail.value,
+    };
+    if (withReasons) {
+      e.reason = detail.reason;
+    }
+    return e;
+  };
+
+  ef.newIdentifyEvent = context => ({
+    kind: 'identify',
+    creationDate: new Date().getTime(),
+    context,
+  });
+
+  ef.newCustomEvent = (eventName, context, data, metricValue) => {
+    const e = {
+      kind: 'custom',
+      creationDate: new Date().getTime(),
+      key: eventName,
+      context,
+    };
+    if (data !== null && data !== undefined) {
+      e.data = data;
+    }
+    if (metricValue !== null && metricValue !== undefined) {
+      e.metricValue = metricValue;
+    }
+    return e;
+  };
+
+  return ef;
+}
+
+module.exports = {
+  EventFactory,
+  isExperiment,
+};

package/event_processor.js

@@ -0,0 +1,320 @@
+const LRUCache = require('lru-cache');
+const { v4: uuidv4 } = require('uuid');
+
+const EventSummarizer = require('./event_summarizer');
+const ContextFilter = require('./context_filter');
+const errors = require('./errors');
+const httpUtils = require('./utils/httpUtils');
+const messages = require('./messages');
+const wrapPromiseCallback = require('./utils/wrapPromiseCallback');
+const { getCanonicalKey } = require('./context');
+
+function EventProcessor(sdkKey, config, errorReporter, diagnosticsManager) {
+  const ep = {};
+
+  const contextFilter = ContextFilter(config),
+    summarizer = EventSummarizer(),
+    contextKeysCache = new LRUCache({ max: config.contextKeysCapacity }),
+    mainEventsUri = config.eventsUri + '/bulk',
+    diagnosticEventsUri = config.eventsUri + '/diagnostic';
+
+  let queue = [],
+    lastKnownPastTime = 0,
+    droppedEvents = 0,
+    deduplicatedUsers = 0,
+    exceededCapacity = false,
+    eventsInLastBatch = 0,
+    shutdown = false,
+    diagnosticsTimer;
+
+  function enqueue(event) {
+    if (queue.length < config.capacity) {
+      queue.push(event);
+      exceededCapacity = false;
+    } else {
+      if (!exceededCapacity) {
+        exceededCapacity = true;
+        config.logger.warn('Exceeded event queue capacity. Increase capacity to avoid dropping events.');
+      }
+      droppedEvents++;
+    }
+  }
+
+  function shouldDebugEvent(event) {
+    if (event.debugEventsUntilDate) {
+      if (event.debugEventsUntilDate > lastKnownPastTime && event.debugEventsUntilDate > new Date().getTime()) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  function makeOutputEvent(event) {
+    switch (event.kind) {
+      case 'feature': {
+        const debug = !!event.debug;
+        const out = {
+          kind: debug ? 'debug' : 'feature',
+          creationDate: event.creationDate,
+          key: event.key,
+          value: event.value,
+          default: event.default,
+          prereqOf: event.prereqOf,
+        };
+        if (event.variation !== undefined && event.variation !== null) {
+          out.variation = event.variation;
+        }
+        if (event.version !== undefined && event.version !== null) {
+          out.version = event.version;
+        }
+        if (event.reason) {
+          out.reason = event.reason;
+        }
+        if (debug) {
+          out.context = processContext(event);
+        } else {
+          out.contextKeys = getContextKeys(event);
+        }
+        return out;
+      }
+      case 'identify':
+        return {
+          kind: 'identify',
+          creationDate: event.creationDate,
+          context: processContext(event),
+        };
+      case 'custom': {
+        const out = {
+          kind: 'custom',
+          creationDate: event.creationDate,
+          key: event.key,
+        };
+
+        out.contextKeys = getContextKeys(event);
+
+        if (event.data !== null && event.data !== undefined) {
+          out.data = event.data;
+        }
+        if (event.metricValue !== null && event.metricValue !== undefined) {
+          out.metricValue = event.metricValue;
+        }
+
+        return out;
+      }
+      default:
+        return event;
+    }
+  }
+
+  function processContext(event) {
+    return contextFilter.filter(event.context);
+  }
+
+  function getCacheKey(event) {
+    const context = event.context;
+    return getCanonicalKey(context);
+  }
+
+  function getContextKeys(event) {
+    const keys = {};
+    const context = event.context;
+    if (context !== undefined) {
+      if (context.kind === undefined && context.key) {
+        keys.user = String(context.key);
+      } else if (context.kind !== 'multi') {
+        keys[context.kind] = String(context.key);
+      } else if (context.kind === 'multi') {
+        Object.keys(context)
+          .filter(key => key !== 'kind')
+          .forEach(key => {
+            if (context[key] !== undefined && context[key].key !== undefined) {
+              keys[key] = context[key].key;
+            }
+          });
+      }
+      return keys;
+    }
+    return undefined;
+  }
+
+  ep.sendEvent = event => {
+    let addIndexEvent = false,
+      addFullEvent = false,
+      addDebugEvent = false;
+
+    if (shutdown) {
+      return;
+    }
+
+    // Always record the event in the summarizer.
+    summarizer.summarizeEvent(event);
+
+    // Decide whether to add the event to the payload. Feature events may be added twice, once for
+    // the event (if tracked) and once for debugging.
+    if (event.kind === 'feature') {
+      addFullEvent = event.trackEvents;
+      addDebugEvent = shouldDebugEvent(event);
+    } else {
+      addFullEvent = true;
+    }
+
+    // For each user we haven't seen before, we add an index event - unless this is already
+    // an identify event for that user.
+    if (event.context) {
+      const isIdentify = event.kind === 'identify';
+      if (contextKeysCache.get(getCacheKey(event))) {
+        if (!isIdentify) {
+          deduplicatedUsers++;
+        }
+      } else {
+        contextKeysCache.set(getCacheKey(event), true);
+        if (!isIdentify) {
+          addIndexEvent = true;
+        }
+      }
+    }
+
+    if (addIndexEvent) {
+      enqueue({
+        kind: 'index',
+        creationDate: event.creationDate,
+        context: processContext(event),
+      });
+    }
+    if (addFullEvent) {
+      enqueue(makeOutputEvent(event));
+    }
+    if (addDebugEvent) {
+      const debugEvent = Object.assign({}, event, { debug: true });
+      enqueue(makeOutputEvent(debugEvent));
+    }
+  };
+
+  ep.flush = function (callback) {
+    return wrapPromiseCallback(
+      new Promise((resolve, reject) => {
+        if (shutdown) {
+          const err = new errors.LDInvalidSDKKeyError('Events cannot be posted because SDK key is invalid');
+          reject(err);
+          return;
+        }
+
+        const worklist = queue;
+        queue = [];
+        const summary = summarizer.getSummary();
+        summarizer.clearSummary();
+        if (Object.keys(summary.features).length) {
+          summary.kind = 'summary';
+          worklist.push(summary);
+        }
+
+        if (!worklist.length) {
+          resolve();
+          return;
+        }
+
+        eventsInLastBatch = worklist.length;
+        config.logger.debug('Flushing %d events', worklist.length);
+
+        tryPostingEvents(worklist, mainEventsUri, uuidv4(), resolve, reject, true);
+      }),
+      callback
+    );
+  };
+
+  function tryPostingEvents(events, uri, payloadId, resolve, reject, canRetry) {
+    const retryOrReject = err => {
+      if (canRetry) {
+        config.logger && config.logger.warn('Will retry posting events after 1 second');
+        setTimeout(() => {
+          tryPostingEvents(events, uri, payloadId, resolve, reject, false);
+        }, 1000);
+      } else {
+        reject(err);
+      }
+    };
+
+    const headers = Object.assign({ 'Content-Type': 'application/json' }, httpUtils.getDefaultHeaders(sdkKey, config));
+    if (payloadId) {
+      headers['X-LaunchDarkly-Payload-ID'] = payloadId;
+      headers['X-LaunchDarkly-Event-Schema'] = '4';
+    }
+
+    const options = { method: 'POST', headers };
+    const body = JSON.stringify(events);
+    httpUtils.httpRequest(uri, options, body, config, (err, resp) => {
+      if (err) {
+        retryOrReject(err);
+        return;
+      }
+      if (resp.headers['date']) {
+        const date = Date.parse(resp.headers['date']);
+        if (date) {
+          lastKnownPastTime = date;
+        }
+      }
+      if (resp.statusCode > 204) {
+        const err = new errors.LDUnexpectedResponseError(
+          messages.httpErrorMessage({ status: resp.statusCode }, 'event posting', 'some events were dropped')
+        );
+        errorReporter && errorReporter(err);
+        if (!errors.isHttpErrorRecoverable(resp.statusCode)) {
+          reject(err);
+          shutdown = true;
+        } else {
+          retryOrReject(err);
+        }
+      } else {
+        resolve();
+      }
+    });
+  }
+
+  function postDiagnosticEvent(event) {
+    tryPostingEvents(
+      event,
+      diagnosticEventsUri,
+      null,
+      () => {},
+      () => {},
+      true
+    );
+  }
+
+  const flushTimer = setInterval(() => {
+    ep.flush().then(
+      () => {},
+      () => {}
+    );
+  }, config.flushInterval * 1000);
+
+  const flushUsersTimer = setInterval(() => {
+    contextKeysCache.reset();
+  }, config.contextKeysFlushInterval * 1000);
+
+  ep.close = () => {
+    clearInterval(flushTimer);
+    clearInterval(flushUsersTimer);
+    diagnosticsTimer && clearInterval(diagnosticsTimer);
+  };
+
+  if (!config.diagnosticOptOut && diagnosticsManager) {
+    const initEvent = diagnosticsManager.createInitEvent();
+    postDiagnosticEvent(initEvent);
+
+    diagnosticsTimer = setInterval(() => {
+      const statsEvent = diagnosticsManager.createStatsEventAndReset(
+        droppedEvents,
+        deduplicatedUsers,
+        eventsInLastBatch
+      );
+      droppedEvents = 0;
+      deduplicatedUsers = 0;
+      postDiagnosticEvent(statsEvent);
+    }, config.diagnosticRecordingInterval * 1000);
+  }
+
+  return ep;
+}
+
+module.exports = EventProcessor;

package/event_summarizer.js

@@ -0,0 +1,101 @@
+const { getContextKinds } = require('./context');
+
+function getKinds(event) {
+  if (event.context) {
+    return getContextKinds(event.context);
+  }
+  if (event.contextKeys) {
+    return Object.keys(event.contextKeys);
+  }
+  return [];
+}
+
+function EventSummarizer() {
+  const es = {};
+
+  let startDate = 0,
+    endDate = 0,
+    counters = {},
+    contextKinds = {};
+
+  es.summarizeEvent = event => {
+    if (event.kind === 'feature') {
+      const counterKey =
+        event.key +
+        ':' +
+        (event.variation !== null && event.variation !== undefined ? event.variation : '') +
+        ':' +
+        (event.version !== null && event.version !== undefined ? event.version : '');
+      const counterVal = counters[counterKey];
+      let kinds = contextKinds[event.key];
+      if (!kinds) {
+        kinds = new Set();
+        contextKinds[event.key] = kinds;
+      }
+      getKinds(event).forEach(kind => kinds.add(kind));
+
+      if (counterVal) {
+        counterVal.count = counterVal.count + 1;
+      } else {
+        counters[counterKey] = {
+          count: 1,
+          key: event.key,
+          version: event.version,
+          variation: event.variation,
+          value: event.value,
+          default: event.default,
+        };
+      }
+      if (startDate === 0 || event.creationDate < startDate) {
+        startDate = event.creationDate;
+      }
+      if (event.creationDate > endDate) {
+        endDate = event.creationDate;
+      }
+    }
+  };
+
+  es.getSummary = () => {
+    const flagsOut = {};
+    for (const c of Object.values(counters)) {
+      let flag = flagsOut[c.key];
+      if (!flag) {
+        flag = {
+          default: c.default,
+          counters: [],
+          contextKinds: [...contextKinds[c.key]],
+        };
+        flagsOut[c.key] = flag;
+      }
+      const counterOut = {
+        value: c.value,
+        count: c.count,
+      };
+      if (c.variation !== undefined && c.variation !== null) {
+        counterOut.variation = c.variation;
+      }
+      if (c.version !== undefined && c.version !== null) {
+        counterOut.version = c.version;
+      } else {
+        counterOut.unknown = true;
+      }
+      flag.counters.push(counterOut);
+    }
+    return {
+      startDate: startDate,
+      endDate: endDate,
+      features: flagsOut,
+    };
+  };
+
+  es.clearSummary = () => {
+    startDate = 0;
+    endDate = 0;
+    counters = {};
+    contextKinds = {};
+  };
+
+  return es;
+}
+
+module.exports = EventSummarizer;

package/feature_store.js

@@ -0,0 +1,120 @@
+// The default in-memory implementation of a feature store, which holds feature flags and
+// other related data received from LaunchDarkly.
+//
+// Other implementations of the same interface can be used by passing them in the featureStore
+// property of the client configuration (that's why the interface here is async, even though
+// the in-memory store doesn't do anything asynchronous - because other implementations may
+// need to be async). The interface is defined by LDFeatureStore in index.d.ts.
+//
+// Additional implementations should use CachingStoreWrapper if possible.
+
+// Note that the contract for feature store methods does *not* require callbacks to be deferred
+// with setImmediate, process.nextTick, etc. It is both allowed and desirable to call them
+// directly whenever possible (i.e. if we don't actually have to do any I/O), since otherwise
+// feature flag retrieval is a major performance bottleneck. These methods are for internal use
+// by the SDK, and the SDK does not make any assumptions about whether a callback executes
+// before or after the next statement.
+
+function InMemoryFeatureStore() {
+  let allData = {};
+  let initCalled = false;
+
+  const store = {};
+
+  function callbackResult(cb, result) {
+    cb && cb(result);
+  }
+
+  store.get = (kind, key, cb) => {
+    const items = allData[kind.namespace] || {};
+    if (Object.hasOwnProperty.call(items, key)) {
+      const item = items[key];
+
+      if (!item || item.deleted) {
+        callbackResult(cb, null);
+      } else {
+        callbackResult(cb, item);
+      }
+    } else {
+      callbackResult(cb, null);
+    }
+  };
+
+  store.all = (kind, cb) => {
+    const results = {};
+    const items = allData[kind.namespace] || {};
+
+    for (const [key, item] of Object.entries(items)) {
+      if (item && !item.deleted) {
+        results[key] = item;
+      }
+    }
+
+    callbackResult(cb, results);
+  };
+
+  store.init = (newData, cb) => {
+    allData = newData;
+    initCalled = true;
+    callbackResult(cb);
+  };
+
+  store.delete = (kind, key, version, cb) => {
+    let items = allData[kind.namespace];
+    if (!items) {
+      items = {};
+      allData[kind] = items;
+    }
+    const deletedItem = { version: version, deleted: true };
+    if (Object.hasOwnProperty.call(items, key)) {
+      const old = items[key];
+      if (!old || old.version < version) {
+        items[key] = deletedItem;
+      }
+    } else {
+      items[key] = deletedItem;
+    }
+
+    callbackResult(cb);
+  };
+
+  store.upsert = (kind, item, cb) => {
+    const key = item.key;
+    let items = allData[kind.namespace];
+    if (!items) {
+      items = {};
+      allData[kind.namespace] = items;
+    }
+
+    if (Object.hasOwnProperty.call(items, key)) {
+      const old = items[key];
+      if (old && old.version < item.version) {
+        items[key] = clone(item);
+      }
+    } else {
+      items[key] = clone(item);
+    }
+
+    callbackResult(cb);
+  };
+
+  store.initialized = cb => {
+    callbackResult(cb, initCalled === true);
+  };
+
+  store.close = () => {
+    // Close on the in-memory store is a no-op
+  };
+
+  store.description = 'memory';
+
+  return store;
+}
+
+// Deep clone an object. Does not preserve any
+// functions on the object
+function clone(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+
+module.exports = InMemoryFeatureStore;