@newrelic/video-core 4.1.8-beta → 4.1.8

package/src/videotrackerstate.js

@@ -89,29 +89,55 @@ class VideoTrackerState {
     this.peakBitrate = 0;
 
     /**
-     * Last tracked bitrate
+     * Time-weighted bitrate calculation accumulators
      */
+    this.partialAverageBitrate = 0;
+    this._totalBitrateDuration = 0;
+    this.weightedBitrate = 0;
     this._lastBitrate = null;
+    this._lastBitrateChangeTimestamp = null;
 
     /**
-     * Tracks the last updated timestamp for bitrate
-     * */
-    this._lastBitrateChangeTimestamp = null;
+     * Array of changed network download bitrate values (only values that differ from previous).
+     * Used for calculating simple mean, min, max (not time-weighted).
+     */
+    this._downloadBitrates = [];
 
     /**
-     * total bitrate partial value for average weighted average bitrate
+     * Previous download bitrate value to detect changes.
      */
-    this.partialAverageBitrate = 0;
+    this._lastDownloadBitrate = null;
 
     /**
-     * Had Startup Failure: TRUE if CONTENT_ERROR occurs before CONTENT_START.
+     * QOE v1.1: Total number of rendition/quality switches where bitrate increased.
      */
-    this.hadStartupFailure = false;
+    this.totalSwitchUps = 0;
 
     /**
-     * Had Playback Failure: TRUE if CONTENT_ERROR occurs during content playback.
+     * QOE v1.1: Total number of rendition/quality switches where bitrate decreased.
      */
-    this.hadPlaybackFailure = false;
+    this.totalSwitchDowns = 0;
+
+    /**
+     * QOE v1.1: Total time in milliseconds spent in paused state (intentional pauses only).
+     * Calculated from timeSincePaused chrono accumulation.
+     */
+    this.totalPauseTime = 0;
+
+    /**
+     * QOE v1.1: Set of distinct renditions played, keyed by "heightxwidth" (e.g., "1080x1920").
+     */
+    this._playedRenditions = new Set();
+
+    /**
+     * Had Startup Error: TRUE if CONTENT_ERROR occurs before CONTENT_START.
+     */
+    this.hadStartupError = false;
+
+    /**
+     * Had Playback Error: TRUE if CONTENT_ERROR occurs during content playback.
+     */
+    this.hadPlaybackError = false;
 
     /**
      * The amount of ms the user has been rebuffering during content playback.
@@ -347,23 +373,45 @@ class VideoTrackerState {
       const kpi = {};
 
       try {
-          // QoE KPIs - Content only
+          // QoE v1 KPIs
           if (this.startupTime !== null) {
               kpi["startupTime"] = this.startupTime;
           }
           if (this.peakBitrate > 0) {
               kpi["peakBitrate"] = this.peakBitrate;
           }
-          kpi["hadStartupFailure"] = this.hadStartupFailure;
-          kpi["hadPlaybackFailure"] = this.hadPlaybackFailure;
+          kpi["hadStartupError"] = this.hadStartupError;
+          kpi["hadPlaybackError"] = this.hadPlaybackError;
           kpi["totalRebufferingTime"] = this.totalRebufferingTime;
-          // Calculate rebuffering ratio as percentage (avoid division by zero)
           kpi["rebufferingRatio"] = this.totalPlaytime > 0
               ? (this.totalRebufferingTime / this.totalPlaytime) * 100
               : 0;
           kpi["totalPlaytime"] = this.totalPlaytime;
           kpi["averageBitrate"] = this.weightedBitrate;
           kpi["numberOfErrors"] = this.numberOfErrors;
+
+          // QoE v1.1 KPIs - Download rate (simple mean of changed values)
+          if (this._downloadBitrates.length > 0) {
+              const sum = this._downloadBitrates.reduce((a, b) => a + b, 0);
+              kpi["avgDownloadRate"] = Math.round(sum / this._downloadBitrates.length);
+              kpi["minDownloadRate"] = Math.min(...this._downloadBitrates);
+              kpi["maxDownloadRate"] = Math.max(...this._downloadBitrates);
+          }
+
+          // QoE v1.1 KPIs - Rendition switching
+          kpi["totalSwitchUps"] = this.totalSwitchUps;
+          kpi["totalSwitchDowns"] = this.totalSwitchDowns;
+
+          // QoE v1.1 KPIs - Pause and session timing
+          kpi["totalPauseTime"] = this.timeSincePaused.getDuration();
+          kpi["totalViewSessionTime"] = this.totalPlaytime;
+
+          // QoE v1.1 KPIs - Renditions
+          kpi["totalRenditions"] = this._playedRenditions.size;
+
+          // Version tag
+          kpi["qoeAggregateVersion"] = "1.1.0";
+
       } catch (error) {
           Log.error("Failed to add attributes for QOE KPIs", error.message);
       }
@@ -549,8 +597,10 @@ class VideoTrackerState {
       }
 
       // Accumulate total rebuffering time for content only
+      // Use exact stopped duration (stopTime - startTime) instead of live getDeltaTime()
       if (!this.isAd() && this.initialBufferingHappened) {
-        this.totalRebufferingTime += this.timeSinceBufferBegin.getDeltaTime();
+        this.totalRebufferingTime +=
+            (this.timeSinceBufferBegin.stopTime - this.timeSinceBufferBegin.startTime);
       }
 
       return true;
@@ -670,13 +720,13 @@ class VideoTrackerState {
     } else {
       this.timeSinceLastError.start();
 
-      // Track failure flags for content errors only
-      // Had Startup Failure: error before content started
+      // Track error flags for content errors only
+      // Had Startup Error: error before content started
       if (!this.isStarted) {
-        this.hadStartupFailure = true;
+        this.hadStartupError = true;
       } else {
-        // Had Playback Failure: any content error
-        this.hadPlaybackFailure = true;
+        // Had Playback Error: any content error during playback
+        this.hadPlaybackError = true;
       }
     }
   }
@@ -689,38 +739,113 @@ class VideoTrackerState {
   }
 
   /**
-   * Updates peak bitrate with current bitrate value (content only).
+   * Updates peak bitrate and time-weighted average bitrate (content only).
    * @param {number} bitrate Current content bitrate in bps.
    */
   trackContentBitrateState(bitrate) {
     if (bitrate && typeof bitrate === "number") {
       this.peakBitrate = Math.max(this.peakBitrate, bitrate);
 
-      if(this._lastBitrate === null || this._lastBitrate !== bitrate) {
-        const deltaPlaytime = this._lastBitrateChangeTimestamp === null ? this.totalPlaytime : Date.now() - this._lastBitrateChangeTimestamp;
-        const currentWeightedBitrate = (bitrate * deltaPlaytime);
-        this.partialAverageBitrate += currentWeightedBitrate;
-        this.weightedBitrate = currentWeightedBitrate / deltaPlaytime;
+      const now = Date.now();
+
+      // If not playing (buffering, paused, etc.), close the current segment
+      // so non-play time is excluded from the weighted average
+      if (!this.isPlaying) {
+        if (this._lastBitrate !== null && this._lastBitrateChangeTimestamp !== null) {
+          const segmentDuration = now - this._lastBitrateChangeTimestamp;
+          if (segmentDuration > 0) {
+            this.partialAverageBitrate += this._lastBitrate * segmentDuration;
+            this._totalBitrateDuration += segmentDuration;
+          }
+          this._lastBitrateChangeTimestamp = null; // Mark as paused
+        }
         this._lastBitrate = bitrate;
-        this._lastBitrateChangeTimestamp = Date.now();
+        return;
+      }
+
+      // Playing: restart timestamp if returning from non-play state
+      if (this._lastBitrateChangeTimestamp === null && this._lastBitrate !== null) {
+        this._lastBitrateChangeTimestamp = now;
+      }
+
+      // Close the PREVIOUS segment when bitrate changes
+      if (this._lastBitrate !== null && this._lastBitrate !== bitrate
+          && this._lastBitrateChangeTimestamp !== null) {
+        const segmentDuration = now - this._lastBitrateChangeTimestamp;
+        if (segmentDuration > 0) {
+          this.partialAverageBitrate += this._lastBitrate * segmentDuration;
+          this._totalBitrateDuration += segmentDuration;
+        }
+        this._lastBitrateChangeTimestamp = now;
       }
+
+      // Initialize timestamp on first observation
+      if (this._lastBitrateChangeTimestamp === null) {
+        this._lastBitrateChangeTimestamp = now;
+      }
+
+      this._lastBitrate = bitrate;
+
+      // Compute weighted average including current in-progress segment
+      let totalWeighted = this.partialAverageBitrate;
+      let totalDuration = this._totalBitrateDuration;
+      const currentSegment = now - this._lastBitrateChangeTimestamp;
+      if (currentSegment > 0) {
+        totalWeighted += bitrate * currentSegment;
+        totalDuration += currentSegment;
+      }
+      this.weightedBitrate = totalDuration > 0
+          ? Math.round(totalWeighted / totalDuration)
+          : bitrate;
     }
   }
 
+  /**
+   * Records network download bitrate observation. Only tracks values that differ from previous.
+   * @param {number} bps Network throughput in bits per second.
+   */
+  trackDownloadRate(bps) {
+    if (!bps || typeof bps !== "number" || bps <= 0) return;
+    if (bps !== this._lastDownloadBitrate) {
+      this._downloadBitrates.push(bps);
+      this._lastDownloadBitrate = bps;
+    }
+  }
+
+  /**
+   * Records a rendition play event (height x width combination).
+   * @param {number} height Rendition height in pixels.
+   * @param {number} width Rendition width in pixels.
+   */
+  addPlayedRendition(height, width) {
+    if (height && width) {
+      this._playedRenditions.add(`${height}x${width}`);
+    }
+  }
+
+
   /**
    * Resets tracked variable for view id change
    * */
   resetViewIdTrackedState() {
     this.peakBitrate = 0;
-    this.partialAverageBitrate = 0;
     this.startupTime = null;
+    this.partialAverageBitrate = 0;
+    this._totalBitrateDuration = 0;
+    this.weightedBitrate = 0;
     this._lastBitrate = null;
     this._lastBitrateChangeTimestamp = null;
+    this._downloadBitrates = [];
+    this._lastDownloadBitrate = null;
+    this.totalSwitchUps = 0;
+    this.totalSwitchDowns = 0;
+    this.timeSincePaused.reset();
+    this._playedRenditions = new Set();
   }
 
   /** Methods to manage total ads time chrono */
   clearTotalAdsTime() {
-    console.log("clear total ads time", this.totalAdTime);
+    Log.debug("clear total ads time", this.totalAdTime);
     this._totalAdPlaytime.reset();
   }
 
@@ -729,12 +854,12 @@ class VideoTrackerState {
   }
 
   startAdsTime() {
-    console.log("startAdsTime");
+    Log.debug("startAdsTime");
     return this._totalAdPlaytime.start();
   }
 
   stopAdsTime() {
-    console.log("stopAdsTime");
+    Log.debug("stopAdsTime");
     return this._totalAdPlaytime.stop();
   }