remoting/webapp/base/js/log_to_server.js

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 /**
   6  * @fileoverview
   7  * Module for sending log entries to the server.
   8  */
   9
  10 'use strict';
  11
  12 /** @suppress {duplicate} */
  13 var remoting = remoting || {};
  14
  15 /**
  16  * @param {remoting.SignalStrategy} signalStrategy Signal strategy.
  17  * @param {boolean=} opt_isHost True if this instance should log role=host
  18  *     events rather than role=client.
  19  * @constructor
  20  * @implements {remoting.Logger}
  21  */
  22 remoting.LogToServer = function(signalStrategy, opt_isHost) {
  23   /** @private */
  24   this.statsAccumulator_ = new remoting.StatsAccumulator();
  25   /** @private */
  26   this.sessionId_ = '';
  27   /** @private */
  28   this.sessionIdGenerationTime_ = 0;
  29   /** @private */
  30   this.sessionStartTime_ = new Date().getTime();
  31   /** @private */
  32   this.signalStrategy_ = signalStrategy;
  33   /** @private {string} */
  34   this.connectionType_ = '';
  35   /** @private */
  36   this.authTotalTime_ = 0;
  37   /** @private {string} */
  38   this.hostVersion_ = '';
  39   /** @private */
  40   this.logEntryMode_ = remoting.ServerLogEntry.VALUE_MODE_UNKNOWN;
  41   /** @private */
  42   this.role_ = opt_isHost ? 'host' : 'client';
  43
  44   this.setSessionId();
  45   signalStrategy.sendConnectionSetupResults(this);
  46 };
  47
  48 // Constants used for generating a session ID.
  49 /** @private */
  50 remoting.LogToServer.SESSION_ID_ALPHABET_ =
  51     'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890';
  52 /** @private */
  53 remoting.LogToServer.SESSION_ID_LEN_ = 20;
  54
  55 /**
  56  * Logs a client session state change.
  57  *
  58  * @param {remoting.ClientSession.State} state
  59  * @param {!remoting.Error} connectionError
  60  */
  61 remoting.LogToServer.prototype.logClientSessionStateChange =
  62     function(state, connectionError) {
  63   this.maybeExpireSessionId_();
  64   // Log the session state change.
  65   var entry = remoting.ServerLogEntry.makeClientSessionStateChange(
  66       state, connectionError, this.logEntryMode_, this.role_);
  67   entry.addClientOSFields();
  68   entry.addChromeVersionField();
  69   entry.addWebappVersionField();
  70   entry.addSessionIdField(this.sessionId_);
  71   this.log_(entry);
  72   // Don't accumulate connection statistics across state changes.
  73   this.logAccumulatedStatistics_();
  74   this.statsAccumulator_.empty();
  75   // Maybe clear the session ID.
  76   if (remoting.LogToServer.isEndOfSession_(state)) {
  77     this.clearSessionId_();
  78   }
  79 };
  80
  81 /**
  82  * Set the connection type (direct, stun relay).
  83  *
  84  * @param {string} connectionType
  85  */
  86 remoting.LogToServer.prototype.setConnectionType = function(connectionType) {
  87   this.connectionType_ = connectionType;
  88 };
  89
  90 /**
  91  * @param {remoting.ChromotingEvent.Mode} mode
  92  */
  93 remoting.LogToServer.prototype.setLogEntryMode = function(mode) {
  94   switch (mode) {
  95     case remoting.ChromotingEvent.Mode.IT2ME:
  96       this.logEntryMode_ = remoting.ServerLogEntry.VALUE_MODE_IT2ME;
  97       break;
  98     case remoting.ChromotingEvent.Mode.ME2ME:
  99       this.logEntryMode_ = remoting.ServerLogEntry.VALUE_MODE_ME2ME;
 100       break;
 101     case remoting.ChromotingEvent.Mode.LGAPP:
 102       this.logEntryMode_ = remoting.ServerLogEntry.VALUE_MODE_APP_REMOTING;
 103       break;
 104     default:
 105       this.logEntryMode_ = remoting.ServerLogEntry.VALUE_MODE_UNKNOWN;
 106   }
 107 };
 108
 109 /**
 110  * @param {remoting.SignalStrategy.Type} strategyType
 111  * @param {remoting.FallbackSignalStrategy.Progress} progress
 112  */
 113 remoting.LogToServer.prototype.logSignalStrategyProgress =
 114     function(strategyType, progress) {
 115   this.maybeExpireSessionId_();
 116   var entry = remoting.ServerLogEntry.makeSignalStrategyProgress(
 117       this.sessionId_, strategyType, progress);
 118   this.log_(entry);
 119 };
 120
 121 /**
 122  * @return {string} The current session id. This is random GUID, refreshed
 123  *     every 24hrs.
 124  */
 125 remoting.LogToServer.prototype.getSessionId = function() {
 126   return this.sessionId_;
 127 };
 128
 129 /**
 130  * Whether a session state is one of the states that occurs at the end of
 131  * a session.
 132  *
 133  * @private
 134  * @param {remoting.ClientSession.State} state
 135  * @return {boolean}
 136  */
 137 remoting.LogToServer.isEndOfSession_ = function(state) {
 138   return ((state == remoting.ClientSession.State.CLOSED) ||
 139       (state == remoting.ClientSession.State.FAILED) ||
 140       (state == remoting.ClientSession.State.CONNECTION_DROPPED) ||
 141       (state == remoting.ClientSession.State.CONNECTION_CANCELED));
 142 };
 143
 144
 145 /**
 146  * Logs connection statistics.
 147  * @param {Object<number>} stats The connection statistics
 148  */
 149 remoting.LogToServer.prototype.logStatistics = function(stats) {
 150   this.maybeExpireSessionId_();
 151   // Store the statistics.
 152   this.statsAccumulator_.add(stats);
 153   // Send statistics to the server if they've been accumulating for at least
 154   // 60 seconds.
 155   if (this.statsAccumulator_.getTimeSinceFirstValue() >=
 156       remoting.Logger.CONNECTION_STATS_ACCUMULATE_TIME) {
 157     this.logAccumulatedStatistics_();
 158   }
 159 };
 160
 161 /**
 162  * Moves connection statistics from the accumulator to the log server.
 163  *
 164  * If all the statistics are zero, then the accumulator is still emptied,
 165  * but the statistics are not sent to the log server.
 166  *
 167  * @private
 168  */
 169 remoting.LogToServer.prototype.logAccumulatedStatistics_ = function() {
 170   var entry = remoting.ServerLogEntry.makeStats(this.statsAccumulator_,
 171                                                 this.connectionType_,
 172                                                 this.logEntryMode_);
 173   if (entry) {
 174     entry.addClientOSFields();
 175     entry.addChromeVersionField();
 176     entry.addWebappVersionField();
 177     entry.addSessionIdField(this.sessionId_);
 178     this.log_(entry);
 179   }
 180   this.statsAccumulator_.empty();
 181 };
 182
 183 /**
 184  * Sends a log entry to the server.
 185  *
 186  * @private
 187  * @param {remoting.ServerLogEntry} entry
 188  */
 189 remoting.LogToServer.prototype.log_ = function(entry) {
 190   // Log the time taken to get to this point from the time this session started.
 191   // Exclude time taken for authorization.
 192   var sessionDurationInSeconds =
 193       (new Date().getTime() - this.sessionStartTime_ -
 194           this.authTotalTime_) / 1000.0;
 195   entry.addSessionDuration(sessionDurationInSeconds);
 196   entry.addApplicationId();
 197   // The host-version will be blank for logs before a session has been created.
 198   // For example, the signal-strategy log-entries won't have host version info.
 199   entry.addHostVersion(this.hostVersion_);
 200
 201   // Send the stanza to the debug log.
 202   console.log('Enqueueing log entry:');
 203   entry.toDebugLog(1);
 204
 205   var stanza = '<cli:iq to="' + remoting.settings.DIRECTORY_BOT_JID + '" ' +
 206                        'type="set" xmlns:cli="jabber:client">' +
 207                  '<gr:log xmlns:gr="google:remoting">' +
 208                    entry.toStanza() +
 209                  '</gr:log>' +
 210                '</cli:iq>';
 211   this.signalStrategy_.sendMessage(stanza);
 212 };
 213
 214 /**
 215  * Sets the session ID to a random string.
 216  */
 217 remoting.LogToServer.prototype.setSessionId = function() {
 218   this.sessionId_ = remoting.LogToServer.generateSessionId_();
 219   this.sessionIdGenerationTime_ = new Date().getTime();
 220 };
 221
 222 /**
 223  * Clears the session ID.
 224  *
 225  * @private
 226  */
 227 remoting.LogToServer.prototype.clearSessionId_ = function() {
 228   this.sessionId_ = '';
 229   this.sessionIdGenerationTime_ = 0;
 230 };
 231
 232 /**
 233  * Sets a new session ID, if the current session ID has reached its maximum age.
 234  *
 235  * This method also logs the old and new session IDs to the server, in separate
 236  * log entries.
 237  *
 238  * @private
 239  */
 240 remoting.LogToServer.prototype.maybeExpireSessionId_ = function() {
 241   if ((this.sessionId_ != '') &&
 242       (new Date().getTime() - this.sessionIdGenerationTime_ >=
 243       remoting.Logger.MAX_SESSION_ID_AGE)) {
 244     // Log the old session ID.
 245     var entry = remoting.ServerLogEntry.makeSessionIdOld(this.sessionId_,
 246                                                          this.logEntryMode_);
 247     this.log_(entry);
 248     // Generate a new session ID.
 249     this.setSessionId();
 250     // Log the new session ID.
 251     entry = remoting.ServerLogEntry.makeSessionIdNew(this.sessionId_,
 252                                                      this.logEntryMode_);
 253     this.log_(entry);
 254   }
 255 };
 256
 257 /**
 258  * Generates a string that can be used as a session ID.
 259  *
 260  * @private
 261  * @return {string} a session ID
 262  */
 263 remoting.LogToServer.generateSessionId_ = function() {
 264   var idArray = [];
 265   for (var i = 0; i < remoting.LogToServer.SESSION_ID_LEN_; i++) {
 266     var index =
 267         Math.random() * remoting.LogToServer.SESSION_ID_ALPHABET_.length;
 268     idArray.push(
 269         remoting.LogToServer.SESSION_ID_ALPHABET_.slice(index, index + 1));
 270   }
 271   return idArray.join('');
 272 };
 273
 274 /**
 275  * @param {number} totalTime The value of time taken to complete authorization.
 276  * @return {void} Nothing.
 277  */
 278 remoting.LogToServer.prototype.setAuthTotalTime = function(totalTime) {
 279   this.authTotalTime_ = totalTime;
 280 };
 281
 282 /**
 283  * @param {string} hostVersion Version of the host for current session.
 284  * @return {void} Nothing.
 285  */
 286 remoting.LogToServer.prototype.setHostVersion = function(hostVersion) {
 287   this.hostVersion_ = hostVersion;
 288 };