feat: Accumulate Events

.eslintrc.json

@@ -10,8 +10,7 @@
     "sourceType": "module"
   },
   "rules": {
-    "sort-imports": ["error"],
-    "@typescript-eslint/no-unused-expressions": "off"
+    "sort-imports": ["error"]
   },
   "overrides": [
     {

package.json

@@ -144,7 +144,7 @@
     "release": "aegir release",
     "build": "aegir build",
     "test": "run-s test:*",
-    "test:node": "aegir test --target node --files 'test/**/*.spec.ts'",
+    "test:node": "aegir test --target node --files 'test/node/**/*.spec.ts'",
     "storybook": "start-storybook -p 6006",
     "build-storybook": "build-storybook"
   },

src/EventAccumulator.ts

@@ -18,9 +18,9 @@ interface eventStore {
 /**
  * EventAccumulator is a class that accumulates events and flushes them to the Countly server.
  */
-export class EventAccumulator implements IEventAccumulator {
-  private readonly metricsService: CountlyWebSdk | CountlyNodeSdk
-  private readonly events: Map<string, eventStore>
+export class EventAccumulator<T extends CountlyWebSdk | CountlyNodeSdk> implements IEventAccumulator {
+  private readonly metricsService: T
+  private readonly events: Map<string, eventStore> = new Map()
   private readonly flushInterval: number
 
   /**
@@ -29,17 +29,25 @@ export class EventAccumulator implements IEventAccumulator {
    * @param {CountlyWebSdk} metricsService - instance
    * @param {number} flushInterval - in milliseconds
    */
-  constructor (metricsService: CountlyWebSdk | CountlyNodeSdk, flushInterval: number = 5 * 60 * 1000) {
+  constructor (metricsService: T, flushInterval: number = 5 * 60 * 1000) {
     this.metricsService = metricsService
     this.flushInterval = flushInterval
-    this.events = new Map()
     this.setupUnloadEvent()
   }
 
+  /**
+   * Setup the beforeunload event to flush all events.
+   */
   private setupUnloadEvent (): void {
-    globalThis.addEventListener('beforeunload', () => {
+    const flushAllHandler = (): void => {
       this.flushAll()
-    })
+    }
+
+    if (typeof globalThis.addEventListener === 'function') {
+      globalThis.addEventListener('beforeunload', flushAllHandler)
+    } else if (typeof globalThis.process?.on === 'function') {
+      globalThis.process.on('beforeExit', flushAllHandler)
+    }
   }
 
   /**
@@ -75,7 +83,7 @@ export class EventAccumulator implements IEventAccumulator {
    *
    * @param {CountlyEventData} newEventData - event data
    */
-  private digestEventData (newEventData: CountlyEventData): void {
+  private accumulateEventData (newEventData: CountlyEventData): void {
     const { key, count, segmentation } = newEventData
     // if event is in the store, update the event data.
     const eventStore = this.events.get(key)
@@ -104,7 +112,7 @@ export class EventAccumulator implements IEventAccumulator {
       throw new Error('Event key is required.')
     }
 
-    this.digestEventData(eventData)
+    this.accumulateEventData(eventData)
 
     // flush the event if flush is true.
     if (flush) {

src/MetricsProvider.ts

@@ -1,6 +1,13 @@
-import type { CountlyWebSdk, metricFeatures } from 'countly-sdk-web'
+import type {
+  CountlyEvent,
+  CountlyWebSdk,
+  IgnoreList,
+  Segments,
+  metricFeatures
+} from 'countly-sdk-web'
 import type { consentTypes, consentTypesExceptAll } from '../types/index.js'
 import { COUNTLY_SETUP_DEFAULTS } from './config.js'
+
 import type { CountlyNodeSdk } from 'countly-sdk-nodejs'
 import { EventAccumulator } from './EventAccumulator.js'
 import type { StorageProvider } from './StorageProvider.js'
@@ -18,7 +25,7 @@ export interface MetricsProviderConstructorOptions<T> {
 }
 
 export default class MetricsProvider<T extends CountlyWebSdk | CountlyNodeSdk> {
-  public readonly accumulate: EventAccumulator
+  public readonly accumulate: EventAccumulator<T>
   private readonly groupedFeatures: Record<consentTypes, metricFeatures[]> = this.mapAllEvents({
     minimal: ['sessions', 'views', 'events'],
     performance: ['crashes', 'apm'],
@@ -34,17 +41,17 @@ export default class MetricsProvider<T extends CountlyWebSdk | CountlyNodeSdk> {
   private readonly initDone: boolean = false
 
   constructor (config: MetricsProviderConstructorOptions<T>) {
+    const { appKey, ...remainderConfig } = config
     const serviceConfig = {
       ...COUNTLY_SETUP_DEFAULTS,
-      ...config,
-      app_key: config.appKey
+      ...remainderConfig,
+      app_key: appKey
     }
     const { autoTrack, metricsService, storageProvider } = serviceConfig
     this.metricsService = metricsService
     this.storageProvider = storageProvider ?? null
-    this.accumulate = new EventAccumulator(metricsService)
-    this.storageProvider = storageProvider ?? null
     this.metricsService.init(serviceConfig)
+    this.accumulate = new EventAccumulator(metricsService)
     this.metricsService.group_features(this.groupedFeatures)
 
     if (autoTrack) {

test/unit/EventAccumulator.spec.ts → test/node/EventAccumulator.spec.ts

@@ -2,16 +2,17 @@ import { expect, sinon } from '../testUtils.js'
 import Countly from 'countly-sdk-nodejs'
 import { EventAccumulator } from '../../src/EventAccumulator.js'
 
-const sleep = async (ms: number): Promise<unknown> => await new Promise(resolve => setTimeout(resolve, ms))
 const sandbox = sinon.createSandbox()
 const addEventListenerStub = sandbox.stub()
 globalThis.addEventListener = addEventListenerStub
 
 describe('EventAccumulator', () => {
   let countlyStub: sinon.SinonStubbedInstance<typeof Countly>
+  let clock: sinon.SinonFakeTimers
 
   beforeEach(() => {
     countlyStub = sandbox.stub(Countly)
+    clock = sandbox.useFakeTimers()
   })
 
   afterEach(() => {
@@ -28,18 +29,19 @@ describe('EventAccumulator', () => {
     }
     // add the event twice with a 100ms delay between them, this is needed to test the duration.
     accumulator.addEvent(event)
-    await sleep(100)
+    await clock.tickAsync(100)
     accumulator.addEvent(event)
     // flush the event
     accumulator.flush('test')
+    // validate the call count
+    expect(countlyStub.add_event.callCount).to.be.equal(1)
     // check the event data
     const { count, dur, key, sum, segmentation } = countlyStub.add_event.getCall(0).args[0]
     expect(count).to.be.equal(2)
     expect(dur).to.be.greaterThanOrEqual(100)
     expect(key).to.be.equal('test')
     expect(sum).to.be.equal(2)
     expect(segmentation).to.be.deep.equal({})
-    expect(countlyStub.add_event.callCount).to.be.equal(1)
   })
 
   it('should flush events after the flush interval', async () => {
@@ -52,15 +54,16 @@ describe('EventAccumulator', () => {
     }
     accumulator.addEvent(event)
     // wait for the flush interval to pass
-    await sleep(150)
+    await clock.tickAsync(150)
+    // validate the call count
+    expect(countlyStub.add_event.callCount).to.be.equal(1)
     // check the event data
     const { count, dur, key, sum, segmentation } = countlyStub.add_event.getCall(0).args[0]
     expect(count).to.be.equal(1)
     expect(dur).to.be.greaterThanOrEqual(100)
     expect(key).to.be.equal('test')
     expect(sum).to.be.equal(1)
     expect(segmentation).to.be.deep.equal({})
-    expect(countlyStub.add_event.callCount).to.be.equal(1)
   })
 
   it('should flush events when flush=true', async () => {
@@ -73,16 +76,17 @@ describe('EventAccumulator', () => {
     }
     // add the event twice with a 100ms delay between them, this is needed to test the duration.
     accumulator.addEvent(event)
-    await sleep(100)
+    await clock.tickAsync(100)
     accumulator.addEvent(event, true)
+    // validate the call count
+    expect(countlyStub.add_event.callCount).to.be.equal(1)
     // check the event data
     const { count, dur, key, sum, segmentation } = countlyStub.add_event.getCall(0).args[0]
     expect(count).to.be.equal(2)
     expect(dur).to.be.greaterThanOrEqual(100)
     expect(key).to.be.equal('test')
     expect(sum).to.be.equal(2)
     expect(segmentation).to.be.deep.equal({})
-    expect(countlyStub.add_event.callCount).to.be.equal(1)
   })
 
   it('should accumulate segments', async () => {
@@ -105,8 +109,10 @@ describe('EventAccumulator', () => {
     }
     // add the event twice with a 100ms delay between them, this is needed to test the duration.
     accumulator.addEvent(event1)
-    await sleep(100)
+    await clock.tickAsync(100)
     accumulator.addEvent(event2, true)
+    // validate the call count
+    expect(countlyStub.add_event.callCount).to.be.equal(1)
     // check the event data
     const { count, dur, key, sum, segmentation } = countlyStub.add_event.getCall(0).args[0]
     expect(count).to.be.equal(2)
@@ -117,7 +123,6 @@ describe('EventAccumulator', () => {
       foo: 'bar',
       bar: 'baz'
     })
-    expect(countlyStub.add_event.callCount).to.be.equal(1)
   })
 
   it('should accumulate different types of events', async () => {
@@ -140,10 +145,12 @@ describe('EventAccumulator', () => {
     }
     accumulator.addEvent(event1)
     // adding the second event after 50ms so that the first event is flushed first
-    await sleep(50)
+    await clock.tickAsync(50)
     accumulator.addEvent(event2)
     // wait for the flush interval to pass
-    await sleep(150)
+    await clock.tickAsync(150)
+    // validate the call count
+    expect(countlyStub.add_event.callCount).to.be.equal(2)
     // check the event data
     const calls = [['test1', { foo: 'bar' }], ['test2', { bar: 'baz' }]]
     calls.forEach(([testKey, segment], idx) => {
@@ -154,7 +161,6 @@ describe('EventAccumulator', () => {
       expect(sum).to.be.equal(1)
       expect(segmentation).to.be.deep.equals(segment)
     })
-    expect(countlyStub.add_event.callCount).to.be.equal(2)
   })
 
   it('should flush all events from the accumulator', async () => {
@@ -186,11 +192,13 @@ describe('EventAccumulator', () => {
 
     accumulator.addEvent(event1)
     // adding the second event after 50ms so that the first event is flushed first
-    await sleep(50)
+    await clock.tickAsync(50)
     accumulator.addEvent(event2)
-    await sleep(50)
+    await clock.tickAsync(50)
     accumulator.addEvent(event3)
     accumulator.flushAll()
+    // validate the call count
+    expect(countlyStub.add_event.callCount).to.be.equal(2)
     // check the event data
     const test1Results = countlyStub.add_event.getCall(0).args[0]
     expect(test1Results.count).to.be.equal(3)
@@ -205,7 +213,5 @@ describe('EventAccumulator', () => {
     expect(test2Results.key).to.be.equal('test2')
     expect(test2Results.sum).to.be.equal(1)
     expect(test2Results.segmentation).to.be.deep.equals({ bar: 'baz' })
-
-    expect(countlyStub.add_event.callCount).to.be.equal(2)
   })
 })

test/node/NodeMetricsProvider.spec.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions */
 import { ensureCall, expect, sinon } from '../testUtils.js'
 import CountlyNodeSdk from 'countly-sdk-nodejs'
 import { NodeMetricsProvider } from '../../src/NodeMetricsProvider.js'