wip

packages/signals/browser-signals/src/core/buffer/index.ts

@@ -12,20 +12,22 @@ interface SignalDatabase extends DBSchema {
 const SIGNALS_DB = 'Segment Signals Buffer'
 const SIGNALS_STORE = 'signals'
 
-interface Storage<T> {
-  get(): Promise<T[]>
-  add(value: T): Promise<void>
-  clear(): Promise<void>
+export interface PersistentStorage<T> {
+  getAll(): Promise<T[]> | T[]
+  add(value: T): Promise<void> | void
+  clear(): Promise<void> | void
 }
 
-class SignalsStorage implements Storage<Signal> {
-  signalStore: Promise<IDBPDatabase<SignalDatabase>>
-  private static readonly MAX_SIGNALS = 25
+export class SignalBuffer implements PersistentStorage<Signal> {
+  private signalStore: Promise<IDBPDatabase<SignalDatabase>>
   private signalCount = 0
-  constructor() {
+  private maxBufferSize: number
+  constructor(settings: { maxBufferSize?: number } = {}) {
+    this.maxBufferSize = settings.maxBufferSize ?? 25 // TODO: increase this number after development
     this.signalStore = this.createSignalStore()
     void this.initializeSignalCount()
   }
+
   private getStore() {
     return this.signalStore
   }
@@ -42,19 +44,19 @@ class SignalsStorage implements Storage<Signal> {
 
   private async initializeSignalCount() {
     try {
-      const store = await this.getStore()
+      const store = await this.signalStore
       this.signalCount = await store.count('signals')
       logger.debug(
-        `Signal count initialized with ${this.signalCount} signals out of ${SignalsStorage.MAX_SIGNALS}`
+        `Signal count initialized with ${this.signalCount} signals out of ${this.maxBufferSize}`
       )
     } catch (e) {
       console.error(e)
     }
   }
   async add(signal: Signal): Promise<void> {
     try {
-      const store = await this.getStore()
-      if (this.signalCount >= SignalsStorage.MAX_SIGNALS) {
+      const store = await this.signalStore
+      if (this.signalCount >= this.maxBufferSize) {
         // Get the key of the oldest signal and delete it
         const oldestKey = await store
           .transaction(SIGNALS_STORE)
@@ -72,7 +74,7 @@ class SignalsStorage implements Storage<Signal> {
     }
   }
 
-  async get(): Promise<Signal[]> {
+  async getAll(): Promise<Signal[]> {
     try {
       const store = await this.getStore()
       return store.getAll(SIGNALS_STORE)
@@ -101,22 +103,3 @@ class SignalsStorage implements Storage<Signal> {
   // }
 }
 // This fails at compile time, as the 'favourite-number' store expects a number.
-export class SignalBuffer {
-  signalStore: Storage<Signal>
-  constructor() {
-    this.signalStore = new SignalsStorage()
-  }
-  async add(signal: Signal) {
-    console.log('Adding signal to buffer', this)
-    return this.signalStore.add(signal)
-  }
-
-  async get() {
-    const signals = await this.signalStore.get()
-    return signals
-  }
-
-  clear() {
-    return this.signalStore.clear()
-  }
-}

packages/signals/browser-signals/src/core/signals/index.ts

@@ -1,24 +1,30 @@
 import { SignalsIngestClient } from '../client'
-import { SignalBuffer } from '../buffer'
+import { SignalBuffer, PersistentStorage } from '../buffer'
 import { SignalEmitter } from '../emitter'
 import { domGenerators } from '../signal-generators/dom-generators'
 import {
   SignalGenerator,
   SignalGeneratorClass,
 } from '../signal-generators/types'
-import { AnyAnalytics } from '../../types'
+import { AnyAnalytics, Signal } from '../../types'
 import { registerGenerator } from '../signal-generators/register'
 import { AnalyticsService } from '../analytics-service'
 
+interface SignalsSettings {
+  maxBufferSize?: number
+}
+
 export class Signals {
-  private buffer: SignalBuffer
+  private buffer: PersistentStorage<Signal>
   private signalEmitter: SignalEmitter
   private cleanup: VoidFunction[] = []
   private signalsClient: SignalsIngestClient
 
-  constructor() {
+  constructor(settings: SignalsSettings = {}) {
     this.signalEmitter = new SignalEmitter()
-    this.buffer = new SignalBuffer()
+
+    this.buffer = new SignalBuffer({ maxBufferSize: settings.maxBufferSize })
+
     this.signalsClient = new SignalsIngestClient()
     this.signalEmitter.subscribe(this.buffer.add.bind(this.buffer))
     this.signalEmitter.subscribe((signal) => {

packages/signals/browser-signals/src/plugin/signals-plugin.ts

@@ -5,6 +5,10 @@ import { AnyAnalytics } from '../types'
 
 interface SignalsPluginSettings {
   enableDebugLogging?: boolean
+  /**
+   * Max number of signals in the default signal store
+   */
+  maxBufferSize?: number
 }
 
 export class SignalsPlugin implements Plugin {
@@ -17,7 +21,9 @@ export class SignalsPlugin implements Plugin {
       logger.enableDebugLogging()
     }
     // subscribe and store signals that may occur before analyics is fully initialized
-    this.signals = new Signals()
+    this.signals = new Signals({
+      maxBufferSize: settings.maxBufferSize,
+    })
   }
 
   isLoaded() {