@newrelic/video-core 3.1.1 → 3.2.0-beta-1

package/src/chrono.js

@@ -0,0 +1,78 @@
+/**
+ * This class calculates time lapses between two points on time.
+ */
+class Chrono {
+  /**
+   * Constructor
+   */
+  constructor() {
+    this.reset();
+  }
+
+  /** Reset chrono values. */
+  reset() {
+    /** Start time */
+    this.startTime = 0;
+
+    /** Stop time */
+    this.stopTime = 0;
+
+    /**
+     * If you set an offset in a chrono, its value will be added getDeltaTime and stop.
+     *
+     * @example
+     * let chrono = new Chrono()
+     * chrono.offset = 500
+     * chrono.start()
+     * process.sleep(500)
+     * chrono.stop() // Will return 1000
+     *
+     * @type {number}
+     */
+    this.offset = 0;
+  }
+
+  /**
+   * Returns the time between start() and the last stop() in ms. Returns null if start wasn't
+   * called.
+   * @return {(number|null)} Time lapse in ms.
+   */
+  getDeltaTime() {
+    if (this.startTime) {
+      return this.offset + (new Date().getTime() - this.startTime);
+    } else {
+      return null;
+    }
+  }
+
+  /**
+   * Starts the chrono.
+   */
+  start() {
+    this.startTime = new Date().getTime();
+    this.stopTime = 0;
+  }
+
+  /**
+   * Stops the timer and returns delta time.
+   * @return {(number|null)} Returns the delta time
+   */
+  stop() {
+    this.stopTime = new Date().getTime();
+    return this.getDeltaTime();
+  }
+
+  /**
+   * Creates a copy of the chrono.
+   * @returns {Chrono} Cloned chrono
+   */
+  clone() {
+    var chrono = new Chrono();
+    chrono.startTime = this.startTime;
+    chrono.stopTime = this.stopTime;
+    chrono.offset = this.offset;
+    return chrono;
+  }
+}
+
+export default Chrono;

package/src/constants.js

