@newrelic/video-core 3.2.0-beta-0 → 4.0.0

package/src/agent.js

@@ -1,6 +1,75 @@
-import { NRVideoEventAggregator } from "./eventAggregator.js";
-import { NRVideoHarvester } from "./harvester.js";
+import { HarvestScheduler } from "./harvestScheduler.js";
+import { NrVideoEventAggregator } from "./eventAggregator.js";
+import Log from "./log.js";
 
-export const customEventAggregator = new NRVideoEventAggregator();
-const harvester = new NRVideoHarvester(customEventAggregator);
-harvester.startTimer();
+/**
+ * Enhanced video analytics agent with HarvestScheduler only.
+ */
+class VideoAnalyticsAgent {
+  constructor() {
+    this.isInitialized = false;
+    this.harvestScheduler = null;
+    this.eventBuffer = null;
+  }
+
+  /**
+   * Initializes the video analytics agent with enhanced HarvestScheduler.
+   */
+  initialize() {
+    if (this.isInitialized) {
+      Log.warn("Video analytics agent already initialized");
+      return;
+    }
+
+    try {
+      this.eventBuffer = new NrVideoEventAggregator();
+      this.harvestScheduler = new HarvestScheduler(this.eventBuffer);
+
+      // Start the enhanced harvest scheduler
+      this.harvestScheduler.startScheduler();
+
+      this.isInitialized = true;
+      Log.notice("Video analytics agent initialized successfully");
+    } catch (error) {
+      Log.error("Failed to initialize video analytics agent:", error.message);
+    }
+  }
+
+  /**
+   * Adds an event to the harvesting system.
+   * @param {object} eventObject - Event to add
+   * @returns {boolean} True if event was added successfully
+   */
+  addEvent(eventObject) {
+    if (!this.isInitialized) {
+      Log.warn("Video analytics agent not initialized, initializing now");
+      this.initialize();
+    }
+
+    try {
+      return this.eventBuffer.add(eventObject);
+    } catch (error) {
+      Log.error("Failed to add event to harvesting system:", error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Sets the harvest interval for the scheduler.
+   * @param {number} interval - The harvest interval in milliseconds.
+   */
+
+  setHarvestInterval(interval) {
+    if (!this.isInitialized) {
+      this.initialize();
+    }
+
+    this.harvestScheduler.updateHarvestInterval(interval);
+  }
+}
+
+// Create singleton instance
+const videoAnalyticsAgent = new VideoAnalyticsAgent();
+
+// Enhanced video analytics harvester
+export const videoAnalyticsHarvester = videoAnalyticsAgent;

package/src/constants.js

@@ -19,11 +19,17 @@ Constants.AdPositions = {
   POST: "post",
 };
 
-Constants.INTERVAL = 10000;
-Constants.MAX_EVENTS_PER_BATCH = 1000;
-Constants.MAX_PAYLOAD_SIZE = 1; // 1mb
-Constants.MAX_BEACON_SIZE = 0.0625; // 64kb
-Constants.MAX_EVENT_SIZE = 0.0625; // 64kb
+// bam.nr-data.net
+//bam-cell.nr-data.net
+
+Constants.COLLECTOR = {
+  US: ["bam.nr-data.net", "bam-cell.nr-data.net"],
+  EU: "bam.eu01.nr-data.net",
+  Staging: "staging-bam-cell.nr-data.net",
+  GOV: "gov-bam.nr-data.net",
+};
+
+// ====== VALID EVENT TYPES ======
 Constants.VALID_EVENT_TYPES = [
   "VideoAction",
   "VideoAdAction",
@@ -31,13 +37,9 @@ Constants.VALID_EVENT_TYPES = [
   "VideoCustomAction",
 ];
 
-Constants.COLLECTOR = {
-  US: "bam-cell.nr-data.net",
-  EU: "bam.eu01.nr-data.net",
-  Stage: "staging-bam-cell.nr-data.net",
-  GOV: "gov-bam.nr-data.net",
-};
-
-// "bam.nr-data.net",
+Constants.MAX_PAYLOAD_SIZE = 1048576; // 1MB = 1024 × 1024 bytes
+Constants.MAX_BEACON_SIZE = 61440; // 60KB = 60 × 1024 bytes
+Constants.MAX_EVENTS_PER_BATCH = 1000;
+Constants.INTERVAL = 10000; //10 seconds
 
 export default Constants;

package/src/core.js

@@ -1,6 +1,6 @@
 import Log from "./log";
 import { recordEvent } from "./recordEvent";
-import { setAuthConfig } from "./authConfiguration";
+import { setVideoConfig } from "./videoConfiguration";
 
 /**
  * Static class that sums up core functionalities of the library.
@@ -8,12 +8,17 @@ import { setAuthConfig } from "./authConfiguration";
  */
 class Core {
   /**
-   * Add a tracker to the system. Trackers added will start reporting its events to NR's backend.
+   * Add a tracker to the system. Trackers added will start reporting its events to the video analytics backend.
    *
    * @param {(Emitter|Tracker)} tracker Tracker instance to add.
+   * @param {object} options Configuration options including video analytics settings.
    */
   static addTracker(tracker, options) {
-    setAuthConfig(options.info);
+    // Set video analytics configuration
+    if (options?.info) {
+      setVideoConfig(options.info);
+    }
+    
     if (tracker.on && tracker.emit) {
       trackers.push(tracker);
       tracker.on("*", eventHandler);
@@ -46,20 +51,52 @@ class Core {
     return trackers;
   }
 
+  /**
+   * Enhanced send method with performance timing.
+   * @param {string} eventType - Type of event
+   * @param {string} actionName - Action name
+   * @param {object} data - Event data
+   */
   static send(eventType, actionName, data) {
-    data["timeSinceLoad"] = window.performance.now() / 1000;
-    recordEvent(eventType, { actionName, ...data });
+    const enrichedData = {
+      actionName,
+      ...data,
+     
+    };
+    
+    return recordEvent(eventType, enrichedData);
   }
 
   /**
-   * Sends an error event. This may be used for external errors launched by the app, the network or
+   * Sends an error event.
+   * This may be used for external errors launched by the app, the network or
    * any external factor. Note that errors within the player are normally reported with
    * tracker.sendError, so this method should not be used to report those.
    *
    * @param {object} att attributes to be sent along the error.
    */
   static sendError(att) {
-    Core.send("ERROR", att);
+    return recordEvent("VideoErrorAction", {
+      actionName: "ERROR",
+      ...att
+    });
+  }
+
+  
+  
+
+  /**
+   * Forces an immediate harvest of all pending events.
+   * @returns {Promise<object>} Harvest result
+   */
+  static async forceHarvest() {
+    try {
+      const { videoAnalyticsHarvester } = require("./agent"); // lazy loading for dynamic import
+      return await videoAnalyticsHarvester.forceHarvest();
+    } catch (error) {
+      Log.error("Failed to force harvest:", error.message);
+      return { success: false, error: error.message };
+    }
   }
 }
 
@@ -67,20 +104,27 @@ let trackers = [];
 let isErrorShown = false;
 
 /**
- * Logs and sends given event.
+ * Enhanced event handler with error handling and performance monitoring.
  *
  * @private
  * @param {Event} e Event
  */
 function eventHandler(e) {
-  let data = cleanData(e.data);
-  if (Log.level <= Log.Levels.DEBUG) {
-    Log.notice("Sent", e.type, data);
-  } else {
-    Log.notice("Sent", e.type);
-  }
+  try {
+    let data = cleanData(e.data);
+    
+    if (Log.level <= Log.Levels.DEBUG) {
+      Log.notice("Sent", e.type, data);
+    } else {
+      Log.notice("Sent", e.type);
+    }
+
+    // Send event without priority discrimination
+    Core.send(e.eventType, e.type, data);
 
-  Core.send(e.eventType, e.type, data);
+  } catch (error) {
+    Log.error("Error in event handler:", error.message);
+  }
 }
 
 /**

package/src/eventAggregator.js

@@ -1,66 +1,218 @@
-import { getPayloadSize } from "./utils";
+import Log from "./log";
 import Constants from "./constants";
-const { MAX_EVENTS_PER_BATCH, MAX_PAYLOAD_SIZE } = Constants;
+import { dataSize } from "./utils";
+
+const { MAX_PAYLOAD_SIZE, MAX_EVENTS_PER_BATCH } = Constants;
 
 /**
- * A simple aggregator that queues raw events without any statistical aggregation.
- * It includes the necessary save/reload logic for the harvester's retry mechanism.
+ * Enhanced event buffer that manages video events with unified priority handling
+ * and automatic size management. All events are treated with equal priority
+ * unless explicitly specified otherwise.
  */
-export class NRVideoEventAggregator {
-  #queue = [];
-  #retryQueue = [];
+export class NrVideoEventAggregator {
+  constructor() {
+    // Simplified to single priority queue for equal treatment
+
+    this.buffer = [];
+    this.maxPayloadSize = MAX_PAYLOAD_SIZE;
+    this.maxEventsPerBatch = MAX_EVENTS_PER_BATCH;
+    this.currentPayloadSize = 0;
+    this.totalEvents = 0;
+
+    // Dual threshold system - whichever is reached first triggers harvest
+    // Payload size thresholds
+    this.smartHarvestPayloadThreshold = Math.floor(this.maxPayloadSize * 0.6); // 60% of 1MB = 600KB
+    this.overflowPayloadThreshold = Math.floor(this.maxPayloadSize * 0.9); // 90% of 1MB = 900KB
+
+    // Event count thresholds
+    this.smartHarvestEventThreshold = Math.floor(this.maxEventsPerBatch * 0.6); // 60% of 1000 = 600 events
+    this.overflowEventThreshold = Math.floor(this.maxEventsPerBatch * 0.9); // 90% of 1000 = 900 events
+
+    // Callback for triggering harvest
+    this.onSmartHarvestTrigger = null;
+  }
 
   /**
-   * Checks if the event queue is empty.
-   * @returns {boolean}
+   * Adds an event to the unified buffer.
+   * All events are treated equally in FIFO order.
+   * @param {object} eventObject - The event to add
    */
-  isEmpty() {
-    return this.#queue.length === 0 && this.#retryQueue.length === 0;
+  add(eventObject) {
+    try {
+      // Calculate event payload size
+      const eventSize = dataSize(eventObject);
+
+      // Check if we need to make room based on EITHER payload size OR event count limits
+      const wouldExceedPayload =
+        this.currentPayloadSize + eventSize >= this.maxPayloadSize;
+      const wouldExceedEventCount =
+        this.totalEvents + 1 >= this.maxEventsPerBatch;
+
+      if (wouldExceedPayload || wouldExceedEventCount) {
+        this.makeRoom(eventSize);
+      }
+
+      // Add to unified buffer
+      this.buffer.push(eventObject);
+      this.totalEvents++;
+      this.currentPayloadSize += eventSize;
+
+      // Check if smart harvest should be triggered
+      this.checkSmartHarvestTrigger();
+
+      return true;
+    } catch (error) {
+      Log.error("Failed to add event to buffer:", error.message);
+      return false;
+    }
   }
 
   /**
-   * Drains the entire queue and returns all events.
-   * Called by the harvester to begin the chunking process.
+   * Checks if smart harvest should be triggered based on dual threshold system.
+   * Triggers when EITHER condition is met first:
+   * - 60% of payload size (600KB) OR 60% of event count (600 events)
+   * - 90% of payload size (900KB) OR 90% of event count (900 events)
+   * @private
+   */
+  checkSmartHarvestTrigger() {
+    const payloadPercentage = this.currentPayloadSize / this.maxPayloadSize;
+    const eventPercentage = this.totalEvents / this.maxEventsPerBatch;
+
+    // Check 90% emergency thresholds first (either payload OR event count)
+    const isPayloadOverflowReached =
+      this.currentPayloadSize >= this.overflowPayloadThreshold;
+    const isEventOverflowReached =
+      this.totalEvents >= this.overflowEventThreshold;
+
+    if (isPayloadOverflowReached || isEventOverflowReached) {
+      const triggerReason = isPayloadOverflowReached
+        ? `payload ${this.currentPayloadSize}/${
+            this.maxPayloadSize
+          } bytes (${Math.round(payloadPercentage * 100)}%)`
+        : `events ${this.totalEvents}/${this.maxEventsPerBatch} (${Math.round(
+            eventPercentage * 100
+          )}%)`;
+
+      Log.warn(
+        `OVERFLOW PREVENTION: ${triggerReason} - Emergency harvest triggered`
+      );
+
+      if (
+        this.onSmartHarvestTrigger &&
+        typeof this.onSmartHarvestTrigger === "function"
+      ) {
+        // Trigger immediate emergency harvest
+        this.onSmartHarvestTrigger("overflow", 90);
+      }
+    }
+
+    // Check 60% smart harvest thresholds (either payload OR event count)
+    else {
+      const isPayloadSmartReached =
+        this.currentPayloadSize >= this.smartHarvestPayloadThreshold;
+      const isEventSmartReached =
+        this.totalEvents >= this.smartHarvestEventThreshold;
+
+      if (isPayloadSmartReached || isEventSmartReached) {
+        if (
+          this.onSmartHarvestTrigger &&
+          typeof this.onSmartHarvestTrigger === "function"
+        ) {
+          // Trigger proactive harvest
+          this.onSmartHarvestTrigger("smart", 60);
+        }
+      }
+    }
+  }
+
+  /**
+   * Sets the callback function for smart harvest triggers.
+   * @param {Function} callback - Function to call when smart harvest is triggered
+   */
+  setSmartHarvestCallback(callback) {
+    this.onSmartHarvestTrigger = callback;
+  }
+
+  /**
+   * Drains all events from the buffer in FIFO order (first in, first out).
+   * No limits needed since buffer already manages size via makeRoom() and smart harvest triggers.
+   * @returns {Array} Array of events in order they were added
    */
   drain() {
-    const allEvents = [...this.#retryQueue, ...this.#queue];
-    this.#queue = []; // Clear the active queue
-    this.#retryQueue = []; // Clear the retry queue
+    try {
+      // Drain ALL events - buffer size is already managed by makeRoom() and smart harvest
+      const events = this.buffer.splice(0);
+
+      // Reset counters since buffer is now empty
+      this.totalEvents = 0;
+      this.currentPayloadSize = 0;
 
-    return allEvents;
+      return events;
+    } catch (error) {
+      Log.error("Failed to drain events from buffer:", error.message);
+      return [];
+    }
   }
 
   /**
-   * Adds a complete, enriched event object to the queue.
-   * @param {object} eventObject - The event to queue.
+   * Checks if the buffer is empty.
+   * @returns {boolean} True if all buffers are empty
    */
-  add(eventObject) {
-    this.#queue.push(eventObject);
+  isEmpty() {
+    return this.totalEvents === 0;
   }
 
-  // --- Methods for the Harvester ---
+  /**
+   * Gets the total number of events across all buffers.
+   * @returns {number} Total event count
+   */
+  size() {
+    return this.totalEvents;
+  }
 
   /**
-   * Cleans up the queue after a harvest attempt, based on the result.
-   * @param {object} result - The result from the harvester, containing a 'retry' flag.
+   * Clears the entire buffer.
    */
-  postHarvestCleanup(result) {
-    if (!result.retry || !result.chunk?.length) {
-      this.#retryQueue = [];
-      return;
+  clear() {
+    this.buffer = [];
+    this.totalEvents = 0;
+  }
+
+  /**
+   * Makes room in the buffer by removing the oldest event.
+   * Uses FIFO approach - removes the first (oldest) event.
+   * @private
+   */
+  makeRoom(newEventSize) {
+    // Before the while loop in makeRoom()
+    if (newEventSize > this.maxPayloadSize) {
+      Log.error("Event dropped: Event size exceeds maximum payload size.");
+      return; // Exit the function to prevent infinite loop
     }
 
+    // Keep a loop to evict events until we meet ALL conditions for the new event
     while (
-      this.#retryQueue.length > 0 &&
-      (getPayloadSize(this.#retryQueue) + getPayloadSize(result.chunk) >
-        MAX_PAYLOAD_SIZE ||
-        this.#retryQueue.length + result.chunk.length > MAX_EVENTS_PER_BATCH)
+      // Condition 1: Exceeding max event count
+      this.totalEvents >= this.maxEventsPerBatch ||
+      // Condition 2: Exceeding max payload size
+      this.currentPayloadSize + newEventSize >= this.maxPayloadSize
     ) {
-      // Removes the oldest item from the retry queue to make space
-      this.#retryQueue.shift();
-    }
+      if (this.buffer.length > 0) {
+        const removed = this.buffer.shift(); // Remove the oldest event (FIFO)
+
+        // Recalculate size and count after removal
+        const removedSize = dataSize(removed);
+        this.totalEvents--;
+        this.currentPayloadSize -= removedSize;
 
-    // Add the entire failed chunk to the retry queue.
-    this.#retryQueue.push(...result.chunk); // result.chunk will be never greater than 1mb or 1000
+        // Optional: Log a warning for a dropped event
+        Log.warn("Event buffer full, oldest event removed.");
+      } else {
+        // Buffer is somehow empty, but conditions were met. Break the loop.
+        break;
+      }
+    }
   }
 }
+
+export default NrVideoEventAggregator;