@newrelic/video-videojs 4.0.2 → 4.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newrelic/video-videojs",
-  "version": "4.0.2",
+  "version": "4.1.0",
   "description": "New relic tracker for Videojs",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -30,16 +30,13 @@
     "@babel/core": "^7.24.5",
     "@babel/plugin-transform-modules-commonjs": "^7.24.1",
     "@babel/preset-env": "^7.24.5",
-    "aws-sdk": "^2.920.0",
     "@newrelic/newrelic-oss-cli": "^0.1.2",
+    "aws-sdk": "^2.920.0",
     "babel-loader": "^9.1.3",
     "videojs-ima": "2.1.0",
     "webpack": "^5.91.0",
     "webpack-cli": "^4.9.2"
   },
-  "dependencies": {
-    "@newrelic/video-core": "^4.0.0"
-  },
   "files": [
     "THIRD_PARTY_NOTICES.md",
     "dist",
@@ -50,5 +47,8 @@
   ],
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@newrelic/video-core": "^4.0.0"
   }
 }

package/src/techs/contrib-hls.js

@@ -1,45 +1,95 @@
 export default class ContribHlsTech {
-  constructor (tech) {
-    this.tech = tech.vhs
+  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() {
+    // Calculate playback bitrate (actual content consumption rate)
+    return this.getContentBitratePlayback();
+  }
+
+  getManifestBitrate() {
+    try {
+      // 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;
+  }
+
+  getSegmentDownloadBitrate() {
+    if (
+      this.tech.stats?.bandwidth !== undefined &&
+      this.tech.stats.bandwidth > 0
+    ) {
+      return this.tech.stats.bandwidth;
+    }
+    return null;
+  }
+
+  getNetworkDownloadBitrate() {
+    if (this.tech.throughput !== undefined && this.tech.throughput > 0) {
+      return this.tech.throughput;
+    }
+    return null;
+  }
+
+  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;
   }
 }
 
 ContribHlsTech.isUsing = function (tech) {
-  return !!tech.vhs
-}
+  return !!tech.vhs;
+};

package/src/techs/hls-js.js

