src/components/metrics/metrics_log.h

   1 // Copyright 2014 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 // This file defines a set of user experience metrics data recorded by
   6 // the MetricsService.  This is the unit of data that is sent to the server.
   7
   8 #ifndef COMPONENTS_METRICS_METRICS_LOG_H_
   9 #define COMPONENTS_METRICS_METRICS_LOG_H_
  10
  11 #include <string>
  12 #include <vector>
  13
  14 #include "base/basictypes.h"
  15 #include "base/time/time.h"
  16 #include "components/metrics/proto/chrome_user_metrics_extension.pb.h"
  17
  18 class PrefRegistrySimple;
  19 class PrefService;
  20
  21 namespace base {
  22 class DictionaryValue;
  23 class HistogramSamples;
  24 }
  25
  26 namespace content {
  27 struct WebPluginInfo;
  28 }
  29
  30 namespace metrics {
  31 class MetricsProvider;
  32 class MetricsServiceClient;
  33 }
  34
  35 namespace tracked_objects {
  36 struct ProcessDataSnapshot;
  37 }
  38
  39 namespace variations {
  40 struct ActiveGroupId;
  41 }
  42
  43 class MetricsLog {
  44  public:
  45   enum LogType {
  46     INITIAL_STABILITY_LOG,  // The initial log containing stability stats.
  47     ONGOING_LOG,            // Subsequent logs in a session.
  48   };
  49
  50   // Creates a new metrics log of the specified type.
  51   // |client_id| is the identifier for this profile on this installation
  52   // |session_id| is an integer that's incremented on each application launch
  53   // |client| is used to interact with the embedder.
  54   // |local_state| is the PrefService that this instance should use.
  55   // Note: |this| instance does not take ownership of the |client|, but rather
  56   // stores a weak pointer to it. The caller should ensure that the |client| is
  57   // valid for the lifetime of this class.
  58   MetricsLog(const std::string& client_id,
  59              int session_id,
  60              LogType log_type,
  61              metrics::MetricsServiceClient* client,
  62              PrefService* local_state);
  63   virtual ~MetricsLog();
  64
  65   // Registers local state prefs used by this class.
  66   static void RegisterPrefs(PrefRegistrySimple* registry);
  67
  68   // Computes the MD5 hash of the given string, and returns the first 8 bytes of
  69   // the hash.
  70   static uint64 Hash(const std::string& value);
  71
  72   // Get the GMT buildtime for the current binary, expressed in seconds since
  73   // January 1, 1970 GMT.
  74   // The value is used to identify when a new build is run, so that previous
  75   // reliability stats, from other builds, can be abandoned.
  76   static int64 GetBuildTime();
  77
  78   // Convenience function to return the current time at a resolution in seconds.
  79   // This wraps base::TimeTicks, and hence provides an abstract time that is
  80   // always incrementing for use in measuring time durations.
  81   static int64 GetCurrentTime();
  82
  83   // Records a user-initiated action.
  84   void RecordUserAction(const std::string& key);
  85
  86   // Record any changes in a given histogram for transmission.
  87   void RecordHistogramDelta(const std::string& histogram_name,
  88                             const base::HistogramSamples& snapshot);
  89
  90   // Records the current operating environment, including metrics provided by
  91   // the specified set of |metrics_providers|.  Takes the list of installed
  92   // plugins, Google Update statistics, and synthetic trial IDs as parameters
  93   // because those can't be obtained synchronously from the UI thread.
  94   // A synthetic trial is one that is set up dynamically by code in Chrome. For
  95   // example, a pref may be mapped to a synthetic trial such that the group
  96   // is determined by the pref value.
  97   void RecordEnvironment(
  98       const std::vector<metrics::MetricsProvider*>& metrics_providers,
  99       const std::vector<variations::ActiveGroupId>& synthetic_trials);
 100
 101   // Loads the environment proto that was saved by the last RecordEnvironment()
 102   // call from prefs and clears the pref value. Returns true on success or false
 103   // if there was no saved environment in prefs or it could not be decoded.
 104   bool LoadSavedEnvironmentFromPrefs();
 105
 106   // Writes application stability metrics, including stability metrics provided
 107   // by the specified set of |metrics_providers|. The system profile portion of
 108   // the log must have already been filled in by a call to RecordEnvironment()
 109   // or LoadSavedEnvironmentFromPrefs().
 110   // NOTE: Has the side-effect of clearing the stability prefs..
 111   //
 112   // If this log is of type INITIAL_STABILITY_LOG, records additional info such
 113   // as number of incomplete shutdowns as well as extra breakpad and debugger
 114   // stats.
 115   void RecordStabilityMetrics(
 116       const std::vector<metrics::MetricsProvider*>& metrics_providers,
 117       base::TimeDelta incremental_uptime,
 118       base::TimeDelta uptime);
 119
 120   // Records general metrics based on the specified |metrics_providers|.
 121   void RecordGeneralMetrics(
 122       const std::vector<metrics::MetricsProvider*>& metrics_providers);
 123
 124   // Stop writing to this record and generate the encoded representation.
 125   // None of the Record* methods can be called after this is called.
 126   void CloseLog();
 127
 128   // Fills |encoded_log| with the serialized protobuf representation of the
 129   // record.  Must only be called after CloseLog() has been called.
 130   void GetEncodedLog(std::string* encoded_log);
 131
 132   const base::TimeTicks& creation_time() const {
 133     return creation_time_;
 134   }
 135
 136   int num_events() const {
 137     return uma_proto_.omnibox_event_size() +
 138            uma_proto_.user_action_event_size();
 139   }
 140
 141   LogType log_type() const { return log_type_; }
 142
 143  protected:
 144   // Exposed for the sake of mocking/accessing in test code.
 145
 146   // Fills |field_trial_ids| with the list of initialized field trials name and
 147   // group ids.
 148   virtual void GetFieldTrialIds(
 149       std::vector<variations::ActiveGroupId>* field_trial_ids) const;
 150
 151   metrics::ChromeUserMetricsExtension* uma_proto() { return &uma_proto_; }
 152   const metrics::ChromeUserMetricsExtension* uma_proto() const {
 153     return &uma_proto_;
 154   }
 155
 156  private:
 157   // Returns true if the environment has already been filled in by a call to
 158   // RecordEnvironment() or LoadSavedEnvironmentFromPrefs().
 159   bool HasEnvironment() const;
 160
 161   // Returns true if the stability metrics have already been filled in by a
 162   // call to RecordStabilityMetrics().
 163   bool HasStabilityMetrics() const;
 164
 165   // Within the stability group, write required attributes.
 166   void WriteRequiredStabilityAttributes(PrefService* pref);
 167
 168   // Within the stability group, write attributes that need to be updated asap
 169   // and can't be delayed until the user decides to restart chromium.
 170   // Delaying these stats would bias metrics away from happy long lived
 171   // chromium processes (ones that don't crash, and keep on running).
 172   void WriteRealtimeStabilityAttributes(PrefService* pref,
 173                                         base::TimeDelta incremental_uptime,
 174                                         base::TimeDelta uptime);
 175
 176   // closed_ is true when record has been packed up for sending, and should
 177   // no longer be written to.  It is only used for sanity checking.
 178   bool closed_;
 179
 180   // The type of the log, i.e. initial or ongoing.
 181   const LogType log_type_;
 182
 183   // Stores the protocol buffer representation for this log.
 184   metrics::ChromeUserMetricsExtension uma_proto_;
 185
 186   // Used to interact with the embedder. Weak pointer; must outlive |this|
 187   // instance.
 188   metrics::MetricsServiceClient* const client_;
 189
 190   // The time when the current log was created.
 191   const base::TimeTicks creation_time_;
 192
 193   PrefService* local_state_;
 194
 195   DISALLOW_COPY_AND_ASSIGN(MetricsLog);
 196 };
 197
 198 #endif  // COMPONENTS_METRICS_METRICS_LOG_H_