@newrelic/video-videojs 4.1.2 → 4.2.1

package/src/ads/utils/mt-constants.js

@@ -36,7 +36,8 @@ export const DASH_SCTE35_EVENT_STREAM_SELECTOR =
 export const HLS_MIME_TYPE = 'application/vnd.apple.mpegurl'; // MIME type used to detect Safari/native HLS playback support
 
 // MediaTailor URL Patterns
-export const MT_SEGMENT_PATTERN = 'segments.mediatailor'; // Identifies MediaTailor ad segments
+export const MT_SEGMENT_PATTERN = 'segments.mediatailor'; // Identifies MediaTailor ad segments (AWS default hostname)
+export const MT_DEFAULT_AD_SEGMENT_PATH = '/tm/'; // Default ad-segment path per AWS CDN integration guide (custom-CDN setups)
 
 export const TRACKING_API_TIMEOUT_MS = 5000; // Keep tracking metadata requests within the guide's 5s end-to-end budget
 export const DEFAULT_LIVE_POLL_INTERVAL_MS = 5000; // Temporary fallback until manifest metadata provides cadence

package/src/ads/utils/mt.js

@@ -3,6 +3,11 @@
  * Helper functions for AWS MediaTailor ad tracking
  */
 
+import nrvideo from '@newrelic/video-core';
+
+const nrvideoCore = nrvideo.default || nrvideo;
+const Log = nrvideoCore.Log;
+
 import {
   DASH_MANIFEST_EXTENSION,
   DASH_SCTE35_EVENT_STREAM_SELECTOR,
@@ -21,6 +26,7 @@ import {
   MT_HLS_CUE_IN_TAG,
   MT_HLS_CUE_OUT_TAG,
   MT_SEGMENT_PATTERN,
+  MT_DEFAULT_AD_SEGMENT_PATH,
   MIN_AD_DURATION,
   AD_TIMING_TOLERANCE,
   SCTE35_SCHEME_MARKER,
@@ -84,16 +90,30 @@ export function buildTrackingEndpointUrl(manifestUrl) {
 /**
  * Checks if segment is a MediaTailor ad segment
  */
-export function isMediaTailorSegment(segment) {
-  // Check MAP URL for MediaTailor pattern
-  if (segment.map && segment.map.uri && segment.map.uri.includes(MT_SEGMENT_PATTERN)) {
-    return true;
-  }
-  // Check segment URL for MediaTailor pattern
-  if (segment.uri && segment.uri.includes(MT_SEGMENT_PATTERN)) {
-    return true;
-  }
-  return false;
+export function isMediaTailorSegment(segment, { adSegmentPrefix } = {}) {
+  const candidates = [MT_SEGMENT_PATTERN, MT_DEFAULT_AD_SEGMENT_PATH];
+  if (adSegmentPrefix) candidates.push(adSegmentPrefix);
+
+  const mapUri = (segment.map && segment.map.uri) || '';
+  const segUri = segment.uri || '';
+
+  return candidates.some(
+    (marker) => mapUri.includes(marker) || segUri.includes(marker),
+  );
+}
+
+export function whichAdSegmentMarker(segment, { adSegmentPrefix } = {}) {
+  const labeled = [
+    { marker: MT_SEGMENT_PATTERN,        label: 'aws-hostname (segments.mediatailor)' },
+    { marker: MT_DEFAULT_AD_SEGMENT_PATH, label: 'default-cdn-path (/tm/)' },
+  ];
+  if (adSegmentPrefix) labeled.push({ marker: adSegmentPrefix, label: `custom-prefix (${adSegmentPrefix})` });
+
+  const mapUri = (segment.map && segment.map.uri) || '';
+  const segUri = segment.uri || '';
+
+  const hit = labeled.find(({ marker }) => mapUri.includes(marker) || segUri.includes(marker));
+  return hit ? hit.label : null;
 }
 
 /**
@@ -350,7 +370,7 @@ export function parseHlsManifestForAdBreaks(manifestText) {
 /**
  * Detects ads from VHS playlist using discontinuityStarts and MediaTailor segments
  */
-export function detectAdBreaksFromVhsPlaylist(playlist) {
+export function detectAdBreaksFromVhsPlaylist(playlist, { adSegmentPrefix } = {}) {
   const segments = playlist.segments;
   const discontinuityStarts = playlist.discontinuityStarts || [];
   const adBreaks = [];
@@ -360,7 +380,7 @@ export function detectAdBreaksFromVhsPlaylist(playlist) {
   let currentTime = 0;
 
   segments.forEach((segment, index) => {
-    const isMTSegment = isMediaTailorSegment(segment);
+    const isMTSegment = isMediaTailorSegment(segment, { adSegmentPrefix });
     const hasDiscontinuity = discontinuityStarts.includes(index);
 
     if (isMTSegment) {
@@ -627,19 +647,19 @@ export function parseIsoDuration(durationStr) {
  * SINGLE_PERIOD: the entire stream is one period; ads are signalled via
  * SCTE-35 <EventStream> elements inside that period.
  */
-export function parseDashManifestForAdBreaks(xmlText) {
+export function parseDashManifestForAdBreaks(xmlText, { adSegmentPrefix } = {}) {
   const parser = new DOMParser();
   const xml = parser.parseFromString(xmlText, 'text/xml');
   const ads = [];
 
   const parserError = xml.querySelector('parsererror');
   if (parserError) {
-    console.error('[MT] DASH XML parse error:', parserError.textContent);
+    Log.error('[MT] DASH XML parse error:', parserError.textContent);
     return ads;
   }
 
   const periods = xml.querySelectorAll('Period');
-  console.log(`[MT] Found ${periods.length} Period(s) in DASH manifest`);
+  Log.debug(`[MT] Found ${periods.length} Period(s) in DASH manifest`);
 
   if (periods.length > 1) {
     // ── MULTI_PERIOD ──────────────────────────────────────────────────────────
@@ -648,7 +668,9 @@ export function parseDashManifestForAdBreaks(xmlText) {
       const baseUrlEl = period.querySelector('BaseURL');
       const baseUrl = baseUrlEl ? baseUrlEl.textContent.trim() : '';
 
-      if (!baseUrl.includes(MT_SEGMENT_PATTERN)) {
+      const adCandidates = [MT_SEGMENT_PATTERN, MT_DEFAULT_AD_SEGMENT_PATH];
+      if (adSegmentPrefix) adCandidates.push(adSegmentPrefix);
+      if (!adCandidates.some((m) => baseUrl.includes(m))) {
         return; // content period
       }
 
@@ -657,11 +679,11 @@ export function parseDashManifestForAdBreaks(xmlText) {
       const duration = parseIsoDuration(period.getAttribute('duration') || '');
 
       if (duration < MIN_AD_DURATION) {
-        console.log(`[MT] Skipping period ${periodId} - duration too short (${duration}s)`);
+        Log.debug(`[MT] Skipping period ${periodId} - duration too short (${duration}s)`);
         return;
       }
 
-      console.log(`[MT] Ad period detected: ${periodId}`, { startTime, duration });
+      Log.debug(`[MT] Ad period detected: ${periodId}`, { startTime, duration });
 
       ads.push({
         id: periodId,
@@ -686,7 +708,7 @@ export function parseDashManifestForAdBreaks(xmlText) {
       DASH_SCTE35_EVENT_STREAM_SELECTOR,
     );
 
-    console.log(`[MT] Found ${eventStreams.length} SCTE-35 EventStream(s) in single-period manifest`);
+    Log.debug(`[MT] Found ${eventStreams.length} SCTE-35 EventStream(s) in single-period manifest`);
 
     eventStreams.forEach((stream) => {
       const timescale = parseFloat(stream.getAttribute('timescale') || '1');
@@ -702,11 +724,11 @@ export function parseDashManifestForAdBreaks(xmlText) {
         const durationSeconds = timescale !== 1 ? duration / timescale : duration;
 
         if (durationSeconds < MIN_AD_DURATION) {
-          console.log(`[MT] Skipping event ${eventId} - duration too short (${durationSeconds}s)`);
+          Log.debug(`[MT] Skipping event ${eventId} - duration too short (${durationSeconds}s)`);
           return;
         }
 
-        console.log(`[MT] SCTE-35 event detected: ${eventId}`, { startTime, durationSeconds });
+        Log.debug(`[MT] SCTE-35 event detected: ${eventId}`, { startTime, durationSeconds });
 
         ads.push({
           id: eventId,
@@ -727,7 +749,7 @@ export function parseDashManifestForAdBreaks(xmlText) {
     });
   }
 
-  console.log(`[MT] Parsed ${ads.length} valid ad break(s) from DASH manifest`);
+  Log.debug(`[MT] Parsed ${ads.length} valid ad break(s) from DASH manifest`);
   return ads;
 }
 

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/tracker.js

@@ -10,6 +10,30 @@ 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);
@@ -17,9 +41,51 @@ export default class VideojsTracker extends nrvideo.VideoTracker {
     this.isContentEnd = false;
     this.imaAdCuePoints = '';
     this.daiInitialized = false;
+    this.adTracking = options?.config?.ad?.type || null;
+    this.previousBitrate = 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 });
 
@@ -126,7 +192,8 @@ 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
-        const bitrate = activePlaylist.attributes['AVERAGE-BANDWIDTH'] ||
+        const bitrate =
+          activePlaylist.attributes['AVERAGE-BANDWIDTH'] ||
           activePlaylist.attributes.BANDWIDTH ||
           null;
         return bitrate !== null ? Math.round(bitrate) : null;
@@ -276,6 +343,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);
@@ -296,6 +364,16 @@ 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);
+
+    this.onQualityLevelChange = this.onQualityLevelChange.bind(this);
+    // Get qualityLevels lazily after player is ready
+    if (typeof this.player.qualityLevels === 'function') {
+      this.qualityLevels = this.player.qualityLevels();
+      if (this.qualityLevels) {
+        this.qualityLevels.on('change', this.onQualityLevelChange);
+      }
+    }
   }
 
   unregisterListeners() {
@@ -318,30 +396,34 @@ 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);
+    if (this.qualityLevels) {
+      this.qualityLevels.off('change', this.onQualityLevelChange);
+    }
   }
 
   onDownload(e) {
     this.sendDownload({ state: e.type });
 
-    // Check if MediaTailor should be used after the source is loaded
-    // Only check on 'loadstart' to avoid multiple checks
     if (
+      this.adTracking === AD_TRACKING.SSAI.MT &&
       !this.adsTracker &&
-      e.type === 'loadstart' &&
-      MediaTailorAdsTracker.isUsing(this.player)
+      e.type === 'loadstart'
     ) {
-      console.log(
-        'VideojsTracker: Creating MediaTailorAdsTracker after source load'
-      );
+      nrvideo.Log.debug('VideojsTracker: Creating MediaTailorAdsTracker');
       this.setAdsTracker(new MediaTailorAdsTracker(this.player, this.options));
-      // MediaTailor SSAI starts with content, not ads (unlike client-side ad frameworks)
+      // 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);
@@ -350,20 +432,33 @@ 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));
       }
     }
@@ -393,6 +488,11 @@ export default class VideojsTracker extends nrvideo.VideoTracker {
    * @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();
   }
 
@@ -412,6 +512,16 @@ export default class VideojsTracker extends nrvideo.VideoTracker {
     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()) {
@@ -479,8 +589,31 @@ export default class VideojsTracker extends nrvideo.VideoTracker {
       this.sendStart();
     }
   }
+
+  onQualityLevelChange(e) {
+    if (this.qualityLevels && this.qualityLevels.selectedIndex >= 0) {
+      const selectedLevel =
+        this.qualityLevels[this.qualityLevels.selectedIndex];
+      if (selectedLevel) {
+        const newBitrate = selectedLevel.bitrate;
+        const oldBitrate = this.previousBitrate;
+
+        this.sendRenditionChanged({
+          oldBitrate,
+          newBitrate,
+        });
+
+        this.previousBitrate = newBitrate;
+      }
+    }
+  }
 }
 
+// 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,
@@ -490,5 +623,6 @@ export {
   ImaAdsTracker,
   BrightcoveImaAdsTracker,
   FreewheelAdsTracker,
+  DaiAdsTracker,
   MediaTailorAdsTracker,
 };