@@ -1,45 +1,88 @@
 export default class HlsJs {
-  constructor (tech) {
-    this.tech = tech.vhs_
+  constructor(tech) {
+    this.tech = tech.vhs_;
+    this.player = tech.el().player; // Store player reference for currentTime
   }
 
-  getResource (tech) {
-    return this.tech.url
+  getResource(tech) {
+    return this.tech.url;
   }
 
-  getRenditionName (tech) {
+  getRenditionName(tech) {
     try {
-      var level = this.tech.levels[this.tech.currentLevel]
-      if (level && level.name) return level.name
-    } catch (err) { }
-    return null
+      var level = this.tech.levels[this.tech.currentLevel];
+      if (level && level.name) return level.name;
+    } catch (err) {}
+    return null;
   }
 
-  getRenditionBitrate (tech) {
+  getRenditionBitrate(tech) {
     try {
-      var level = this.tech.levels[this.tech.currentLevel]
-      if (level && level.bitrate) return level.bitrate
-    } catch (err) { }
-    return null
+      var level = this.tech.levels[this.tech.currentLevel];
+      if (level && level.bitrate) return level.bitrate;
+    } catch (err) {}
+    return null;
   }
 
-  getRenditionWidth (tech) {
+  getRenditionWidth(tech) {
     try {
-      var level = this.tech.levels[this.tech.currentLevel]
-      if (level && level.width) return level.width
-    } catch (err) { }
-    return null
+      var level = this.tech.levels[this.tech.currentLevel];
+      if (level && level.width) return level.width;
+    } catch (err) {}
+    return null;
   }
 
-  getRenditionHeight (tech) {
+  getRenditionHeight(tech) {
     try {
-      var level = this.tech.levels[this.tech.currentLevel]
-      if (level && level.height) return level.height
-    } catch (err) { }
-    return null
+      var level = this.tech.levels[this.tech.currentLevel];
+      if (level && level.height) return level.height;
+    } catch (err) {}
+    return null;
+  }
+
+  getBitrate() {
+    // Default uses playback bitrate (Method 4)
+    return this.getContentBitratePlayback();
+  }
+
+  getContentBitratePlayback() {
+    try {
+      // 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;
+  }
+
+  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) {
-  return !!tech.vhs_
-}
+  return !!tech.vhs_;
+};

package/src/techs/shaka.js

@@ -1,49 +1,101 @@
 export default class ShakaTech {
-  constructor (tech) {
-    this.tech = tech.shakaPlayer
+  constructor(tech) {
+    this.tech = tech.shakaPlayer;
+    this.player = tech.el().player; // Store player reference for playback bitrate calculation
   }
 
-  getSrc (tech) {
+  getSrc(tech) {
     try {
-      return this.tech.getManifestUri()
+      return this.tech.getManifestUri();
     } catch (err) {}
-    return null
+    return null;
   }
 
-  getRenditionBitrate (tech) {
+  getRenditionBitrate(tech) {
     try {
-      return this.tech.getStats().streamBandwidth
-    } catch (err) { }
-    return null
+      return this.tech.getStats().streamBandwidth;
+    } catch (err) {}
+    return null;
   }
 
-  getRenditionWidth (tech) {
+  getManifestBitrate() {
     try {
-      var tracks = this.tech.getVariantTracks()
+      // 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();
       for (var i in tracks) {
-        var track = tracks[i]
+        var track = tracks[i];
         if (track.active && track.type === 'video') {
-          return track.width
+          return track.width;
         }
       }
-    } catch (err) { }
-    return null
+    } catch (err) {}
+    return null;
   }
 
-  getRenditionHeight (tech) {
+  getRenditionHeight(tech) {
     try {
-      var tracks = this.tech.getVariantTracks()
+      var tracks = this.tech.getVariantTracks();
       for (var i in tracks) {
-        var track = tracks[i]
+        var track = tracks[i];
         if (track.active && track.type === 'video') {
-          return track.height
+          return track.height;
         }
       }
-    } catch (err) { }
-    return null
+    } catch (err) {}
+    return null;
+  }
+
+  getBitrate() {
+    // Calculate playback bitrate (actual content consumption rate)
+    return this.getContentBitratePlayback();
+  }
+
+  getContentBitratePlayback() {
+    try {
+      // Get the current variant's bitrate from manifest (streamBandwidth)
+      var stats = this.tech.getStats();
+      if (stats && stats.streamBandwidth && stats.streamBandwidth > 0) {
+        return stats.streamBandwidth;
+      }
+    } catch (err) {}
+    return null;
+  }
+
+  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;
   }
 }
 
 ShakaTech.isUsing = function (tech) {
-  return !!tech.shakaPlayer
-}
+  return !!tech.shakaPlayer;
+};

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;
@@ -112,176 +113,102 @@ export default class VideojsTracker extends nrvideo.VideoTracker {
   }
 
   getBitrate() {
-    let videoBitrate = 0;
-    let audioBitrate = 0;
-    let totalBitrate = 0;
+    return this.getContentBitratePlayback();
+  }
 
-    if (this.player) {
+  // Measures: Actual content consumption rate during playback
+  getContentBitratePlayback() {
+    try {
       const tech = this.player.tech({ IWillNotUseThisInPlugins: true });
 
-      if (tech) {
-        let playlists, currentMedia;
-
-        // Method 1: Try VHS (Video HTTP Streaming) - most common for HLS/DASH
-        if (tech.vhs && tech.vhs.playlists && tech.vhs.playlists.media) {
-          playlists = tech.vhs.playlists;
-          currentMedia = tech.vhs.playlists.media();
-        } else if (tech.hls && tech.hls.playlists && tech.hls.playlists.media) {
-          playlists = tech.hls.playlists;
-          currentMedia = tech.hls.playlists.media();
-        }
-
-        if (currentMedia && currentMedia.attributes) {
-          if (currentMedia.attributes.BANDWIDTH) {
-            videoBitrate = currentMedia.attributes.BANDWIDTH;
-          }
-
-          // Get audio bitrate if available
-          const audioTracks = this.player.audioTracks();
-          let activeAudioTrack;
-
-          if (audioTracks && audioTracks.length > 0) {
-            for (let i = 0; i < audioTracks.length; i++) {
-              if (audioTracks[i].enabled) {
-                activeAudioTrack = audioTracks[i];
-                break;
-              }
-            }
-          }
-
-          if (activeAudioTrack && currentMedia.attributes.AUDIO) {
-            let masterPlaylist;
-            if (playlists) {
-              masterPlaylist = playlists.master || playlists.main;
-            }
-
-            if (
-              masterPlaylist &&
-              masterPlaylist.mediaGroups &&
-              masterPlaylist.mediaGroups.AUDIO
-            ) {
-              const audioGroup =
-                masterPlaylist.mediaGroups.AUDIO[currentMedia.attributes.AUDIO];
-              const audioMediaInfo =
-                audioGroup && audioGroup[activeAudioTrack.id];
-
-              if (
-                audioMediaInfo &&
-                audioMediaInfo.playlists &&
-                audioMediaInfo.playlists[0]
-              ) {
-                const audioPlaylist = audioMediaInfo.playlists[0].attributes;
-                if (audioPlaylist && audioPlaylist.BANDWIDTH) {
-                  audioBitrate = audioPlaylist.BANDWIDTH;
-                }
-              }
-            }
-          }
-
-          totalBitrate = videoBitrate + audioBitrate;
-
-          return totalBitrate; // Return in bps
-        }
-
-        // Method 2: Try Shaka Player
-        const shakaPlayer =
-          tech.shakaPlayer_ || tech.shaka_ || tech.shakaPlayer;
-        if (shakaPlayer && typeof shakaPlayer.getStats === 'function') {
-          const stats = shakaPlayer.getStats();
-          if (stats && stats.streamBandwidth) {
-            return stats.streamBandwidth;
-          }
-        }
-
-        // Method 3: Try HLS.js
-        const hlsJs = tech.hls_;
-        if (hlsJs && hlsJs.levels && hlsJs.currentLevel >= 0) {
-          const currentLevel = hlsJs.levels[hlsJs.currentLevel];
-          if (currentLevel && currentLevel.bitrate) {
-            return currentLevel.bitrate;
-          }
-        }
+      // 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
+        );
       }
 
-      // Method 4: Try DASH.js
-      let dashPlayer;
-      if (this.player.mediaPlayer) {
-        dashPlayer = this.player.mediaPlayer;
-      } else if (this.player.dash && this.player.dash.mediaPlayer) {
-        dashPlayer = this.player.dash.mediaPlayer;
+      // 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;
+  }
 
-      if (
-        dashPlayer &&
-        typeof dashPlayer.getQualityFor === 'function' &&
-        typeof dashPlayer.getBitrateInfoListFor === 'function'
-      ) {
-        // Get audio bitrate
-        const audioQuality = dashPlayer.getQualityFor('audio');
-        const audioBitrateList = dashPlayer.getBitrateInfoListFor('audio');
-        if (
-          audioQuality !== undefined &&
-          audioBitrateList &&
-          audioBitrateList[audioQuality] &&
-          audioBitrateList[audioQuality].bitrate
-        ) {
-          audioBitrate = audioBitrateList[audioQuality].bitrate;
-        }
-
-        // Get video bitrate
-        const videoQuality = dashPlayer.getQualityFor('video');
-        const videoBitrateList = dashPlayer.getBitrateInfoListFor('video');
-        if (
-          videoQuality !== undefined &&
-          videoBitrateList &&
-          videoBitrateList[videoQuality] &&
-          videoBitrateList[videoQuality].bitrate
-        ) {
-          videoBitrate = videoBitrateList[videoQuality].bitrate;
-        } else {
-          videoBitrate = videoBitrate || 0;
-        }
-
-        totalBitrate = audioBitrate + videoBitrate;
-        return totalBitrate;
-      }
+  getRenditionName() {
+    let tech = this.getTech();
+    if (tech && tech.getRenditionName) {
+      return tech.getRenditionName();
     }
+  }
 
-    // Fallback: Try tech-specific implementations from your wrappers
-    const techWrapper = this.getTech();
-    if (techWrapper) {
-      if (
-        techWrapper.getBitrate &&
-        typeof techWrapper.getBitrate === 'function'
-      ) {
-        return techWrapper.getBitrate();
+  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;
       }
 
-      if (
-        techWrapper.tech &&
-        techWrapper.tech.stats &&
-        techWrapper.tech.stats.bandwidth
-      ) {
-        return techWrapper.tech.stats.bandwidth;
+      // Fallback to tech wrappers (Shaka/Hls.js)
+      const techWrapper = this.getTech();
+      if (techWrapper?.getManifestBitrate) {
+        return techWrapper.getManifestBitrate();
       }
+    } catch (e) {
+      /* ignore */
     }
-
     return null;
   }
 
-  getRenditionName() {
-    let tech = this.getTech();
-    if (tech && tech.getRenditionName) {
-      return tech.getRenditionName();
+  getSegmentDownloadBitrate() {
+    try {
+      const tech = this.player.tech({ IWillNotUseThisInPlugins: true });
+
+      // 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;
   }
 
-  getRenditionBitrate() {
-    let tech = this.getTech();
+  getNetworkDownloadBitrate() {
+    const tech = this.player.tech({ IWillNotUseThisInPlugins: true });
+
+    if (tech?.vhs?.throughput && tech.vhs.throughput > 0) {
+      return tech.vhs.throughput;
+    }
 
-    if (tech && tech.getRenditionBitrate) {
-      return tech.getRenditionBitrate();
+    // Fallback to tech wrapper implementation
+    const techWrapper = this.getTech();
+    if (techWrapper?.getNetworkDownloadBitrate) {
+      return techWrapper.getNetworkDownloadBitrate();
     }
+
+    return null;
   }
 
   getRenditionHeight() {
@@ -364,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);
   }
 
@@ -387,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);
   }