@@ -0,0 +1,43 @@
+/**
+ * Constants for the library.
+ * @class Constants
+ * @static
+ */
+class Constants {}
+
+/**
+ * Enum for types/positions of ads.
+ * @example var type = Constants.AdPositions.PRE
+ * @enum {String}
+ */
+Constants.AdPositions = {
+  /** For ads shown before the content. */
+  PRE: "pre",
+  /** For ads shown during the content. */
+  MID: "mid",
+  /** For ads shown after the content. */
+  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
+Constants.VALID_EVENT_TYPES = [
+  "VideoAction",
+  "VideoAdAction",
+  "VideoErrorAction",
+  "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",
+
+export default Constants;

package/src/core.js

@@ -0,0 +1,100 @@
+import Log from "./log";
+import { recordEvent } from "./recordEvent";
+import { setAuthConfig } from "./authConfiguration";
+
+/**
+ * Static class that sums up core functionalities of the library.
+ * @static
+ */
+class Core {
+  /**
+   * Add a tracker to the system. Trackers added will start reporting its events to NR's backend.
+   *
+   * @param {(Emitter|Tracker)} tracker Tracker instance to add.
+   */
+  static addTracker(tracker, options) {
+    setAuthConfig(options.info);
+    if (tracker.on && tracker.emit) {
+      trackers.push(tracker);
+      tracker.on("*", eventHandler);
+      if (typeof tracker.trackerInit == "function") {
+        tracker.trackerInit();
+      }
+    } else {
+      Log.error("Tried to load a non-tracker.", tracker);
+    }
+  }
+
+  /**
+   * Disposes and remove given tracker. Removes its listeners.
+   *
+   * @param {Tracker} tracker Tracker to remove.
+   */
+  static removeTracker(tracker) {
+    tracker.off("*", eventHandler);
+    tracker.dispose();
+    let index = trackers.indexOf(tracker);
+    if (index !== -1) trackers.splice(index, 1);
+  }
+
+  /**
+   * Returns the array of trackers.
+   *
+   * @returns {Tracker[]} Array of trackers.
+   */
+  static getTrackers() {
+    return trackers;
+  }
+
+  static send(eventType, actionName, data) {
+    data["timeSinceLoad"] = window.performance.now() / 1000;
+    recordEvent(eventType, { actionName, ...data });
+  }
+
+  /**
+   * 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);
+  }
+}
+
+let trackers = [];
+let isErrorShown = false;
+
+/**
+ * Logs and sends given event.
+ *
+ * @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);
+  }
+
+  Core.send(e.eventType, e.type, data);
+}
+
+/**
+ * Cleans given object, removing all items with value === null.
+ * @private
+ * @param {Object} data Data to clean
+ * @returns {Object} Cleaned object
+ */
+function cleanData(data) {
+  let ret = {};
+  for (let i in data) {
+    if (data[i] !== null && typeof data[i] !== "undefined") ret[i] = data[i];
+  }
+  return ret;
+}
+
+export default Core;

package/src/emitter.js

@@ -0,0 +1,81 @@
+/**
+ * This base class implements a basic behavior of listeners and events. Extend this object to have
+ * this feature built-in inside your classes.
+ *
+ * @class Emitter
+ */
+class Emitter {
+  /**
+   * Sets a listener to a given event. Use {@link emit} to trigger those events.
+   * Pass '*' to listen ALL events.
+   *
+   * @param {string} event Name of the event.
+   * @param {function} callback Callback of the event. Receives event and data.
+   * @return this
+   */
+  on(event, callback) {
+    this._listeners = this._listeners || {};
+    if (typeof callback === "function") {
+      this._listeners[event] = this._listeners[event] || [];
+      this._listeners[event].push(callback);
+      return this;
+    }
+  }
+
+  /**
+   * Removes given callback from the listeners of this object.
+   *
+   * @param {string} event Name of the event.
+   * @param {function} callback Callback of the event.
+   * @return this
+   */
+  off(event, callback) {
+    this._listeners = this._listeners || {};
+
+    if (this._listeners[event]) {
+      var index = this._listeners[event].indexOf(callback);
+      if (index !== -1) {
+        this._listeners[event].splice(index, 1);
+      }
+    }
+    return this;
+  }
+
+  /**
+   * Emits given event, triggering all the associated callbacks.
+   *
+   * @param {string} event Name of the event.
+   * @param {object} [data] Custom data to be sent to the callbacks.
+   * @return this
+   */
+  emit(eventType, event, data) {
+    this._listeners = this._listeners || {};
+    data = data || {};
+
+    if (Array.isArray(this._listeners[event])) {
+      this._listeners[event].forEach((callback) => {
+        callback.call(this, {
+          eventType,
+          type: event,
+          data: data,
+          target: this,
+        });
+      });
+    }
+
+    if (Array.isArray(this._listeners["*"])) {
+      this._listeners["*"].forEach((callback) => {
+        callback.call(this, {
+          eventType,
+          type: event,
+          data: data,
+          target: this,
+        });
+      });
+    }
+
+    return this;
+  }
+}
+
+export default Emitter;

package/src/eventAggregator.js

@@ -0,0 +1,66 @@
+import { getPayloadSize } from "./utils";
+import Constants from "./constants";
+const { MAX_EVENTS_PER_BATCH, MAX_PAYLOAD_SIZE } = 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.
+ */
+export class NRVideoEventAggregator {
+  #queue = [];
+  #retryQueue = [];
+
+  /**
+   * Checks if the event queue is empty.
+   * @returns {boolean}
+   */
+  isEmpty() {
+    return this.#queue.length === 0 && this.#retryQueue.length === 0;
+  }
+
+  /**
+   * Drains the entire queue and returns all events.
+   * Called by the harvester to begin the chunking process.
+   */
+  drain() {
+    const allEvents = [...this.#retryQueue, ...this.#queue];
+    this.#queue = []; // Clear the active queue
+    this.#retryQueue = []; // Clear the retry queue
+
+    return allEvents;
+  }
+
+  /**
+   * Adds a complete, enriched event object to the queue.
+   * @param {object} eventObject - The event to queue.
+   */
+  add(eventObject) {
+    this.#queue.push(eventObject);
+  }
+
+  // --- Methods for the Harvester ---
+
+  /**
+   * Cleans up the queue after a harvest attempt, based on the result.
+   * @param {object} result - The result from the harvester, containing a 'retry' flag.
+   */
+  postHarvestCleanup(result) {
+    if (!result.retry || !result.chunk?.length) {
+      this.#retryQueue = [];
+      return;
+    }
+
+    while (
+      this.#retryQueue.length > 0 &&
+      (getPayloadSize(this.#retryQueue) + getPayloadSize(result.chunk) >
+        MAX_PAYLOAD_SIZE ||
+        this.#retryQueue.length + result.chunk.length > MAX_EVENTS_PER_BATCH)
+    ) {
+      // Removes the oldest item from the retry queue to make space
+      this.#retryQueue.shift();
+    }
+
+    // Add the entire failed chunk to the retry queue.
+    this.#retryQueue.push(...result.chunk); // result.chunk will be never greater than 1mb or 1000
+  }
+}

package/src/harvester.js

@@ -0,0 +1,171 @@
+import Constants from "./constants";
+import pkg from "../package.json";
+import { callApi, getPayloadSize } from "./utils";
+
+const { INTERVAL, MAX_EVENTS_PER_BATCH, MAX_PAYLOAD_SIZE, MAX_BEACON_SIZE } =
+  Constants;
+
+/**
+ * A scheduler and dispatcher for sending raw event data to the New Relic 'ins' endpoint.
+ * It manages the harvest cycle, URL construction, and retries.
+ */
+export class NRVideoHarvester {
+  #started = false;
+  #aggregate; // EventAggregator instance
+  #timerId = null; // Timer ID for cleanup
+
+  /**
+   * @param {object} agentController - The agent's configuration object.
+   * @param {object} aggregate - The aggregator instance (e.g., EventAggregator).
+   */
+  constructor(aggregate) {
+    this.#aggregate = aggregate;
+    // Ensure any queued data is sent when the user navigates away.
+    window.addEventListener("pagehide", () =>
+      this.triggerHarvest({ isFinalHarvest: true })
+    );
+  }
+
+  /**
+   * Starts the periodic harvest timer.
+   */
+  startTimer() {
+    if (this.#started) return;
+    this.#started = true;
+    const onHarvestInterval = () => {
+      this.triggerHarvest({});
+      if (this.#started) {
+        this.#timerId = setTimeout(onHarvestInterval, INTERVAL);
+      }
+    };
+    this.#timerId = setTimeout(onHarvestInterval, INTERVAL);
+  }
+
+  /**
+   * Stops the harvest timer and cleans up resources.
+   */
+  stopTimer() {
+    this.#started = false;
+    if (this.#timerId) {
+      clearTimeout(this.#timerId);
+      this.#timerId = null;
+    }
+  }
+
+  /**
+   * Executes a harvest cycle by draining the queue and sending it in chunks.
+   */
+
+  triggerHarvest(options = {}) {
+    if (this.#aggregate.isEmpty()) return;
+
+    try {
+      // 1. Drain the entire queue to get all pending events.
+      const allEvents = this.#aggregate.drain();
+
+      // 2. Determine the correct size limit for this harvest.
+      const maxChunkSize = options.isFinalHarvest
+        ? MAX_BEACON_SIZE
+        : MAX_PAYLOAD_SIZE;
+
+      // 3. Split the events into chunks that respect size and count limits.
+      const chunks = this.chunkEvents(allEvents, maxChunkSize);
+
+      // 4. Send each chunk sequentially.
+      chunks.forEach((chunk, index) => {
+        const isLastChunk = index === chunks.length - 1;
+        this.sendChunk(chunk, options, isLastChunk);
+      });
+    } catch (error) {
+      console.error("Error during harvest:", error);
+      // Re-add events to the queue if something went wrong
+      // This is a failsafe to prevent data loss
+    }
+  }
+
+  /**
+   * Splits an array of events into multiple smaller arrays (chunks).
+   */
+  chunkEvents(events, maxChunkSize) {
+    const chunks = [];
+    let currentChunk = [];
+
+    for (const event of events) {
+      if (currentChunk.length >= MAX_EVENTS_PER_BATCH) {
+        chunks.push(currentChunk);
+        currentChunk = [];
+      }
+
+      currentChunk.push(event);
+      const payloadSize = getPayloadSize({ ins: currentChunk });
+      // Use the maxChunkSize passed into the function
+      if (payloadSize > maxChunkSize) {
+        const lastEvent = currentChunk.pop();
+        if (currentChunk.length > 0) {
+          chunks.push(currentChunk);
+        }
+        currentChunk = [lastEvent];
+      }
+    }
+
+    if (currentChunk.length > 0) {
+      chunks.push(currentChunk);
+    }
+
+    return chunks;
+  }
+
+  /**
+   * Sends a single chunk of events.
+   */
+  sendChunk(chunk, options, isLastChunk) {
+    const url = this.#buildUrl();
+    if (!url) {
+      // If URL construction failed, treat as a failed request that shouldn't be retried
+      this.#aggregate.postHarvestCleanup({ retry: false, status: 0 });
+      return;
+    }
+
+    const payload = { body: { ins: chunk } };
+
+    callApi(
+      {
+        url: url,
+        payload: payload,
+        options: options,
+      },
+      (result) => {
+        // Pass the failed chunk back to the aggregator for re-queuing.
+        if (result.retry) {
+          result.chunk = chunk;
+        }
+        this.#aggregate.postHarvestCleanup(result);
+      }
+    );
+  }
+
+  /**
+   * Constructs the specific URL for the New Relic 'ins' endpoint with all required parameters.
+   * @private
+   */
+
+  #buildUrl() {
+    try {
+      if (!window.NRVIDEO || !window.NRVIDEO.info) {
+        throw new Error("NRVIDEO info is not available.");
+      }
+
+      const { beacon, licenseKey, applicationID, sa } = window.NRVIDEO.info;
+
+      if (!beacon || !licenseKey || !applicationID)
+        throw new Error(
+          "Options object provided by New Relic is not correctly initialized"
+        );
+      const url = `https://${beacon}/ins/1/${licenseKey}?a=${applicationID}&v=${pkg.version}&ref=${window.location.href}&ca=VA`;
+      return url;
+    } catch (error) {
+      console.error(error.message);
+      return null; // Return null instead of undefined
+    }
+  }
+}

package/src/index.js

@@ -0,0 +1,22 @@
+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 { version } from "../package.json";
+
+const nrvideo = {
+  Constants,
+  Chrono,
+  Log,
+  Emitter,
+  Tracker,
+  VideoTracker,
+  VideoTrackerState,
+  Core,
+  version,
+};
+export default nrvideo;