components/device_event_log/device_event_log.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/device_event_log/device_event_log.h"
   6
   7 #include <string>
   8
   9 #include "base/logging.h"
  10 #include "base/thread_task_runner_handle.h"
  11 #include "components/device_event_log/device_event_log_impl.h"
  12
  13 namespace device_event_log {
  14
  15 namespace {
  16
  17 const size_t kDefaultMaxEntries = 4000;
  18
  19 const int kSlowMethodThresholdMs = 10;
  20 const int kVerySlowMethodThresholdMs = 50;
  21
  22 DeviceEventLogImpl* g_device_event_log = NULL;
  23
  24 }  // namespace
  25
  26 const LogLevel kDefaultLogLevel = LOG_LEVEL_EVENT;
  27
  28 void Initialize(size_t max_entries) {
  29   CHECK(!g_device_event_log);
  30   if (max_entries == 0)
  31     max_entries = kDefaultMaxEntries;
  32   g_device_event_log =
  33       new DeviceEventLogImpl(base::ThreadTaskRunnerHandle::Get(), max_entries);
  34 }
  35
  36 bool IsInitialized() {
  37   return !!g_device_event_log;
  38 }
  39
  40 void Shutdown() {
  41   delete g_device_event_log;
  42   g_device_event_log = NULL;
  43 }
  44
  45 void AddEntry(const char* file,
  46               int line,
  47               LogType type,
  48               LogLevel level,
  49               const std::string& event) {
  50   if (g_device_event_log) {
  51     g_device_event_log->AddEntry(file, line, type, level, event);
  52   } else {
  53     DeviceEventLogImpl::SendToVLogOrErrorLog(file, line, type, level, event);
  54   }
  55 }
  56
  57 void AddEntryWithDescription(const char* file,
  58                              int line,
  59                              LogType type,
  60                              LogLevel level,
  61                              const std::string& event,
  62                              const std::string& desc) {
  63   std::string event_with_desc = event;
  64   if (!desc.empty())
  65     event_with_desc += ": " + desc;
  66   AddEntry(file, line, type, level, event_with_desc);
  67 }
  68
  69 std::string GetAsString(StringOrder order,
  70                         const std::string& format,
  71                         const std::string& types,
  72                         LogLevel max_level,
  73                         size_t max_events) {
  74   if (!g_device_event_log)
  75     return "DeviceEventLog not initialized.";
  76   return g_device_event_log->GetAsString(order, format, types, max_level,
  77                                          max_events);
  78 }
  79
  80 namespace internal {
  81
  82 DeviceEventLogInstance::DeviceEventLogInstance(const char* file,
  83                                                int line,
  84                                                device_event_log::LogType type,
  85                                                device_event_log::LogLevel level)
  86     : file_(file), line_(line), type_(type), level_(level) {
  87 }
  88
  89 DeviceEventLogInstance::~DeviceEventLogInstance() {
  90   device_event_log::AddEntry(file_, line_, type_, level_, stream_.str());
  91 }
  92
  93 DeviceEventSystemErrorLogInstance::DeviceEventSystemErrorLogInstance(
  94     const char* file,
  95     int line,
  96     device_event_log::LogType type,
  97     device_event_log::LogLevel level,
  98     logging::SystemErrorCode err)
  99     : err_(err), log_instance_(file, line, type, level) {
 100 }
 101
 102 DeviceEventSystemErrorLogInstance::~DeviceEventSystemErrorLogInstance() {
 103   stream() << ": " << ::logging::SystemErrorCodeToString(err_);
 104 }
 105
 106 ScopedDeviceLogIfSlow::ScopedDeviceLogIfSlow(LogType type,
 107                                              const char* file,
 108                                              const std::string& name)
 109     : file_(file), type_(type), name_(name) {
 110 }
 111
 112 ScopedDeviceLogIfSlow::~ScopedDeviceLogIfSlow() {
 113   if (timer_.Elapsed().InMilliseconds() >= kSlowMethodThresholdMs) {
 114     LogLevel level(LOG_LEVEL_DEBUG);
 115     if (timer_.Elapsed().InMilliseconds() >= kVerySlowMethodThresholdMs)
 116       level = LOG_LEVEL_ERROR;
 117     DEVICE_LOG(type_, level) << "@@@ Slow method: " << file_ << ":" << name_
 118                              << ": " << timer_.Elapsed().InMilliseconds()
 119                              << "ms";
 120   }
 121 }
 122
 123 }  // namespace internal
 124
 125 }  // namespace device_event_log