components/metrics/persisted_logs.cc

   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 #include "components/metrics/persisted_logs.h"
   6
   7 #include <string>
   8
   9 #include "base/base64.h"
  10 #include "base/md5.h"
  11 #include "base/metrics/histogram.h"
  12 #include "base/prefs/pref_service.h"
  13 #include "base/prefs/scoped_user_pref_update.h"
  14 #include "base/sha1.h"
  15 #include "base/timer/elapsed_timer.h"
  16 #include "components/metrics/compression_utils.h"
  17
  18 namespace metrics {
  19
  20 namespace {
  21
  22 PersistedLogs::LogReadStatus MakeRecallStatusHistogram(
  23     PersistedLogs::LogReadStatus status) {
  24   UMA_HISTOGRAM_ENUMERATION("PrefService.PersistentLogRecallProtobufs",
  25                             status, PersistedLogs::END_RECALL_STATUS);
  26   return status;
  27 }
  28
  29 // Reads the value at |index| from |list_value| as a string and Base64-decodes
  30 // it into |result|. Returns true on success.
  31 bool ReadBase64String(const base::ListValue& list_value,
  32                       size_t index,
  33                       std::string* result) {
  34   std::string base64_result;
  35   if (!list_value.GetString(index, &base64_result))
  36     return false;
  37   return base::Base64Decode(base64_result, result);
  38 }
  39
  40 // Base64-encodes |str| and appends the result to |list_value|.
  41 void AppendBase64String(const std::string& str, base::ListValue* list_value) {
  42   std::string base64_str;
  43   base::Base64Encode(str, &base64_str);
  44   list_value->Append(base::Value::CreateStringValue(base64_str));
  45 }
  46
  47 }  // namespace
  48
  49 void PersistedLogs::LogHashPair::Init(const std::string& log_data) {
  50   DCHECK(!log_data.empty());
  51
  52   if (!GzipCompress(log_data, &compressed_log_data)) {
  53     NOTREACHED();
  54     return;
  55   }
  56
  57   UMA_HISTOGRAM_PERCENTAGE(
  58       "UMA.ProtoCompressionRatio",
  59       static_cast<int>(100 * compressed_log_data.size() / log_data.size()));
  60   UMA_HISTOGRAM_CUSTOM_COUNTS(
  61       "UMA.ProtoGzippedKBSaved",
  62       static_cast<int>((log_data.size() - compressed_log_data.size()) / 1024),
  63       1, 2000, 50);
  64
  65   hash = base::SHA1HashString(log_data);
  66 }
  67
  68 void PersistedLogs::LogHashPair::Clear() {
  69   compressed_log_data.clear();
  70   hash.clear();
  71 }
  72
  73 void PersistedLogs::LogHashPair::Swap(PersistedLogs::LogHashPair* input) {
  74   compressed_log_data.swap(input->compressed_log_data);
  75   hash.swap(input->hash);
  76 }
  77
  78 PersistedLogs::PersistedLogs(PrefService* local_state,
  79                              const char* pref_name,
  80                              const char* old_pref_name,
  81                              size_t min_log_count,
  82                              size_t min_log_bytes,
  83                              size_t max_log_size)
  84     : local_state_(local_state),
  85       pref_name_(pref_name),
  86       old_pref_name_(old_pref_name),
  87       min_log_count_(min_log_count),
  88       min_log_bytes_(min_log_bytes),
  89       max_log_size_(max_log_size),
  90       last_provisional_store_index_(-1) {
  91   DCHECK(local_state_);
  92   // One of the limit arguments must be non-zero.
  93   DCHECK(min_log_count_ > 0 || min_log_bytes_ > 0);
  94 }
  95
  96 PersistedLogs::~PersistedLogs() {}
  97
  98 void PersistedLogs::SerializeLogs() {
  99   // Remove any logs that are over the serialization size limit.
 100   if (max_log_size_) {
 101     for (std::vector<LogHashPair>::iterator it = list_.begin();
 102          it != list_.end();) {
 103       size_t log_size = it->compressed_log_data.length();
 104       if (log_size > max_log_size_) {
 105         UMA_HISTOGRAM_COUNTS("UMA.Large Accumulated Log Not Persisted",
 106                              static_cast<int>(log_size));
 107         it = list_.erase(it);
 108       } else {
 109         ++it;
 110       }
 111     }
 112   }
 113
 114   ListPrefUpdate update(local_state_, pref_name_);
 115   WriteLogsToPrefList(update.Get());
 116
 117   // Clear the old pref now that we've written to the new one.
 118   // TODO(asvitkine): Remove the old pref in M39.
 119   local_state_->ClearPref(old_pref_name_);
 120 }
 121
 122 PersistedLogs::LogReadStatus PersistedLogs::DeserializeLogs() {
 123   // First, try reading from old pref. If it's empty, read from the new one.
 124   // TODO(asvitkine): Remove the old pref in M39.
 125   const base::ListValue* unsent_logs = local_state_->GetList(old_pref_name_);
 126   if (!unsent_logs->empty())
 127     return ReadLogsFromOldPrefList(*unsent_logs);
 128
 129   unsent_logs = local_state_->GetList(pref_name_);
 130   return ReadLogsFromPrefList(*unsent_logs);
 131 }
 132
 133 void PersistedLogs::StoreLog(const std::string& log_data) {
 134   list_.push_back(LogHashPair());
 135   list_.back().Init(log_data);
 136 }
 137
 138 void PersistedLogs::StageLog() {
 139   // CHECK, rather than DCHECK, because swap()ing with an empty list causes
 140   // hard-to-identify crashes much later.
 141   CHECK(!list_.empty());
 142   DCHECK(!has_staged_log());
 143   staged_log_.Swap(&list_.back());
 144   list_.pop_back();
 145
 146   // If the staged log was the last provisional store, clear that.
 147   if (static_cast<size_t>(last_provisional_store_index_) == list_.size())
 148     last_provisional_store_index_ = -1;
 149   DCHECK(has_staged_log());
 150 }
 151
 152 void PersistedLogs::DiscardStagedLog() {
 153   DCHECK(has_staged_log());
 154   staged_log_.Clear();
 155 }
 156
 157 void PersistedLogs::StoreStagedLogAsUnsent(StoreType store_type) {
 158   list_.push_back(LogHashPair());
 159   list_.back().Swap(&staged_log_);
 160   if (store_type == PROVISIONAL_STORE)
 161     last_provisional_store_index_ = list_.size() - 1;
 162 }
 163
 164 void PersistedLogs::DiscardLastProvisionalStore() {
 165   if (last_provisional_store_index_ == -1)
 166     return;
 167   DCHECK_LT(static_cast<size_t>(last_provisional_store_index_), list_.size());
 168   list_.erase(list_.begin() + last_provisional_store_index_);
 169   last_provisional_store_index_ = -1;
 170 }
 171
 172 void PersistedLogs::WriteLogsToPrefList(base::ListValue* list_value) {
 173   list_value->Clear();
 174   // Leave the list completely empty if there are no storable values.
 175   if (list_.empty())
 176     return;
 177
 178   size_t start = 0;
 179   // If there are too many logs, keep the most recent logs up to the length
 180   // limit, and at least to the minimum number of bytes.
 181   if (list_.size() > min_log_count_) {
 182     start = list_.size();
 183     size_t bytes_used = 0;
 184     std::vector<LogHashPair>::const_reverse_iterator end = list_.rend();
 185     for (std::vector<LogHashPair>::const_reverse_iterator it = list_.rbegin();
 186          it != end; ++it) {
 187       const size_t log_size = it->compressed_log_data.length();
 188       if (bytes_used >= min_log_bytes_ &&
 189           (list_.size() - start) >= min_log_count_) {
 190         break;
 191       }
 192       bytes_used += log_size;
 193       --start;
 194     }
 195   }
 196   DCHECK_LT(start, list_.size());
 197
 198   for (size_t i = start; i < list_.size(); ++i) {
 199     AppendBase64String(list_[i].compressed_log_data, list_value);
 200     AppendBase64String(list_[i].hash, list_value);
 201   }
 202 }
 203
 204 PersistedLogs::LogReadStatus PersistedLogs::ReadLogsFromPrefList(
 205     const base::ListValue& list_value) {
 206   if (list_value.empty())
 207     return MakeRecallStatusHistogram(LIST_EMPTY);
 208
 209   // For each log, there's two entries in the list (the data and the hash).
 210   DCHECK_EQ(0U, list_value.GetSize() % 2);
 211   const size_t log_count = list_value.GetSize() / 2;
 212
 213   // Resize |list_| ahead of time, so that values can be decoded directly into
 214   // the elements of the list.
 215   DCHECK(list_.empty());
 216   list_.resize(log_count);
 217
 218   for (size_t i = 0; i < log_count; ++i) {
 219     if (!ReadBase64String(list_value, i * 2, &list_[i].compressed_log_data) ||
 220         !ReadBase64String(list_value, i * 2 + 1, &list_[i].hash)) {
 221       list_.clear();
 222       return MakeRecallStatusHistogram(LOG_STRING_CORRUPTION);
 223     }
 224   }
 225
 226   return MakeRecallStatusHistogram(RECALL_SUCCESS);
 227 }
 228
 229 PersistedLogs::LogReadStatus PersistedLogs::ReadLogsFromOldPrefList(
 230     const base::ListValue& list_value) {
 231   // We append (2) more elements to persisted lists: the size of the list and a
 232   // checksum of the elements.
 233   const size_t kChecksumEntryCount = 2;
 234
 235   if (list_value.GetSize() == 0)
 236     return MakeRecallStatusHistogram(LIST_EMPTY);
 237   if (list_value.GetSize() <= kChecksumEntryCount)
 238     return MakeRecallStatusHistogram(LIST_SIZE_TOO_SMALL);
 239
 240   // The size is stored at the beginning of the list_value.
 241   int size;
 242   bool valid = (*list_value.begin())->GetAsInteger(&size);
 243   if (!valid)
 244     return MakeRecallStatusHistogram(LIST_SIZE_MISSING);
 245   // Account for checksum and size included in the list_value.
 246   if (static_cast<size_t>(size) != list_value.GetSize() - kChecksumEntryCount)
 247     return MakeRecallStatusHistogram(LIST_SIZE_CORRUPTION);
 248
 249   // Allocate strings for all of the logs we are going to read in.
 250   // Do this ahead of time so that we can decode the string values directly into
 251   // the elements of |list_|, and thereby avoid making copies of the
 252   // serialized logs, which can be fairly large.
 253   DCHECK(list_.empty());
 254   list_.resize(size);
 255
 256   base::MD5Context ctx;
 257   base::MD5Init(&ctx);
 258   std::string encoded_log;
 259   size_t local_index = 0;
 260   for (base::ListValue::const_iterator it = list_value.begin() + 1;
 261        it != list_value.end() - 1;  // Last element is the checksum.
 262        ++it, ++local_index) {
 263     bool valid = (*it)->GetAsString(&encoded_log);
 264     if (!valid) {
 265       list_.clear();
 266       return MakeRecallStatusHistogram(LOG_STRING_CORRUPTION);
 267     }
 268
 269     base::MD5Update(&ctx, encoded_log);
 270
 271     std::string log_text;
 272     if (!base::Base64Decode(encoded_log, &log_text)) {
 273       list_.clear();
 274       return MakeRecallStatusHistogram(DECODE_FAIL);
 275     }
 276
 277     DCHECK_LT(local_index, list_.size());
 278     list_[local_index].Init(log_text);
 279   }
 280
 281   // Verify checksum.
 282   base::MD5Digest digest;
 283   base::MD5Final(&digest, &ctx);
 284   std::string recovered_md5;
 285   // We store the hash at the end of the list_value.
 286   valid = (*(list_value.end() - 1))->GetAsString(&recovered_md5);
 287   if (!valid) {
 288     list_.clear();
 289     return MakeRecallStatusHistogram(CHECKSUM_STRING_CORRUPTION);
 290   }
 291   if (recovered_md5 != base::MD5DigestToBase16(digest)) {
 292     list_.clear();
 293     return MakeRecallStatusHistogram(CHECKSUM_CORRUPTION);
 294   }
 295   return MakeRecallStatusHistogram(RECALL_SUCCESS);
 296 }
 297
 298 }  // namespace metrics