@newrelic/video-videojs 4.1.1 → 4.2.0

package/src/register-plugin.js

@@ -12,8 +12,8 @@ if (typeof videojs !== 'undefined') {
    */
   registerPlugin('newrelic', function (options) {
     if (!this.newrelictracker) {
-      this.newrelictracker = new nrvideo.VideojsTracker(this);
-      nrvideo.Core.addTracker(this.newrelictracker);
+      this.newrelictracker = new nrvideo.VideojsTracker(this, options);
+      nrvideo.Core.addTracker(this.newrelictracker, options);
     }
     return this.newrelictracker;
   });

package/src/techs/contrib-hls.js

@@ -15,7 +15,7 @@ export default class ContribHlsTech {
   getRenditionBitrate() {
     try {
       var media = this.tech.playlists.media();
-      if (media && media.attributes) return media.attributes.BANDWIDTH;
+      if (media && media.attributes) return Math.round(media.attributes.BANDWIDTH);
     } catch (err) {}
     return null;
   }
@@ -50,7 +50,7 @@ export default class ContribHlsTech {
       // 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));
+        return Math.round(Math.max(...playlists.map((p) => p.attributes.BANDWIDTH)));
       }
     } catch (err) {}
     return null;
@@ -61,14 +61,14 @@ export default class ContribHlsTech {
       this.tech.stats?.bandwidth !== undefined &&
       this.tech.stats.bandwidth > 0
     ) {
-      return this.tech.stats.bandwidth;
+      return Math.round(this.tech.stats.bandwidth);
     }
     return null;
   }
 
   getNetworkDownloadBitrate() {
     if (this.tech.throughput !== undefined && this.tech.throughput > 0) {
-      return this.tech.throughput;
+      return Math.round(this.tech.throughput);
     }
     return null;
   }
@@ -79,11 +79,10 @@ export default class ContribHlsTech {
       const media = this.tech.playlists.media();
       if (media && media.attributes) {
         // Use AVERAGE-BANDWIDTH if available, fallback to BANDWIDTH
-        return (
-          media.attributes['AVERAGE-BANDWIDTH'] ||
+        const bitrate = media.attributes['AVERAGE-BANDWIDTH'] ||
           media.attributes.BANDWIDTH ||
-          null
-        );
+          null;
+        return bitrate !== null ? Math.round(bitrate) : null;
       }
     } catch (err) {}
     return null;

package/src/techs/hls-js.js

@@ -19,7 +19,7 @@ export default class HlsJs {
   getRenditionBitrate(tech) {
     try {
       var level = this.tech.levels[this.tech.currentLevel];
-      if (level && level.bitrate) return level.bitrate;
+      if (level && level.bitrate) return Math.round(level.bitrate);
     } catch (err) {}
     return null;
   }
@@ -50,7 +50,7 @@ export default class HlsJs {
       // Get the current active level's bitrate from manifest
       const level = this.tech.levels[this.tech.currentLevel];
       if (level && level.bitrate) {
-        return level.bitrate;
+        return Math.round(level.bitrate);
       }
     } catch (err) {}
     return null;
@@ -60,7 +60,7 @@ export default class HlsJs {
     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));
+        return Math.round(Math.max(...this.tech.levels.map(l => l.bitrate)));
       }
     } catch (err) {}
     return null;
@@ -70,14 +70,14 @@ export default class HlsJs {
     try {
       // VHS stats.bandwidth
       if (this.tech.stats && this.tech.stats.bandwidth > 0)
-        return this.tech.stats.bandwidth;
+        return Math.round(this.tech.stats.bandwidth);
     } catch (err) {}
     return null;
   }
 
   getNetworkDownloadBitrate() {
     if (this.tech.throughput && this.tech.throughput > 0) {
-      return this.tech.throughput;
+      return Math.round(this.tech.throughput);
     }
     return null;
   }

package/src/techs/shaka.js

