Send UMA stability stats in a separate UMA log on startup.

chrome/browser/metrics/metrics_service.h

 // 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.
 
 // This file defines a service that collects information about the user
 // experience in order to help improve future versions of the app.
 
 #ifndef CHROME_BROWSER_METRICS_METRICS_SERVICE_H_
 #define CHROME_BROWSER_METRICS_METRICS_SERVICE_H_
 
@@ skipping 93 matching lines @@
     UNINITIALIZED_PHASE = 0,
     START_METRICS_RECORDING = 100,
     CREATE_PROFILE = 200,
     STARTUP_TIMEBOMB_ARM = 300,
     THREAD_WATCHER_START = 400,
     MAIN_MESSAGE_LOOP_RUN = 500,
     SHUTDOWN_TIMEBOMB_ARM = 600,
     SHUTDOWN_COMPLETE = 700,
   };
 
+  enum ReportingState {
+    REPORTING_ENABLED,
+    REPORTING_DISABLED,
+  };
+
   MetricsService();
   virtual ~MetricsService();
 
+  // Initializes metrics recording state. Updates various bookkeeping values in
+  // prefs and sets up the scheduler. This is a separate function rather than
+  // being done by the constructor so that field trials could be created before
+  // this is run. Takes |reporting_state| parameter which specifies whether UMA
+  // is enabled.
+  void InitializeMetricsRecordingState(ReportingState reporting_state);
+
   // Starts the metrics system, turning on recording and uploading of metrics.
   // Should be called when starting up with metrics enabled, or when metrics
   // are turned on.
   void Start();
 
   // Starts the metrics system in a special test-only mode. Metrics won't ever
   // be uploaded or persisted in this mode, but metrics will be recorded in
   // memory.
   void StartRecordingForTests();
 
@@ skipping 19 matching lines @@
   //
   // If |reporting_will_be_enabled| is true, this method returns an entropy
   // provider that has a high source of entropy, partially based on the client
   // ID. Otherwise, an entropy provider that is based on a low entropy source
   // is returned.
   //
   // Note that this reporting state can not be checked by reporting_active()
   // because this method may need to be called before the MetricsService needs
   // to be started.
   scoped_ptr<const base::FieldTrial::EntropyProvider> CreateEntropyProvider(
-      bool reporting_will_be_enabled);
+      ReportingState reporting_state);
 
   // Force the client ID to be generated. This is useful in case it's needed
   // before recording.
   void ForceClientIdCreation();
 
   // At startup, prefs needs to be called with a list of all the pref names and
   // types we'll be using.
   static void RegisterPrefs(PrefRegistrySimple* registry);
 
   // Set up notifications which indicate that a user is performing work. This is
@@ skipping 43 matching lines @@
   // Saves in the preferences if the browser is running under a debugger.
   // This count is eventually send via UMA logs.
   void RecordBreakpadHasDebugger(bool has_debugger);
 
 #if defined(OS_WIN)
   // Counts (and removes) the browser crash dump attempt signals left behind by
   // any previous browser processes which generated a crash dump.
   void CountBrowserCrashDumpAttempts();
 #endif  // OS_WIN
 
-  // Save any unsent logs into a persistent store in a pref.  We always do this
-  // at shutdown, but we can do it as we reduce the list as well.
-  void StoreUnsentLogs();
-
 #if defined(OS_CHROMEOS)
   // Start the external metrics service, which collects metrics from Chrome OS
   // and passes them to UMA.
   void StartExternalMetrics();
 
   // Records a Chrome OS crash.
   void LogChromeOSCrash(const std::string &crash_type);
 #endif
 
   bool recording_active() const;
@@ skipping 12 matching lines @@
   // registered at a time for a given trial_name. Only the last group name that
   // is registered for a given trial name will be recorded. The values passed
   // in must not correspond to any real field trial in the code.
   // To use this method, SyntheticTrialGroup should friend your class.
   void RegisterSyntheticFieldTrial(const SyntheticTrialGroup& trial_group);
 
  private:
   // The MetricsService has a lifecycle that is stored as a state.
   // See metrics_service.cc for description of this lifecycle.
   enum State {
-    INITIALIZED,            // Constructor was called.
-    INIT_TASK_SCHEDULED,    // Waiting for deferred init tasks to complete.
-    INIT_TASK_DONE,         // Waiting for timer to send initial log.
-    INITIAL_LOG_READY,      // Initial log generated, and waiting for reply.
-    SENDING_OLD_LOGS,       // Sending unsent logs from previous session.
-    SENDING_CURRENT_LOGS,   // Sending standard current logs as they acrue.
+    INITIALIZED,                    // Constructor was called.
+    INIT_TASK_SCHEDULED,            // Waiting for deferred init tasks to
+                                    // complete.
+    INIT_TASK_DONE,                 // Waiting for timer to send initial log.
+    SENDING_INITIAL_STABILITY_LOG,  // Initial stability log being sent.
+    SENDING_INITIAL_METRICS_LOG,    // Initial metrics log being sent.
+    SENDING_OLD_LOGS,               // Sending unsent logs from last session.
+    SENDING_CURRENT_LOGS,           // Sending ongoing logs as they accrue.
   };
 
   enum ShutdownCleanliness {
     CLEANLY_SHUTDOWN = 0xdeadbeef,
     NEED_TO_SHUTDOWN = ~CLEANLY_SHUTDOWN
   };
 
   // Designates which entropy source was returned from this MetricsService.
   // This is used for testing to validate that we return the correct source
   // depending on the state of the service.
