add debug

Author: silesky

packages/signals/signals/README.md

@@ -77,6 +77,14 @@ You can *turn off debugging* by doing:
 https://my-website.com?segment_signals_debug=false
 ```
 
+* This also logs all signals to the js console.
+
+#### Alternative method of enabling debug mode
+In your JS console:
+```js
+SegmentSignalsPlugin.debug() 
+```
+
 ### Advanced
 
 #### Listening to signals
@@ -109,3 +117,5 @@ Network signals emit when an HTTP Request is made, or an HTTP Response is receiv
 - First party domain (e.g if on `foo.com`, then `foo.com/api/products`, but not `bar.com/api/products`)
 - Contains the content-type: `application/json`
 
+
+

packages/signals/signals/src/core/debug-mode/index.ts

@@ -14,12 +14,17 @@ export const parseDebugModeQueryString = (): boolean | undefined => {
   return undefined
 }
 
-export const parseDebugLoggingQueryString = (): boolean | undefined => {
+/**
+ * This turns on advanced logging for signals!
+ */
+export const parseSignalsLoggingAdvancedQueryString = ():
+  | boolean
+  | undefined => {
   const queryParams = new URLSearchParams(window.location.search)
 
   const val =
-    queryParams.get('segment_signals_logging') ||
-    queryParams.get('seg_signals_logging')
+    queryParams.get('segment_signals_logging_advanced') ||
+    queryParams.get('seg_signals_logging_advanced')
   if (val === 'true' || val === 'false') {
     return val === 'true'
   }

packages/signals/signals/src/core/emitter/index.ts

@@ -6,12 +6,21 @@ export interface EmitSignal {
   emit: (signal: Signal) => void
 }
 
+interface SignalEmitterSettings {
+  shouldLogSignals: () => boolean
+}
+
 export class SignalEmitter implements EmitSignal {
   private emitter = new Emitter<{ add: [Signal] }>()
   private listeners = new Set<(signal: Signal) => void>()
-
+  private settings?: SignalEmitterSettings
+  constructor(settings?: SignalEmitterSettings) {
+    this.settings = settings
+  }
   emit(signal: Signal) {
-    logger.debug('New signal:', signal.type, signal.data)
+    if (this.settings?.shouldLogSignals()) {
+      logger.log('New signal:', signal.type, signal.data)
+    }
     this.emitter.emit('add', signal)
   }
 

packages/signals/signals/src/core/signals/settings.ts

@@ -5,6 +5,7 @@ import { SignalsIngestSettingsConfig } from '../client'
 import { SandboxSettingsConfig } from '../processor/sandbox'
 import { NetworkSettingsConfig } from '../signal-generators/network-gen'
 import { SignalsPluginSettingsConfig } from '../../types'
+import { DebugStorage } from '../../lib/storage/debug-storage'
 
 export type SignalsSettingsConfig = Pick<
   SignalsPluginSettingsConfig,
@@ -111,17 +112,24 @@ export class SignalGlobalSettings {
 }
 
 export class SignalsDebugSettings {
-  private storageType = 'sessionStorage' as const
   private static redactionKey = 'segment_signals_debug_redaction_disabled'
   private static ingestionKey = 'segment_signals_debug_ingestion_enabled'
-  private static logSignals = 'segment_signals_debug_log_signals_enabled'
+  private static logSignals = 'segment_signals_log_signals_enabled'
+  storage: DebugStorage
 
   constructor(disableRedaction?: boolean, enableIngestion?: boolean) {
+    this.storage = new DebugStorage('sessionStorage')
     if (typeof disableRedaction === 'boolean') {
-      this.setDebugKey(SignalsDebugSettings.redactionKey, disableRedaction)
+      this.storage.setDebugKey(
+        SignalsDebugSettings.redactionKey,
+        disableRedaction
+      )
     }
     if (typeof enableIngestion === 'boolean') {
-      this.setDebugKey(SignalsDebugSettings.ingestionKey, enableIngestion)
+      this.storage.setDebugKey(
+        SignalsDebugSettings.ingestionKey,
+        enableIngestion
+      )
     }
 
     const debugModeInQs = parseDebugModeQueryString()
@@ -132,46 +140,20 @@ export class SignalsDebugSettings {
   }
 
   setAllDebugging = (boolean: boolean) => {
-    this.setDebugKey(SignalsDebugSettings.redactionKey, boolean)
-    this.setDebugKey(SignalsDebugSettings.ingestionKey, boolean)
-    this.setDebugKey(SignalsDebugSettings.logSignals, boolean)
-  }
-
-  private setDebugKey = (key: string, enable: boolean): void => {
-    try {
-      if (enable) {
-        window[this.storageType].setItem(key, 'true')
-      } else {
-        logger.debug(`Removing debug key ${key} from storage`)
-        window.sessionStorage.removeItem(key)
-      }
-    } catch (e) {
-      logger.debug('Storage error', e)
-    }
-  }
-
-  private getDebugKey = (key: string): boolean => {
-    try {
-      const isEnabled = Boolean(window[this.storageType].getItem(key))
-      if (isEnabled) {
-        logger.debug(`${key}=true (app. storage)`)
-        return true
-      }
-    } catch (e) {
-      logger.debug('Storage error', e)
-    }
-    return false
+    this.storage.setDebugKey(SignalsDebugSettings.redactionKey, boolean)
+    this.storage.setDebugKey(SignalsDebugSettings.ingestionKey, boolean)
+    this.storage.setDebugKey(SignalsDebugSettings.logSignals, boolean)
   }
 
   getDisableSignalsRedaction = (): boolean => {
-    return this.getDebugKey(SignalsDebugSettings.redactionKey)
+    return this.storage.getDebugKey(SignalsDebugSettings.redactionKey)
   }
 
   getEnableSignalsIngestion = (): boolean => {
-    return this.getDebugKey(SignalsDebugSettings.ingestionKey)
+    return this.storage.getDebugKey(SignalsDebugSettings.ingestionKey)
   }
 
   getEnableLogSignals = (): boolean => {
-    return this.getDebugKey(SignalsDebugSettings.logSignals)
+    return this.storage.getDebugKey(SignalsDebugSettings.logSignals)
   }
 }

packages/signals/signals/src/core/signals/signals.ts

@@ -38,7 +38,10 @@ export class Signals implements ISignals {
   private globalSettings: SignalGlobalSettings
   constructor(settingsConfig: SignalsSettingsConfig = {}) {
     this.globalSettings = new SignalGlobalSettings(settingsConfig)
-    this.signalEmitter = new SignalEmitter()
+    this.signalEmitter = new SignalEmitter({
+      shouldLogSignals: () =>
+        this.globalSettings.signalsDebug.getEnableLogSignals(),
+    })
     this.signalsClient = new SignalsIngestClient(
       this.globalSettings.ingestClient
     )
@@ -129,16 +132,11 @@ export class Signals implements ISignals {
     void this.buffer.clear()
   }
 
-  // create a reference so we prevent duplicate subscriptions
-  private logSignal = (signal: Signal) => {
-    logger.log(signal.type, signal.data, signal.metadata)
-  }
   /**
    * Disable redaction, ingestion of signals, and other debug logging.
    */
   debug(boolean = true): void {
     this.globalSettings.signalsDebug.setAllDebugging(boolean)
-    this.signalEmitter.subscribe(this.logSignal)
   }
 
   /**

packages/signals/signals/src/lib/logger/index.ts

@@ -1,48 +1,28 @@
-import { parseDebugLoggingQueryString } from '../../core/debug-mode'
+import { parseSignalsLoggingAdvancedQueryString } from '../../core/debug-mode'
+import { DebugStorage } from '../storage/debug-storage'
 
 class Logger {
   private storageType = 'sessionStorage' as const
-  private static loggingKey = 'segment_signals_debug_logging'
+  private static advancedLogging = 'segment_signals_logging_advanced'
 
+  storage = new DebugStorage(this.storageType)
   constructor() {
-    const val = parseDebugLoggingQueryString()
+    const val = parseSignalsLoggingAdvancedQueryString()
     if (typeof val === 'boolean') {
-      this.setDebugKey(Logger.loggingKey, val)
+      this.storage.setDebugKey(Logger.advancedLogging, val)
     }
   }
 
   private debugLoggingEnabled = (): boolean => {
-    try {
-      const isEnabled = Boolean(
-        globalThis[this.storageType].getItem(Logger.loggingKey)
-      )
-      if (isEnabled) {
-        return true
-      }
-    } catch (e) {
-      console.warn('Storage error', e)
-    }
-    return false
-  }
-
-  private setDebugKey = (key: string, enable: boolean) => {
-    try {
-      if (enable) {
-        globalThis[this.storageType].setItem(key, 'true')
-      } else {
-        globalThis[this.storageType].removeItem(key)
-      }
-    } catch (e) {
-      console.warn('Storage error', e)
-    }
+    return this.storage.getDebugKey(Logger.advancedLogging)
   }
 
   enableDebugLogging = (bool = true) => {
-    this.setDebugKey(Logger.loggingKey, bool)
+    this.storage.setDebugKey(Logger.advancedLogging, bool)
   }
 
   log = (...args: any[]): void => {
-    console.log('[signals]', ...args)
+    console.log('[signals log]', ...args)
   }
 
   debug = (...args: any[]): void => {

packages/signals/signals/src/lib/storage/debug-storage.ts

@@ -0,0 +1,29 @@
+export class DebugStorage {
+  private storageType: 'localStorage' | 'sessionStorage'
+  constructor(type: 'localStorage' | 'sessionStorage') {
+    this.storageType = type
+  }
+  public setDebugKey = (key: string, enable: boolean): void => {
+    try {
+      if (enable) {
+        window[this.storageType].setItem(key, 'true')
+      } else {
+        window.sessionStorage.removeItem(key)
+      }
+    } catch (e) {
+      console.warn('Storage error', e)
+    }
+  }
+
+  public getDebugKey = (key: string): boolean => {
+    try {
+      const isEnabled = Boolean(window[this.storageType].getItem(key))
+      if (isEnabled) {
+        return true
+      }
+    } catch (e) {
+      console.warn('Storage error', e)
+    }
+    return false
+  }
+}