base/metrics/statistics_recorder.cc

   1 // Copyright (c) 2012 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 "base/metrics/statistics_recorder.h"
   6
   7 #include "base/at_exit.h"
   8 #include "base/debug/leak_annotations.h"
   9 #include "base/json/string_escape.h"
  10 #include "base/logging.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/metrics/histogram.h"
  13 #include "base/stl_util.h"
  14 #include "base/strings/stringprintf.h"
  15 #include "base/synchronization/lock.h"
  16 #include "base/values.h"
  17
  18 namespace {
  19 // Initialize histogram statistics gathering system.
  20 base::LazyInstance<base::StatisticsRecorder>::Leaky g_statistics_recorder_ =
  21     LAZY_INSTANCE_INITIALIZER;
  22 }  // namespace
  23
  24 namespace base {
  25
  26 // static
  27 void StatisticsRecorder::Initialize() {
  28   // Ensure that an instance of the StatisticsRecorder object is created.
  29   g_statistics_recorder_.Get();
  30 }
  31
  32 // static
  33 bool StatisticsRecorder::IsActive() {
  34   if (lock_ == NULL)
  35     return false;
  36   base::AutoLock auto_lock(*lock_);
  37   return NULL != histograms_;
  38 }
  39
  40 // static
  41 HistogramBase* StatisticsRecorder::RegisterOrDeleteDuplicate(
  42     HistogramBase* histogram) {
  43   // As per crbug.com/79322 the histograms are intentionally leaked, so we need
  44   // to annotate them. Because ANNOTATE_LEAKING_OBJECT_PTR may be used only once
  45   // for an object, the duplicates should not be annotated.
  46   // Callers are responsible for not calling RegisterOrDeleteDuplicate(ptr)
  47   // twice if (lock_ == NULL) || (!histograms_).
  48   if (lock_ == NULL) {
  49     ANNOTATE_LEAKING_OBJECT_PTR(histogram);  // see crbug.com/79322
  50     return histogram;
  51   }
  52
  53   HistogramBase* histogram_to_delete = NULL;
  54   HistogramBase* histogram_to_return = NULL;
  55   {
  56     base::AutoLock auto_lock(*lock_);
  57     if (histograms_ == NULL) {
  58       histogram_to_return = histogram;
  59     } else {
  60       const std::string& name = histogram->histogram_name();
  61       HistogramMap::iterator it = histograms_->find(HistogramNameRef(name));
  62       if (histograms_->end() == it) {
  63         (*histograms_)[HistogramNameRef(name)] = histogram;
  64         ANNOTATE_LEAKING_OBJECT_PTR(histogram);  // see crbug.com/79322
  65         // If there are callbacks for this histogram, we set the kCallbackExists
  66         // flag.
  67         auto callback_iterator = callbacks_->find(name);
  68         if (callback_iterator != callbacks_->end()) {
  69           if (!callback_iterator->second.is_null())
  70             histogram->SetFlags(HistogramBase::kCallbackExists);
  71           else
  72             histogram->ClearFlags(HistogramBase::kCallbackExists);
  73         }
  74         histogram_to_return = histogram;
  75       } else if (histogram == it->second) {
  76         // The histogram was registered before.
  77         histogram_to_return = histogram;
  78       } else {
  79         // We already have one histogram with this name.
  80         histogram_to_return = it->second;
  81         histogram_to_delete = histogram;
  82       }
  83     }
  84   }
  85   delete histogram_to_delete;
  86   return histogram_to_return;
  87 }
  88
  89 // static
  90 const BucketRanges* StatisticsRecorder::RegisterOrDeleteDuplicateRanges(
  91     const BucketRanges* ranges) {
  92   DCHECK(ranges->HasValidChecksum());
  93   scoped_ptr<const BucketRanges> ranges_deleter;
  94
  95   if (lock_ == NULL) {
  96     ANNOTATE_LEAKING_OBJECT_PTR(ranges);
  97     return ranges;
  98   }
  99
 100   base::AutoLock auto_lock(*lock_);
 101   if (ranges_ == NULL) {
 102     ANNOTATE_LEAKING_OBJECT_PTR(ranges);
 103     return ranges;
 104   }
 105
 106   std::list<const BucketRanges*>* checksum_matching_list;
 107   RangesMap::iterator ranges_it = ranges_->find(ranges->checksum());
 108   if (ranges_->end() == ranges_it) {
 109     // Add a new matching list to map.
 110     checksum_matching_list = new std::list<const BucketRanges*>();
 111     ANNOTATE_LEAKING_OBJECT_PTR(checksum_matching_list);
 112     (*ranges_)[ranges->checksum()] = checksum_matching_list;
 113   } else {
 114     checksum_matching_list = ranges_it->second;
 115   }
 116
 117   for (const BucketRanges* existing_ranges : *checksum_matching_list) {
 118     if (existing_ranges->Equals(ranges)) {
 119       if (existing_ranges == ranges) {
 120         return ranges;
 121       } else {
 122         ranges_deleter.reset(ranges);
 123         return existing_ranges;
 124       }
 125     }
 126   }
 127   // We haven't found a BucketRanges which has the same ranges. Register the
 128   // new BucketRanges.
 129   checksum_matching_list->push_front(ranges);
 130   return ranges;
 131 }
 132
 133 // static
 134 void StatisticsRecorder::WriteHTMLGraph(const std::string& query,
 135                                         std::string* output) {
 136   if (!IsActive())
 137     return;
 138
 139   Histograms snapshot;
 140   GetSnapshot(query, &snapshot);
 141   for (const HistogramBase* histogram : snapshot) {
 142     histogram->WriteHTMLGraph(output);
 143     output->append("<br><hr><br>");
 144   }
 145 }
 146
 147 // static
 148 void StatisticsRecorder::WriteGraph(const std::string& query,
 149                                     std::string* output) {
 150   if (!IsActive())
 151     return;
 152   if (query.length())
 153     StringAppendF(output, "Collections of histograms for %s\n", query.c_str());
 154   else
 155     output->append("Collections of all histograms\n");
 156
 157   Histograms snapshot;
 158   GetSnapshot(query, &snapshot);
 159   for (const HistogramBase* histogram : snapshot) {
 160     histogram->WriteAscii(output);
 161     output->append("\n");
 162   }
 163 }
 164
 165 // static
 166 std::string StatisticsRecorder::ToJSON(const std::string& query) {
 167   if (!IsActive())
 168     return std::string();
 169
 170   std::string output("{");
 171   if (!query.empty()) {
 172     output += "\"query\":";
 173     EscapeJSONString(query, true, &output);
 174     output += ",";
 175   }
 176
 177   Histograms snapshot;
 178   GetSnapshot(query, &snapshot);
 179   output += "\"histograms\":[";
 180   bool first_histogram = true;
 181   for (const HistogramBase* histogram : snapshot) {
 182     if (first_histogram)
 183       first_histogram = false;
 184     else
 185       output += ",";
 186     std::string json;
 187     histogram->WriteJSON(&json);
 188     output += json;
 189   }
 190   output += "]}";
 191   return output;
 192 }
 193
 194 // static
 195 void StatisticsRecorder::GetHistograms(Histograms* output) {
 196   if (lock_ == NULL)
 197     return;
 198   base::AutoLock auto_lock(*lock_);
 199   if (histograms_ == NULL)
 200     return;
 201
 202   for (const auto& entry : *histograms_) {
 203     DCHECK_EQ(entry.first.name_, entry.second->histogram_name());
 204     output->push_back(entry.second);
 205   }
 206 }
 207
 208 // static
 209 void StatisticsRecorder::GetBucketRanges(
 210     std::vector<const BucketRanges*>* output) {
 211   if (lock_ == NULL)
 212     return;
 213   base::AutoLock auto_lock(*lock_);
 214   if (ranges_ == NULL)
 215     return;
 216
 217   for (const auto& entry : *ranges_) {
 218     for (const auto& range_entry : *entry.second) {
 219       output->push_back(range_entry);
 220     }
 221   }
 222 }
 223
 224 // static
 225 HistogramBase* StatisticsRecorder::FindHistogram(const std::string& name) {
 226   if (lock_ == NULL)
 227     return NULL;
 228   base::AutoLock auto_lock(*lock_);
 229   if (histograms_ == NULL)
 230     return NULL;
 231
 232   HistogramMap::iterator it = histograms_->find(HistogramNameRef(name));
 233   if (histograms_->end() == it)
 234     return NULL;
 235   return it->second;
 236 }
 237
 238 // static
 239 bool StatisticsRecorder::SetCallback(
 240     const std::string& name,
 241     const StatisticsRecorder::OnSampleCallback& cb) {
 242   DCHECK(!cb.is_null());
 243   if (lock_ == NULL)
 244     return false;
 245   base::AutoLock auto_lock(*lock_);
 246   if (histograms_ == NULL)
 247     return false;
 248
 249   if (ContainsKey(*callbacks_, name))
 250     return false;
 251   callbacks_->insert(std::make_pair(name, cb));
 252
 253   auto histogram_iterator = histograms_->find(HistogramNameRef(name));
 254   if (histogram_iterator != histograms_->end())
 255     histogram_iterator->second->SetFlags(HistogramBase::kCallbackExists);
 256
 257   return true;
 258 }
 259
 260 // static
 261 void StatisticsRecorder::ClearCallback(const std::string& name) {
 262   if (lock_ == NULL)
 263     return;
 264   base::AutoLock auto_lock(*lock_);
 265   if (histograms_ == NULL)
 266     return;
 267
 268   callbacks_->erase(name);
 269
 270   // We also clear the flag from the histogram (if it exists).
 271   auto histogram_iterator = histograms_->find(HistogramNameRef(name));
 272   if (histogram_iterator != histograms_->end())
 273     histogram_iterator->second->ClearFlags(HistogramBase::kCallbackExists);
 274 }
 275
 276 // static
 277 StatisticsRecorder::OnSampleCallback StatisticsRecorder::FindCallback(
 278     const std::string& name) {
 279   if (lock_ == NULL)
 280     return OnSampleCallback();
 281   base::AutoLock auto_lock(*lock_);
 282   if (histograms_ == NULL)
 283     return OnSampleCallback();
 284
 285   auto callback_iterator = callbacks_->find(name);
 286   return callback_iterator != callbacks_->end() ? callback_iterator->second
 287                                                 : OnSampleCallback();
 288 }
 289
 290 // private static
 291 void StatisticsRecorder::GetSnapshot(const std::string& query,
 292                                      Histograms* snapshot) {
 293   if (lock_ == NULL)
 294     return;
 295   base::AutoLock auto_lock(*lock_);
 296   if (histograms_ == NULL)
 297     return;
 298
 299   for (const auto& entry : *histograms_) {
 300     if (entry.first.name_.find(query) != std::string::npos)
 301       snapshot->push_back(entry.second);
 302   }
 303 }
 304
 305 // This singleton instance should be started during the single threaded portion
 306 // of main(), and hence it is not thread safe.  It initializes globals to
 307 // provide support for all future calls.
 308 StatisticsRecorder::StatisticsRecorder() {
 309   DCHECK(!histograms_);
 310   if (lock_ == NULL) {
 311     // This will leak on purpose. It's the only way to make sure we won't race
 312     // against the static uninitialization of the module while one of our
 313     // static methods relying on the lock get called at an inappropriate time
 314     // during the termination phase. Since it's a static data member, we will
 315     // leak one per process, which would be similar to the instance allocated
 316     // during static initialization and released only on  process termination.
 317     lock_ = new base::Lock;
 318   }
 319   base::AutoLock auto_lock(*lock_);
 320   histograms_ = new HistogramMap;
 321   callbacks_ = new CallbackMap;
 322   ranges_ = new RangesMap;
 323
 324   if (VLOG_IS_ON(1))
 325     AtExitManager::RegisterCallback(&DumpHistogramsToVlog, this);
 326 }
 327
 328 // static
 329 void StatisticsRecorder::DumpHistogramsToVlog(void* instance) {
 330   std::string output;
 331   StatisticsRecorder::WriteGraph(std::string(), &output);
 332   VLOG(1) << output;
 333 }
 334
 335 StatisticsRecorder::~StatisticsRecorder() {
 336   DCHECK(histograms_ && ranges_ && lock_);
 337
 338   // Clean up.
 339   scoped_ptr<HistogramMap> histograms_deleter;
 340   scoped_ptr<CallbackMap> callbacks_deleter;
 341   scoped_ptr<RangesMap> ranges_deleter;
 342   // We don't delete lock_ on purpose to avoid having to properly protect
 343   // against it going away after we checked for NULL in the static methods.
 344   {
 345     base::AutoLock auto_lock(*lock_);
 346     histograms_deleter.reset(histograms_);
 347     callbacks_deleter.reset(callbacks_);
 348     ranges_deleter.reset(ranges_);
 349     histograms_ = NULL;
 350     callbacks_ = NULL;
 351     ranges_ = NULL;
 352   }
 353   // We are going to leak the histograms and the ranges.
 354 }
 355
 356
 357 // static
 358 StatisticsRecorder::HistogramMap* StatisticsRecorder::histograms_ = NULL;
 359 // static
 360 StatisticsRecorder::CallbackMap* StatisticsRecorder::callbacks_ = NULL;
 361 // static
 362 StatisticsRecorder::RangesMap* StatisticsRecorder::ranges_ = NULL;
 363 // static
 364 base::Lock* StatisticsRecorder::lock_ = NULL;
 365
 366 }  // namespace base