@newrelic/video-core 4.1.8 → 5.0.0

package/package.json

@@ -1,9 +1,24 @@
 {
   "name": "@newrelic/video-core",
-  "version": "4.1.8",
+  "version": "5.0.0",
   "description": "New Relic video tracking core library",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./browser": {
+      "import": "./dist/esm/browser/index.js",
+      "require": "./dist/cjs/browser/index.js"
+    },
+    "./vega": {
+      "import": "./dist/esm/vega/index.js",
+      "require": "./dist/cjs/vega/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "scripts": {
     "build": "webpack --mode production",
     "build:dev": "webpack --mode development",
@@ -26,6 +41,7 @@
     "Bharat Sarsawat"
   ],
   "license": "Apache-2.0",
+  "sideEffects": false,
   "devDependencies": {
     "@babel/core": "^7.24.5",
     "@babel/plugin-transform-modules-commonjs": "^7.24.1",
@@ -36,18 +52,17 @@
     "@semantic-release/commit-analyzer": "^12.0.0",
     "@semantic-release/git": "^10.0.1",
     "@semantic-release/github": "^10.0.3",
-    "@semantic-release/npm": "^12.0.0",
+    "@semantic-release/npm": "^13.1.5",
     "@semantic-release/release-notes-generator": "^13.0.0",
-    "aws-sdk": "^2.920.0",
-    "babel-jest": "^30.2.0",
+    "babel-jest": "^30.0.0",
     "babel-loader": "^9.1.3",
     "diff": "^5.0.0",
     "jest": "^30.2.0",
     "jest-environment-jsdom": "^30.2.0",
     "jsdom": "^25.0.1",
-    "mocha": "^10.4.0",
-    "nyc": "^15.1.0",
-    "semantic-release": "^23.0.8",
+    "mocha": "^11.0.0",
+    "nyc": "^18.0.0",
+    "semantic-release": "^25.0.8",
     "sinon": "^2.4.1",
     "webpack": "^5.91.0",
     "webpack-cli": "^4.9.2"
@@ -65,5 +80,8 @@
   ],
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "terser-webpack-plugin": "^5.6.1"
   }
 }

package/src/{agent.js → browser/agent.js}

@@ -1,8 +1,11 @@
 import { HarvestScheduler } from "./harvestScheduler.js";
-import { NrVideoEventAggregator } from "./eventAggregator.js";
-import Constants from "./constants.js";
-import Log from "./log.js";
-import Tracker from "./tracker";
+import { NrVideoEventAggregator } from "../eventAggregator.js";
+import Log from "../log.js";
+import { registerHarvester } from "../recordEvent.js";
+import {
+  bufferEventWithQoeDedup,
+  refreshQoeKpisInBuffer,
+} from "../utils/qoeFilters";
 
 /**
  * Enhanced video analytics agent with HarvestScheduler only.
@@ -49,20 +52,8 @@ class VideoAnalyticsAgent {
     }
 
     try {
-      if(eventObject.actionName && eventObject.actionName === Tracker.Events.QOE_AGGREGATE) {
-          // Ensure only one QOE_AGGREGATE event per (actionName + viewId) in buffer per harvest cycle.
-          // Each player has a unique viewId, so multi-player scenarios are handled correctly.
-          // Dirty-check dedup happens at drain time in HarvestScheduler._qoeKpisUnchanged().
-          if (eventObject.viewId) {
-              return this.eventBuffer.addOrReplaceByActionNameAndViewId(
-                  Tracker.Events.QOE_AGGREGATE,
-                  eventObject.viewId,
-                  eventObject
-              );
-          }
-          return this.eventBuffer.addOrReplaceByActionName(Tracker.Events.QOE_AGGREGATE, eventObject);
-      }
-      return this.eventBuffer.add(eventObject);
+      // QOE_AGGREGATE dedup + plain append, shared with the Vega pipeline.
+      return bufferEventWithQoeDedup(this.eventBuffer, eventObject);
     } catch (error) {
       Log.error("Failed to add event to harvesting system:", error.message);
       return false;
@@ -109,28 +100,16 @@ class VideoAnalyticsAgent {
    * @param {string} [viewId] - The viewId of the player whose QoE event to update
    */
   refreshQoeKpis(freshKpis, viewId) {
-    if (!this.eventBuffer || !freshKpis) return;
-    const existing = viewId
-      ? this.eventBuffer.findByActionNameAndViewId(Tracker.Events.QOE_AGGREGATE, viewId)
-      : this.eventBuffer.findByActionName(Tracker.Events.QOE_AGGREGATE);
-    if (existing) {
-      const updated = { ...existing };
-      for (const key of Constants.QOE_KPI_KEYS) {
-        if (key in freshKpis) {
-          updated[key] = freshKpis[key];
-        }
-      }
-      if (viewId) {
-        this.eventBuffer.addOrReplaceByActionNameAndViewId(Tracker.Events.QOE_AGGREGATE, viewId, updated);
-      } else {
-        this.eventBuffer.addOrReplaceByActionName(Tracker.Events.QOE_AGGREGATE, updated);
-      }
-    }
+    refreshQoeKpisInBuffer(this.eventBuffer, freshKpis, viewId);
   }
 }
 
 // Create singleton instance
 const videoAnalyticsAgent = new VideoAnalyticsAgent();
 
