Include time elapsed since start of a remoting session in each log entry.

remoting/webapp/crd/js/log_to_server.js

 // Copyright (c) 2012 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.
 
 /**
  * @fileoverview
  * Module for sending log entries to the server.
  */
 
 'use strict';
 
 /** @suppress {duplicate} */
 var remoting = remoting || {};
 
 /**
  * @param {remoting.SignalStrategy} signalStrategy Signal strategy.
  * @param {remoting.DesktopConnectedView.Mode} mode The mode of this connection.
  * @constructor
  */
 remoting.LogToServer = function(signalStrategy, mode) {
   /** @private */
   this.statsAccumulator_ = new remoting.StatsAccumulator();
   /** @private */
   this.sessionId_ = '';
   /** @private */
   this.sessionIdGenerationTime_ = 0;
   /** @private */
-  this.sessionStartTime_ = 0;
+  this.sessionStartTime_ = new Date().getTime();
   /** @private */
   this.signalStrategy_ = signalStrategy;
   /** @private */
   this.mode_ = mode;
   /** @type {string} @private */
   this.connectionType_ = '';
 
   this.setSessionId_();
   signalStrategy.sendConnectionSetupResults(this);
 };
@@ skipping 14 matching lines @@
 
 /**
  * Logs a client session state change.
  *
  * @param {remoting.ClientSession.State} state
  * @param {remoting.Error} connectionError
  */
 remoting.LogToServer.prototype.logClientSessionStateChange =
     function(state, connectionError) {
   this.maybeExpireSessionId_();
-  // Set the session start time if we haven't done so already.
-  if (remoting.LogToServer.isStartOfSession_(state)) {
-    if (this.sessionStartTime_ == 0) {
-      this.sessionStartTime_ = new Date().getTime();
-    }
-  }
   // Log the session state change.
   var entry = remoting.ServerLogEntry.makeClientSessionStateChange(
       state, connectionError, this.mode_);
   entry.addHostFields();
   entry.addChromeVersionField();
   entry.addWebappVersionField();
   entry.addSessionIdField(this.sessionId_);
   // Maybe clear the session start time, and log the session duration.
-  if (remoting.LogToServer.shouldAddDuration_(state) &&
-      (this.sessionStartTime_ != 0)) {
+  if (remoting.LogToServer.shouldAddDuration_(state)) {
     entry.addSessionDurationField(
         (new Date().getTime() - this.sessionStartTime_) / 1000.0);
-    if (remoting.LogToServer.isEndOfSession_(state)) {
-      this.sessionStartTime_ = 0;
-    }
   }
+
   this.log_(entry);
   // Don't accumulate connection statistics across state changes.
   this.logAccumulatedStatistics_();
   this.statsAccumulator_.empty();
   // Maybe clear the session ID.
   if (remoting.LogToServer.isEndOfSession_(state)) {
     this.clearSessionId_();
   }
+
 };
 
 /**
  * Set the connection type (direct, stun relay).
  *
  * @param {string} connectionType
  */
 remoting.LogToServer.prototype.setConnectionType = function(connectionType) {
   this.connectionType_ = connectionType;
 };
 
 /**
  * @param {remoting.SignalStrategy.Type} strategyType
  * @param {remoting.FallbackSignalStrategy.Progress} progress
- * @param {number} elapsedTimeInMs
  */
 remoting.LogToServer.prototype.logSignalStrategyProgress =
-    function(strategyType, progress, elapsedTimeInMs) {
+    function(strategyType, progress) {
   this.maybeExpireSessionId_();
   var entry = remoting.ServerLogEntry.makeSignalStrategyProgress(
-      this.sessionId_, strategyType, progress, elapsedTimeInMs);
+      this.sessionId_, strategyType, progress);
   this.log_(entry);
 };
 
 /**
  * Whether a session state is one of the states that occurs at the start of
  * a session.
  *
  * @private
  * @param {remoting.ClientSession.State} state
  * @return {boolean}
@@ skipping 24 matching lines @@
  *
  * @private
  * @param {remoting.ClientSession.State} state
  * @return {boolean}
  */
 remoting.LogToServer.shouldAddDuration_ = function(state) {
   // Duration is added to log entries at the end of the session, as well as at
   // some intermediate states where it is relevant (e.g. to determine how long
   // it took for a session to become CONNECTED).
   return (remoting.LogToServer.isEndOfSession_(state) ||
       (state == remoting.ClientSession.State.CONNECTED));

[anandc, 2015/02/28 01:20:27]

I think this function should be removed, now that we using this approach to
calculate time-to-connect. Instead, just call isEndOfSession.
WDYT?
In fact, we could probably get rid of the session-duration field.

[Jamie, 2015/02/28 01:52:34]

Yes, the session duration field isn't buying us anything since it's basically
the same as the elapsed time for that specific event.

 };
 
 /**
  * Logs connection statistics.
  * @param {Object<string, number>} stats The connection statistics
  */
 remoting.LogToServer.prototype.logStatistics = function(stats) {
   this.maybeExpireSessionId_();
   // Store the statistics.
   this.statsAccumulator_.add(stats);
@@ skipping 27 matching lines @@
   this.statsAccumulator_.empty();
 };
 
 /**
  * Sends a log entry to the server.
  *
  * @private
  * @param {remoting.ServerLogEntry} entry
  */
 remoting.LogToServer.prototype.log_ = function(entry) {
+  // Log the time taken to get to this point from the time this session started.
+  var elapsedTimeInMs = new Date().getTime() - this.sessionStartTime_;
+  entry.addElapsedTimeMs(elapsedTimeInMs);
+
   // Send the stanza to the debug log.
   console.log('Enqueueing log entry:');
   entry.toDebugLog(1);
 
   var stanza = '<cli:iq to="' + remoting.settings.DIRECTORY_BOT_JID + '" ' +
                        'type="set" xmlns:cli="jabber:client">' +
                  '<gr:log xmlns:gr="google:remoting">' +
                    entry.toStanza() +
                  '</gr:log>' +
                '</cli:iq>';
@@ skipping 54 matching lines @@
 remoting.LogToServer.generateSessionId_ = function() {
   var idArray = [];
   for (var i = 0; i < remoting.LogToServer.SESSION_ID_LEN_; i++) {
     var index =
         Math.random() * remoting.LogToServer.SESSION_ID_ALPHABET_.length;
     idArray.push(
         remoting.LogToServer.SESSION_ID_ALPHABET_.slice(index, index + 1));
   }
   return idArray.join('');
 };