feat: Accumulate Events

.editorconfig

@@ -0,0 +1,8 @@
+root=true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+charset = utf-8
+indent_style = space
+indent_size = 2

.eslintrc.json

@@ -10,12 +10,19 @@
     "sourceType": "module"
   },
   "rules": {
+    "sort-imports": ["error"],
+    "@typescript-eslint/no-unused-expressions": "off"
   },
   "overrides": [
     {
-      "files": "test/**/*.spec.ts",
-      "rules": {
-        "@typescript-eslint/no-unused-expressions": "off"
+      "files": [
+        "test/**/*.ts"
+      ],
+      "parserOptions": {
+        "project": "test/tsconfig.json"
+      },
+      "env": {
+        "mocha": true
       }
     }
   ]

.mocharc.json

@@ -0,0 +1,9 @@
+{
+  "extensions": ["ts"],
+  "spec": ["test/**/*.spec.*"],
+  "require": ["ts-node/register"],
+  "node-option": [
+    "experimental-specifier-resolution=node",
+    "loader=ts-node/esm"
+  ]
+}

package.json

@@ -54,12 +54,6 @@
       "import": "./dist/src/*.js"
     }
   },
-  "eslintConfig": {
-    "extends": "ipfs",
-    "parserOptions": {
-      "sourceType": "module"
-    }
-  },
   "release": {
     "branches": [
       "main"
@@ -149,9 +143,8 @@
     "lint": "aegir lint",
     "release": "aegir release",
     "build": "aegir build",
-    "pretest": "run-s build",
     "test": "run-s test:*",
-    "test:node": "aegir test -t node -f 'dist/test/node.spec.js'",
+    "test:node": "aegir test --target node --files 'test/**/*.spec.ts'",
     "storybook": "start-storybook -p 6006",
     "build-storybook": "build-storybook"
   },
@@ -178,6 +171,7 @@
     "@storybook/testing-library": "^0.0.13",
     "@types/mocha": "^10.0.1",
     "@types/react-dom": "^18.0.10",
+    "@types/sinon": "^10.0.13",
     "@types/sinon-chai": "^3.2.9",
     "@types/styled-components": "^5.1.26",
     "aegir": "^38.1.0",
@@ -196,6 +190,7 @@
     "sinon": "^15.0.1",
     "sinon-chai": "^3.7.0",
     "style-loader": "^3.3.1",
+    "ts-node": "^10.9.1",
     "typescript": "^4.9.4"
   },
   "peerDependencies": {

src/BrowserMetricsProvider.ts

@@ -1,7 +1,7 @@
-import Countly from 'countly-sdk-web'
+import type { MetricProviderOptionalConstructorArgs, WithOptional } from '../types/index.js'
 import MetricsProvider, { MetricsProviderConstructorOptions } from './MetricsProvider.js'
 import { BrowserStorageProvider } from './BrowserStorageProvider.js'
-import type { MetricProviderOptionalConstructorArgs, WithOptional } from './types/index.js'
+import Countly from 'countly-sdk-web'
 
 export class BrowserMetricsProvider extends MetricsProvider<typeof Countly> {
   constructor (args: WithOptional<MetricsProviderConstructorOptions<typeof Countly>, MetricProviderOptionalConstructorArgs>) {

src/BrowserStorageProvider.ts

@@ -1,5 +1,5 @@
-import type { consentTypes } from './types/index.js'
 import type { StorageProvider } from './StorageProvider.js'
+import type { consentTypes } from '../types/index.js'
 
 export class BrowserStorageProvider implements StorageProvider {
   setStore (consentArray: consentTypes[]): void {

src/EventAccumulator.ts

@@ -0,0 +1,145 @@
+import type { CountlyEvent, CountlyEventData, CountlyWebSdk, IEventAccumulator } from 'countly-sdk-web'
+import type { CountlyNodeSdk } from 'countly-sdk-nodejs'
+
+const eventDefaults: CountlyEventData = {
+  key: '',
+  count: 1,
+  sum: 1,
+  dur: 0,
+  segmentation: {}
+}
+
+interface eventStore {
+  eventData: CountlyEventData
+  startTime: number
+  timeout: NodeJS.Timeout
+}
+
+/**
+ * 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>
+  private readonly flushInterval: number
+
+  /**
+   * Create a new EventAccumulator
+   *
+   * @param {CountlyWebSdk} metricsService - instance
+   * @param {number} flushInterval - in milliseconds
+   */
+  constructor (metricsService: CountlyWebSdk | CountlyNodeSdk, flushInterval: number = 5 * 60 * 1000) {
+    this.metricsService = metricsService
+    this.flushInterval = flushInterval
+    this.events = new Map()
+    this.setupUnloadEvent()
+  }
+
+  private setupUnloadEvent (): void {
+    globalThis.addEventListener('beforeunload', () => {
+      this.flushAll()
+    })
+  }
+
+  /**
+   * Pad events with default values
+   *
+   * @param {CountlyEvent} event - event to add defaults to
+   * @returns {CountlyEventData} - event with defaults added
+   */
+  private addEventDefaults (event: CountlyEvent): CountlyEventData {
+    return { ...eventDefaults, ...event }
+  }
+
+  /**
+   * Setup the event accumulator for a key type for the first time.
+   *
+   * @param {CountlyEventData} eventData - event data
+   */
+  private setupEventAccumulator (eventData: CountlyEventData): void {
+    const { key } = eventData
+    this.events.set(key, {
+      eventData,
+      // set start time to now. This will be updated when the event is flushed.
+      startTime: Date.now(),
+      // set a timeout to flush the event after the flush interval.
+      timeout: setTimeout(() => {
+        this.flush(key)
+      }, this.flushInterval)
+    })
+  }
+
+  /**
+   * Digest only the event data from an event.
+   *
+   * @param {CountlyEventData} newEventData - event data
+   */
+  private digestEventData (newEventData: CountlyEventData): void {
+    const { key, count, segmentation } = newEventData
+    // if event is in the store, update the event data.
+    const eventStore = this.events.get(key)
+    if (eventStore == null) {
+      this.setupEventAccumulator(newEventData)
+      return
+    }
+    const { eventData } = eventStore
+    eventData.count += count
+    eventData.sum += 1
+    eventData.segmentation = { ...eventData.segmentation, ...segmentation }
+  }
+
+  /**
+   * Add an event to the accumulator
+   *
+   * @param {CountlyEvent} event - event to add
+   * @param {boolean} flush - optionally whether to flush the event immediately
+   */
+  addEvent (event: CountlyEvent, flush: boolean = false): void {
+    const eventData = this.addEventDefaults(event)
+    const { key } = eventData
+
+    // validate event
+    if (key === '') {
+      throw new Error('Event key is required.')
+    }
+
+    this.digestEventData(eventData)
+
+    // flush the event if flush is true.
+    if (flush) {
+      this.flush(key)
+    }
+  }
+
+  /**
+   * Flush an event from the accumulator
+   *
+   * @param {string} key - event key
+   */
+  flush (key: string): void {
+    const eventStore = this.events.get(key)
+    if (eventStore == null) {
+      return
+    }
+
+    const { eventData, startTime, timeout } = eventStore
+
+    // update duration to ms from start.
+    eventData.dur = Date.now() - startTime
+    // add event to the async queue.
+    this.metricsService.add_event(eventData)
+    clearTimeout(timeout)
+    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+    this.events.delete(key)
+  }
+
+  /**
+   * Flush all events from the accumulator
+   */
+  flushAll (): void {
+    this.events.forEach((_, key) => {
+      this.flush(key)
+    })
+  }
+}

src/MetricsProvider.ts

@@ -1,23 +1,24 @@
+import type { CountlyWebSdk, metricFeatures } from 'countly-sdk-web'
+import type { consentTypes, consentTypesExceptAll } from '../types/index.js'
 import { COUNTLY_SETUP_DEFAULTS } from './config.js'
-
-import type { metricFeatures, CountlyWebSdk } from 'countly-sdk-web'
 import type { CountlyNodeSdk } from 'countly-sdk-nodejs'
-import type { consentTypes, consentTypesExceptAll } from './types/index.js'
+import { EventAccumulator } from './EventAccumulator.js'
 import type { StorageProvider } from './StorageProvider.js'
 
 export interface MetricsProviderConstructorOptions<T> {
   appKey: string
   autoTrack?: boolean
   interval?: number
   max_events?: number
+  metricsService: T
   queue_size?: number
   session_update?: number
   url?: string
-  metricsService: T
   storageProvider?: StorageProvider | null
 }
 
 export default class MetricsProvider<T extends CountlyWebSdk | CountlyNodeSdk> {
+  public readonly accumulate: EventAccumulator
   private readonly groupedFeatures: Record<consentTypes, metricFeatures[]> = this.mapAllEvents({
     minimal: ['sessions', 'views', 'events'],
     performance: ['crashes', 'apm'],
@@ -41,7 +42,8 @@ export default class MetricsProvider<T extends CountlyWebSdk | CountlyNodeSdk> {
     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.metricsService.group_features(this.groupedFeatures)
 

src/NodeMetricsProvider.ts

@@ -1,7 +1,6 @@
-import Countly from 'countly-sdk-nodejs'
-
+import type { MetricProviderOptionalConstructorArgs, WithOptional } from '../types/index.js'
 import MetricsProvider, { MetricsProviderConstructorOptions } from './MetricsProvider.js'
-import type { MetricProviderOptionalConstructorArgs, WithOptional } from './types/index.js'
+import Countly from 'countly-sdk-nodejs'
 
 export class NodeMetricsProvider extends MetricsProvider<typeof Countly> {
   constructor (args: WithOptional<MetricsProviderConstructorOptions<typeof Countly>, MetricProviderOptionalConstructorArgs>) {

src/StorageProvider.ts

@@ -1,4 +1,4 @@
-import type { consentTypes } from './types/index.js'
+import type { consentTypes } from '../types/index.js'
 
 export interface StorageProviderInterface {
   setStore: (values: consentTypes[]) => void

src/index.ts

@@ -3,4 +3,4 @@ export * from './config.js'
 export * from './BrowserMetricsProvider.js'
 export * from './MetricsProvider.js'
 export * from './NodeMetricsProvider.js'
-export * from './types/index.js'
+export * from '../types/index.js'

test/node/NodeMetricsProvider.spec.ts

@@ -1,9 +1,8 @@
-import CountlyNodeSdk from 'countly-sdk-nodejs'
-
 import { ensureCall, expect, sinon } from '../testUtils.js'
+import CountlyNodeSdk from 'countly-sdk-nodejs'
 import { NodeMetricsProvider } from '../../src/NodeMetricsProvider.js'
 import type { StorageProvider } from '../../src/StorageProvider.js'
-import type { consentTypes } from '../../src/types/index.js'
+import type { consentTypes } from '../../types/index.js'
 
 const sandbox = sinon.createSandbox()
 
@@ -18,6 +17,7 @@ describe('NodeMetricsProvider', function () {
   afterEach(function () {
     sandbox.restore()
   })
+
   describe('instantiation', function () {
     it('with defaults', function () {
       const telemetry = new NodeMetricsProvider({ appKey: 'foo', url: 'bar' })

test/testUtils.ts

@@ -1,6 +1,6 @@
 import chai from 'chai'
-import sinonChai from 'sinon-chai'
 import sinon from 'sinon'
+import sinonChai from 'sinon-chai'
 
 chai.use(sinonChai)
 const expect = chai.expect
@@ -20,6 +20,7 @@ export const ensureCall = <T extends readonly any[], R>(config: EnsureCallOption
     expect(config.spy.getCall(config.callIndex).args[config.argsIndex ?? 0]).to.deep.equal(config.expectedArgs)
   }
 }
+
 export {
   expect,
   chai,

test/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "types": ["node", "mocha", "chai", "sinon"]
+  },
+  "include": [
+    "../src",
+    "../types",
+    "./**/*.ts",
+    "node/NodeMetricsProvider.spec.ts"
+  ]
+}