launchdarkly-js-sdk-common 3.4.0 → 4.0.2

package/src/__tests__/diagnosticEvents-test.js

@@ -0,0 +1,449 @@
+import { baseOptionDefs } from '../configuration';
+import { DiagnosticId, DiagnosticsAccumulator, DiagnosticsManager } from '../diagnosticEvents';
+import PersistentStorage from '../PersistentStorage';
+import { sleepAsync } from 'launchdarkly-js-test-helpers';
+
+import * as stubPlatform from './stubPlatform';
+import { MockEventSender } from './testUtils';
+
+// These tests cover the logic in diagnosticEvents.js. Some of the statistics in diagnostic events come from
+// other SDK components; the tests for those components will verify that they generate the right values.
+
+describe('DiagnosticId', () => {
+  it('creates unique IDs', () => {
+    const id1 = DiagnosticId('key');
+    const id2 = DiagnosticId('key');
+    expect(id1.diagnosticId).not.toEqual(id2.diagnosticId);
+  });
+
+  it('uses only last 6 characters of key', () => {
+    const id = DiagnosticId('0123456789abcdef');
+    expect(id.sdkKeySuffix).toEqual('abcdef');
+  });
+});
+
+describe('DiagnosticsAccumulator', () => {
+  it('sets initial properties', () => {
+    const acc = DiagnosticsAccumulator(1000);
+    expect(acc.getProps()).toEqual({
+      dataSinceDate: 1000,
+      droppedEvents: 0,
+      eventsInLastBatch: 0,
+      streamInits: [],
+    });
+  });
+
+  it('increments dropped events', () => {
+    const acc = DiagnosticsAccumulator(1000);
+    acc.incrementDroppedEvents();
+    acc.incrementDroppedEvents();
+    expect(acc.getProps().droppedEvents).toEqual(2);
+  });
+
+  it('sets event count', () => {
+    const acc = DiagnosticsAccumulator(1000);
+    acc.setEventsInLastBatch(99);
+    expect(acc.getProps().eventsInLastBatch).toEqual(99);
+  });
+
+  it('records successful stream init', () => {
+    const acc = DiagnosticsAccumulator(1000);
+    acc.recordStreamInit(1001, false, 500);
+    expect(acc.getProps().streamInits).toEqual([{ timestamp: 1001, failed: false, durationMillis: 500 }]);
+  });
+
+  it('records failed stream init', () => {
+    const acc = DiagnosticsAccumulator(1000);
+    acc.recordStreamInit(1001, true, 500);
+    expect(acc.getProps().streamInits).toEqual([{ timestamp: 1001, failed: true, durationMillis: 500 }]);
+  });
+
+  it('resets properties', () => {
+    const acc = DiagnosticsAccumulator(1000);
+    acc.incrementDroppedEvents();
+    acc.setEventsInLastBatch(99);
+    acc.recordStreamInit(1001, false, 500);
+    acc.reset(1002);
+    expect(acc.getProps()).toEqual({
+      dataSinceDate: 1002,
+      droppedEvents: 0,
+      eventsInLastBatch: 0,
+      streamInits: [],
+    });
+  });
+});
+
+describe('DiagnosticsManager', () => {
+  const diagnosticId = DiagnosticId('123456');
+  const envId = 'my-environment-id';
+  const defaultStartTime = 1000;
+  const defaultInterval = 100000;
+  const localStorageKey = 'ld:' + envId + ':$diagnostics';
+  const sdkData = {
+    name: 'js-test',
+    version: '0.0.1',
+  };
+  const platformData = {
+    name: 'Positron',
+    osArch: 'usrobots',
+    osName: 'Robbie',
+    osVersion: '1940',
+  };
+  const defaultConfig = {
+    baseUrl: baseOptionDefs.baseUrl.default,
+    streamUrl: baseOptionDefs.streamUrl.default,
+    eventsUrl: baseOptionDefs.eventsUrl.default,
+    eventCapacity: 50,
+    fetchGoals: true,
+    flushInterval: 1000,
+    streamReconnectDelay: 900,
+    diagnosticRecordingInterval: defaultInterval,
+  };
+  const defaultConfigInEvent = {
+    allAttributesPrivate: false,
+    allowFrequentDuplicateEvents: false,
+    autoAliasingOptOut: false,
+    bootstrapMode: false,
+    customBaseURI: false,
+    customEventsURI: false,
+    customStreamURI: false,
+    diagnosticRecordingIntervalMillis: defaultInterval,
+    eventsCapacity: defaultConfig.eventCapacity,
+    eventsFlushIntervalMillis: defaultConfig.flushInterval,
+    fetchGoalsDisabled: false,
+    inlineUsersInEvents: false,
+    reconnectTimeMillis: defaultConfig.streamReconnectDelay,
+    sendEventsOnlyForVariation: false,
+    streamingDisabled: true,
+    usingSecureMode: false,
+  };
+  const expectedStatsForPeriodicEvent1 = {
+    droppedEvents: 1,
+    eventsInLastBatch: 2,
+    streamInits: [{ timestamp: 1001, durationMillis: 100 }, { timestamp: 1002, failed: true, durationMillis: 500 }],
+  };
+  const expectedStatsForPeriodicEvent2 = {
+    droppedEvents: 0,
+    eventsInLastBatch: 1,
+    streamInits: [{ timestamp: 1003, durationMillis: 99 }],
+  };
+
+  async function withManager(extraConfig, overridePlatform, asyncCallback) {
+    const platform = overridePlatform || stubPlatform.defaults();
+    const storage = PersistentStorage(platform.localStorage, platform.testing.logger);
+    platform.diagnosticSdkData = sdkData;
+    platform.diagnosticPlatformData = platformData;
+    const config = { ...defaultConfig, ...extraConfig };
+    const acc = DiagnosticsAccumulator(defaultStartTime);
+    const sender = MockEventSender();
+    const m = DiagnosticsManager(platform, storage, acc, sender, envId, config, diagnosticId);
+    try {
+      return await asyncCallback(m, acc, sender);
+    } finally {
+      m.stop();
+    }
+  }
+
+  function setupStatsForPeriodicEvent1(acc) {
+    acc.incrementDroppedEvents();
+    acc.setEventsInLastBatch(2);
+    acc.recordStreamInit(1001, false, 100);
+    acc.recordStreamInit(1002, true, 500);
+  }
+
+  function setupStatsForPeriodicEvent2(acc) {
+    acc.setEventsInLastBatch(1);
+    acc.recordStreamInit(1003, false, 99);
+  }
+
+  async function getPostedEvent(sender, config) {
+    const posted = await sender.calls.take();
+    const baseUrl = { ...defaultConfig, ...config }.eventsUrl;
+    expect(posted.url).toEqual(baseUrl + '/events/diagnostic/' + envId);
+    return posted.events;
+  }
+
+  describe('in default mode', () => {
+    it('does not send init event before start()', async () => {
+      await withManager({}, null, async (manager, acc, sender) => {
+        expect(sender.calls.length()).toEqual(0);
+      });
+    });
+
+    it('sends init event on start() with default config', async () => {
+      await withManager({}, null, async (manager, acc, sender) => {
+        manager.start();
+        expect(sender.calls.length()).toEqual(1);
+        const initEvent = await getPostedEvent(sender);
+        expect(initEvent).toEqual({
+          kind: 'diagnostic-init',
+          creationDate: defaultStartTime,
+          id: diagnosticId,
+          sdk: sdkData,
+          platform: platformData,
+          configuration: defaultConfigInEvent,
+        });
+      });
+    });
+
+    it('sends init event on start() with custom config', async () => {
+      const configAndResultValues = [
+        [{ allAttributesPrivate: true }, { allAttributesPrivate: true }],
+        [{ allowFrequentDuplicateEvents: true }, { allowFrequentDuplicateEvents: true }],
+        [{ bootstrap: {} }, { bootstrapMode: true }],
+        [{ baseUrl: 'http://other' }, { customBaseURI: true }],
+        [{ eventsUrl: 'http://other' }, { customEventsURI: true }],
+        [{ streamUrl: 'http://other' }, { customStreamURI: true }],
+        [{ diagnosticRecordingInterval: 99999 }, { diagnosticRecordingIntervalMillis: 99999 }],
+        [{ eventCapacity: 222 }, { eventsCapacity: 222 }],
+        [{ flushInterval: 2222 }, { eventsFlushIntervalMillis: 2222 }],
+        [{ fetchGoals: false }, { fetchGoalsDisabled: true }],
+        [{ inlineUsersInEvents: true }, { inlineUsersInEvents: true }],
+        [{ streamReconnectDelay: 2222 }, { reconnectTimeMillis: 2222 }],
+        [{ sendEventsOnlyForVariation: true }, { sendEventsOnlyForVariation: true }],
+        [{ streaming: true }, { streamingDisabled: false }],
+        [{ hash: 'x' }, { usingSecureMode: true }],
+        [{ autoAliasingOptOut: true }, { autoAliasingOptOut: true }],
+      ];
+      for (const i in configAndResultValues) {
+        const configOverrides = configAndResultValues[i][0];
+        const expectedConfig = { ...defaultConfigInEvent, ...configAndResultValues[i][1] };
+        await withManager(configOverrides, null, async (manager, acc, sender) => {
+          manager.start();
+          expect(sender.calls.length()).toEqual(1);
+          const initEvent = await getPostedEvent(sender, configOverrides);
+          expect(initEvent).toEqual({
+            kind: 'diagnostic-init',
+            creationDate: defaultStartTime,
+            id: diagnosticId,
+            sdk: sdkData,
+            platform: platformData,
+            configuration: expectedConfig,
+          });
+        });
+      }
+    });
+
+    it('allows client to indicate that streaming is now enabled', async () => {
+      await withManager({}, null, async (manager, acc, sender) => {
+        manager.setStreaming(true);
+        manager.start();
+        expect(sender.calls.length()).toEqual(1);
+        const initEvent = await getPostedEvent(sender);
+        expect(initEvent).toEqual({
+          kind: 'diagnostic-init',
+          creationDate: defaultStartTime,
+          id: diagnosticId,
+          sdk: sdkData,
+          platform: platformData,
+          configuration: { ...defaultConfigInEvent, streamingDisabled: false },
+        });
+      });
+    });
+
+    it('sends periodic events', async () => {
+      const interval = 100;
+      // Note that since we haven't added any special instrumentation to DiagnosticsManager to let the test
+      // control the exact timing of the periodic events, this test is assuming that we can do a few simple
+      // steps before 100ms elapses.
+      await withManager({ diagnosticRecordingInterval: interval }, null, async (manager, acc, sender) => {
+        manager.start();
+        const initEvent = await getPostedEvent(sender);
+        expect(initEvent.kind).toEqual('diagnostic-init');
+
+        setupStatsForPeriodicEvent1(acc);
+
+        const periodic1 = await getPostedEvent(sender);
+        expect(periodic1).toMatchObject({
+          kind: 'diagnostic',
+          dataSinceDate: defaultStartTime,
+          id: diagnosticId,
+          ...expectedStatsForPeriodicEvent1,
+        });
+        expect(periodic1.creationDate).toBeGreaterThanOrEqual(defaultStartTime);
+
+        setupStatsForPeriodicEvent2(acc);
+
+        const periodic2 = await getPostedEvent(sender);
+        expect(periodic2).toMatchObject({
+          kind: 'diagnostic',
+          dataSinceDate: periodic1.creationDate,
+          id: diagnosticId,
+          ...expectedStatsForPeriodicEvent2,
+        });
+      });
+    });
+  });
+
+  describe('in combined (browser) mode', () => {
+    const interval = 100;
+    const expectedConfig = { ...defaultConfigInEvent, diagnosticRecordingIntervalMillis: interval };
+
+    it('does not send event before start()', async () => {
+      const overridePlatform = stubPlatform.defaults();
+      overridePlatform.diagnosticUseCombinedEvent = true;
+      await withManager({}, overridePlatform, async (manager, acc, sender) => {
+        expect(sender.calls.length()).toEqual(0);
+      });
+    });
+
+    it('if local storage has no data, sends event on start(), then sends periodic event', async () => {
+      const timeBeforeStart = new Date().getTime();
+      const overridePlatform = stubPlatform.defaults();
+      overridePlatform.diagnosticUseCombinedEvent = true;
+      await withManager({ diagnosticRecordingInterval: interval }, overridePlatform, async (manager, acc, sender) => {
+        manager.start();
+
+        const firstEvent = await getPostedEvent(sender);
+        expect(firstEvent).toMatchObject({
+          kind: 'diagnostic-combined',
+          id: diagnosticId,
+          dataSinceDate: defaultStartTime,
+          sdk: sdkData,
+          platform: platformData,
+          configuration: expectedConfig,
+          droppedEvents: 0,
+          eventsInLastBatch: 0,
+          streamInits: [],
+        });
+        expect(firstEvent.creationDate).toBeGreaterThanOrEqual(timeBeforeStart);
+
+        setupStatsForPeriodicEvent1(acc);
+
+        const periodic1 = await getPostedEvent(sender);
+        expect(periodic1).toMatchObject({
+          kind: 'diagnostic-combined',
+          id: diagnosticId,
+          sdk: sdkData,
+          platform: platformData,
+          configuration: expectedConfig,
+          ...expectedStatsForPeriodicEvent1,
+        });
+        expect(periodic1.dataSinceDate).toBeGreaterThan(firstEvent.dataSinceDate);
+      });
+    });
+
+    it('if local storage has non-recent data, sends cached event on start(), then sends periodic event', async () => {
+      const timeBeforeStart = new Date().getTime();
+      const storedStats = {
+        dataSinceDate: timeBeforeStart - interval - 1,
+        droppedEvents: 1,
+        eventsInLastBatch: 2,
+        streamInits: [{ timestamp: 1000, durationMillis: 500 }],
+      };
+      const overridePlatform = stubPlatform.defaults();
+      overridePlatform.diagnosticUseCombinedEvent = true;
+      overridePlatform.testing.setLocalStorageImmediately(localStorageKey, JSON.stringify(storedStats));
+      await withManager({ diagnosticRecordingInterval: interval }, overridePlatform, async (manager, acc, sender) => {
+        const timeBeforeStart = new Date().getTime();
+        manager.start();
+        await sleepAsync(10); // manager's localstorage logic is async, so allow it to catch up with us
+
+        expect(sender.calls.length()).toEqual(1);
+        const firstEvent = await getPostedEvent(sender);
+        expect(firstEvent).toMatchObject({
+          kind: 'diagnostic-combined',
+          id: diagnosticId,
+          sdk: sdkData,
+          platform: platformData,
+          configuration: { ...defaultConfigInEvent, diagnosticRecordingIntervalMillis: interval },
+          ...storedStats,
+        });
+        expect(firstEvent.creationDate).toBeGreaterThanOrEqual(timeBeforeStart);
+
+        setupStatsForPeriodicEvent1(acc);
+
+        const periodic1 = await getPostedEvent(sender);
+        expect(periodic1).toMatchObject({
+          kind: 'diagnostic-combined',
+          id: diagnosticId,
+          sdk: sdkData,
+          platform: platformData,
+          configuration: expectedConfig,
+          ...expectedStatsForPeriodicEvent1,
+        });
+        expect(periodic1.dataSinceDate).toBeGreaterThan(firstEvent.dataSinceDate);
+      });
+    });
+
+    it('defers event on start() if event was sent recently', async () => {
+      const timeBeforeStart = new Date().getTime();
+      const interval = 200;
+      const storedStats = {
+        dataSinceDate: timeBeforeStart - interval + 100,
+        droppedEvents: 1,
+        eventsInLastBatch: 2,
+        streamInits: [{ timestamp: 1000, durationMillis: 500 }],
+      };
+      const overridePlatform = stubPlatform.defaults();
+      overridePlatform.diagnosticUseCombinedEvent = true;
+      overridePlatform.testing.setLocalStorageImmediately(localStorageKey, JSON.stringify(storedStats));
+      await withManager({ diagnosticRecordingInterval: interval }, overridePlatform, async (manager, acc, sender) => {
+        const timeBeforeStart = new Date().getTime();
+        manager.start();
+        await sleepAsync(10); // manager's localstorage logic is async, so allow it to catch up with us
+        expect(sender.calls.length()).toEqual(0);
+
+        acc.incrementDroppedEvents();
+        acc.setEventsInLastBatch(3);
+        acc.recordStreamInit(1001, false, 501);
+
+        const firstEvent = await getPostedEvent(sender);
+        expect(firstEvent).toMatchObject({
+          kind: 'diagnostic-combined',
+          id: diagnosticId,
+          sdk: sdkData,
+          platform: platformData,
+          configuration: { ...defaultConfigInEvent, diagnosticRecordingIntervalMillis: interval },
+          dataSinceDate: storedStats.dataSinceDate,
+          droppedEvents: 2,
+          eventsInLastBatch: 3,
+          streamInits: [{ timestamp: 1000, durationMillis: 500 }, { timestamp: 1001, durationMillis: 501 }],
+        });
+        expect(firstEvent.creationDate).toBeGreaterThanOrEqual(timeBeforeStart);
+      });
+    });
+
+    it('continues sending periodic events', async () => {
+      // In the previous tests in this group, we always separately verified the first periodic event (after
+      // the initial event) because there could be a different code path for scheduling it depending on the
+      // initial conditions. But we can assume that the scheduling of the second event does not depend on the
+      // initial conditions - it will always be scheduled when the first one gets sent.
+      const interval = 100;
+      const expectedConfig = { ...defaultConfigInEvent, diagnosticRecordingIntervalMillis: interval };
+      const overridePlatform = stubPlatform.defaults();
+      overridePlatform.diagnosticUseCombinedEvent = true;
+      await withManager({ diagnosticRecordingInterval: interval }, overridePlatform, async (manager, acc, sender) => {
+        manager.start();
+
+        const firstEvent = await getPostedEvent(sender);
+        expect(firstEvent).toMatchObject({
+          kind: 'diagnostic-combined',
+          dataSinceDate: defaultStartTime,
+        });
+
+        setupStatsForPeriodicEvent1(acc);
+
+        const periodic1 = await getPostedEvent(sender);
+        expect(periodic1).toMatchObject({
+          kind: 'diagnostic-combined',
+          ...expectedStatsForPeriodicEvent1,
+        });
+        expect(periodic1.dataSinceDate).toBeGreaterThan(firstEvent.dataSinceDate);
+
+        setupStatsForPeriodicEvent2(acc);
+
+        const periodic2 = (await sender.calls.take()).events;
+        expect(periodic2).toMatchObject({
+          kind: 'diagnostic-combined',
+          id: diagnosticId,
+          sdk: sdkData,
+          platform: platformData,
+          configuration: expectedConfig,
+          ...expectedStatsForPeriodicEvent2,
+        });
+        expect(periodic2.dataSinceDate).toBeGreaterThan(periodic1.dataSinceDate);
+      });
+    });
+  });
+});

