| OLD | NEW |
|---|
| (Empty) |
| 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 <cmath> | |
| 8 #include <list> | |
| 9 | |
| 10 #include "base/files/file_path.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 std::string DateAndTimeWithMicroseconds(const base::Time& time) { | |
| 27 base::Time::Exploded exploded; | |
| 28 time.LocalExplode(&exploded); | |
| 29 // base::Time::Exploded does not include microseconds, but sometimes we need | |
| 30 // microseconds, so append '.' + usecs to the end of the formatted string. | |
| 31 int usecs = static_cast<int>(fmod(time.ToDoubleT() * 1000000, 1000000)); | |
| 32 return base::StringPrintf("%04d/%02d/%02d %02d:%02d:%02d.%06d", | |
| 33 exploded.year, | |
| 34 exploded.month, | |
| 35 exploded.day_of_month, | |
| 36 exploded.hour, | |
| 37 exploded.minute, | |
| 38 exploded.second, | |
| 39 usecs); | |
| 40 } | |
| 41 | |
| 42 std::string TimeWithSeconds(const base::Time& time) { | |
| 43 base::Time::Exploded exploded; | |
| 44 time.LocalExplode(&exploded); | |
| 45 return base::StringPrintf("%02d:%02d:%02d", | |
| 46 exploded.hour, | |
| 47 exploded.minute, | |
| 48 exploded.second); | |
| 49 } | |
| 50 | |
| 51 std::string TimeWithMillieconds(const base::Time& time) { | |
| 52 base::Time::Exploded exploded; | |
| 53 time.LocalExplode(&exploded); | |
| 54 return base::StringPrintf("%02d:%02d:%02d.%03d", | |
| 55 exploded.hour, | |
| 56 exploded.minute, | |
| 57 exploded.second, | |
| 58 exploded.millisecond); | |
| 59 } | |
| 60 | |
| 61 class NetworkEventLog; | |
| 62 NetworkEventLog* g_network_event_log = NULL; | |
| 63 size_t g_max_network_event_log_entries = 4000; | |
| 64 const char* kLogLevelName[] = {"Error", "User", "Event", "Debug"}; | |
| 65 | |
| 66 struct LogEntry { | |
| 67 LogEntry(const std::string& file, | |
| 68 int file_line, | |
| 69 LogLevel log_level, | |
| 70 const std::string& event, | |
| 71 const std::string& description); | |
| 72 | |
| 73 std::string ToString(bool show_time, | |
| 74 bool show_file, | |
| 75 bool show_level, | |
| 76 bool show_desc, | |
| 77 bool format_html) const; | |
| 78 void ToDictionary(base::DictionaryValue*) const; | |
| 79 | |
| 80 std::string GetNormalText(bool show_desc) const; | |
| 81 std::string GetHtmlText(bool show_desc) const; | |
| 82 std::string GetAsJSON() const; | |
| 83 | |
| 84 void SendToVLogOrErrorLog() const; | |
| 85 | |
| 86 bool ContentEquals(const LogEntry& other) const; | |
| 87 | |
| 88 std::string file; | |
| 89 int file_line; | |
| 90 LogLevel log_level; | |
| 91 std::string event; | |
| 92 std::string description; | |
| 93 base::Time time; | |
| 94 int count; | |
| 95 }; | |
| 96 | |
| 97 LogEntry::LogEntry(const std::string& file, | |
| 98 int file_line, | |
| 99 LogLevel log_level, | |
| 100 const std::string& event, | |
| 101 const std::string& description) | |
| 102 : file(file), | |
| 103 file_line(file_line), | |
| 104 log_level(log_level), | |
| 105 event(event), | |
| 106 description(description), | |
| 107 time(base::Time::Now()), | |
| 108 count(1) {} | |
| 109 | |
| 110 std::string LogEntry::ToString(bool show_time, | |
| 111 bool show_file, | |
| 112 bool show_level, | |
| 113 bool show_desc, | |
| 114 bool format_html) const { | |
| 115 std::string line; | |
| 116 if (show_time) | |
| 117 line += "[" + TimeWithMillieconds(time) + "] "; | |
| 118 if (show_level) { | |
| 119 const char* kLevelDesc[] = { | |
| 120 "ERROR", | |
| 121 "USER", | |
| 122 "EVENT", | |
| 123 "DEBUG" | |
| 124 }; | |
| 125 line += base::StringPrintf("%s: ", kLevelDesc[log_level]); | |
| 126 } | |
| 127 if (show_file) { | |
| 128 std::string filestr = format_html ? net::EscapeForHTML(file) : file; | |
| 129 line += base::StringPrintf("%s:%d ", file.c_str(), file_line); | |
| 130 } | |
| 131 line += format_html ? GetHtmlText(show_desc) : GetNormalText(show_desc); | |
| 132 if (count > 1) | |
| 133 line += base::StringPrintf(" (%d)", count); | |
| 134 return line; | |
| 135 } | |
| 136 | |
| 137 void LogEntry::ToDictionary(base::DictionaryValue* output) const { | |
| 138 output->SetString("timestamp", DateAndTimeWithMicroseconds(time)); | |
| 139 output->SetString("timestampshort", TimeWithSeconds(time)); | |
| 140 output->SetString("level", kLogLevelName[log_level]); | |
| 141 output->SetString("file", | |
| 142 base::StringPrintf("%s:%d ", file.c_str(), file_line)); | |
| 143 output->SetString("event", event); | |
| 144 output->SetString("description", description); | |
| 145 } | |
| 146 | |
| 147 std::string LogEntry::GetAsJSON() const { | |
| 148 base::DictionaryValue entry; | |
| 149 ToDictionary(&entry); | |
| 150 std::string json; | |
| 151 JSONStringValueSerializer serializer(&json); | |
| 152 if (!serializer.Serialize(entry)) { | |
| 153 LOG(ERROR) << "Failed to serialize to JSON"; | |
| 154 } | |
| 155 return json; | |
| 156 } | |
| 157 | |
| 158 std::string LogEntry::GetNormalText(bool show_desc) const { | |
| 159 std::string text = event; | |
| 160 if (show_desc && !description.empty()) | |
| 161 text += ": " + description; | |
| 162 return text; | |
| 163 } | |
| 164 | |
| 165 std::string LogEntry::GetHtmlText(bool show_desc) const { | |
| 166 std::string text; | |
| 167 if (log_level == LOG_LEVEL_DEBUG) | |
| 168 text += "<i>"; | |
| 169 else if (log_level == LOG_LEVEL_USER) | |
| 170 text += "<b>"; | |
| 171 else if (log_level == LOG_LEVEL_ERROR) | |
| 172 text += "<b><i>"; | |
| 173 | |
| 174 text += event; | |
| 175 if (show_desc && !description.empty()) | |
| 176 text += ": " + net::EscapeForHTML(description); | |
| 177 | |
| 178 if (log_level == LOG_LEVEL_DEBUG) | |
| 179 text += "</i>"; | |
| 180 else if (log_level == LOG_LEVEL_USER) | |
| 181 text += "</b>"; | |
| 182 else if (log_level == LOG_LEVEL_ERROR) | |
| 183 text += "</i></b>"; | |
| 184 return text; | |
| 185 } | |
| 186 | |
| 187 void LogEntry::SendToVLogOrErrorLog() const { | |
| 188 if (log_level != LOG_LEVEL_ERROR && !VLOG_IS_ON(1)) | |
| 189 return; | |
| 190 const bool show_time = true; | |
| 191 const bool show_file = true; | |
| 192 const bool show_level = false; | |
| 193 const bool show_desc = true; | |
| 194 const bool format_html = false; | |
| 195 std::string output = | |
| 196 ToString(show_time, show_file, show_level, show_desc, format_html); | |
| 197 if (log_level == LOG_LEVEL_ERROR) | |
| 198 LOG(ERROR) << output; | |
| 199 else | |
| 200 VLOG(1) << output; | |
| 201 } | |
| 202 | |
| 203 bool LogEntry::ContentEquals(const LogEntry& other) const { | |
| 204 return file == other.file && | |
| 205 file_line == other.file_line && | |
| 206 event == other.event && | |
| 207 description == other.description; | |
| 208 } | |
| 209 | |
| 210 void GetFormat(const std::string& format_string, | |
| 211 bool* show_time, | |
| 212 bool* show_file, | |
| 213 bool* show_level, | |
| 214 bool* show_desc, | |
| 215 bool* format_html, | |
| 216 bool* format_json) { | |
| 217 base::StringTokenizer tokens(format_string, ","); | |
| 218 *show_time = false; | |
| 219 *show_file = false; | |
| 220 *show_level = false; | |
| 221 *show_desc = false; | |
| 222 *format_html = false; | |
| 223 *format_json = false; | |
| 224 while (tokens.GetNext()) { | |
| 225 std::string tok(tokens.token()); | |
| 226 if (tok == "time") | |
| 227 *show_time = true; | |
| 228 if (tok == "file") | |
| 229 *show_file = true; | |
| 230 if (tok == "level") | |
| 231 *show_level = true; | |
| 232 if (tok == "desc") | |
| 233 *show_desc = true; | |
| 234 if (tok == "html") | |
| 235 *format_html = true; | |
| 236 if (tok == "json") | |
| 237 *format_json = true; | |
| 238 } | |
| 239 } | |
| 240 | |
| 241 typedef std::list<LogEntry> LogEntryList; | |
| 242 | |
| 243 class NetworkEventLog { | |
| 244 public: | |
| 245 NetworkEventLog() {} | |
| 246 ~NetworkEventLog() {} | |
| 247 | |
| 248 void AddLogEntry(const LogEntry& entry); | |
| 249 | |
| 250 std::string GetAsString(StringOrder order, | |
| 251 const std::string& format, | |
| 252 LogLevel max_level, | |
| 253 size_t max_events); | |
| 254 | |
| 255 LogEntryList& entries() { return entries_; } | |
| 256 | |
| 257 private: | |
| 258 LogEntryList entries_; | |
| 259 | |
| 260 DISALLOW_COPY_AND_ASSIGN(NetworkEventLog); | |
| 261 }; | |
| 262 | |
| 263 void NetworkEventLog::AddLogEntry(const LogEntry& entry) { | |
| 264 if (!entries_.empty()) { | |
| 265 LogEntry& last = entries_.back(); | |
| 266 if (last.ContentEquals(entry)) { | |
| 267 // Update count and time for identical events to avoid log spam. | |
| 268 ++last.count; | |
| 269 last.log_level = std::min(last.log_level, entry.log_level); | |
| 270 last.time = base::Time::Now(); | |
| 271 return; | |
| 272 } | |
| 273 } | |
| 274 if (entries_.size() >= g_max_network_event_log_entries) { | |
| 275 const size_t max_error_entries = g_max_network_event_log_entries / 2; | |
| 276 // Remove the first (oldest) non-error entry, or the oldest entry if more | |
| 277 // than half the entries are errors. | |
| 278 size_t error_count = 0; | |
| 279 for (LogEntryList::iterator iter = entries_.begin(); iter != entries_.end(); | |
| 280 ++iter) { | |
| 281 if (iter->log_level != LOG_LEVEL_ERROR) { | |
| 282 entries_.erase(iter); | |
| 283 break; | |
| 284 } | |
| 285 if (++error_count > max_error_entries) { | |
| 286 // Too many error entries, remove the oldest entry. | |
| 287 entries_.pop_front(); | |
| 288 break; | |
| 289 } | |
| 290 } | |
| 291 } | |
| 292 entries_.push_back(entry); | |
| 293 entry.SendToVLogOrErrorLog(); | |
| 294 } | |
| 295 | |
| 296 std::string NetworkEventLog::GetAsString(StringOrder order, | |
| 297 const std::string& format, | |
| 298 LogLevel max_level, | |
| 299 size_t max_events) { | |
| 300 if (entries_.empty()) | |
| 301 return "No Log Entries."; | |
| 302 | |
| 303 bool show_time, show_file, show_level, show_desc, format_html, format_json; | |
| 304 GetFormat(format, | |
| 305 &show_time, | |
| 306 &show_file, | |
| 307 &show_level, | |
| 308 &show_desc, | |
| 309 &format_html, | |
| 310 &format_json); | |
| 311 | |
| 312 std::string result; | |
| 313 base::ListValue log_entries; | |
| 314 if (order == OLDEST_FIRST) { | |
| 315 size_t offset = 0; | |
| 316 if (max_events > 0 && max_events < entries_.size()) { | |
| 317 // Iterate backwards through the list skipping uninteresting entries to | |
| 318 // determine the first entry to include. | |
| 319 size_t shown_events = 0; | |
| 320 size_t num_entries = 0; | |
| 321 for (LogEntryList::const_reverse_iterator riter = entries_.rbegin(); | |
| 322 riter != entries_.rend(); | |
| 323 ++riter) { | |
| 324 ++num_entries; | |
| 325 if (riter->log_level > max_level) | |
| 326 continue; | |
| 327 if (++shown_events >= max_events) | |
| 328 break; | |
| 329 } | |
| 330 offset = entries_.size() - num_entries; | |
| 331 } | |
| 332 for (LogEntryList::const_iterator iter = entries_.begin(); | |
| 333 iter != entries_.end(); | |
| 334 ++iter) { | |
| 335 if (offset > 0) { | |
| 336 --offset; | |
| 337 continue; | |
| 338 } | |
| 339 if (iter->log_level > max_level) | |
| 340 continue; | |
| 341 if (format_json) { | |
| 342 log_entries.AppendString((*iter).GetAsJSON()); | |
| 343 } else { | |
| 344 result += (*iter).ToString( | |
| 345 show_time, show_file, show_level, show_desc, format_html); | |
| 346 result += "\n"; | |
| 347 } | |
| 348 } | |
| 349 } else { | |
| 350 size_t nlines = 0; | |
| 351 // Iterate backwards through the list to show the most recent entries first. | |
| 352 for (LogEntryList::const_reverse_iterator riter = entries_.rbegin(); | |
| 353 riter != entries_.rend(); | |
| 354 ++riter) { | |
| 355 if (riter->log_level > max_level) | |
| 356 continue; | |
| 357 if (format_json) { | |
| 358 log_entries.AppendString((*riter).GetAsJSON()); | |
| 359 } else { | |
| 360 result += (*riter).ToString( | |
| 361 show_time, show_file, show_level, show_desc, format_html); | |
| 362 result += "\n"; | |
| 363 } | |
| 364 if (max_events > 0 && ++nlines >= max_events) | |
| 365 break; | |
| 366 } | |
| 367 } | |
| 368 if (format_json) { | |
| 369 JSONStringValueSerializer serializer(&result); | |
| 370 serializer.Serialize(log_entries); | |
| 371 } | |
| 372 | |
| 373 return result; | |
| 374 } | |
| 375 | |
| 376 } // namespace | |
| 377 | |
| 378 const LogLevel kDefaultLogLevel = LOG_LEVEL_EVENT; | |
| 379 | |
| 380 void Initialize() { | |
| 381 if (g_network_event_log) | |
| 382 delete g_network_event_log; // reset log | |
| 383 g_network_event_log = new NetworkEventLog(); | |
| 384 } | |
| 385 | |
| 386 void Shutdown() { | |
| 387 delete g_network_event_log; | |
| 388 g_network_event_log = NULL; | |
| 389 } | |
| 390 | |
| 391 bool IsInitialized() { return g_network_event_log != NULL; } | |
| 392 | |
| 393 namespace internal { | |
| 394 | |
| 395 size_t GetMaxLogEntries() { return g_max_network_event_log_entries; } | |
| 396 | |
| 397 void SetMaxLogEntries(size_t max_entries) { | |
| 398 g_max_network_event_log_entries = max_entries; | |
| 399 if (!g_network_event_log) | |
| 400 return; | |
| 401 while (g_network_event_log->entries().size() > max_entries) | |
| 402 g_network_event_log->entries().pop_front(); | |
| 403 } | |
| 404 | |
| 405 void AddEntry(const char* file, | |
| 406 int file_line, | |
| 407 LogLevel log_level, | |
| 408 const std::string& event, | |
| 409 const std::string& description) { | |
| 410 std::string filestr; | |
| 411 if (file) | |
| 412 filestr = base::FilePath(std::string(file)).BaseName().value(); | |
| 413 LogEntry entry(filestr, file_line, log_level, event, description); | |
| 414 if (!g_network_event_log) { | |
| 415 entry.SendToVLogOrErrorLog(); | |
| 416 return; | |
| 417 } | |
| 418 g_network_event_log->AddLogEntry(entry); | |
| 419 } | |
| 420 | |
| 421 } // namespace internal | |
| 422 | |
| 423 std::string GetAsString(StringOrder order, | |
| 424 const std::string& format, | |
| 425 LogLevel max_level, | |
| 426 size_t max_events) { | |
| 427 if (!g_network_event_log) | |
| 428 return "NetworkEventLog not initialized."; | |
| 429 return g_network_event_log->GetAsString(order, format, max_level, max_events); | |
| 430 } | |
| 431 | |
| 432 std::string ValueAsString(const base::Value& value) { | |
| 433 std::string vstr; | |
| 434 base::JSONWriter::WriteWithOptions( | |
| 435 &value, base::JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &vstr); | |
| 436 return vstr.empty() ? "''" : vstr; | |
| 437 } | |
| 438 | |
| 439 } // namespace network_event_log | |
| 440 } // namespace chromeos | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 773703002:
Generalize network_event_log -> device_event_log (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master