fix(events): Allow disabling event logging, check r/o FS (#96)

* fix(events): Allow disabling event logging, check r/o FS

* pass in config into newDefaultEventDispatcher

* Update src/index.spec.ts

Co-authored-by: Sameeran Kunche <[email protected]>

* sort lines alphabetically

---------

Co-authored-by: Sameeran Kunche <[email protected]>

Author: felipecsl

src/i-client-config.ts

@@ -45,4 +45,26 @@ export interface IClientConfig {
 
   /** Amount of time in milliseconds to wait between API calls to refresh configuration data. Default of 30_000 (30s). */
   pollingIntervalMs?: number;
+
+  /** Configuration settings for the event dispatcher */
+  eventIngestionConfig?: {
+    /** Maximum number of events to send per delivery request. Defaults to 1000 events. */
+    batchSize?: number;
+    /** Number of milliseconds to wait between each batch delivery. Defaults to 10 seconds. */
+    deliveryIntervalMs?: number;
+    /** Whether to disable event ingestion. Defaults to false. */
+    disabled?: boolean;
+    /**
+     * Maximum number of events to queue in memory before starting to drop events.
+     * Note: This is only used if localStorage is not available.
+     * Defaults to 10000 events.
+     */
+    maxQueueSize?: number;
+    /** Maximum number of retry attempts before giving up on a batch delivery. Defaults to 3 retries. */
+    maxRetries?: number;
+    /** Maximum amount of milliseconds to wait before retrying a failed delivery. Defaults to 30 seconds. */
+    maxRetryDelayMs?: number;
+    /** Minimum amount of milliseconds to wait before retrying a failed delivery. Defaults to 5 seconds */
+    retryIntervalMs?: number;
+  };
 }

src/index.spec.ts

@@ -30,7 +30,9 @@ import {
   validateTestAssignments,
 } from '../test/testHelpers';
 
-import { getInstance, IAssignmentEvent, IAssignmentLogger, init } from '.';
+import * as util from './util/index';
+
+import { getInstance, IAssignmentEvent, IAssignmentLogger, init, NO_OP_EVENT_DISPATCHER } from '.';
 
 import SpyInstance = jest.SpyInstance;
 
@@ -367,22 +369,34 @@ describe('EppoClient E2E test', () => {
     describe('Bandit assignment cache', () => {
       const flagKey = 'banner_bandit_flag'; // piggyback off a shared test data flag
       const bobKey = 'bob';
-      const bobAttributes: Attributes = { age: 25, country: 'USA', gender_identity: 'female' };
+      const bobAttributes: Attributes = {
+        age: 25,
+        country: 'USA',
+        gender_identity: 'female',
+      };
       const bobActions: Record<string, Attributes> = {
         nike: { brand_affinity: 1.5, loyalty_tier: 'silver' },
         adidas: { brand_affinity: -1.0, loyalty_tier: 'bronze' },
         reebok: { brand_affinity: 0.5, loyalty_tier: 'gold' },
       };
 
       const aliceKey = 'alice';
-      const aliceAttributes: Attributes = { age: 25, country: 'USA', gender_identity: 'female' };
+      const aliceAttributes: Attributes = {
+        age: 25,
+        country: 'USA',
+        gender_identity: 'female',
+      };
       const aliceActions: Record<string, Attributes> = {
         nike: { brand_affinity: 1.5, loyalty_tier: 'silver' },
         adidas: { brand_affinity: -1.0, loyalty_tier: 'bronze' },
         reebok: { brand_affinity: 0.5, loyalty_tier: 'gold' },
       };
       const charlieKey = 'charlie';
-      const charlieAttributes: Attributes = { age: 25, country: 'USA', gender_identity: 'female' };
+      const charlieAttributes: Attributes = {
+        age: 25,
+        country: 'USA',
+        gender_identity: 'female',
+      };
       const charlieActions: Record<string, Attributes> = {
         nike: { brand_affinity: 1.0, loyalty_tier: 'gold' },
         adidas: { brand_affinity: 1.0, loyalty_tier: 'silver' },
@@ -452,7 +466,11 @@ describe('EppoClient E2E test', () => {
 
   describe('Best Bandit Action', () => {
     const flagKey = 'banner_bandit_flag'; // piggyback off a shared test data flag
-    const bobAttributes: Attributes = { age: 25, country: 'USA', gender_identity: 'female' };
+    const bobAttributes: Attributes = {
+      age: 25,
+      country: 'USA',
+      gender_identity: 'female',
+    };
     const bobActions: Record<string, Attributes> = {
       nike: { brand_affinity: -10.5, loyalty_tier: 'silver' },
       adidas: { brand_affinity: 1.0, loyalty_tier: 'bronze' },
@@ -469,7 +487,6 @@ describe('EppoClient E2E test', () => {
 
     it('Should return the highest ranked bandit', async () => {
       const client = getInstance();
-
       const bestAction = client.getBestAction(flagKey, bobAttributes, bobActions, 'default');
 
       expect(bestAction).toEqual('adidas');
@@ -590,4 +607,108 @@ describe('EppoClient E2E test', () => {
       expect(client.getStringAssignment(flagKey, 'subject', {}, 'default-value')).toBe('control');
     });
   });
+
+  describe('eventIngestionConfig', () => {
+    it('should not be used if eventIngestionConfig.disabled is true', async () => {
+      const client = await init({
+        apiKey,
+        baseUrl: `http://127.0.0.1:${TEST_SERVER_PORT}`,
+        assignmentLogger: mockLogger,
+        eventIngestionConfig: {
+          disabled: true,
+        },
+      });
+      expect(client['eventDispatcher']).toEqual(NO_OP_EVENT_DISPATCHER);
+    });
+
+    it('should be used if eventIngestionConfig.disabled is false', async () => {
+      const client = await init({
+        apiKey,
+        baseUrl: `http://127.0.0.1:${TEST_SERVER_PORT}`,
+        assignmentLogger: mockLogger,
+        eventIngestionConfig: {
+          disabled: false,
+        },
+      });
+      expect(client['eventDispatcher']).not.toEqual(NO_OP_EVENT_DISPATCHER);
+    });
+
+    describe('read-only file system handling', () => {
+      // Save original implementation
+      let isReadOnlyFsSpy: SpyInstance;
+
+      beforeEach(() => {
+        // Reset the module before each test
+        jest.resetModules();
+        // Create a spy on isReadOnlyFs that we can mock
+        isReadOnlyFsSpy = jest.spyOn(util, 'isReadOnlyFs');
+      });
+
+      afterEach(() => {
+        isReadOnlyFsSpy.mockRestore();
+      });
+
+      it('should use BoundedEventQueue when file system is read-only', async () => {
+        // Mock isReadOnlyFs to return true (read-only file system)
+        isReadOnlyFsSpy.mockReturnValue(true);
+        const client = await init({
+          apiKey,
+          baseUrl: `http://127.0.0.1:${TEST_SERVER_PORT}`,
+          assignmentLogger: mockLogger,
+          eventIngestionConfig: {
+            disabled: false,
+          },
+        });
+
+        // Check that the event queue is a BoundedEventQueue
+        // We can't directly check the type, but we can check that it's not a FileBackedNamedEventQueue
+        // by checking if the queue has a 'queueDirectory' property
+        const eventDispatcher = client['eventDispatcher'];
+        const eventQueue = eventDispatcher['batchProcessor']['eventQueue'];
+        expect(eventQueue).toBeDefined();
+        expect(eventQueue['queueDirectory']).toBeUndefined();
+      });
+
+      it('should use FileBackedNamedEventQueue when file system is writable', async () => {
+        // Mock isReadOnlyFs to return false (writable file system)
+        isReadOnlyFsSpy.mockReturnValue(false);
+        const client = await init({
+          apiKey,
+          baseUrl: `http://127.0.0.1:${TEST_SERVER_PORT}`,
+          assignmentLogger: mockLogger,
+          eventIngestionConfig: {
+            disabled: false,
+          },
+        });
+
+        // Check that the event queue is a FileBackedNamedEventQueue
+        // by checking if the queue has a 'queueDirectory' property
+        const eventDispatcher = client['eventDispatcher'];
+        const eventQueue = eventDispatcher['batchProcessor']['eventQueue'];
+        expect(eventQueue).toBeDefined();
+        expect(eventQueue['queueDirectory']).toBeDefined();
+      });
+
+      it('should use BoundedEventQueue when isReadOnlyFs throws an error', async () => {
+        // Mock isReadOnlyFs to throw an error
+        isReadOnlyFsSpy.mockImplementation(() => {
+          throw new Error('Test error');
+        });
+        const client = await init({
+          apiKey,
+          baseUrl: `http://127.0.0.1:${TEST_SERVER_PORT}`,
+          assignmentLogger: mockLogger,
+          eventIngestionConfig: {
+            disabled: false,
+          },
+        });
+
+        // Check that the event queue is a BoundedEventQueue
+        const eventDispatcher = client['eventDispatcher'];
+        const eventQueue = eventDispatcher['batchProcessor']['eventQueue'];
+        expect(eventQueue).toBeDefined();
+        expect(eventQueue['queueDirectory']).toBeUndefined();
+      });
+    });
+  });
 });

src/index.ts

@@ -3,20 +3,25 @@ import {
   BanditActions,
   BanditParameters,
   BanditVariation,
+  BoundedEventQueue,
   ContextAttributes,
   EppoClient,
   Event,
+  EventDispatcher,
   Flag,
   FlagConfigurationRequestParameters,
   FlagKey,
   MemoryOnlyConfigurationStore,
+  NamedEventQueue,
+  applicationLogger,
   newDefaultEventDispatcher,
 } from '@eppo/js-client-sdk-common';
 
 import FileBackedNamedEventQueue from './events/file-backed-named-event-queue';
 import { IClientConfig } from './i-client-config';
 import { sdkName, sdkVersion } from './sdk-data';
 import { generateSalt } from './util';
+import { isReadOnlyFs } from './util/index';
 
 export {
   Attributes,
@@ -35,6 +40,13 @@ export { IClientConfig };
 
 let clientInstance: EppoClient;
 
+export const NO_OP_EVENT_DISPATCHER: EventDispatcher = {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  attachContext: () => {},
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  dispatch: () => {},
+};
+
 /**
  * Initializes the Eppo client with configuration parameters.
  * This method should be called once on application startup.
@@ -52,6 +64,7 @@ export async function init(config: IClientConfig): Promise<EppoClient> {
     pollingIntervalMs,
     throwOnFailedInitialization = true,
     pollAfterFailedInitialization = false,
+    eventIngestionConfig,
   } = config;
   if (!apiKey) {
     throw new Error('API key is required');
@@ -75,7 +88,7 @@ export async function init(config: IClientConfig): Promise<EppoClient> {
   const flagConfigurationStore = new MemoryOnlyConfigurationStore<Flag>();
   const banditVariationConfigurationStore = new MemoryOnlyConfigurationStore<BanditVariation[]>();
   const banditModelConfigurationStore = new MemoryOnlyConfigurationStore<BanditParameters>();
-  const eventDispatcher = newEventDispatcher(apiKey);
+  const eventDispatcher = newEventDispatcher(apiKey, eventIngestionConfig);
 
   clientInstance = new EppoClient({
     flagConfigurationStore,
@@ -130,10 +143,48 @@ export function getInstance(): EppoClient {
   return clientInstance;
 }
 
-function newEventDispatcher(sdkKey: string) {
-  const eventQueue = new FileBackedNamedEventQueue<Event>('events');
+function newEventDispatcher(
+  sdkKey: string,
+  config: IClientConfig['eventIngestionConfig'] = {},
+): EventDispatcher {
+  const {
+    batchSize = 1_000,
+    deliveryIntervalMs = 10_000,
+    disabled = false,
+    maxQueueSize = 10_000,
+    maxRetries = 3,
+    maxRetryDelayMs = 30_000,
+    retryIntervalMs = 5_000,
+  } = config;
+  if (disabled) {
+    return NO_OP_EVENT_DISPATCHER;
+  }
+  let eventQueue: NamedEventQueue<Event>;
+  try {
+    // Check if the file system is read-only
+    if (isReadOnlyFs(`${process.cwd()}/.queues`)) {
+      applicationLogger.warn(
+        'File system appears to be read-only. Using in-memory event queue instead.',
+      );
+      eventQueue = new BoundedEventQueue<Event>('events', [], maxQueueSize);
+    } else {
+      eventQueue = new FileBackedNamedEventQueue<Event>('events');
+    }
+  } catch (error) {
+    // If there's any error during the check, fall back to BoundedEventQueue
+    applicationLogger.warn(
+      `Error checking file system: ${error}. Using in-memory event queue instead.`,
+    );
+    eventQueue = new BoundedEventQueue<Event>('events', [], maxQueueSize);
+  }
+
   const emptyNetworkStatusListener =
     // eslint-disable-next-line @typescript-eslint/no-empty-function
     { isOffline: () => false, onNetworkStatusChange: () => {} };
-  return newDefaultEventDispatcher(eventQueue, emptyNetworkStatusListener, sdkKey);
+  return newDefaultEventDispatcher(eventQueue, emptyNetworkStatusListener, sdkKey, batchSize, {
+    deliveryIntervalMs,
+    retryIntervalMs,
+    maxRetryDelayMs,
+    maxRetries,
+  });
 }

src/util/index.ts

@@ -0,0 +1,18 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Checks if the file system is read-only by attempting to write to a temporary file.
+ * @param directory The directory to check for write access
+ * @returns True if the file system is read-only, false otherwise
+ */
+export function isReadOnlyFs(directory: string): boolean {
+  try {
+    const testFilePath = path.join(directory, '.write_test_' + Date.now());
+    fs.writeFileSync(testFilePath, 'test', { flag: 'w' });
+    fs.unlinkSync(testFilePath);
+    return false;
+  } catch (error) {
+    return true;
+  }
+}