feat: Added Offline storage support to Event processor for React Native Apps

packages/event-processor/__tests__/v1EventProcessor.spec.ts

@@ -114,7 +114,7 @@ describe('LogTierV1EventProcessor', () => {
     stubDispatcher = {
       dispatchEvent(event: EventV1Request, callback: EventDispatcherCallback): void {
         dispatchStub(event)
-        callback(200)
+        callback({ statusCode: 200 })
       },
     }
   })
@@ -161,7 +161,7 @@ describe('LogTierV1EventProcessor', () => {
         done()
       })
 
-      localCallback(200)
+      localCallback({ statusCode: 200 })
     })
 
     it('should return a promise that is resolved when the dispatcher callback returns a 400 response', done => {
@@ -198,7 +198,7 @@ describe('LogTierV1EventProcessor', () => {
       stubDispatcher = {
         dispatchEvent(event: EventV1Request, callback: EventDispatcherCallback): void {
           dispatchStub(event)
-          callback(200)
+          callback({ statusCode: 200 })
         },
       }
 
@@ -224,7 +224,7 @@ describe('LogTierV1EventProcessor', () => {
     it('should stop accepting events after stop is called', () => {
       const dispatcher = {
         dispatchEvent: jest.fn((event: EventV1Request, callback: EventDispatcherCallback) => {
-          setTimeout(() => callback(204), 0)
+          setTimeout(() => callback({ statusCode: 204 }), 0)
         })
       }
       const processor = new LogTierV1EventProcessor({
@@ -282,10 +282,10 @@ describe('LogTierV1EventProcessor', () => {
       })
       expect(stopPromiseResolved).toBe(false)
 
-      dispatchCbs[0](204)
+      dispatchCbs[0]({ statusCode: 204 })
       jest.advanceTimersByTime(100)
       expect(stopPromiseResolved).toBe(false)
-      dispatchCbs[1](204)
+      dispatchCbs[1]({ statusCode: 204 })
       await stopPromise
       expect(stopPromiseResolved).toBe(true)
     })

packages/event-processor/src/eventDispatcher.ts

@@ -15,7 +15,11 @@
  */
 import { EventV1 } from "./v1/buildEventV1";
 
-export type EventDispatcherCallback = (status: number) => void
+export type EventDispatcherResponse = {
+  statusCode: number  
+}
+
+export type EventDispatcherCallback = (response: EventDispatcherResponse) => void
 
 export interface EventDispatcher {
   dispatchEvent(event: EventV1Request, callback: EventDispatcherCallback): void

packages/event-processor/src/eventProcessor.ts

@@ -15,124 +15,67 @@
  */
 // TODO change this to use Managed from js-sdk-models when available
 import { Managed } from './managed'
-import { ConversionEvent, ImpressionEvent, areEventContextsEqual } from './events'
-import { EventDispatcher, EventV1Request } from './eventDispatcher'
+import { ConversionEvent, ImpressionEvent } from './events'
+import { EventV1Request } from './eventDispatcher'
 import { EventQueue, DefaultEventQueue, SingleEventQueue } from './eventQueue'
 import { getLogger } from '@optimizely/js-sdk-logging'
 import { NOTIFICATION_TYPES, NotificationCenter } from '@optimizely/js-sdk-utils'
-import RequestTracker from './requestTracker';
-
-const logger = getLogger('EventProcessor')
-
-export type ProcessableEvents = ConversionEvent | ImpressionEvent
-
-export type EventDispatchResult = { result: boolean; event: ProcessableEvents }
-
-export interface EventProcessor extends Managed {
-  process(event: ProcessableEvents): void
-}
 
 const DEFAULT_FLUSH_INTERVAL = 30000 // Unit is ms - default flush interval is 30s
 const DEFAULT_BATCH_SIZE = 10
 
-export abstract class AbstractEventProcessor implements EventProcessor {
-  protected dispatcher: EventDispatcher
-  protected queue: EventQueue<ProcessableEvents>
-  private notificationCenter?: NotificationCenter
-  protected requestTracker: RequestTracker
-
-  constructor({
-    dispatcher,
-    flushInterval = 30000,
-    batchSize = 3000,
-    notificationCenter,
-  }: {
-    dispatcher: EventDispatcher
-    flushInterval?: number
-    batchSize?: number
-    notificationCenter?: NotificationCenter
-  }) {
-    this.dispatcher = dispatcher
-
-    if (flushInterval <= 0) {
-      logger.warn(
-        `Invalid flushInterval ${flushInterval}, defaulting to ${DEFAULT_FLUSH_INTERVAL}`,
-      )
-      flushInterval = DEFAULT_FLUSH_INTERVAL
-    }
-
-    batchSize = Math.floor(batchSize)
-    if (batchSize < 1) {
-      logger.warn(
-        `Invalid batchSize ${batchSize}, defaulting to ${DEFAULT_BATCH_SIZE}`,
-      )
-      batchSize = DEFAULT_BATCH_SIZE
-    }
-
-    batchSize = Math.max(1, batchSize)
-    if (batchSize > 1) {
-      this.queue = new DefaultEventQueue<ProcessableEvents>({
-        flushInterval,
-        maxQueueSize: batchSize,
-        sink: buffer => this.drainQueue(buffer),
-        batchComparator: areEventContextsEqual,
-      })
-    } else {
-      this.queue = new SingleEventQueue({
-        sink: buffer => this.drainQueue(buffer),
-      })
-    }
-    this.notificationCenter = notificationCenter
-
-    this.requestTracker = new RequestTracker()
-  }
+const logger = getLogger('EventProcessor')
 
-  drainQueue(buffer: ProcessableEvents[]): Promise<void> {
-    const reqPromise = new Promise<void>(resolve => {
-      logger.debug('draining queue with %s events', buffer.length)
+export type ProcessableEvent = ConversionEvent | ImpressionEvent
 
-      if (buffer.length === 0) {
-        resolve()
-        return
-      }
+export type EventDispatchResult = { result: boolean; event: ProcessableEvent }
 
-      const formattedEvent = this.formatEvents(buffer)
-      this.dispatcher.dispatchEvent(formattedEvent, () => {
-        resolve()
-      })
-      this.sendEventNotification(formattedEvent)
-    })
-    this.requestTracker.trackRequest(reqPromise)
-    return reqPromise
-  }
+export interface EventProcessor extends Managed {
+  process(event: ProcessableEvent): void
+}
 
-  protected sendEventNotification(event: EventV1Request): void {
-    if (this.notificationCenter) {
-      this.notificationCenter.sendNotifications(
-        NOTIFICATION_TYPES.LOG_EVENT,
-        event,
-      )
-    }
+export function validateAndGetFlushInterval(flushInterval: number): number {
+  if (flushInterval <= 0) {
+    logger.warn(
+      `Invalid flushInterval ${flushInterval}, defaulting to ${DEFAULT_FLUSH_INTERVAL}`,
+    )
+    flushInterval = DEFAULT_FLUSH_INTERVAL
   }
+  return flushInterval
+}
 
-  process(event: ProcessableEvents): void {
-    this.queue.enqueue(event)
+export function validateAndGetBatchSize(batchSize: number): number {
+  batchSize = Math.floor(batchSize)
+  if (batchSize < 1) {
+    logger.warn(
+      `Invalid batchSize ${batchSize}, defaulting to ${DEFAULT_BATCH_SIZE}`,
+    )
+    batchSize = DEFAULT_BATCH_SIZE
   }
+  batchSize = Math.max(1, batchSize)
+  return batchSize
+}
 
-  stop(): Promise<any> {
-    // swallow - an error stopping this queue shouldn't prevent this from stopping
-    try {
-      this.queue.stop()
-      return this.requestTracker.onRequestsComplete()
-    } catch (e) {
-      logger.error('Error stopping EventProcessor: "%s"', e.message, e)
-    }
-    return Promise.resolve()
+export function getQueue(batchSize: number, flushInterval: number, sink: any, batchComparator: any): EventQueue<ProcessableEvent> {
+  let queue: EventQueue<ProcessableEvent>
+  if (batchSize > 1) {
+    queue = new DefaultEventQueue<ProcessableEvent>({
+      flushInterval,
+      maxQueueSize: batchSize,
+      sink,
+      batchComparator,
+    })
+  } else {
+    queue = new SingleEventQueue({ sink })
   }
+  return queue
+}
 
-  start(): void {
-    this.queue.start()
+export function sendEventNotification(notificationCenter: NotificationCenter | undefined, event: EventV1Request): void {
+  if (notificationCenter) {
+    notificationCenter.sendNotifications(
+      NOTIFICATION_TYPES.LOG_EVENT,
+      event,
+    )
   }
-
-  protected abstract formatEvents(events: ProcessableEvents[]): EventV1Request
 }

packages/event-processor/src/index.react_native.ts

@@ -20,4 +20,4 @@ export * from './eventDispatcher'
 export * from './managed'
 export * from './pendingEventsDispatcher'
 export * from './v1/buildEventV1'
-export { LogTierV1ReactNativeEventProcessor as LogTierV1EventProcessor } from './v1/v1EventProcessor'
+export * from './v1/v1EventProcessor.react_native'

packages/event-processor/src/index.ts

@@ -20,4 +20,4 @@ export * from './eventDispatcher'
 export * from './managed'
 export * from './pendingEventsDispatcher'
 export * from './v1/buildEventV1'
-export { LogTierV1EventProcessor } from './v1/v1EventProcessor'
+export * from './v1/v1EventProcessor'