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_ 199