feat: extend stats object (#10)

src/playback-watcher.js

@@ -10,7 +10,7 @@
 
 import window from 'global/window';
 import Ranges from './ranges';
-import videojs from 'video.js';
+import logger from './util/logger';
 
 // Set of events that reset the playback-watcher time check logic and clear the timeout
 const timerCancelEvents = [
@@ -38,10 +38,8 @@ export default class PlaybackWatcher {
     this.lastRecordedTime = null;
     this.timer_ = null;
     this.checkCurrentTimeTimeout_ = null;
+    this.logger_ = logger('PlaybackWatcher');
 
-    if (options.debug) {
-      this.logger_ = videojs.log.bind(videojs, 'playback-watcher ->');
-    }
     this.logger_('initialize');
 
     let canPlayHandler = () => this.monitorCurrentTime_();
@@ -403,12 +401,4 @@ export default class PlaybackWatcher {
 
     return null;
   }
-
-  /**
-   * A debugging logger noop that is set to console.log only if debugging
-   * is enabled globally
-   *
-   * @private
-   */
-  logger_() {}
 }

src/ranges.js

@@ -364,6 +364,24 @@ const timeUntilRebuffer = function(buffered, currentTime, playbackRate = 1) {
   return (bufferedEnd - currentTime) / playbackRate;
 };
 
+/**
+ * Converts a TimeRanges object into an array representation
+ * @param {TimeRanges} timeRanges
+ * @returns {Array}
+ */
+const timeRangesToArray = (timeRanges) => {
+  const timeRangesList = [];
+
+  for (let i = 0; i < timeRanges.length; i++) {
+    timeRangesList.push({
+      start: timeRanges.start(i),
+      end: timeRanges.end(i)
+    });
+  }
+
+  return timeRangesList;
+};
+
 export default {
   findRange,
   findNextRange,
@@ -373,5 +391,6 @@ export default {
   TIME_FUDGE_FACTOR,
   SAFE_TIME_DELTA,
   printableRange,
-  timeUntilRebuffer
+  timeUntilRebuffer,
+  timeRangesToArray
 };

src/segment-loader.js

@@ -12,6 +12,7 @@ import { initSegmentId } from './bin-utils';
 import {mediaSegmentRequest, REQUEST_ERRORS} from './media-segment-request';
 import { TIME_FUDGE_FACTOR, timeUntilRebuffer as timeUntilRebuffer_ } from './ranges';
 import { minRebufferMaxBandwidthSelector } from './playlist-selectors';
+import logger from './util/logger';
 
 // in ms
 const CHECK_BUFFER_DELAY = 500;
@@ -178,9 +179,7 @@ export default class SegmentLoader extends videojs.EventTarget {
     // ...for determining the fetch location
     this.fetchAtBuffer_ = false;
 
-    if (options.debug) {
-      this.logger_ = videojs.log.bind(videojs, 'segment-loader', this.loaderType_, '->');
-    }
+    this.logger_ = logger(`SegmentLoader[${this.loaderType_}]`);
   }
 
   /**
@@ -678,27 +677,17 @@ export default class SegmentLoader extends videojs.EventTarget {
       return null;
     }
 
-    this.logger_('checkBuffer_',
-      'mediaIndex:', mediaIndex,
-      'hasPlayed:', hasPlayed,
-      'currentTime:', currentTime,
-      'syncPoint:', syncPoint,
-      'fetchAtBuffer:', this.fetchAtBuffer_,
-      'bufferedTime:', bufferedTime);
-
     // When the syncPoint is null, there is no way of determining a good
     // conservative segment index to fetch from
     // The best thing to do here is to get the kind of sync-point data by
     // making a request
     if (syncPoint === null) {
       mediaIndex = this.getSyncSegmentCandidate_(playlist);
-      this.logger_('getSync', 'mediaIndex:', mediaIndex);
       return this.generateSegmentInfo_(playlist, mediaIndex, null, true);
     }
 
     // Under normal playback conditions fetching is a simple walk forward
     if (mediaIndex !== null) {
-      this.logger_('walkForward', 'mediaIndex:', mediaIndex + 1);
       let segment = playlist.segments[mediaIndex];
 
       if (segment && segment.end) {
@@ -731,9 +720,6 @@ export default class SegmentLoader extends videojs.EventTarget {
       mediaIndex = mediaSourceInfo.mediaIndex;
       startOfSegment = mediaSourceInfo.startTime;
     }
-    this.logger_('getMediaIndexForTime',
-      'mediaIndex:', mediaIndex,
-      'startOfSegment:', startOfSegment);
 
     return this.generateSegmentInfo_(playlist, mediaIndex, startOfSegment, false);
   }
@@ -1280,14 +1266,6 @@ export default class SegmentLoader extends videojs.EventTarget {
       (segmentProcessingThroughput - rate) / (++this.throughput.count);
   }
 
-  /**
-   * A debugging logger noop that is set to console.log only if debugging
-   * is enabled globally
-   *
-   * @private
-   */
-  logger_() {}
-
   /**
    * Adds a cue to the segment-metadata track with some metadata information about the
    * segment

src/sync-controller.js

@@ -6,6 +6,7 @@ import mp4probe from 'mux.js/lib/mp4/probe';
 import {inspect as tsprobe} from 'mux.js/lib/tools/ts-inspector.js';
 import {sumDurations} from './playlist';
 import videojs from 'video.js';
+import logger from './util/logger';
 
 export const syncPointStrategies = [
   // Stategy "VOD": Handle the VOD-case where the sync-point is *always*
@@ -147,9 +148,7 @@ export default class SyncController extends videojs.EventTarget {
     this.discontinuities = [];
     this.datetimeToDisplayTime = null;
 
-    if (options.debug) {
-      this.logger_ = videojs.log.bind(videojs, 'sync-controller ->');
-    }
+    this.logger_ = logger('SyncController');
   }
 
   /**
@@ -258,7 +257,6 @@ export default class SyncController extends videojs.EventTarget {
           strategy: strategy.name,
           syncPoint
         });
-        this.logger_(`syncPoint found via <${strategy.name}>:`, syncPoint);
       }
     }
 
@@ -547,12 +545,4 @@ export default class SyncController extends videojs.EventTarget {
       }
     }
   }
-
-  /**
-   * A debugging logger noop that is set to console.log only if debugging
-   * is enabled globally
-   *
-   * @private
-   */
-  logger_() {}
 }

src/util/logger.js

@@ -0,0 +1,11 @@
+import videojs from 'video.js';
+
+const logger = (source) => {
+  if (videojs.log.debug) {
+    return videojs.log.debug.bind(videojs, 'VHS:', `${source} >`);
+  }
+
+  return function() {};
+};
+
+export default logger;

src/videojs-http-streaming.js

@@ -10,6 +10,7 @@ import Playlist from './playlist';
 import xhrFactory from './xhr';
 import {Decrypter, AsyncStream, decrypt} from 'aes-decrypter';
 import utils from './bin-utils';
+import {timeRangesToArray} from './ranges';
 import {MediaSource, URL} from 'videojs-contrib-media-sources';
 import m3u8 from 'm3u8-parser';
 import videojs from 'video.js';
@@ -484,6 +485,46 @@ class HlsHandler extends Component {
       mediaSecondsLoaded: {
         get: () => this.masterPlaylistController_.mediaSecondsLoaded_() || 0,
         enumerable: true
+      },
+      buffered: {
+        get: () => timeRangesToArray(this.tech_.buffered()),
+        enumerable: true
+      },
+      currentTime: {
+        get: () => this.tech_.currentTime(),
+        enumerable: true
+      },
+      currentSource: {
+        get: () => this.tech_.currentSource_,
+        enumerable: true
+      },
+      currentTech: {
+        get: () => this.tech_.name_,
+        enumerable: true
+      },
+      duration: {
+        get: () => this.tech_.duration(),
+        enumerable: true
+      },
+      master: {
+        get: () => this.playlists.master,
+        enumerable: true
+      },
+      playerDimensions: {
+        get: () => this.tech_.currentDimensions(),
+        enumerable: true
+      },
+      seekable: {
+        get: () => timeRangesToArray(this.tech_.seekable()),
+        enumerable: true
+      },
+      timestamp: {
+        get: () => Date.now(),
+        enumerable: true
+      },
+      videoPlaybackQuality: {
+        get: () => this.tech_.getVideoPlaybackQuality(),
+        enumerable: true
       }
     });
 

test/ranges.test.js

@@ -331,3 +331,13 @@ QUnit.test('creates printable ranges', function(assert) {
                '10 => 25, 20 => 40, -1 => -2',
                'formats ranges correctly');
 });
+
+QUnit.test('converts time ranges to an array', function(assert) {
+  assert.deepEqual(Ranges.timeRangesToArray(createTimeRanges()), [], 'empty range empty array');
+  assert.deepEqual(Ranges.timeRangesToArray(createTimeRanges([[0, 1]])),
+               [{start: 0, end: 1}],
+               'formats range correctly');
+  assert.deepEqual(Ranges.timeRangesToArray(createTimeRanges([[10, 20], [30, 40]])),
+               [{start: 10, end: 20}, {start: 30, end: 40}],
+               'formats ranges correctly');
+});