@@ -13,7 +13,8 @@ export default class ShakaTech {
 
   getRenditionBitrate(tech) {
     try {
-      return this.tech.getStats().streamBandwidth;
+      const bitrate = this.tech.getStats().streamBandwidth;
+      return bitrate ? Math.round(bitrate) : null;
     } catch (err) {}
     return null;
   }
@@ -23,9 +24,9 @@ export default class ShakaTech {
       // Return highest available bitrate from all variants
       const tracks = this.tech.getVariantTracks();
       if (tracks && tracks.length > 0) {
-        return Math.max(
+        return Math.round(Math.max(
           ...tracks.map((t) => t.videoBandwidth + (t.audioBandwidth || 0)),
-        );
+        ));
       }
     } catch (err) {}
     return null;
@@ -67,7 +68,7 @@ export default class ShakaTech {
       // Get the current variant's bitrate from manifest (streamBandwidth)
       var stats = this.tech.getStats();
       if (stats && stats.streamBandwidth && stats.streamBandwidth > 0) {
-        return stats.streamBandwidth;
+        return Math.round(stats.streamBandwidth);
       }
     } catch (err) {}
     return null;
@@ -78,7 +79,7 @@ export default class ShakaTech {
       // Use estimatedBandwidth for measured bitrate
       var stats = this.tech.getStats();
       if (stats && stats.estimatedBandwidth > 0) {
-        return stats.estimatedBandwidth;
+        return Math.round(stats.estimatedBandwidth);
       }
     } catch (err) {}
     return null;
@@ -89,7 +90,7 @@ export default class ShakaTech {
       // Shaka: use estimatedBandwidth for download bitrate (no separate property)
       var stats = this.tech.getStats();
       if (stats && stats.estimatedBandwidth > 0) {
-        return stats.estimatedBandwidth;
+        return Math.round(stats.estimatedBandwidth);
       }
     } catch (err) {}
     return null;

package/src/tracker.js

@@ -8,17 +8,86 @@ import ImaAdsTracker from './ads/ima';
 import BrightcoveImaAdsTracker from './ads/brightcove-ima';
 import FreewheelAdsTracker from './ads/freewheel';
 import DaiAdsTracker from './ads/dai';
+import MediaTailorAdsTracker from './ads/media-tailor';
+
+/**
+ * Explicit ad tracking modes. Pass via config.ad.type.
+ *
+ * CSAI (Client-Side Ad Insertion)
+ *   All CSAI frameworks share the adsready event path. The tracker auto-detects
+ *   the right framework (Brightcove IMA → IMA → Freewheel → generic) — no sub-type needed.
+ *
+ * SSAI (Server-Side Ad Insertion) — sub-type is always required.
+ *   Each SSAI platform has its own SDK and a different activation path.
+ *   Cannot be auto-detected — declare which one you are using.
+ *   SSAI.DAI — Google DAI (google.ima.dai.api)
+ *   SSAI.MT  — AWS MediaTailor
+ *
+ * If config.ad is not set, no ad tracking runs (safe default).
+ * To add a new SSAI platform: add a key to SSAI — validation derives from this object.
+ */
+export const AD_TRACKING = {
+  CSAI: 'csai',
+  SSAI: Object.freeze({
+    DAI: 'ssai:dai',
+    MT:  'ssai:mt',
+  }),
+};
 
 export default class VideojsTracker extends nrvideo.VideoTracker {
   constructor(player, options) {
     super(player, options);
-
+    this.options = options;
     this.isContentEnd = false;
     this.imaAdCuePoints = '';
     this.daiInitialized = false;
+    this.adTracking = options?.config?.ad?.type || null;
+
+    // When options are provided but config.ad is not declared, no ad tracking
+    // will run. Warn so the caller knows to set it explicitly.
+    if (options && !this.adTracking) {
+      nrvideo.Log.warn(
+        'VideojsTracker: config.ad not set — no ad tracking will run. ' +
+        'Set config.ad.type to enable it (e.g. AD_TRACKING.CSAI, AD_TRACKING.SSAI.MT).'
+      );
+    }
+
+    // Merge config.ad options (segmentPrefix, trackingUrl) into the internal
+    // mediatailor object that MediaTailorAdsTracker reads.
+    if (this.adTracking === AD_TRACKING.SSAI.MT) {
+      const adConfig = options?.config?.ad || {};
+      this.options = Object.assign({}, this.options, {
+        mediatailor: {
+          segmentPrefix: adConfig.segmentPrefix,
+          trackingUrl:   adConfig.trackingUrl,
+          ...this.options?.mediatailor,
+        },
+      });
+    }
+
     nrvideo.Core.addTracker(this, options);
   }
 
+  /**
+   * Sets the ad tracking mode at runtime.
+   * Must be called before the first loadstart / adsready event to take effect.
+   * @param {'csai'|'ssai:dai'|'ssai:mt'} type
+   */
+  setAdTracking(type) {
+    const valid = [
+      AD_TRACKING.CSAI,
+      ...Object.values(AD_TRACKING.SSAI),
+    ];
+    if (!valid.includes(type)) {
+      nrvideo.Log.warn(
+        `VideojsTracker.setAdTracking: unknown value "${type}". Valid values: ${valid.join(', ')}`
+      );
+      return;
+    }
+    this.adTracking = type;
+    nrvideo.Log.debug(`VideojsTracker: adTracking set to "${type}"`);
+  }
+
   getTech() {
     let tech = this.player.tech({ IWillNotUseThisInPlugins: true });
 
@@ -125,17 +194,18 @@ export default class VideojsTracker extends nrvideo.VideoTracker {
       if (tech?.vhs?.playlists?.media()) {
         const activePlaylist = tech.vhs.playlists.media();
         // Use AVERAGE-BANDWIDTH if available, fallback to BANDWIDTH
-        return (
+        const bitrate =
           activePlaylist.attributes['AVERAGE-BANDWIDTH'] ||
           activePlaylist.attributes.BANDWIDTH ||
-          null
-        );
+          null;
+        return bitrate !== null ? Math.round(bitrate) : null;
       }
 
       // 2. Fallback to tech wrappers (Shaka/Hls.js) if they have a getBitrate method
       const techWrapper = this.getTech();
       if (techWrapper?.getBitrate) {
-        return techWrapper.getBitrate();
+        const bitrate = techWrapper.getBitrate();
+        return bitrate !== null ? Math.round(bitrate) : null;
       }
     } catch (err) {
       /* ignore */
@@ -161,13 +231,14 @@ export default class VideojsTracker extends nrvideo.VideoTracker {
         const maxBitrate = Math.max(
           ...allRenditions.map((p) => p.attributes.BANDWIDTH || 0),
         );
-        return maxBitrate > 0 ? maxBitrate : null;
+        return maxBitrate > 0 ? Math.round(maxBitrate) : null;
       }
 
       // Fallback to tech wrappers (Shaka/Hls.js)
       const techWrapper = this.getTech();
       if (techWrapper?.getManifestBitrate) {
-        return techWrapper.getManifestBitrate();
+        const bitrate = techWrapper.getManifestBitrate();
+        return bitrate !== null ? Math.round(bitrate) : null;
       }
     } catch (e) {
       /* ignore */
@@ -181,13 +252,14 @@ export default class VideojsTracker extends nrvideo.VideoTracker {
 
       // VHS stats.bandwidth
       if (tech?.vhs?.stats?.bandwidth && tech.vhs.stats.bandwidth > 0) {
-        return tech.vhs.stats.bandwidth;
+        return Math.round(tech.vhs.stats.bandwidth);
       }
 
       // Fallback to tech wrappers (Shaka/Hls.js)
       const techWrapper = this.getTech();
       if (techWrapper?.getSegmentDownloadBitrate) {
-        return techWrapper.getSegmentDownloadBitrate();
+        const bitrate = techWrapper.getSegmentDownloadBitrate();
+        return bitrate !== null ? Math.round(bitrate) : null;
       }
     } catch (err) {
       /* ignore */
@@ -199,13 +271,14 @@ export default class VideojsTracker extends nrvideo.VideoTracker {
     const tech = this.player.tech({ IWillNotUseThisInPlugins: true });
 
     if (tech?.vhs?.throughput && tech.vhs.throughput > 0) {
-      return tech.vhs.throughput;
+      return Math.round(tech.vhs.throughput);
     }
 
     // Fallback to tech wrapper implementation
     const techWrapper = this.getTech();
     if (techWrapper?.getNetworkDownloadBitrate) {
-      return techWrapper.getNetworkDownloadBitrate();
+      const bitrate = techWrapper.getNetworkDownloadBitrate();
+      return bitrate !== null ? Math.round(bitrate) : null;
     }
 
     return null;
@@ -272,6 +345,7 @@ export default class VideojsTracker extends nrvideo.VideoTracker {
     this.onTimeupdate = this.onTimeupdate.bind(this);
     this.OnAdsAllpodsCompleted = this.OnAdsAllpodsCompleted.bind(this);
     this.onStreamManager = this.onStreamManager.bind(this);
+    this.onCanPlayThrough = this.onCanPlayThrough.bind(this);
 
     this.player.on('loadstart', this.onDownload);
     this.player.on('loadeddata', this.onDownload);
@@ -292,6 +366,7 @@ export default class VideojsTracker extends nrvideo.VideoTracker {
     this.player.on('timeupdate', this.onTimeupdate);
     this.player.on('ads-allpods-completed', this.OnAdsAllpodsCompleted);
     this.player.on('stream-manager', this.onStreamManager);
+    this.player.on('canplaythrough', this.onCanPlayThrough);
   }
 
   unregisterListeners() {
@@ -314,15 +389,31 @@ export default class VideojsTracker extends nrvideo.VideoTracker {
     this.player.off('timeupdate', this.onTimeupdate);
     this.player.off('ads-allpods-completed', this.OnAdsAllpodsCompleted);
     this.player.off('stream-manager', this.onStreamManager);
+    this.player.off('canplaythrough', this.onCanPlayThrough);
   }
 
   onDownload(e) {
     this.sendDownload({ state: e.type });
+
+    if (
+      this.adTracking === AD_TRACKING.SSAI.MT &&
+      !this.adsTracker &&
+      e.type === 'loadstart'
+    ) {
+      nrvideo.Log.debug('VideojsTracker: Creating MediaTailorAdsTracker');
+      this.setAdsTracker(new MediaTailorAdsTracker(this.player, this.options));
+      // MediaTailor SSAI starts with content, not ads (unlike client-side frameworks)
+      this.adsTracker.setIsAd(false);
+    }
   }
 
   // DAI methods
   onStreamManager(event) {
-    if (!this.adsTracker && event.StreamManager) {
+    if (
+      this.adTracking === AD_TRACKING.SSAI.DAI &&
+      !this.adsTracker &&
+      event.StreamManager
+    ) {
       const daiTracker = new DaiAdsTracker(this.player);
       daiTracker.setStreamManager(event.StreamManager);
       this.setAdsTracker(daiTracker);
@@ -331,20 +422,29 @@ export default class VideojsTracker extends nrvideo.VideoTracker {
   // DAI methods end
 
   onAdsready() {
+    // SSAI platforms never fire adsready — skip when an SSAI type is explicitly set.
+    if (Object.values(AD_TRACKING.SSAI).includes(this.adTracking)) return;
+
+    // config.ad.type is not set — warn and fall back to auto-detection.
+    if (!this.adTracking) {
+      nrvideo.Log.warn(
+        'VideojsTracker: adsready fired but config.ad.type is not set — ' +
+        'attempting CSAI auto-detection for backward compatibility.'
+      );
+    }
+
     if (!this.adsTracker) {
       if (BrightcoveImaAdsTracker.isUsing(this.player)) {
-        // BC IMA
+        nrvideo.Log.debug('VideojsTracker: auto-detected BrightcoveImaAdsTracker');
         this.setAdsTracker(new BrightcoveImaAdsTracker(this.player));
       } else if (ImaAdsTracker.isUsing(this.player)) {
-        // IMA
+        nrvideo.Log.debug('VideojsTracker: auto-detected ImaAdsTracker');
         this.setAdsTracker(new ImaAdsTracker(this.player));
       } else if (FreewheelAdsTracker.isUsing(this.player)) {
-        // FW
-
+        nrvideo.Log.debug('VideojsTracker: auto-detected FreewheelAdsTracker');
         this.setAdsTracker(new FreewheelAdsTracker(this.player));
-        // } else if (OnceAdsTracker.isUsing(this)) { // Once
       } else {
-        // Generic
+        nrvideo.Log.debug('VideojsTracker: no specific CSAI framework detected, using generic VideojsAdsTracker');
         this.setAdsTracker(new VideojsAdsTracker(this.player));
       }
     }
@@ -369,15 +469,50 @@ export default class VideojsTracker extends nrvideo.VideoTracker {
     this.FreewheelAdsCompleted = true;
   }
 
+  /**
+   * Check if ads tracker is currently in ad mode
+   * @returns {boolean} True if ads are playing
+   */
+  isAdsTrackerActive() {
+    // For CSAI: videojs-contrib-ads manages ad state exclusively
+    if (this.player.ads) {
+      return this.player.ads.state === 'ads-playback';
+    }
+    // For SSAI (no player.ads): check tracker's isAd flag (manually toggled)
+    return this.adsTracker && this.adsTracker.isAd && this.adsTracker.isAd();
+  }
+
   onPlay() {
     this.sendRequest();
   }
 
   onPause() {
+    // Don't send CONTENT_PAUSE if ads are playing (ads tracker handles it)
+    if (this.isAdsTrackerActive()) {
+      return;
+    }
+    // Don't send CONTENT_PAUSE if video has ended (CONTENT_END will be sent instead)
+    if (this.player.ended()) {
+      return;
+    }
     this.sendPause();
   }
 
+  onCanPlayThrough() {
+    // Don't send CONTENT_BUFFER_END if ads are playing (ads tracker handles it)
+    if (this.isAdsTrackerActive()) {
+      return;
+    }
+    // Send BUFFER_END when buffer fills, even if paused
+    // This ensures accurate buffer duration metrics when user pauses during buffering
+    this.sendBufferEnd();
+  }
+
   onPlaying() {
+    // Don't send CONTENT_RESUME if ads are playing (ads tracker handles it)
+    if (this.isAdsTrackerActive()) {
+      return;
+    }
     this.sendResume();
     this.sendBufferEnd();
   }
@@ -402,10 +537,18 @@ export default class VideojsTracker extends nrvideo.VideoTracker {
   }
 
   onSeeking() {
+    // Don't send CONTENT_SEEK_START if ads are playing (ads tracker handles it)
+    if (this.isAdsTrackerActive()) {
+      return;
+    }
     this.sendSeekStart();
   }
 
   onSeeked() {
+    // Don't send CONTENT_SEEK_END if ads are playing (ads tracker handles it)
+    if (this.isAdsTrackerActive()) {
+      return;
+    }
     this.sendSeekEnd();
   }
 
@@ -420,6 +563,10 @@ export default class VideojsTracker extends nrvideo.VideoTracker {
   }
 
   onWaiting(e) {
+    // Don't send CONTENT_BUFFER_START if ads are playing (ads tracker handles it)
+    if (this.isAdsTrackerActive()) {
+      return;
+    }
     this.sendBufferStart();
   }
 
@@ -430,6 +577,11 @@ export default class VideojsTracker extends nrvideo.VideoTracker {
   }
 }
 
+// Attach AD_TRACKING and Log as static properties so UMD callers can use
+// VideojsTracker.AD_TRACKING and VideojsTracker.Log without importing named exports.
+VideojsTracker.AD_TRACKING = AD_TRACKING;
+VideojsTracker.Log = nrvideo.Log;
+
 // Static members
 export {
   HlsJsTech,
@@ -439,4 +591,6 @@ export {
   ImaAdsTracker,
   BrightcoveImaAdsTracker,
   FreewheelAdsTracker,
+  DaiAdsTracker,
+  MediaTailorAdsTracker,
 };