Add support for log file rotation.

ui/file_manager/file_manager/common/js/importer_common.js

 // Copyright 2014 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.
 
 // Shared cloud importer namespace
 var importer = importer || {};
 
 /** @enum {string} */
 importer.ScanEvent = {
   FINALIZED: 'finalized',
   INVALIDATED: 'invalidated',
   UPDATED: 'updated'
 };
 
 /**
  * Storage keys for settings saved by importer.
  * @enum {string}
  */
 importer.Setting = {
   HAS_COMPLETED_IMPORT: 'importer-has-completed-import',
   MACHINE_ID: 'importer-machine-id',
-  PHOTOS_APP_ENABLED: 'importer-photo-app-enabled'
+  PHOTOS_APP_ENABLED: 'importer-photo-app-enabled',
+  LAST_KNOWN_LOG_ID: 'importer-last-known-log-id'
 };
 
 /**
  * @typedef {function(
  *     !importer.ScanEvent, importer.ScanResult)}
  */
 importer.ScanObserver;
 
 /**
  * Volume types eligible for the affections of Cloud Import.
@@ skipping 183 matching lines @@
           });
 };
 
 /**
  * @return {!Promise.<string>} Resolves with the filename of this
  *     machines history file.
  */
 importer.getHistoryFilename = function() {
   return importer.getMachineId().then(
       function(machineId) {
-        return 'import-history.' + machineId + '.log';
+        return 'import-history-' + machineId + '.log';
       });
 };
 
 /**
+ * @param {number} logId
  * @return {!Promise.<string>} Resolves with the filename of this
  *     machines debug log file.
  */
-importer.getDebugLogFilename = function() {
+importer.getDebugLogFilename = function(logId) {
   return importer.getMachineId().then(
       function(machineId) {
-        return 'import-debug.' + machineId + '.log';
+        return 'import-debug-' + machineId + '-' + logId + '.log';
       });
 };
 
 /**
  * @return {number} A relatively unique six digit integer that is most likely
  *     unique to this machine among a user's machines. Used only to segregate
  *     log files on sync storage.
  */
 importer.generateMachineId_ = function() {
   return Math.floor(Math.random() * 899999) + 100000;
@@ skipping 414 matching lines @@
 
 /** @override  */
 importer.RuntimeLogger.prototype.error = function(content) {
   this.write_('ERROR', content);
   console.error(content);
 };
 
 /** @override  */
 importer.RuntimeLogger.prototype.catcher = function(context) {
   return function(error) {
-    this.error('Caught promise error. Context: ' + context +
-        ' Error: ' + error.message);
+    var prefix = '(' + context + ')';
+    var message = prefix + ' Caught error in promise chain.';
+
+    if (error) {
+      this.error(message + ' Error' + error.message);
+      this.write_('STACK', prefix + ' Trace: ' + error.stack);
+    } else {
+      this.error(message);
+      error = new Error(message);
+    }
+
+    throw error;
   }.bind(this);
 };
 
 /**
  * Writes a message to the logger followed by a new line.
  *
  * @param {string} type
  * @param {string} message
  */
 importer.RuntimeLogger.prototype.write_ = function(type, message) {
@@ skipping 37 matching lines @@
 /** @private {importer.Logger} */
 importer.logger_ = null;
 
 /**
  * Creates a new logger instance...all ready to go.
  *
  * @return {!importer.Logger}
  */
 importer.getLogger = function() {
   if (!importer.logger_) {
+    var nextLogId = importer.getNextDebugLogId_();
+
+    /** @return {!Promise} */
+    var rotator = function() {
+      return importer.rotateLogs(
+          nextLogId,
+          importer.ChromeSyncFileEntryProvider.getFileEntry);
+    };
+
+    // This is a sligtly odd arrangement in service of two goals.
+    //
+    // 1) Make a logger available synchronously.
+    // 2) Nuke old log files before reusing their names.
+    //
+    // In support of these goals we push the "rotator" between
+    // the call to load the file entry and the method that
+    // produces the name of the file to load. That method
+    // (getDebugLogFilename) returns promise. We exploit this.
     importer.logger_ = new importer.RuntimeLogger(
         importer.ChromeSyncFileEntryProvider.getFileEntry(
-            importer.getDebugLogFilename()));
+            /** @type {!Promise<string>} */ (rotator().then(
+                importer.getDebugLogFilename.bind(null, nextLogId)))));
   }
+
   return importer.logger_;
 };
 
 /**
+ * Returns the log ID for the next debug log to use.
+ * @private
+ */
+importer.getNextDebugLogId_ = function() {
+  return new Date().getMonth() % 2;
+};
+
+/**
+ * Deletes the "next" log file if it has just-now become active.
+ *
+ * Basically we toggle back and forth writing to two log files. At the time
+ * we flip from one to another we want to delete the oldest data we have.
+ * In this case it will be the "next" log.
+ *
+ * This function must be run befor instantiating the logger.

[fukino, 2015/02/23 03:42:26]

nit: s/befor/before

[Steve McKay, 2015/02/23 03:50:18]

Done.

+ *
+ * @param {number} nextLogId
+ * @param {function(!Promise<string>): !Promise<!FileEntry>} fileFactory
+ *     Injected primarily to facilitate testing.
+ * @return {!Promise} Resolves when trimming is complete.
+ */
+importer.rotateLogs = function(nextLogId, fileFactory) {
+  var storage = importer.ChromeLocalStorage.getInstance();
+
+  /** @return {!Promise} */
+  var rememberLogId = function() {
+    return storage.set(
+        importer.Setting.LAST_KNOWN_LOG_ID,
+        nextLogId);
+  };
+
+  return storage.get(importer.Setting.LAST_KNOWN_LOG_ID)
+      .then(
+          /** @param {number} lastKnownLogId */
+          function(lastKnownLogId) {
+            if (nextLogId === lastKnownLogId ||
+                lastKnownLogId === undefined) {
+              return Promise.resolve();
+            }
+
+            return fileFactory(importer.getDebugLogFilename(nextLogId))
+                .then(
+                    /**
+                     * @param {!FileEntry} entry
+                     * @return {!Promise}
+                     * @suppress {checkTypes}
+                     */
+                    function(entry) {
+                      return new Promise(entry.remove.bind(entry));
+                    });
+          })
+          .then(rememberLogId)
+          .catch(rememberLogId);
+};
+
+/**
  * Friendly wrapper around chrome.storage.local.
  *
  * NOTE: If you want to use this in a test, install MockChromeStorageAPI.
  *
  * @constructor
  */
 importer.ChromeLocalStorage = function() {};
 
 /**
  * @param {string} key
@@ skipping 42 matching lines @@
       });
 };
 
 /** @private @const {!importer.ChromeLocalStorage} */
 importer.ChromeLocalStorage.INSTANCE_ = new importer.ChromeLocalStorage();
 
 /** @return {!importer.ChromeLocalStorage} */
 importer.ChromeLocalStorage.getInstance = function() {
   return importer.ChromeLocalStorage.INSTANCE_;
 };