@@ skipping 70 matching lines @@
   void EnableRecording();
   void DisableRecording();
 
   // If in_idle is true, sets idle_since_last_transmission to true.
   // If in_idle is false and idle_since_last_transmission_ is true, sets
   // idle_since_last_transmission to false and starts the timer (provided
   // starting the timer is permitted).
   void HandleIdleSinceLastTransmission(bool in_idle);
 
   // Set up client ID, session ID, etc.
-  void InitializeMetricsState();
+  void InitializeMetricsState(ReportingState reporting_state);
 
   // Generates a new client ID to use to identify self to metrics server.
   static std::string GenerateClientID();
 
   // Schedule the next save of LocalState information.  This is called
   // automatically by the task that performs each save to schedule the next one.
   void ScheduleNextStateSave();
 
   // Save the LocalState information immediately. This should not be called by
   // anybody other than the scheduler to avoid doing too many writes. When you
@@ skipping 23 matching lines @@
   // Callbacks for various stages of final log info collection. Do not call
   // these directly.
   void OnMemoryDetailCollectionDone();
   void OnHistogramSynchronizationDone();
   void OnFinalLogInfoCollectionDone();
 
   // Either closes the current log or creates and closes the initial log
   // (depending on |state_|), and stages it for upload.
   void StageNewLog();
 
-  // Record stats, client ID, Session ID, etc. in a special "first" log.
-  void PrepareInitialLog();
+  // Prepares the initial stability log, which is only logged when the previous
+  // run of Chrome crashed.  This log contains any stability metrics left over
+  // from that previous run, and only these stability metrics.  It uses the
+  // system profile from the previous session.
+  void PrepareInitialStabilityLog();
+
+  // Prepares the initial metrics log, which includes startup histograms and
+  // profiler data, as well as incremental stability-related metrics.
+  void PrepareInitialMetricsLog(MetricsLog::LogType log_type);
 
   // Uploads the currently staged log (which must be non-null).
   void SendStagedLog();
 
   // Prepared the staged log to be passed to the server. Upon return,
   // current_fetch_ should be reset with its upload data set to a compressed
   // copy of the staged log.
   void PrepareFetchWithStagedLog();
 
   // Implementation of net::URLFetcherDelegate. Called after transmission
@@ skipping 56 matching lines @@
   // Indicate whether recording and reporting are currently happening.
   // These should not be set directly, but by calling SetRecording and
   // SetReporting.
   bool recording_active_;
   bool reporting_active_;
 
   // Indicate whether test mode is enabled, where the initial log should never
   // be cut, and logs are neither persisted nor uploaded.
   bool test_mode_active_;
 
-  // The progession of states made by the browser are recorded in the following
+  // The progression of states made by the browser are recorded in the following
   // state.
   State state_;
 
+  // Whether the initial stability log has been recorded during startup.
+  bool has_initial_stability_log_;
+
   // Chrome OS hardware class (e.g., hardware qualification ID). This
   // class identifies the configured system components such as CPU,
   // WiFi adapter, etc.  For non Chrome OS hosts, this will be an
   // empty string.
   std::string hardware_class_;
 
   // The list of plugins which was retrieved on the file thread.
   std::vector<content::WebPluginInfo> plugins_;
 
   // Google Update statistics, which were retrieved on a blocking pool thread.
   GoogleUpdateMetrics google_update_metrics_;
 
-  // The initial log, used to record startup metrics.
-  scoped_ptr<MetricsLog> initial_log_;
+  // The initial metrics log, used to record startup metrics (histograms and
+  // profiler data). Note that if a crash occurred in the previous session, an
+  // initial stability log may be sent before this.
+  scoped_ptr<MetricsLog> initial_metrics_log_;
 
   // The outstanding transmission appears as a URL Fetch operation.
   scoped_ptr<net::URLFetcher> current_fetch_;
 
   // The TCP/UDP echo server to collect network connectivity stats.
   std::string network_stats_server_;
 
   // The HTTP pipelining test server.
   std::string http_pipelining_test_server_;
 
@@ skipping 82 matching lines @@
   friend class extensions::ExtensionDownloader;
   friend class extensions::ManifestFetchData;
 
   // Returns true if prefs::kMetricsReportingEnabled is set.
   static bool IsMetricsReportingEnabled();
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(MetricsServiceHelper);
 };
 
 #endif  // CHROME_BROWSER_METRICS_METRICS_SERVICE_H_