Log signal strategy progress to server.

remoting/webapp/crd/js/fallback_signal_strategy.js

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 'use strict';
 
 /** @suppress {duplicate} */
 var remoting = remoting || {};
 
 /**
  * A signal strategy encapsulating a primary and a back-up strategy. If the
  * primary fails or times out, then the secondary is used. Information about
  * which strategy was used, and why, is returned via |onProgressCallback|.
  *
  * @param {function(
  *             function(remoting.SignalStrategy.State)
  *         ):remoting.SignalStrategy} primaryFactory
  * @param {function(
  *             function(remoting.SignalStrategy.State)
  *         ):remoting.SignalStrategy} secondaryFactory
  * @param {function(remoting.SignalStrategy.State):void} onStateChangedCallback
- * @param {function(remoting.FallbackSignalStrategy.Progress)}
- *     onProgressCallback
  *
  * @implements {remoting.SignalStrategy}
  * @constructor
  */
 remoting.FallbackSignalStrategy = function(
-    primaryFactory, secondaryFactory,
-    onStateChangedCallback, onProgressCallback) {
+    primaryFactory, secondaryFactory, onStateChangedCallback) {
   /**
    * @type {remoting.SignalStrategy}
    * @private
    */
   this.primary_ = primaryFactory(this.onPrimaryStateChanged_.bind(this));
 
   /**
    * @type {remoting.SignalStrategy}
    * @private
    */
   this.secondary_ = secondaryFactory(this.onSecondaryStateChanged_.bind(this));
 
   /**
    * @type {function(remoting.SignalStrategy.State)}
    * @private
    */
   this.onStateChangedCallback_ = onStateChangedCallback;
 
   /**
-   * @type {function(remoting.FallbackSignalStrategy.Progress)}
-   * @private
-   */
-  this.onProgressCallback_ = onProgressCallback;
-
-  /**
    * @type {?function(Element):void}
    * @private
    */
   this.onIncomingStanzaCallback_ = null;
 
   /**
    * @type {number}
    * @private
    * @const
    */
@@ skipping 41 matching lines @@
    * @type {string}
    * @private
    */
   this.authToken_ = '';
 
   /**
    * @type {number}
    * @private
    */
   this.primaryConnectTimerId_ = 0;
+
+  /**
+   * @type {remoting.LogToServer}
+   * @private
+   */
+  this.logToServer_ = null;
+
+  /**
+   * @type {Array.<{progress: remoting.FallbackSignalStrategy.Progress,
+   *                elapsed: number}>}
+   */
+  this.connectionSetupResults_ = [];
+
+  /**
+   * @type {number}
+   * @private
+   */
+  this.startTime_ = 0;
 };
 
 /**
  * @enum {string}
  */
 remoting.FallbackSignalStrategy.Progress = {
   PRIMARY_SUCCEEDED: 'primary-succeeded',

[rmsousa, 2015/01/17 00:23:17]

This naming is fairly ambiguous - I assume the intention of naming them primary
and secondary rather than hardcoding xmpp and wcs is that it is
theoretically/futurely possible to have a different precedence, or new signal
strategy types. But if that's the case, references to "primary" or "secondary"
in the logs are meaningless, because one can't really tell (authoritatively)
what primary and secondary means without external/time-dependent context. A log
entry should be self contained - otherwise, how can one, for example, calculate
aggregate stats for data that spans across a change in the external context?
(especially if that change may take time to propagate from 0 to 100%)

We should have an additional enum for SignalStrategyName (SignalStrategyType?
SignalStrategyImplementation?), and add primaryStrategyName and
secondaryStrategyName log fields.

[Jamie, 2015/01/21 19:41:08]

Done.

   PRIMARY_FAILED: 'primary-failed',
   PRIMARY_TIMED_OUT: 'primary-timed-out',
   PRIMARY_SUCCEEDED_LATE: 'primary-succeeded-late',
   PRIMARY_FAILED_LATE: 'primary-failed-late',
   SECONDARY_SUCCEEDED: 'secondary-succeeded',
   SECONDARY_FAILED: 'secondary-failed'
 };
 
 remoting.FallbackSignalStrategy.prototype.dispose = function() {
   this.primary_.dispose();
@@ skipping 21 matching lines @@
  * @param {string} username
  * @param {string} authToken
  */
 remoting.FallbackSignalStrategy.prototype.connect =
     function(server, username, authToken) {
   base.debug.assert(this.state_ == this.State.NOT_CONNECTED);
   this.server_ = server;
   this.username_ = username;
   this.authToken_ = authToken;
   this.state_ = this.State.PRIMARY_PENDING;
+  this.startTime_ = new Date().getTime();
   this.primary_.setIncomingStanzaCallback(this.onIncomingStanzaCallback_);
   this.primary_.connect(server, username, authToken);
   this.primaryConnectTimerId_ =
       window.setTimeout(this.onPrimaryTimeout_.bind(this),
                         this.PRIMARY_CONNECT_TIMEOUT_MS_);
 };
 
 /**
  * Sends a message. Can be called only in CONNECTED state.
  * @param {string} message
  */
 remoting.FallbackSignalStrategy.prototype.sendMessage = function(message) {
   this.getConnectedSignalStrategy_().sendMessage(message);
 };
 
+/**
+ * Send any messages accumulated during connection set-up.
+ *
+ * @param {remoting.LogToServer} logToServer The LogToServer instance for the
+ *     connection.
+ */
+remoting.FallbackSignalStrategy.prototype.sendConnectionSetupResults =
+    function(logToServer) {
+  this.logToServer_ = logToServer;
+  this.sendConnectionSetupResultsInternal_();
+}
+
+remoting.FallbackSignalStrategy.prototype.sendConnectionSetupResultsInternal_ =
+    function() {
+  for (var i = 0; i < this.connectionSetupResults_.length; ++i) {
+    var result = this.connectionSetupResults_[i];
+    this.logToServer_.logSignalStrategyProgress(result.progress,
+        result.elapsed);
+  }
+  this.connectionSetupResults_ = [];
+};
+
 /** @return {remoting.SignalStrategy.State} Current state */
 remoting.FallbackSignalStrategy.prototype.getState = function() {
   return (this.externalState_ === null)
       ? remoting.SignalStrategy.State.NOT_CONNECTED
       : this.externalState_;
 };
 
 /** @return {remoting.Error} Error when in FAILED state. */
 remoting.FallbackSignalStrategy.prototype.getError = function() {
   base.debug.assert(this.state_ == this.State.SECONDARY_FAILED);
@@ skipping 33 matching lines @@
 /**
  * @param {remoting.SignalStrategy.State} state
  * @private
  */
 remoting.FallbackSignalStrategy.prototype.onPrimaryStateChanged_ =
     function(state) {
   switch (state) {
     case remoting.SignalStrategy.State.CONNECTED:
       if (this.state_ == this.State.PRIMARY_PENDING) {
         window.clearTimeout(this.primaryConnectTimerId_);
-        this.onProgressCallback_(
+        this.updateProgress_(
             remoting.FallbackSignalStrategy.Progress.PRIMARY_SUCCEEDED);
         this.state_ = this.State.PRIMARY_SUCCEEDED;
       } else {
-        this.onProgressCallback_(
+        this.updateProgress_(
             remoting.FallbackSignalStrategy.Progress.PRIMARY_SUCCEEDED_LATE);
       }
       break;
 
     case remoting.SignalStrategy.State.FAILED:
       if (this.state_ == this.State.PRIMARY_PENDING) {
         window.clearTimeout(this.primaryConnectTimerId_);
-        this.onProgressCallback_(
+        this.updateProgress_(
             remoting.FallbackSignalStrategy.Progress.PRIMARY_FAILED);
         this.connectSecondary_();
       } else {
-        this.onProgressCallback_(
+        this.updateProgress_(
             remoting.FallbackSignalStrategy.Progress.PRIMARY_FAILED_LATE);
       }
       return;  // Don't notify the external callback
 
     case remoting.SignalStrategy.State.CLOSED:
       this.state_ = this.State.CLOSED;
       break;
   }
 
   this.notifyExternalCallback_(state);
 };
 
 /**
  * @param {remoting.SignalStrategy.State} state
  * @private
  */
 remoting.FallbackSignalStrategy.prototype.onSecondaryStateChanged_ =
     function(state) {
   switch (state) {
     case remoting.SignalStrategy.State.CONNECTED:
-      this.onProgressCallback_(
+      this.updateProgress_(
           remoting.FallbackSignalStrategy.Progress.SECONDARY_SUCCEEDED);
       this.state_ = this.State.SECONDARY_SUCCEEDED;
       break;
 
     case remoting.SignalStrategy.State.FAILED:
-      this.onProgressCallback_(
+      this.updateProgress_(
           remoting.FallbackSignalStrategy.Progress.SECONDARY_FAILED);
       this.state_ = this.State.SECONDARY_FAILED;
       break;
 
     case remoting.SignalStrategy.State.CLOSED:
       this.state_ = this.State.CLOSED;
       break;
   }
 
   this.notifyExternalCallback_(state);
@@ skipping 29 matching lines @@
   this.state_ = this.State.SECONDARY_PENDING;
   this.primary_.setIncomingStanzaCallback(null);
   this.secondary_.setIncomingStanzaCallback(this.onIncomingStanzaCallback_);
   this.secondary_.connect(this.server_, this.username_, this.authToken_);
 };
 
 /**
  * @private
  */
 remoting.FallbackSignalStrategy.prototype.onPrimaryTimeout_ = function() {
-  this.onProgressCallback_(
+  this.updateProgress_(
       remoting.FallbackSignalStrategy.Progress.PRIMARY_TIMED_OUT);
   this.connectSecondary_();
 };
+
+/**
+ * @param {remoting.FallbackSignalStrategy.Progress} progress
+ * @private
+ */
+remoting.FallbackSignalStrategy.prototype.updateProgress_ = function(progress) {
+  console.log('FallbackSignalStrategy progress: ' + progress);
+  this.connectionSetupResults_.push({
+    'progress': progress,
+    'elapsed': new Date().getTime() - this.startTime_
+  });
+  if (this.logToServer_) {
+    this.sendConnectionSetupResultsInternal_();
+  }
+};