package/src/__tests__/loggers-test.js

@@ -0,0 +1,149 @@
+const { format } = require('util');
+const loggers = require('../loggers');
+
+describe('commonBasicLogger', () => {
+  it('uses console methods by default', () => {
+    const realLog = console.log,
+      realInfo = console.info,
+      realWarn = console.warn,
+      realError = console.error;
+    const mockLog = jest.fn(),
+      mockInfo = jest.fn(),
+      mockWarn = jest.fn(),
+      mockError = jest.fn();
+    try {
+      console.log = mockLog;
+      console.info = mockInfo;
+      console.warn = mockWarn;
+      console.error = mockError;
+      const logger = loggers.commonBasicLogger({ level: 'debug' });
+      logger.debug('a');
+      logger.info('b');
+      logger.warn('c');
+      logger.error('d');
+      expect(mockLog).toHaveBeenCalledWith('[LaunchDarkly] a');
+      expect(mockInfo).toHaveBeenCalledWith('[LaunchDarkly] b');
+      expect(mockWarn).toHaveBeenCalledWith('[LaunchDarkly] c');
+      expect(mockError).toHaveBeenCalledWith('[LaunchDarkly] d');
+    } finally {
+      console.log = realLog;
+      console.info = realInfo;
+      console.warn = realWarn;
+      console.error = realError;
+    }
+  });
+
+  it('can write to an arbitrary function', () => {
+    const outputFn = jest.fn();
+    const logger = loggers.commonBasicLogger({ destination: outputFn });
+    logger.warn('hello');
+    expect(outputFn).toHaveBeenCalledWith('warn: [LaunchDarkly] hello');
+  });
+
+  it('throws an exception immediately if destination is not a function', () => {
+    expect(() => loggers.commonBasicLogger({ destination: 'Mars' })).toThrow();
+  });
+
+  it('does not use formatter if there is only one argument', () => {
+    const outputFn = jest.fn();
+    const logger = loggers.commonBasicLogger({ destination: outputFn }, format);
+    logger.warn('%d things');
+    expect(outputFn).toHaveBeenCalledWith('warn: [LaunchDarkly] %d things');
+  });
+
+  it('uses formatter if there are multiple arguments', () => {
+    const outputFn = jest.fn();
+    const logger = loggers.commonBasicLogger({ destination: outputFn }, format);
+    logger.warn('%d things', 3);
+    expect(outputFn).toHaveBeenCalledWith('warn: [LaunchDarkly] 3 things');
+  });
+
+  it('does not use formatter if there is none', () => {
+    const outputFn = jest.fn();
+    const logger = loggers.commonBasicLogger({ destination: outputFn }, null);
+    logger.warn('%d things', 3);
+    expect(outputFn).toHaveBeenCalledWith('warn: [LaunchDarkly] %d things');
+  });
+
+  describe('output filtering by level', () => {
+    const testLevel = (minLevel, enabledLevels) => {
+      it('level: ' + minLevel, () => {
+        const outputFn = jest.fn();
+        const config = { destination: outputFn };
+        if (minLevel) {
+          config.level = minLevel;
+        }
+        const logger = loggers.commonBasicLogger({ level: minLevel, destination: outputFn });
+        logger.debug('some debug output');
+        logger.info('some info output');
+        logger.warn('some warn output');
+        logger.error('some error output');
+        for (const [level, shouldBeEnabled] of Object.entries(enabledLevels)) {
+          const line = level + ': [LaunchDarkly] some ' + level + ' output';
+          if (shouldBeEnabled) {
+            expect(outputFn).toHaveBeenCalledWith(line);
+          } else {
+            expect(outputFn).not.toHaveBeenCalledWith(line);
+          }
+        }
+      });
+    };
+
+    testLevel('debug', { debug: true, info: true, warn: true, error: true });
+    testLevel('info', { debug: false, info: true, warn: true, error: true });
+    testLevel('warn', { debug: false, info: false, warn: true, error: true });
+    testLevel('error', { debug: false, info: false, warn: false, error: true });
+    testLevel('none', { debug: false, info: false, warn: false, error: false });
+
+    // default is info
+    testLevel(undefined, { debug: false, info: true, warn: true, error: true });
+  });
+
+  it('does not throw an error if console is undefined or null', () => {
+    const oldConsole = console;
+    try {
+      console = null; // eslint-disable-line no-global-assign
+      const logger = loggers.commonBasicLogger({ level: 'debug' });
+      logger.debug('x');
+      logger.info('x');
+      logger.warn('x');
+      logger.error('x');
+      console = undefined; // eslint-disable-line no-global-assign
+      logger.debug('x');
+      logger.info('x');
+      logger.warn('x');
+      logger.error('x');
+    } finally {
+      console = oldConsole; // eslint-disable-line no-global-assign
+    }
+  });
+});
+
+describe('validateLogger', () => {
+  function mockLogger() {
+    return {
+      error: jest.fn(),
+      warn: jest.fn(),
+      info: jest.fn(),
+      debug: jest.fn(),
+    };
+  }
+
+  const levels = ['error', 'warn', 'info', 'debug'];
+
+  it('throws an error if the logger does not conform to the LDLogger schema', () => {
+    // If the method does not exist
+    levels.forEach(method => {
+      const logger = mockLogger();
+      delete logger[method];
+      expect(() => loggers.validateLogger(logger)).toThrow(/Provided logger instance must support .* method/);
+    });
+
+    // If the method is not a function
+    levels.forEach(method => {
+      const logger = mockLogger();
+      logger[method] = 'invalid';
+      expect(() => loggers.validateLogger(logger)).toThrow(/Provided logger instance must support .* method/);
+    });
+  });
+});