@newrelic/video-videojs 4.0.3 → 4.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newrelic/video-videojs",
-  "version": "4.0.3",
+  "version": "4.1.0",
   "description": "New relic tracker for Videojs",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",

package/src/techs/contrib-hls.js

@@ -1,83 +1,95 @@
 export default class ContribHlsTech {
-  constructor (tech) {
-    this.tech = tech.vhs
-    this.player = tech.el().player // Store player reference for playback bitrate calculation
+  constructor(tech) {
+    this.tech = tech.vhs;
+    this.player = tech.el().player; // Store player reference for playback bitrate calculation
   }
 
-  getRenditionName () {
+  getRenditionName() {
     try {
-      var media = this.tech.playlists.media()
-      if (media && media.attributes) return media.attributes.NAME
-    } catch (err) { }
-    return null
+      var media = this.tech.playlists.media();
+      if (media && media.attributes) return media.attributes.NAME;
+    } catch (err) {}
+    return null;
   }
 
-  getRenditionBitrate () {
+  getRenditionBitrate() {
     try {
-      var media = this.tech.playlists.media()
-      if (media && media.attributes) return media.attributes.BANDWIDTH
-    } catch (err) { }
-    return null
+      var media = this.tech.playlists.media();
+      if (media && media.attributes) return media.attributes.BANDWIDTH;
+    } catch (err) {}
+    return null;
   }
 
-  getRenditionWidth () {
+  getRenditionWidth() {
     try {
-      var media = this.tech.playlists.media()
+      var media = this.tech.playlists.media();
       if (media && media.attributes && media.attributes.RESOLUTION) {
-        return media.attributes.RESOLUTION.width
+        return media.attributes.RESOLUTION.width;
       }
-    } catch (err) { }
-    return null
+    } catch (err) {}
+    return null;
   }
 
-  getRenditionHeight () {
+  getRenditionHeight() {
     try {
-      var media = this.tech.playlists.media()
+      var media = this.tech.playlists.media();
       if (media && media.attributes && media.attributes.RESOLUTION) {
-        return media.attributes.RESOLUTION.height
+        return media.attributes.RESOLUTION.height;
       }
-    } catch (err) { }
-    return null
+    } catch (err) {}
+    return null;
   }
 
-  getBitrate () {
+  getBitrate() {
     // Calculate playback bitrate (actual content consumption rate)
-    return this.getContentBitratePlayback()
+    return this.getContentBitratePlayback();
   }
 
-  getContentBitratePlayback () {
+  getManifestBitrate() {
     try {
-      // VHS provides stats for calculating actual playback bitrate
-      if (this.tech.stats && this.player) {
-        const stats = this.tech.stats
-
-        // Calculate actual playback bitrate based on content consumption
-        if (stats.mediaBytesTransferred > 0 && stats.mediaRequests > 0) {
-          const currentTime = this.player.currentTime() // in seconds
-          const playbackRate = this.player.playbackRate() || 1
+      // Return highest available bitrate from all renditions
+      const playlists = this.tech.playlists.master.playlists;
+      if (playlists && playlists.length > 0) {
+        return Math.max(...playlists.map((p) => p.attributes.BANDWIDTH));
+      }
+    } catch (err) {}
+    return null;
+  }
 
-          // Adjust playback time by playback rate
-          const effectivePlaybackTime = currentTime / playbackRate
+  getSegmentDownloadBitrate() {
+    if (
+      this.tech.stats?.bandwidth !== undefined &&
+      this.tech.stats.bandwidth > 0
+    ) {
+      return this.tech.stats.bandwidth;
+    }
+    return null;
+  }
 
-          if (effectivePlaybackTime > 0) {
-            const bitsTransferred = stats.mediaBytesTransferred * 8
-            return bitsTransferred / effectivePlaybackTime
-          }
-        }
-      }
+  getNetworkDownloadBitrate() {
+    if (this.tech.throughput !== undefined && this.tech.throughput > 0) {
+      return this.tech.throughput;
+    }
+    return null;
+  }
 
-      // Fallback to VHS bandwidth estimates if stats not available
-      if (this.tech.bandwidth !== undefined && this.tech.bandwidth > 0) {
-        return this.tech.bandwidth
-      }
-      if (this.tech.systemBandwidth !== undefined && this.tech.systemBandwidth > 0) {
-        return this.tech.systemBandwidth
+  getContentBitratePlayback() {
+    try {
+      // Get the current active rendition's bitrate from manifest
+      const media = this.tech.playlists.media();
+      if (media && media.attributes) {
+        // Use AVERAGE-BANDWIDTH if available, fallback to BANDWIDTH
+        return (
+          media.attributes['AVERAGE-BANDWIDTH'] ||
+          media.attributes.BANDWIDTH ||
+          null
+        );
       }
-    } catch (err) { }
-    return null
+    } catch (err) {}
+    return null;
   }
 }
 
 ContribHlsTech.isUsing = function (tech) {
-  return !!tech.vhs
-}
+  return !!tech.vhs;
+};

package/src/techs/hls-js.js

@@ -47,23 +47,40 @@ export default class HlsJs {
 
   getContentBitratePlayback() {
     try {
-      if (this.tech.stats && this.player) {
-        const stats = this.tech.stats;
-        // Calculate actual playback bitrate based on content consumption
-        if (stats.mediaBytesTransferred > 0 && stats.mediaRequests > 0) {
-          const currentTime = this.player.currentTime(); // in seconds
-          const playbackRate = this.player.playbackRate() || 1;
-          const effectivePlaybackTime = currentTime / playbackRate;
+      // Get the current active level's bitrate from manifest
+      const level = this.tech.levels[this.tech.currentLevel];
+      if (level && level.bitrate) {
+        return level.bitrate;
+      }
+    } catch (err) {}
+    return null;
+  }
 
-          if (effectivePlaybackTime > 0) {
-            const bitsTransferred = stats.mediaBytesTransferred * 8;
-            return bitsTransferred / effectivePlaybackTime;
-          }
-        }
+  getManifestBitrate() {
+    try {
+      // Return highest available bitrate from all renditions
+      if (this.tech.levels && this.tech.levels.length > 0) {
+        return Math.max(...this.tech.levels.map(l => l.bitrate));
       }
     } catch (err) {}
     return null;
   }
+
+  getSegmentDownloadBitrate() {
+    try {
+      // VHS stats.bandwidth
+      if (this.tech.stats && this.tech.stats.bandwidth > 0)
+        return this.tech.stats.bandwidth;
+    } catch (err) {}
+    return null;
+  }
+
+  getNetworkDownloadBitrate() {
+    if (this.tech.throughput && this.tech.throughput > 0) {
+      return this.tech.throughput;
+    }
+    return null;
+  }
 }
 
 HlsJs.isUsing = function (tech) {

package/src/techs/shaka.js

@@ -18,6 +18,19 @@ export default class ShakaTech {
     return null;
   }
 
+  getManifestBitrate() {
+    try {
+      // Return highest available bitrate from all variants
+      const tracks = this.tech.getVariantTracks();
+      if (tracks && tracks.length > 0) {
+        return Math.max(
+          ...tracks.map((t) => t.videoBandwidth + (t.audioBandwidth || 0)),
+        );
+      }
+    } catch (err) {}
+    return null;
+  }
+
   getRenditionWidth(tech) {
     try {
       var tracks = this.tech.getVariantTracks();
@@ -51,18 +64,32 @@ export default class ShakaTech {
 
   getContentBitratePlayback() {
     try {
+      // Get the current variant's bitrate from manifest (streamBandwidth)
       var stats = this.tech.getStats();
-      if (stats) {
-        // Shaka's estimatedBandwidth is the actual measured network bandwidth
-        // This is the closest equivalent to playback bitrate calculation
-        if (stats.estimatedBandwidth && stats.estimatedBandwidth > 0) {
-          return stats.estimatedBandwidth;
-        }
+      if (stats && stats.streamBandwidth && stats.streamBandwidth > 0) {
+        return stats.streamBandwidth;
+      }
+    } catch (err) {}
+    return null;
+  }
 
-        // Fallback to streamBandwidth (bitrate of current variant from manifest)
-        if (stats.streamBandwidth && stats.streamBandwidth > 0) {
-          return stats.streamBandwidth;
-        }
+  getSegmentDownloadBitrate() {
+    try {
+      // Use estimatedBandwidth for measured bitrate
+      var stats = this.tech.getStats();
+      if (stats && stats.estimatedBandwidth > 0) {
+        return stats.estimatedBandwidth;
+      }
+    } catch (err) {}
+    return null;
+  }
+
+  getNetworkDownloadBitrate() {
+    try {
+      // Shaka: use estimatedBandwidth for download bitrate (no separate property)
+      var stats = this.tech.getStats();
+      if (stats && stats.estimatedBandwidth > 0) {
+        return stats.estimatedBandwidth;
       }
     } catch (err) {}
     return null;

package/src/tracker.js

@@ -12,6 +12,7 @@ import DaiAdsTracker from './ads/dai';
 export default class VideojsTracker extends nrvideo.VideoTracker {
   constructor(player, options) {
     super(player, options);
+
     this.isContentEnd = false;
     this.imaAdCuePoints = '';
     this.daiInitialized = false;
@@ -117,37 +118,28 @@ export default class VideojsTracker extends nrvideo.VideoTracker {
 
   // Measures: Actual content consumption rate during playback
   getContentBitratePlayback() {
-    const tech = this.player.tech({ IWillNotUseThisInPlugins: true });
-
-    // VHS/HLS support - calculate actual playback bitrate
-    if (tech?.vhs?.stats) {
-      const stats = tech.vhs.stats;
-
-      // Calculate actual playback bitrate based on content consumption
-      // This represents the bitrate at which content is being played back
-      if (stats.mediaBytesTransferred > 0 && stats.mediaRequests > 0) {
-        // Get total playback time (accounting for playback rate)
-        const currentTime = this.player.currentTime(); // in seconds
-        const playbackRate = this.player.playbackRate() || 1;
-
-        // Adjust playback time by playback rate
-        // If playing at 2x speed, you consume 2x the bitrate
-        const effectivePlaybackTime = currentTime / playbackRate;
-
-        if (effectivePlaybackTime > 0) {
-          const bitsTransferred = stats.mediaBytesTransferred * 8;
-          const playbackBitrate = bitsTransferred / effectivePlaybackTime;
-          return playbackBitrate;
-        }
+    try {
+      const tech = this.player.tech({ IWillNotUseThisInPlugins: true });
+
+      // 1. Get the current active rendition (The most accurate "Playback Bitrate")
+      if (tech?.vhs?.playlists?.media()) {
+        const activePlaylist = tech.vhs.playlists.media();
+        // Use AVERAGE-BANDWIDTH if available, fallback to BANDWIDTH
+        return (
+          activePlaylist.attributes['AVERAGE-BANDWIDTH'] ||
+          activePlaylist.attributes.BANDWIDTH ||
+          null
+        );
       }
-    }
 
-    // Support for other tech implementations using the same formula
-    const techWrapper = this.getTech();
-    if (techWrapper?.getBitrate) {
-      return techWrapper.getBitrate();
+      // 2. Fallback to tech wrappers (Shaka/Hls.js) if they have a getBitrate method
+      const techWrapper = this.getTech();
+      if (techWrapper?.getBitrate) {
+        return techWrapper.getBitrate();
+      }
+    } catch (err) {
+      /* ignore */
     }
-
     return null;
   }
 
@@ -158,14 +150,65 @@ export default class VideojsTracker extends nrvideo.VideoTracker {
     }
   }
 
-  getRenditionBitrate() {
-    // Returns the target bitrate from the manifest (static, changes only on rendition switch)
-    // This is different from getBitrate() which returns the actual measured bitrate
-    let tech = this.getTech();
+  getManifestBitrate() {
+    try {
+      const tech = this.player.tech({ IWillNotUseThisInPlugins: true });
+      // tech.vhs.playlists.master.playlists contains the array of all renditions
+      const allRenditions = tech?.vhs?.playlists?.master?.playlists;
+
+      if (allRenditions && allRenditions.length > 0) {
+        // Find the highest BANDWIDTH value in the list
+        const maxBitrate = Math.max(
+          ...allRenditions.map((p) => p.attributes.BANDWIDTH || 0),
+        );
+        return maxBitrate > 0 ? maxBitrate : null;
+      }
+
+      // Fallback to tech wrappers (Shaka/Hls.js)
+      const techWrapper = this.getTech();
+      if (techWrapper?.getManifestBitrate) {
+        return techWrapper.getManifestBitrate();
+      }
+    } catch (e) {
+      /* ignore */
+    }
+    return null;
+  }
+
+  getSegmentDownloadBitrate() {
+    try {
+      const tech = this.player.tech({ IWillNotUseThisInPlugins: true });
 
-    if (tech && tech.getRenditionBitrate) {
-      return tech.getRenditionBitrate();
+      // VHS stats.bandwidth
+      if (tech?.vhs?.stats?.bandwidth && tech.vhs.stats.bandwidth > 0) {
+        return tech.vhs.stats.bandwidth;
+      }
+
+      // Fallback to tech wrappers (Shaka/Hls.js)
+      const techWrapper = this.getTech();
+      if (techWrapper?.getSegmentDownloadBitrate) {
+        return techWrapper.getSegmentDownloadBitrate();
+      }
+    } catch (err) {
+      /* ignore */
+    }
+    return null;
+  }
+
+  getNetworkDownloadBitrate() {
+    const tech = this.player.tech({ IWillNotUseThisInPlugins: true });
+
+    if (tech?.vhs?.throughput && tech.vhs.throughput > 0) {
+      return tech.vhs.throughput;
+    }
+
+    // Fallback to tech wrapper implementation
+    const techWrapper = this.getTech();
+    if (techWrapper?.getNetworkDownloadBitrate) {
+      return techWrapper.getNetworkDownloadBitrate();
     }
+
+    return null;
   }
 
   getRenditionHeight() {
@@ -248,7 +291,6 @@ export default class VideojsTracker extends nrvideo.VideoTracker {
     this.player.on('waiting', this.onWaiting);
     this.player.on('timeupdate', this.onTimeupdate);
     this.player.on('ads-allpods-completed', this.OnAdsAllpodsCompleted);
-
     this.player.on('stream-manager', this.onStreamManager);
   }
 
@@ -271,7 +313,6 @@ export default class VideojsTracker extends nrvideo.VideoTracker {
     this.player.off('waiting', this.onWaiting);
     this.player.off('timeupdate', this.onTimeupdate);
     this.player.off('ads-allpods-completed', this.OnAdsAllpodsCompleted);
-
     this.player.off('stream-manager', this.onStreamManager);
   }