@newrelic/video-core 4.1.8-beta → 5.0.0

package/package.json

@@ -1,9 +1,24 @@
 {
   "name": "@newrelic/video-core",
-  "version": "4.1.8-beta",
+  "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,21 +41,28 @@
     "Bharat Sarsawat"
   ],
   "license": "Apache-2.0",
+  "sideEffects": false,
   "devDependencies": {
     "@babel/core": "^7.24.5",
     "@babel/plugin-transform-modules-commonjs": "^7.24.1",
-    "@newrelic/newrelic-oss-cli": "^0.1.2",
     "@babel/preset-env": "^7.24.5",
     "@babel/register": "^7.24.6",
-    "aws-sdk": "^2.920.0",
-    "babel-jest": "^30.2.0",
+    "@newrelic/newrelic-oss-cli": "^0.1.2",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^12.0.0",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^10.0.3",
+    "@semantic-release/npm": "^13.1.5",
+    "@semantic-release/release-notes-generator": "^13.0.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",
+    "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"
@@ -58,5 +80,8 @@
   ],
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "terser-webpack-plugin": "^5.6.1"
   }
 }

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

@@ -1,7 +1,11 @@
 import { HarvestScheduler } from "./harvestScheduler.js";
-import { NrVideoEventAggregator } from "./eventAggregator.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.
@@ -48,11 +52,8 @@ class VideoAnalyticsAgent {
     }
 
     try {
-      if(eventObject.actionName && eventObject.actionName === Tracker.Events.QOE_AGGREGATE) {
-          // This makes sure that there is only one QOE aggregate event for a harvest cycle
-          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;
@@ -71,10 +72,44 @@ class VideoAnalyticsAgent {
 
     this.harvestScheduler.updateHarvestInterval(interval);
   }
+
+  /**
+   * Forces the next harvest cycle to include QOE_AGGREGATE events.
+   * Called at CONTENT_END to ensure final QoE is sent.
+   */
+  forceNextQoeCycle() {
+    if (this.harvestScheduler) {
+      this.harvestScheduler.forceNextQoeCycle = true;
+    }
+  }
+
+  /**
+   * Sets a callback to be called before each drain to refresh QoE KPIs.
+   * @param {Function|null} callback - Function that refreshes QoE data in the buffer, or null to clear
+   */
+  setBeforeDrainCallback(callback) {
+    if (this.harvestScheduler) {
+      this.harvestScheduler.beforeDrainCallback = callback;
+    }
+  }
+
+  /**
+   * Updates QoE KPI fields on the existing QOE_AGGREGATE event in the buffer.
+   * Scoped to a specific viewId to support multiple players on the same page.
+   * @param {object} freshKpis - Object with latest KPI values
+   * @param {string} [viewId] - The viewId of the player whose QoE event to update
+   */
+  refreshQoeKpis(freshKpis, viewId) {
+    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,9 +1,15 @@
-import { NrVideoEventAggregator } from "./eventAggregator";
-import { RetryQueueHandler } from "./retryQueueHandler";
-import { OptimizedHttpClient } from "./optimizedHttpClient";
-import { buildUrl, dataSize } from "./utils";
-import Constants from "./constants";
-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,
@@ -27,49 +33,55 @@ export class HarvestScheduler {
     }
 
     // Scheduler state
-    this.isStarted = false;
-    this.currentTimerId = null;
     this.harvestCycle = Constants.INTERVAL;
     this.isHarvesting = false;
+    this.qoeCycleCount = 1;
+    this.forceNextQoeCycle = false;
+    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");
   }
 
@@ -87,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({});
   }
 
   /**
@@ -180,7 +169,6 @@ export class HarvestScheduler {
       return {
         success: false,
         error: error.message,
-        consecutiveFailures: this.consecutiveFailures,
       };
     } finally {
       this.isHarvesting = false;
@@ -237,15 +225,47 @@ export class HarvestScheduler {
   /**
    * Drains events from the event buffer and optionally includes retry queue data.
    * Uses fresh-events-first approach with payload limits.
+   * Filters out QOE_AGGREGATE events based on the harvest interval multiplier,
+   * always including them on the first and final harvest cycles.
    * @param {object} options - Harvest options
    * @returns {Array} Drained events
    * @private
    */
-  drainEvents() {
+  drainEvents(options = {}) {
+    // Determine if this cycle should include the QOE_AGGREGATE event
+    const multiplier = window.NRVIDEO?.config?.qoeIntervalFactor ?? 1;
+    const isForced = !!options.isFinalHarvest || this.forceNextQoeCycle;
+    const isQoeCycle =
+      (this.qoeCycleCount - 1) % multiplier === 0 || isForced;
+
+    // Reset force flag after use
+    if (this.forceNextQoeCycle) this.forceNextQoeCycle = false;
+
+    // Refresh QoE KPIs with latest tracker state before draining
+    if (this.beforeDrainCallback && typeof this.beforeDrainCallback === 'function') {
+      try {
+        this.beforeDrainCallback();
+      } catch (e) {
+        Log.error("Before drain callback failed:", e.message);
+      }
+    }
+
     // Always drain fresh events first (priority approach)
     const freshEvents = this.eventBuffer.drain();
-    let events = [...freshEvents];
-    let currentPayloadSize = dataSize(freshEvents);
+    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.
+    applyQoeDirtyFilter(filteredFreshEvents, this._lastSentQoeKpis, isForced);
+
+    let events = [...filteredFreshEvents];
+    let currentPayloadSize = dataSize(filteredFreshEvents);
 
     // Always check retry queue if it has data - no flags needed
     if (this.retryQueueHandler && this.retryQueueHandler.getQueueSize() > 0) {
@@ -336,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 });
   }
 
   /**
@@ -351,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;
     }
@@ -362,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);
   }
 
   /**
@@ -413,4 +413,5 @@ export class HarvestScheduler {
       triggerFinalHarvest();
     });
   }
+
 }

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;