+// Self-register for the 'Browser' routing key. Importing this module is what
+// makes the Browser pipeline reachable in the consumer's bundle.
+registerHarvester("Browser", videoAnalyticsAgent);
+
 // Enhanced video analytics harvester
 export const videoAnalyticsHarvester = videoAnalyticsAgent;

package/src/{harvestScheduler.js → browser/harvestScheduler.js}

@@ -1,10 +1,15 @@
-import { NrVideoEventAggregator } from "./eventAggregator";
-import { RetryQueueHandler } from "./retryQueueHandler";
-import { OptimizedHttpClient } from "./optimizedHttpClient";
-import { buildUrl, dataSize } from "./utils";
-import Constants from "./constants";
-import Tracker from "./tracker";
-import Log from "./log";
+import { NrVideoEventAggregator } from "../eventAggregator";
+import { RetryQueueHandler } from "../retryQueueHandler";
+import { OptimizedHttpClient } from "../optimizedHttpClient";
+import { buildUrl, dataSize } from "../utils";
+import {
+  partitionByQoeCycle,
+  applyQoeDirtyFilter,
+} from "../utils/qoeFilters";
+import { createHarvestTimer } from "../utils/harvestTimer";
+import Constants from "../constants";
+import Tracker from "../tracker";
+import Log from "../log";
 
 /**
  * Enhanced harvest scheduler that orchestrates the video analytics data collection,
@@ -28,8 +33,6 @@ export class HarvestScheduler {
     }
 
     // Scheduler state
-    this.isStarted = false;
-    this.currentTimerId = null;
     this.harvestCycle = Constants.INTERVAL;
     this.isHarvesting = false;
     this.qoeCycleCount = 1;
@@ -37,44 +40,48 @@ export class HarvestScheduler {
     this.beforeDrainCallback = null;
     this._lastSentQoeKpis = {};
 
+    // Periodic harvest timer. Chained-setTimeout under the hood
+    this.timer = createHarvestTimer({
+      interval: this.harvestCycle,
+      onTick: () => this.onHarvestInterval(),
+      errorLabel: "HarvestScheduler",
+    });
+
     // Page lifecycle handling
     this.setupPageLifecycleHandlers();
   }
 
+  /**
+   * Whether the scheduler is currently running. Backed by the shared timer.
+   * @returns {boolean}
+   */
+  get isStarted() {
+    return this.timer.isRunning();
+  }
+
   /**
    * Starts the harvest scheduler.
    */
   startScheduler() {
-    if (this.isStarted) {
+    if (this.timer.isRunning()) {
       Log.warn("Harvest scheduler is already started");
       return;
     }
 
-    this.isStarted = true;
-
     Log.notice("Starting harvest scheduler", {
       harvestCycle: this.harvestCycle,
       eventBufferSize: this.eventBuffer ? this.eventBuffer.size() : 0,
     });
 
-    this.scheduleNextHarvest();
+    this.timer.start();
   }
 
   /**
    * Stops the harvest scheduler.
    */
   stopScheduler() {
-    if (!this.isStarted) {
-      return;
-    }
-
-    this.isStarted = false;
-
-    if (this.currentTimerId) {
-      clearTimeout(this.currentTimerId);
-      this.currentTimerId = null;
-    }
-
+    if (!this.timer.isRunning()) return;
+    this.timer.stop();
     Log.notice("Harvest scheduler stopped");
   }
 
@@ -92,53 +99,30 @@ export class HarvestScheduler {
     // If buffer is empty, abort harvest
     if (!this.eventBuffer || this.eventBuffer.isEmpty()) return;
 
-    // Clear existing timer to prevent redundant harvests
-    if (this.currentTimerId) {
-      clearTimeout(this.currentTimerId);
-      this.currentTimerId = null;
-    }
-
     try {
       await this.triggerHarvest({});
     } catch (error) {
       Log.error(`${type} harvest failed:`, error.message);
     } finally {
-      // Schedule next harvest after smart harvest completes
-      if (this.isStarted) {
-        this.scheduleNextHarvest();
-      }
+      // Reset the periodic clock — next periodic tick happens `harvestCycle`
+      // after this smart drain, not at the originally-scheduled time.
+      this.timer.cancelAndReschedule();
     }
   }
 
   /**
-   * Schedules the next harvest based on current conditions.
-   * @private
-   */
-  scheduleNextHarvest() {
-    if (!this.isStarted) return;
-
-    const interval = this.harvestCycle;
-    this.currentTimerId = setTimeout(() => this.onHarvestInterval(), interval);
-  }
-
-  /**
-   * Handles the harvest interval timer.
+   * Periodic-tick callback. Invoked by the shared harvest timer on each cycle.
    * @private
    */
   async onHarvestInterval() {
-    try {
-      // Check if there's any data to harvest (buffer or retry queue) before starting the harvest process
-      const hasBufferData = this.eventBuffer && !this.eventBuffer.isEmpty();
-      const hasRetryData =
-        this.retryQueueHandler && this.retryQueueHandler.getQueueSize() > 0;
-
-      if (!hasBufferData && !hasRetryData) return;
-      await this.triggerHarvest({});
-    } catch (error) {
-      Log.error("Error during scheduled harvest:", error.message);
-    } finally {
-      this.scheduleNextHarvest();
-    }
+    // Check if there's any data to harvest (buffer or retry queue) before
+    // starting the harvest process — avoids unnecessary network calls when
+    // there's nothing to ship.
+    const hasBufferData = this.eventBuffer && !this.eventBuffer.isEmpty();
+    const hasRetryData =
+      this.retryQueueHandler && this.retryQueueHandler.getQueueSize() > 0;
+    if (!hasBufferData && !hasRetryData) return;
+    await this.triggerHarvest({});
   }
 
   /**
@@ -185,7 +169,6 @@ export class HarvestScheduler {
       return {
         success: false,
         error: error.message,
-        consecutiveFailures: this.consecutiveFailures,
       };
     } finally {
       this.isHarvesting = false;
@@ -269,35 +252,17 @@ export class HarvestScheduler {
 
     // Always drain fresh events first (priority approach)
     const freshEvents = this.eventBuffer.drain();
-    let filteredFreshEvents;
-    if (isQoeCycle) {
-      filteredFreshEvents = freshEvents;
-    } else {
-      // On non-QoE cycles, put QoE events back into buffer instead of losing them
-      filteredFreshEvents = [];
-      for (const e of freshEvents) {
-        if (e.actionName === Tracker.Events.QOE_AGGREGATE) {
-          this.eventBuffer.add(e);
-        } else {
-          filteredFreshEvents.push(e);
-        }
-      }
-    }
+    let filteredFreshEvents = partitionByQoeCycle(
+      freshEvents,
+      isQoeCycle,
+      this.eventBuffer
+    );
 
     this.qoeCycleCount++;
 
-    // Cross-cycle dirty check: skip QoE if KPIs unchanged since last send
-    // Forced cycles (CONTENT_END, page unload) always send QoE
-    for (let i = filteredFreshEvents.length - 1; i >= 0; i--) {
-      const e = filteredFreshEvents[i];
-      if (e.actionName === Tracker.Events.QOE_AGGREGATE) {
-        if (!isForced && this._qoeKpisUnchanged(e)) {
-          filteredFreshEvents.splice(i, 1);
-        } else {
-          this._saveQoeKpis(e);
-        }
-      }
-    }
+    // Cross-cycle dirty check: skip QoE if KPIs unchanged since last send.
+    // Forced cycles (CONTENT_END, page unload) always send QoE.
+    applyQoeDirtyFilter(filteredFreshEvents, this._lastSentQoeKpis, isForced);
 
     let events = [...filteredFreshEvents];
     let currentPayloadSize = dataSize(filteredFreshEvents);
@@ -391,12 +356,7 @@ export class HarvestScheduler {
    * @private
    */
   handleHarvestFailure(error) {
-    this.consecutiveFailures++;
-
-    Log.warn("Harvest failure handled", {
-      error: error.message,
-      consecutiveFailures: this.consecutiveFailures,
-    });
+    Log.warn("Harvest failure handled", { error: error.message });
   }
 
   /**
@@ -406,7 +366,7 @@ export class HarvestScheduler {
    */
 
   updateHarvestInterval(newInterval) {
-    if (typeof newInterval !== "number" && isNaN(newInterval)) {
+    if (typeof newInterval !== "number" || isNaN(newInterval)) {
       Log.warn("Invalid newInterval provided to updateHarvestInterval");
       return;
     }
@@ -417,26 +377,11 @@ export class HarvestScheduler {
     }
 
     // Check if the interval has actually changed to avoid unnecessary actions
-    if (this.harvestCycle === newInterval) {
-      return;
-    }
+    if (this.harvestCycle === newInterval) return;
 
-    // 1. Update the harvestCycle property with the new interval
     this.harvestCycle = newInterval;
     Log.notice("Updated harvestCycle:", this.harvestCycle);
-
-    // 2. Clear the existing timer
-    if (this.currentTimerId) {
-      clearTimeout(this.currentTimerId);
-      this.currentTimerId = null;
-    }
-
-    // 3. Schedule a new timer with the updated interval
-    if (this.isStarted) {
-      this.scheduleNextHarvest();
-    }
-
-    return;
+    this.timer.updateInterval(newInterval);
   }
 
   /**
@@ -469,31 +414,4 @@ export class HarvestScheduler {
     });
   }
 
-  /**
-   * Checks if QoE KPIs are unchanged since last send.
-   * @param {object} event - QoE event to compare
-   * @returns {boolean} True if KPIs are identical to last sent
-   * @private
-   */
-  _qoeKpisUnchanged(event) {
-    const snapshot = this._lastSentQoeKpis[event.viewId];
-    if (!snapshot) return false;
-    for (const key of Constants.QOE_KPI_KEYS) {
-      if (event[key] !== snapshot[key]) return false;
-    }
-    return true;
-  }
-
-  /**
-   * Saves QoE KPI values after sending, keyed by viewId to support multiple players.
-   * @param {object} event - QoE event that was sent
-   * @private
-   */
-  _saveQoeKpis(event) {
-    const snapshot = {};
-    for (const key of Constants.QOE_KPI_KEYS) {
-      snapshot[key] = event[key];
-    }
-    this._lastSentQoeKpis[event.viewId] = snapshot;
-  }
 }

package/src/browser/index.js

@@ -0,0 +1,58 @@
+import Core from "../core";
+import Constants from "../constants";
+import Chrono from "../chrono";
+import Log from "../log";
+import Emitter from "../emitter";
+import Tracker from "../tracker";
+import VideoTracker from "../videotracker";
+import VideoTrackerState from "../videotrackerstate";
+import { NrVideoEventAggregator } from "../eventAggregator";
+import { RetryQueueHandler } from "../retryQueueHandler";
+import { OptimizedHttpClient } from "../optimizedHttpClient";
+import { HarvestScheduler } from "./harvestScheduler";
+import { videoAnalyticsHarvester } from "./agent";
+import { getRegisteredHarvester } from "../recordEvent";
+// recordEvent is the single shared implementation from `src/recordEvent.js`
+// — handles both Browser and Vega pipelines via the registry.
+import { recordEvent } from "../recordEvent";
+import { version } from "../../package.json";
+
+const nrvideo = {
+  Constants,
+  Chrono,
+  Log,
+  Emitter,
+  Tracker,
+  VideoTracker,
+  VideoTrackerState,
+  Core,
+  version,
+
+  NrVideoEventAggregator,
+  RetryQueueHandler,
+  OptimizedHttpClient,
+  HarvestScheduler,
+
+  recordEvent,
+};
+
+export {
+  Core,
+  Constants,
+  Chrono,
+  Log,
+  Emitter,
+  Tracker,
+  VideoTracker,
+  VideoTrackerState,
+  NrVideoEventAggregator,
+  RetryQueueHandler,
+  OptimizedHttpClient,
+  HarvestScheduler,
+  videoAnalyticsHarvester,
+  getRegisteredHarvester,
+  recordEvent,
+  version,
+};
+
+export default nrvideo;

package/src/connectedDevice/connectedDeviceAgent.js

@@ -0,0 +1,116 @@
+import ConnectedDeviceHarvester from "./connectedDeviceHarvester";
+import Log from "../log";
+import { registerHarvester } from "../recordEvent";
+
+/**
+ * Vega-side analytics agent. Mirror of `VideoAnalyticsAgent` in `agent.js`.
+ */
+class ConnectedDeviceAnalyticsAgent {
+  constructor() {
+    this.isInitialized = false;
+    this.harvester = null;
+  }
+
+  /**
+   * Lazy initialization. Reads `info` from `globalThis.__NRVIDEO_CD__` and
+   * constructs the wrapped `ConnectedDeviceHarvester`. If `info` is not yet populated,
+   * returns without flipping `isInitialized` so the next `addEvent` retries.
+   */
+  initialize() {
+    if (this.isInitialized) return;
+
+    const info = globalThis.__NRVIDEO_CD__?.info;
+    if (!info) {
+      Log.warn(
+        "ConnectedDeviceAnalyticsAgent.initialize: globalThis.__NRVIDEO_CD__.info is missing"
+      );
+      return;
+    }
+
+    try {
+      this.harvester = new ConnectedDeviceHarvester(info);
+      this.isInitialized = true;
+      Log.notice("ConnectedDeviceAnalyticsAgent initialized");
+    } catch (err) {
+      Log.error("ConnectedDeviceAnalyticsAgent.initialize failed:", err.message);
+    }
+  }
+
+  /**
+   * Buffers an event for the wrapped ConnectedDeviceHarvester. Triggers lazy init on
+   * the first call. Drops events silently if init has not yet succeeded
+   * (defensive — under normal flow, `setVideoConfig` runs synchronously
+   * inside `super()` before any player event can fire).
+   *
+   *
+   * @param {object} eventObject
+   * @returns {boolean}
+   */
+  addEvent(eventObject) {
+    if (!this.isInitialized) this.initialize();
+    if (!this.isInitialized) return false;
+    return this.harvester.addEvent(eventObject);
+  }
+
+  /**
+   * Forwards to the underlying ConnectedDeviceHarvester. No-op if not yet initialized.
+   * @see ConnectedDeviceHarvester#forceQoeNextHarvest
+   */
+  forceQoeNextHarvest() {
+    if (this.harvester) this.harvester.forceQoeNextHarvest();
+  }
+
+  /**
+   * API-parity alias for `forceQoeNextHarvest`. Lets `videotracker.js` call a
+   * single method name on whichever harvester `getHarvester()` returns —
+   * Browser exposes `forceNextQoeCycle`, Vega exposes both names.
+   */
+  forceNextQoeCycle() {
+    this.forceQoeNextHarvest();
+  }
+
+  /**
+   * Forwards to the underlying ConnectedDeviceHarvester. No-op if not yet initialized.
+   * @see ConnectedDeviceHarvester#setBeforeDrainCallback
+   * @param {Function|null} cb
+   */
+  setBeforeDrainCallback(cb) {
+    if (this.harvester) this.harvester.setBeforeDrainCallback(cb);
+  }
+
+  /**
+   * Forwards to the underlying ConnectedDeviceHarvester. Triggers lazy init so
+   * `videotracker.js`'s drain callback (registered in sendStart) can refresh
+   * QoE on the buffered event before send.
+   *
+   * @param {object} freshKpis
+   * @param {string} [viewId]
+   */
+  refreshQoeKpis(freshKpis, viewId) {
+    if (!this.isInitialized) this.initialize();
+    if (this.harvester) this.harvester.refreshQoeKpis(freshKpis, viewId);
+  }
+
+  /**
+   * Forwards to the underlying ConnectedDeviceHarvester. Triggers lazy init so
+   * `tracker.setHarvestInterval(...)` works for VegaTracker the same way it
+   * does for other trackers.
+   *
+   * @param {number} interval
+   */
+  setHarvestInterval(interval) {
+    if (!this.isInitialized) this.initialize();
+    if (this.harvester) this.harvester.setHarvestInterval(interval);
+  }
+}
+
+const connectedDeviceAnalyticsAgent = new ConnectedDeviceAnalyticsAgent();
+
+// Self-register for the 'Vega' routing key. Importing this module is what
+// makes the Vega pipeline reachable in the consumer's bundle. If no consumer
+// imports this module (e.g., Html5Tracker-only build), the entire Vega chain
+// — connectedDeviceHarvester, connectedDeviceConstants, and indirectly
+// retryQueueHandler/optimizedHttpClient — is tree-shaken.
+registerHarvester("Vega", connectedDeviceAnalyticsAgent);
+
+export const connectedDeviceAnalyticsHarvester = connectedDeviceAnalyticsAgent;