Signals sampling

packages/browser/src/browser/index.ts

@@ -122,6 +122,13 @@ export interface CDNSettings {
         version: number
       }
     | {}
+
+  /**
+   * Settings for auto instrumentation
+   */
+  autoInstrumentationSettings?: {
+    sampleRate: number
+  }
 }
 
 export interface AnalyticsBrowserSettings {

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

@@ -8,13 +8,17 @@ export class SignalsIngestSettings {
   flushInterval: number
   apiHost: string
   shouldDisableSignalRedaction: () => boolean
+  signalIngestion: () => boolean
   writeKey?: string
+  sampleRate: number
   constructor(settings: SignalsIngestSettingsConfig) {
     this.flushAt = settings.flushAt ?? 5
     this.apiHost = settings.apiHost ?? 'signals.segment.io/v1'
     this.flushInterval = settings.flushInterval ?? 2000
     this.shouldDisableSignalRedaction =
       settings.shouldDisableSignalRedaction ?? (() => false)
+    this.signalIngestion = settings.signalIngestion ?? (() => false)
+    this.sampleRate = settings.sampleRate ?? 0
   }
 }
 
@@ -23,6 +27,8 @@ export interface SignalsIngestSettingsConfig {
   flushAt?: number
   flushInterval?: number
   shouldDisableSignalRedaction?: () => boolean
+  signalIngestion?: () => boolean
+  sampleRate?: number
 }
 /**
  * This currently just uses the Segment analytics-next library to send signals.
@@ -69,10 +75,25 @@ export class SignalsIngestClient {
     return analytics
   }
 
+  private shouldIngestSignals(): boolean {
+    let shouldIngest = false
+    if (Math.random() > this.settings.sampleRate) {
+      // currently a no-op, but will be used once signals are sent outside of debug mode
+      shouldIngest = false
+    }
+    if (this.settings.signalIngestion()) {
+      shouldIngest = true
+    }
+    return shouldIngest
+  }
+
   private sendTrackCall(signal: Signal) {
     if (!this.analytics) {
       throw new Error('Please initialize before calling this method.')
     }
+    if (!this.shouldIngestSignals()) {
+      return
+    }
     const disableRedaction = this.settings.shouldDisableSignalRedaction()
     const data = disableRedaction
       ? signal.data

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

@@ -14,6 +14,8 @@ export type SignalsSettingsConfig = Pick<
   | 'flushAt'
   | 'flushInterval'
   | 'disableSignalsRedaction'
+  | 'signalsIngestion'
+  | 'sampleRate'
   | 'networkSignalsAllowList'
   | 'networkSignalsDisallowList'
   | 'networkSignalsAllowSameDomain'
@@ -34,6 +36,7 @@ export class SignalGlobalSettings {
   network: NetworkSettingsConfig
 
   private redaction = new SignalRedactionSettings()
+  private ingestion = new SignalIngestionSettings()
 
   constructor(settings: SignalsSettingsConfig) {
     if (settings.maxBufferSize && settings.signalStorage) {
@@ -55,6 +58,8 @@ export class SignalGlobalSettings {
       flushAt: settings.flushAt,
       flushInterval: settings.flushInterval,
       shouldDisableSignalRedaction: this.redaction.getDisableSignalRedaction,
+      signalIngestion: this.ingestion.getSignalIngestion,
+      sampleRate: settings.sampleRate,
     }
     this.sandbox = {
       functionHost: settings.functionHost,
@@ -70,6 +75,7 @@ export class SignalGlobalSettings {
   public update({
     edgeFnDownloadURL,
     disallowListURLs,
+    sampleRate,
   }: {
     /**
      * The URL to download the edge function from
@@ -79,13 +85,18 @@ export class SignalGlobalSettings {
      * Add new URLs to the disallow list
      */
     disallowListURLs: (string | undefined)[]
+    /**
+     * The sample rate pulled from CDN settings
+     */
+    sampleRate: number
   }): void {
     edgeFnDownloadURL && (this.sandbox.edgeFnDownloadURL = edgeFnDownloadURL)
     this.network.networkSignalsFilterList.disallowed.addURLLike(
       ...disallowListURLs.filter(<T>(val: T): val is NonNullable<T> =>
         Boolean(val)
       )
     )
+    this.ingestClient.sampleRate = sampleRate
   }
 }
 
@@ -139,3 +150,54 @@ class SignalRedactionSettings {
     return false
   }
 }
+
+class SignalIngestionSettings {
+  private static ingestionKey = 'segment_signals_debug_ingestion_enabled'
+  constructor(initialValue?: boolean) {
+    if (typeof initialValue === 'boolean') {
+      this.setSignalIngestion(initialValue)
+    }
+
+    // setting ?segment_signals_debug=true will disable redaction, and set a key in local storage
+    // this setting will persist across page loads (even if there is no query string)
+    // in order to clear the setting, user must set ?segment_signals_debug=false
+    const debugModeInQs = parseDebugModeQueryString()
+    logger.debug('debugMode is set to true via query string')
+    if (typeof debugModeInQs === 'boolean') {
+      this.setSignalIngestion(debugModeInQs)
+    }
+  }
+
+  setSignalIngestion(shouldEnable: boolean) {
+    try {
+      if (shouldEnable) {
+        window.sessionStorage.setItem(
+          SignalIngestionSettings.ingestionKey,
+          'true'
+        )
+      } else {
+        logger.debug('Removing ingestion key from storage')
+        window.sessionStorage.removeItem(SignalIngestionSettings.ingestionKey)
+      }
+    } catch (e) {
+      logger.debug('Storage error', e)
+    }
+  }
+
+  getSignalIngestion() {
+    try {
+      const isEnabled = Boolean(
+        window.sessionStorage.getItem(SignalIngestionSettings.ingestionKey)
+      )
+      if (isEnabled) {
+        logger.debug(
+          `${SignalIngestionSettings.ingestionKey}=true (app. storage)`
+        )
+        return true
+      }
+    } catch (e) {
+      logger.debug('Storage error', e)
+    }
+    return false
+  }
+}

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

@@ -91,6 +91,9 @@ export class Signals implements ISignals {
         analyticsService.instance.settings.apiHost,
         analyticsService.instance.settings.cdnURL,
       ],
+      sampleRate:
+        analyticsService.instance.settings.cdnSettings
+          .autoInstrumentationSettings?.sampleRate || 0,
     })
 
     const sandbox = new Sandbox(

packages/signals/signals/src/types/analytics-api.ts

@@ -8,9 +8,14 @@ export type EdgeFnCDNSettings = {
   downloadURL: string
 }
 
+export type AutoInstrumentationCDNSettings = {
+  sampleRate: number
+}
+
 export interface CDNSettings {
   integrations: CDNSettingsIntegrations
   edgeFunction?: EdgeFnCDNSettings | { [key: string]: never }
+  autoInstrumentationSettings?: AutoInstrumentationCDNSettings
 }
 
 export interface SegmentEventStub {

packages/signals/signals/src/types/settings.ts

@@ -23,6 +23,16 @@ export interface SignalsPluginSettingsConfig {
    */
   disableSignalsRedaction?: boolean
 
+  /**
+   * If signals ingestion is enabled/disabled
+   */
+  signalsIngestion?: boolean
+
+  /**
+   * Percentage of sessions that should be ingested
+   */
+  sampleRate?: number
+
   /**
    * Override signals API host
    * @default signals.segment.io/v1