chromeos/network/network_event_log.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 "chromeos/network/network_event_log.h"
   6
   7 #include <list>
   8
   9 #include "base/files/file_path.h"
  10 #include "base/i18n/time_formatting.h"
  11 #include "base/json/json_string_value_serializer.h"
  12 #include "base/json/json_writer.h"
  13 #include "base/logging.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/strings/string_tokenizer.h"
  16 #include "base/strings/stringprintf.h"
  17 #include "base/strings/utf_string_conversions.h"
  18 #include "base/values.h"
  19 #include "net/base/escape.h"
  20
  21 namespace chromeos {
  22 namespace network_event_log {
  23
  24 namespace {
  25
  26 class NetworkEventLog;
  27 NetworkEventLog* g_network_event_log = NULL;
  28 size_t g_max_network_event_log_entries = 4000;
  29 const char* kLogLevelName[] = {"Error", "User", "Event", "Debug"};
  30
  31 struct LogEntry {
  32   LogEntry(const std::string& file,
  33            int file_line,
  34            LogLevel log_level,
  35            const std::string& event,
  36            const std::string& description);
  37
  38   std::string ToString(bool show_time,
  39                        bool show_file,
  40                        bool show_desc,
  41                        bool format_html) const;
  42   void ToDictionary(base::DictionaryValue*) const;
  43
  44   std::string GetNormalText(bool show_desc) const;
  45   std::string GetHtmlText(bool show_desc) const;
  46   std::string GetAsJSON() const;
  47
  48   void SendToVLogOrErrorLog() const;
  49
  50   bool ContentEquals(const LogEntry& other) const;
  51
  52   std::string file;
  53   int file_line;
  54   LogLevel log_level;
  55   std::string event;
  56   std::string description;
  57   base::Time time;
  58   int count;
  59 };
  60
  61 LogEntry::LogEntry(const std::string& file,
  62                    int file_line,
  63                    LogLevel log_level,
  64                    const std::string& event,
  65                    const std::string& description)
  66     : file(file),
  67       file_line(file_line),
  68       log_level(log_level),
  69       event(event),
  70       description(description),
  71       time(base::Time::Now()),
  72       count(1) {}
  73
  74 std::string LogEntry::ToString(bool show_time,
  75                                bool show_file,
  76                                bool show_desc,
  77                                bool format_html) const {
  78   std::string line;
  79   if (show_time)
  80     line += "[" + base::UTF16ToUTF8(base::TimeFormatTimeOfDay(time)) + "] ";
  81   if (show_file) {
  82     std::string filestr = format_html ? net::EscapeForHTML(file) : file;
  83     line += base::StringPrintf("%s:%d ", file.c_str(), file_line);
  84   }
  85   line += format_html ? GetHtmlText(show_desc) : GetNormalText(show_desc);
  86   if (count > 1)
  87     line += base::StringPrintf(" (%d)", count);
  88   return line;
  89 }
  90
  91 void LogEntry::ToDictionary(base::DictionaryValue* output) const {
  92   output->SetString("timestamp", base::TimeFormatShortDateAndTime(time));
  93   output->SetString("level", kLogLevelName[log_level]);
  94   output->SetString("file",
  95                     base::StringPrintf("%s:%d ", file.c_str(), file_line));
  96   output->SetString("event", event);
  97   output->SetString("description", description);
  98 }
  99
 100 std::string LogEntry::GetAsJSON() const {
 101   base::DictionaryValue entry;
 102   ToDictionary(&entry);
 103   std::string json;
 104   JSONStringValueSerializer serializer(&json);
 105   if (!serializer.Serialize(entry)) {
 106     LOG(ERROR) << "Failed to serialize to JSON";
 107   }
 108   return json;
 109 }
 110
 111 std::string LogEntry::GetNormalText(bool show_desc) const {
 112   std::string text = event;
 113   if (show_desc && !description.empty())
 114     text += ": " + description;
 115   return text;
 116 }
 117
 118 std::string LogEntry::GetHtmlText(bool show_desc) const {
 119   std::string text;
 120   if (log_level == LOG_LEVEL_DEBUG)
 121     text += "<i>";
 122   else if (log_level == LOG_LEVEL_USER)
 123     text += "<b>";
 124   else if (log_level == LOG_LEVEL_ERROR)
 125     text += "<b><i>";
 126
 127   text += event;
 128   if (show_desc && !description.empty())
 129     text += ": " + net::EscapeForHTML(description);
 130
 131   if (log_level == LOG_LEVEL_DEBUG)
 132     text += "</i>";
 133   else if (log_level == LOG_LEVEL_USER)
 134     text += "</b>";
 135   else if (log_level == LOG_LEVEL_ERROR)
 136     text += "</i></b>";
 137   return text;
 138 }
 139
 140 void LogEntry::SendToVLogOrErrorLog() const {
 141   const bool show_time = true;
 142   const bool show_file = true;
 143   const bool show_desc = true;
 144   const bool format_html = false;
 145   std::string output = ToString(show_time, show_file, show_desc, format_html);
 146   if (log_level == LOG_LEVEL_ERROR)
 147     LOG(ERROR) << output;
 148   else
 149     VLOG(1) << output;
 150 }
 151
 152 bool LogEntry::ContentEquals(const LogEntry& other) const {
 153   return file == other.file &&
 154          file_line == other.file_line &&
 155          event == other.event &&
 156          description == other.description;
 157 }
 158
 159 void GetFormat(const std::string& format_string,
 160                bool* show_time,
 161                bool* show_file,
 162                bool* show_desc,
 163                bool* format_html,
 164                bool* format_json) {
 165   base::StringTokenizer tokens(format_string, ",");
 166   *show_time = false;
 167   *show_file = false;
 168   *show_desc = false;
 169   *format_html = false;
 170   *format_json = false;
 171   while (tokens.GetNext()) {
 172     std::string tok(tokens.token());
 173     if (tok == "time")
 174       *show_time = true;
 175     if (tok == "file")
 176       *show_file = true;
 177     if (tok == "desc")
 178       *show_desc = true;
 179     if (tok == "html")
 180       *format_html = true;
 181     if (tok == "json")
 182       *format_json = true;
 183   }
 184 }
 185
 186 typedef std::list<LogEntry> LogEntryList;
 187
 188 class NetworkEventLog {
 189  public:
 190   NetworkEventLog() {}
 191   ~NetworkEventLog() {}
 192
 193   void AddLogEntry(const LogEntry& entry);
 194
 195   std::string GetAsString(StringOrder order,
 196                           const std::string& format,
 197                           LogLevel max_level,
 198                           size_t max_events);
 199
 200   LogEntryList& entries() { return entries_; }
 201
 202  private:
 203   LogEntryList entries_;
 204
 205   DISALLOW_COPY_AND_ASSIGN(NetworkEventLog);
 206 };
 207
 208 void NetworkEventLog::AddLogEntry(const LogEntry& entry) {
 209   if (!entries_.empty()) {
 210     LogEntry& last = entries_.back();
 211     if (last.ContentEquals(entry)) {
 212       // Update count and time for identical events to avoid log spam.
 213       ++last.count;
 214       last.log_level = std::min(last.log_level, entry.log_level);
 215       last.time = base::Time::Now();
 216       return;
 217     }
 218   }
 219   if (entries_.size() >= g_max_network_event_log_entries) {
 220     const size_t max_error_entries = g_max_network_event_log_entries / 2;
 221     // Remove the first (oldest) non-error entry, or the oldest entry if more
 222     // than half the entries are errors.
 223     size_t error_count = 0;
 224     for (LogEntryList::iterator iter = entries_.begin(); iter != entries_.end();
 225          ++iter) {
 226       if (iter->log_level != LOG_LEVEL_ERROR) {
 227         entries_.erase(iter);
 228         break;
 229       }
 230       if (++error_count > max_error_entries) {
 231         // Too many error entries, remove the oldest entry.
 232         entries_.pop_front();
 233         break;
 234       }
 235     }
 236   }
 237   entries_.push_back(entry);
 238   entry.SendToVLogOrErrorLog();
 239 }
 240
 241 std::string NetworkEventLog::GetAsString(StringOrder order,
 242                                          const std::string& format,
 243                                          LogLevel max_level,
 244                                          size_t max_events) {
 245   if (entries_.empty())
 246     return "No Log Entries.";
 247
 248   bool show_time, show_file, show_desc, format_html, format_json;
 249   GetFormat(
 250       format, &show_time, &show_file, &show_desc, &format_html, &format_json);
 251
 252   std::string result;
 253   base::ListValue log_entries;
 254   if (order == OLDEST_FIRST) {
 255     size_t offset = 0;
 256     if (max_events > 0 && max_events < entries_.size()) {
 257       // Iterate backwards through the list skipping uninteresting entries to
 258       // determine the first entry to include.
 259       size_t shown_events = 0;
 260       size_t num_entries = 0;
 261       for (LogEntryList::const_reverse_iterator riter = entries_.rbegin();
 262            riter != entries_.rend();
 263            ++riter) {
 264         ++num_entries;
 265         if (riter->log_level > max_level)
 266           continue;
 267         if (++shown_events >= max_events)
 268           break;
 269       }
 270       offset = entries_.size() - num_entries;
 271     }
 272     for (LogEntryList::const_iterator iter = entries_.begin();
 273          iter != entries_.end();
 274          ++iter) {
 275       if (offset > 0) {
 276         --offset;
 277         continue;
 278       }
 279       if (iter->log_level > max_level)
 280         continue;
 281       if (format_json) {
 282         log_entries.AppendString((*iter).GetAsJSON());
 283       } else {
 284         result +=
 285             (*iter).ToString(show_time, show_file, show_desc, format_html);
 286         result += "\n";
 287       }
 288     }
 289   } else {
 290     size_t nlines = 0;
 291     // Iterate backwards through the list to show the most recent entries first.
 292     for (LogEntryList::const_reverse_iterator riter = entries_.rbegin();
 293          riter != entries_.rend();
 294          ++riter) {
 295       if (riter->log_level > max_level)
 296         continue;
 297       if (format_json) {
 298         log_entries.AppendString((*riter).GetAsJSON());
 299       } else {
 300         result +=
 301             (*riter).ToString(show_time, show_file, show_desc, format_html);
 302         result += "\n";
 303       }
 304       if (max_events > 0 && ++nlines >= max_events)
 305         break;
 306     }
 307   }
 308   if (format_json) {
 309     JSONStringValueSerializer serializer(&result);
 310     serializer.Serialize(log_entries);
 311   }
 312
 313   return result;
 314 }
 315
 316 }  // namespace
 317
 318 const LogLevel kDefaultLogLevel = LOG_LEVEL_EVENT;
 319
 320 void Initialize() {
 321   if (g_network_event_log)
 322     delete g_network_event_log;  // reset log
 323   g_network_event_log = new NetworkEventLog();
 324 }
 325
 326 void Shutdown() {
 327   delete g_network_event_log;
 328   g_network_event_log = NULL;
 329 }
 330
 331 bool IsInitialized() { return g_network_event_log != NULL; }
 332
 333 namespace internal {
 334
 335 size_t GetMaxLogEntries() { return g_max_network_event_log_entries; }
 336
 337 void SetMaxLogEntries(size_t max_entries) {
 338   g_max_network_event_log_entries = max_entries;
 339   if (!g_network_event_log)
 340     return;
 341   while (g_network_event_log->entries().size() > max_entries)
 342     g_network_event_log->entries().pop_front();
 343 }
 344
 345 void AddEntry(const char* file,
 346               int file_line,
 347               LogLevel log_level,
 348               const std::string& event,
 349               const std::string& description) {
 350   std::string filestr;
 351   if (file)
 352     filestr = base::FilePath(std::string(file)).BaseName().value();
 353   LogEntry entry(filestr, file_line, log_level, event, description);
 354   if (!g_network_event_log) {
 355     entry.SendToVLogOrErrorLog();
 356     return;
 357   }
 358   g_network_event_log->AddLogEntry(entry);
 359 }
 360
 361 }  // namespace internal
 362
 363 std::string GetAsString(StringOrder order,
 364                         const std::string& format,
 365                         LogLevel max_level,
 366                         size_t max_events) {
 367   if (!g_network_event_log)
 368     return "NetworkEventLog not initialized.";
 369   return g_network_event_log->GetAsString(order, format, max_level, max_events);
 370 }
 371
 372 std::string ValueAsString(const base::Value& value) {
 373   std::string vstr;
 374   base::JSONWriter::WriteWithOptions(
 375       &value, base::JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &vstr);
 376   return vstr.empty() ? "''" : vstr;
 377 }
 378
 379 }  // namespace network_event_log
 380 }  // namespace chromeos