henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2004 The WebRTC Project Authors. All rights reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
| 11 | #if defined(WEBRTC_WIN) |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 12 | #include <windows.h> |
conceptgenesis | 3f70562 | 2016-01-30 14:40:44 -0800 | [diff] [blame] | 13 | #if _MSC_VER < 1900 |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 14 | #define snprintf _snprintf |
conceptgenesis | 3f70562 | 2016-01-30 14:40:44 -0800 | [diff] [blame] | 15 | #endif |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 16 | #undef ERROR // wingdi.h |
| 17 | #endif |
| 18 | |
| 19 | #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) |
| 20 | #include <CoreServices/CoreServices.h> |
| 21 | #elif defined(WEBRTC_ANDROID) |
| 22 | #include <android/log.h> |
Yves Gerey | 988cc08 | 2018-10-23 12:03:01 +0200 | [diff] [blame] | 23 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 24 | // Android has a 1024 limit on log inputs. We use 60 chars as an |
| 25 | // approx for the header/tag portion. |
| 26 | // See android/system/core/liblog/logd_write.c |
| 27 | static const int kMaxLogLineSize = 1024 - 60; |
| 28 | #endif // WEBRTC_MAC && !defined(WEBRTC_IOS) || WEBRTC_ANDROID |
| 29 | |
Yves Gerey | 988cc08 | 2018-10-23 12:03:01 +0200 | [diff] [blame] | 30 | #include <stdio.h> |
| 31 | #include <string.h> |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 32 | #include <time.h> |
Jonas Olsson | a4d8737 | 2019-07-05 19:08:33 +0200 | [diff] [blame] | 33 | |
andresp@webrtc.org | ff689be | 2015-02-12 11:54:26 +0000 | [diff] [blame] | 34 | #include <algorithm> |
Karl Wiberg | cefc465 | 2018-05-23 23:20:38 +0200 | [diff] [blame] | 35 | #include <cstdarg> |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 36 | #include <vector> |
| 37 | |
Danil Chapovalov | ef98ae6 | 2019-10-11 17:18:29 +0200 | [diff] [blame] | 38 | #include "absl/base/attributes.h" |
Yves Gerey | 988cc08 | 2018-10-23 12:03:01 +0200 | [diff] [blame] | 39 | #include "rtc_base/checks.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 40 | #include "rtc_base/critical_section.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 41 | #include "rtc_base/logging.h" |
Tommi | e51a0a8 | 2018-02-27 15:30:29 +0100 | [diff] [blame] | 42 | #include "rtc_base/platform_thread_types.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 43 | #include "rtc_base/string_encode.h" |
| 44 | #include "rtc_base/string_utils.h" |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 45 | #include "rtc_base/strings/string_builder.h" |
Yves Gerey | 988cc08 | 2018-10-23 12:03:01 +0200 | [diff] [blame] | 46 | #include "rtc_base/thread_annotations.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 47 | #include "rtc_base/time_utils.h" |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 48 | |
| 49 | namespace rtc { |
andrew | 88703d7 | 2015-09-07 00:34:56 -0700 | [diff] [blame] | 50 | namespace { |
Jonas Olsson | 2b6f135 | 2018-02-15 11:57:03 +0100 | [diff] [blame] | 51 | // By default, release builds don't log, debug builds at info level |
| 52 | #if !defined(NDEBUG) |
| 53 | static LoggingSeverity g_min_sev = LS_INFO; |
| 54 | static LoggingSeverity g_dbg_sev = LS_INFO; |
| 55 | #else |
| 56 | static LoggingSeverity g_min_sev = LS_NONE; |
| 57 | static LoggingSeverity g_dbg_sev = LS_NONE; |
| 58 | #endif |
andrew | 88703d7 | 2015-09-07 00:34:56 -0700 | [diff] [blame] | 59 | |
| 60 | // Return the filename portion of the string (that following the last slash). |
| 61 | const char* FilenameFromPath(const char* file) { |
| 62 | const char* end1 = ::strrchr(file, '/'); |
| 63 | const char* end2 = ::strrchr(file, '\\'); |
| 64 | if (!end1 && !end2) |
| 65 | return file; |
| 66 | else |
| 67 | return (end1 > end2) ? end1 + 1 : end2 + 1; |
| 68 | } |
| 69 | |
Jonas Olsson | 2b6f135 | 2018-02-15 11:57:03 +0100 | [diff] [blame] | 70 | // Global lock for log subsystem, only needed to serialize access to streams_. |
Danil Chapovalov | ef98ae6 | 2019-10-11 17:18:29 +0200 | [diff] [blame] | 71 | ABSL_CONST_INIT GlobalLock g_log_crit; |
andrew | 88703d7 | 2015-09-07 00:34:56 -0700 | [diff] [blame] | 72 | } // namespace |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 73 | |
Paulina Hensman | f1e3cb4 | 2018-06-20 14:07:05 +0200 | [diff] [blame] | 74 | // Inefficient default implementation, override is recommended. |
| 75 | void LogSink::OnLogMessage(const std::string& msg, |
| 76 | LoggingSeverity severity, |
| 77 | const char* tag) { |
Jiawei Ou | 3ea1878 | 2018-10-31 23:14:24 -0700 | [diff] [blame] | 78 | OnLogMessage(tag + (": " + msg), severity); |
| 79 | } |
| 80 | |
| 81 | void LogSink::OnLogMessage(const std::string& msg, |
| 82 | LoggingSeverity /* severity */) { |
| 83 | OnLogMessage(msg); |
Paulina Hensman | f1e3cb4 | 2018-06-20 14:07:05 +0200 | [diff] [blame] | 84 | } |
| 85 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 86 | ///////////////////////////////////////////////////////////////////////////// |
| 87 | // LogMessage |
| 88 | ///////////////////////////////////////////////////////////////////////////// |
| 89 | |
andrew | 88703d7 | 2015-09-07 00:34:56 -0700 | [diff] [blame] | 90 | bool LogMessage::log_to_stderr_ = true; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 91 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 92 | // The list of logging streams currently configured. |
| 93 | // Note: we explicitly do not clean this up, because of the uncertain ordering |
| 94 | // of destructors at program exit. Let the person who sets the stream trigger |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 95 | // cleanup by setting to null, or let it leak (safe at program exit). |
Danil Chapovalov | b9f6902 | 2019-10-21 09:19:10 +0200 | [diff] [blame] | 96 | ABSL_CONST_INIT LogSink* LogMessage::streams_ RTC_GUARDED_BY(g_log_crit) = |
| 97 | nullptr; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 98 | |
| 99 | // Boolean options default to false (0) |
| 100 | bool LogMessage::thread_, LogMessage::timestamp_; |
| 101 | |
Karl Wiberg | ab4f1c1 | 2018-05-04 10:42:28 +0200 | [diff] [blame] | 102 | LogMessage::LogMessage(const char* file, int line, LoggingSeverity sev) |
| 103 | : LogMessage(file, line, sev, ERRCTX_NONE, 0) {} |
| 104 | |
Peter Boström | 225789d | 2015-10-23 15:20:56 +0200 | [diff] [blame] | 105 | LogMessage::LogMessage(const char* file, |
| 106 | int line, |
| 107 | LoggingSeverity sev, |
| 108 | LogErrorContext err_ctx, |
Tommi | e51a0a8 | 2018-02-27 15:30:29 +0100 | [diff] [blame] | 109 | int err) |
Jonas Olsson | d8c5078 | 2018-09-07 11:21:28 +0200 | [diff] [blame] | 110 | : severity_(sev) { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 111 | if (timestamp_) { |
Taylor Brandstetter | 4f0dfbd | 2016-06-15 17:15:23 -0700 | [diff] [blame] | 112 | // Use SystemTimeMillis so that even if tests use fake clocks, the timestamp |
| 113 | // in log messages represents the real system time. |
| 114 | int64_t time = TimeDiff(SystemTimeMillis(), LogStartTime()); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 115 | // Also ensure WallClockStartTime is initialized, so that it matches |
| 116 | // LogStartTime. |
| 117 | WallClockStartTime(); |
Jonas Olsson | d8c5078 | 2018-09-07 11:21:28 +0200 | [diff] [blame] | 118 | print_stream_ << "[" << rtc::LeftPad('0', 3, rtc::ToString(time / 1000)) |
| 119 | << ":" << rtc::LeftPad('0', 3, rtc::ToString(time % 1000)) |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 120 | << "] "; |
| 121 | } |
| 122 | |
| 123 | if (thread_) { |
henrika | ba35d05 | 2015-07-14 17:04:08 +0200 | [diff] [blame] | 124 | PlatformThreadId id = CurrentThreadId(); |
Jonas Olsson | d8c5078 | 2018-09-07 11:21:28 +0200 | [diff] [blame] | 125 | print_stream_ << "[" << id << "] "; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 126 | } |
| 127 | |
Paulina Hensman | f1e3cb4 | 2018-06-20 14:07:05 +0200 | [diff] [blame] | 128 | if (file != nullptr) { |
| 129 | #if defined(WEBRTC_ANDROID) |
| 130 | tag_ = FilenameFromPath(file); |
| 131 | print_stream_ << "(line " << line << "): "; |
| 132 | #else |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 133 | print_stream_ << "(" << FilenameFromPath(file) << ":" << line << "): "; |
Paulina Hensman | f1e3cb4 | 2018-06-20 14:07:05 +0200 | [diff] [blame] | 134 | #endif |
| 135 | } |
andrew | 88703d7 | 2015-09-07 00:34:56 -0700 | [diff] [blame] | 136 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 137 | if (err_ctx != ERRCTX_NONE) { |
Karl Wiberg | 881f168 | 2018-03-08 15:03:23 +0100 | [diff] [blame] | 138 | char tmp_buf[1024]; |
| 139 | SimpleStringBuilder tmp(tmp_buf); |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 140 | tmp.AppendFormat("[0x%08X]", err); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 141 | switch (err_ctx) { |
| 142 | case ERRCTX_ERRNO: |
| 143 | tmp << " " << strerror(err); |
| 144 | break; |
kwiberg | 77eab70 | 2016-09-28 17:42:01 -0700 | [diff] [blame] | 145 | #ifdef WEBRTC_WIN |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 146 | case ERRCTX_HRESULT: { |
| 147 | char msgbuf[256]; |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 148 | DWORD flags = |
| 149 | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 150 | if (DWORD len = FormatMessageA( |
Tommi | e51a0a8 | 2018-02-27 15:30:29 +0100 | [diff] [blame] | 151 | flags, nullptr, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 152 | msgbuf, sizeof(msgbuf) / sizeof(msgbuf[0]), nullptr)) { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 153 | while ((len > 0) && |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 154 | isspace(static_cast<unsigned char>(msgbuf[len - 1]))) { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 155 | msgbuf[--len] = 0; |
| 156 | } |
| 157 | tmp << " " << msgbuf; |
| 158 | } |
| 159 | break; |
| 160 | } |
Tommi | 0eefb4d | 2015-05-23 09:54:07 +0200 | [diff] [blame] | 161 | #endif // WEBRTC_WIN |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 162 | default: |
| 163 | break; |
| 164 | } |
| 165 | extra_ = tmp.str(); |
| 166 | } |
| 167 | } |
| 168 | |
Tommi | e51a0a8 | 2018-02-27 15:30:29 +0100 | [diff] [blame] | 169 | #if defined(WEBRTC_ANDROID) |
jiayl | 66f0da2 | 2015-09-14 15:06:39 -0700 | [diff] [blame] | 170 | LogMessage::LogMessage(const char* file, |
| 171 | int line, |
| 172 | LoggingSeverity sev, |
Tommi | e51a0a8 | 2018-02-27 15:30:29 +0100 | [diff] [blame] | 173 | const char* tag) |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 174 | : LogMessage(file, line, sev, ERRCTX_NONE, 0 /* err */) { |
Jonas Olsson | d8c5078 | 2018-09-07 11:21:28 +0200 | [diff] [blame] | 175 | tag_ = tag; |
| 176 | print_stream_ << tag << ": "; |
jiayl | 66f0da2 | 2015-09-14 15:06:39 -0700 | [diff] [blame] | 177 | } |
Tommi | e51a0a8 | 2018-02-27 15:30:29 +0100 | [diff] [blame] | 178 | #endif |
| 179 | |
| 180 | // DEPRECATED. Currently only used by downstream projects that use |
| 181 | // implementation details of logging.h. Work is ongoing to remove those |
| 182 | // dependencies. |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 183 | LogMessage::LogMessage(const char* file, |
| 184 | int line, |
| 185 | LoggingSeverity sev, |
Tommi | e51a0a8 | 2018-02-27 15:30:29 +0100 | [diff] [blame] | 186 | const std::string& tag) |
| 187 | : LogMessage(file, line, sev) { |
Jonas Olsson | d8c5078 | 2018-09-07 11:21:28 +0200 | [diff] [blame] | 188 | print_stream_ << tag << ": "; |
Tommi | e51a0a8 | 2018-02-27 15:30:29 +0100 | [diff] [blame] | 189 | } |
jiayl | 66f0da2 | 2015-09-14 15:06:39 -0700 | [diff] [blame] | 190 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 191 | LogMessage::~LogMessage() { |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 192 | FinishPrintStream(); |
| 193 | |
Jonas Olsson | d8c5078 | 2018-09-07 11:21:28 +0200 | [diff] [blame] | 194 | const std::string str = print_stream_.Release(); |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 195 | |
Jonas Olsson | 2b6f135 | 2018-02-15 11:57:03 +0100 | [diff] [blame] | 196 | if (severity_ >= g_dbg_sev) { |
Tommi | e51a0a8 | 2018-02-27 15:30:29 +0100 | [diff] [blame] | 197 | #if defined(WEBRTC_ANDROID) |
jiayl | 66f0da2 | 2015-09-14 15:06:39 -0700 | [diff] [blame] | 198 | OutputToDebug(str, severity_, tag_); |
Tommi | e51a0a8 | 2018-02-27 15:30:29 +0100 | [diff] [blame] | 199 | #else |
| 200 | OutputToDebug(str, severity_); |
| 201 | #endif |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 202 | } |
| 203 | |
Danil Chapovalov | ef98ae6 | 2019-10-11 17:18:29 +0200 | [diff] [blame] | 204 | GlobalLockScope cs(&g_log_crit); |
Danil Chapovalov | b9f6902 | 2019-10-21 09:19:10 +0200 | [diff] [blame] | 205 | for (LogSink* entry = streams_; entry != nullptr; entry = entry->next_) { |
| 206 | if (severity_ >= entry->min_severity_) { |
Paulina Hensman | f1e3cb4 | 2018-06-20 14:07:05 +0200 | [diff] [blame] | 207 | #if defined(WEBRTC_ANDROID) |
Danil Chapovalov | b9f6902 | 2019-10-21 09:19:10 +0200 | [diff] [blame] | 208 | entry->OnLogMessage(str, severity_, tag_); |
Paulina Hensman | f1e3cb4 | 2018-06-20 14:07:05 +0200 | [diff] [blame] | 209 | #else |
Danil Chapovalov | b9f6902 | 2019-10-21 09:19:10 +0200 | [diff] [blame] | 210 | entry->OnLogMessage(str, severity_); |
Paulina Hensman | f1e3cb4 | 2018-06-20 14:07:05 +0200 | [diff] [blame] | 211 | #endif |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 212 | } |
| 213 | } |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 214 | } |
| 215 | |
Karl Wiberg | cefc465 | 2018-05-23 23:20:38 +0200 | [diff] [blame] | 216 | void LogMessage::AddTag(const char* tag) { |
| 217 | #ifdef WEBRTC_ANDROID |
Jonas Olsson | d8c5078 | 2018-09-07 11:21:28 +0200 | [diff] [blame] | 218 | tag_ = tag; |
Karl Wiberg | cefc465 | 2018-05-23 23:20:38 +0200 | [diff] [blame] | 219 | #endif |
| 220 | } |
| 221 | |
Jonas Olsson | d8c5078 | 2018-09-07 11:21:28 +0200 | [diff] [blame] | 222 | rtc::StringBuilder& LogMessage::stream() { |
| 223 | return print_stream_; |
Jonas Olsson | 2b6f135 | 2018-02-15 11:57:03 +0100 | [diff] [blame] | 224 | } |
| 225 | |
| 226 | int LogMessage::GetMinLogSeverity() { |
| 227 | return g_min_sev; |
| 228 | } |
| 229 | |
| 230 | LoggingSeverity LogMessage::GetLogToDebug() { |
| 231 | return g_dbg_sev; |
| 232 | } |
Honghai Zhang | 82d7862 | 2016-05-06 11:29:15 -0700 | [diff] [blame] | 233 | int64_t LogMessage::LogStartTime() { |
Taylor Brandstetter | 4f0dfbd | 2016-06-15 17:15:23 -0700 | [diff] [blame] | 234 | static const int64_t g_start = SystemTimeMillis(); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 235 | return g_start; |
| 236 | } |
| 237 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 238 | uint32_t LogMessage::WallClockStartTime() { |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 239 | static const uint32_t g_start_wallclock = time(nullptr); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 240 | return g_start_wallclock; |
| 241 | } |
| 242 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 243 | void LogMessage::LogThreads(bool on) { |
| 244 | thread_ = on; |
| 245 | } |
| 246 | |
| 247 | void LogMessage::LogTimestamps(bool on) { |
| 248 | timestamp_ = on; |
| 249 | } |
| 250 | |
Tommi | 0eefb4d | 2015-05-23 09:54:07 +0200 | [diff] [blame] | 251 | void LogMessage::LogToDebug(LoggingSeverity min_sev) { |
Jonas Olsson | 2b6f135 | 2018-02-15 11:57:03 +0100 | [diff] [blame] | 252 | g_dbg_sev = min_sev; |
Danil Chapovalov | ef98ae6 | 2019-10-11 17:18:29 +0200 | [diff] [blame] | 253 | GlobalLockScope cs(&g_log_crit); |
Tommi | 00aac5a | 2015-05-25 11:25:59 +0200 | [diff] [blame] | 254 | UpdateMinLogSeverity(); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 255 | } |
| 256 | |
andrew | 88703d7 | 2015-09-07 00:34:56 -0700 | [diff] [blame] | 257 | void LogMessage::SetLogToStderr(bool log_to_stderr) { |
| 258 | log_to_stderr_ = log_to_stderr; |
| 259 | } |
| 260 | |
Tommi | 0eefb4d | 2015-05-23 09:54:07 +0200 | [diff] [blame] | 261 | int LogMessage::GetLogToStream(LogSink* stream) { |
Danil Chapovalov | ef98ae6 | 2019-10-11 17:18:29 +0200 | [diff] [blame] | 262 | GlobalLockScope cs(&g_log_crit); |
Tommi | 0eefb4d | 2015-05-23 09:54:07 +0200 | [diff] [blame] | 263 | LoggingSeverity sev = LS_NONE; |
Danil Chapovalov | b9f6902 | 2019-10-21 09:19:10 +0200 | [diff] [blame] | 264 | for (LogSink* entry = streams_; entry != nullptr; entry = entry->next_) { |
| 265 | if (stream == nullptr || stream == entry) { |
| 266 | sev = std::min(sev, entry->min_severity_); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 267 | } |
| 268 | } |
| 269 | return sev; |
| 270 | } |
| 271 | |
Tommi | 0eefb4d | 2015-05-23 09:54:07 +0200 | [diff] [blame] | 272 | void LogMessage::AddLogToStream(LogSink* stream, LoggingSeverity min_sev) { |
Danil Chapovalov | ef98ae6 | 2019-10-11 17:18:29 +0200 | [diff] [blame] | 273 | GlobalLockScope cs(&g_log_crit); |
Danil Chapovalov | b9f6902 | 2019-10-21 09:19:10 +0200 | [diff] [blame] | 274 | stream->min_severity_ = min_sev; |
| 275 | stream->next_ = streams_; |
| 276 | streams_ = stream; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 277 | UpdateMinLogSeverity(); |
| 278 | } |
| 279 | |
Tommi | 0eefb4d | 2015-05-23 09:54:07 +0200 | [diff] [blame] | 280 | void LogMessage::RemoveLogToStream(LogSink* stream) { |
Danil Chapovalov | ef98ae6 | 2019-10-11 17:18:29 +0200 | [diff] [blame] | 281 | GlobalLockScope cs(&g_log_crit); |
Danil Chapovalov | b9f6902 | 2019-10-21 09:19:10 +0200 | [diff] [blame] | 282 | for (LogSink** entry = &streams_; *entry != nullptr; |
| 283 | entry = &(*entry)->next_) { |
| 284 | if (*entry == stream) { |
| 285 | *entry = (*entry)->next_; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 286 | break; |
| 287 | } |
| 288 | } |
| 289 | UpdateMinLogSeverity(); |
| 290 | } |
| 291 | |
Tommi | 0eefb4d | 2015-05-23 09:54:07 +0200 | [diff] [blame] | 292 | void LogMessage::ConfigureLogging(const char* params) { |
| 293 | LoggingSeverity current_level = LS_VERBOSE; |
| 294 | LoggingSeverity debug_level = GetLogToDebug(); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 295 | |
| 296 | std::vector<std::string> tokens; |
| 297 | tokenize(params, ' ', &tokens); |
| 298 | |
Tommi | 0eefb4d | 2015-05-23 09:54:07 +0200 | [diff] [blame] | 299 | for (const std::string& token : tokens) { |
| 300 | if (token.empty()) |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 301 | continue; |
| 302 | |
| 303 | // Logging features |
Tommi | 0eefb4d | 2015-05-23 09:54:07 +0200 | [diff] [blame] | 304 | if (token == "tstamp") { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 305 | LogTimestamps(); |
Tommi | 0eefb4d | 2015-05-23 09:54:07 +0200 | [diff] [blame] | 306 | } else if (token == "thread") { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 307 | LogThreads(); |
| 308 | |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 309 | // Logging levels |
Tommi | 0eefb4d | 2015-05-23 09:54:07 +0200 | [diff] [blame] | 310 | } else if (token == "verbose") { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 311 | current_level = LS_VERBOSE; |
Tommi | 0eefb4d | 2015-05-23 09:54:07 +0200 | [diff] [blame] | 312 | } else if (token == "info") { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 313 | current_level = LS_INFO; |
Tommi | 0eefb4d | 2015-05-23 09:54:07 +0200 | [diff] [blame] | 314 | } else if (token == "warning") { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 315 | current_level = LS_WARNING; |
Tommi | 0eefb4d | 2015-05-23 09:54:07 +0200 | [diff] [blame] | 316 | } else if (token == "error") { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 317 | current_level = LS_ERROR; |
Tommi | 0eefb4d | 2015-05-23 09:54:07 +0200 | [diff] [blame] | 318 | } else if (token == "none") { |
| 319 | current_level = LS_NONE; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 320 | |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 321 | // Logging targets |
Tommi | 0eefb4d | 2015-05-23 09:54:07 +0200 | [diff] [blame] | 322 | } else if (token == "debug") { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 323 | debug_level = current_level; |
| 324 | } |
| 325 | } |
| 326 | |
Robin Raymond | ce1b140 | 2018-11-22 20:10:11 -0500 | [diff] [blame] | 327 | #if defined(WEBRTC_WIN) && !defined(WINUWP) |
Tommi | 0eefb4d | 2015-05-23 09:54:07 +0200 | [diff] [blame] | 328 | if ((LS_NONE != debug_level) && !::IsDebuggerPresent()) { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 329 | // First, attempt to attach to our parent's console... so if you invoke |
| 330 | // from the command line, we'll see the output there. Otherwise, create |
| 331 | // our own console window. |
| 332 | // Note: These methods fail if a console already exists, which is fine. |
Tommi | e51a0a8 | 2018-02-27 15:30:29 +0100 | [diff] [blame] | 333 | if (!AttachConsole(ATTACH_PARENT_PROCESS)) |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 334 | ::AllocConsole(); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 335 | } |
Robin Raymond | ce1b140 | 2018-11-22 20:10:11 -0500 | [diff] [blame] | 336 | #endif // defined(WEBRTC_WIN) && !defined(WINUWP) |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 337 | |
| 338 | LogToDebug(debug_level); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 339 | } |
| 340 | |
danilchap | 3c6abd2 | 2017-09-06 05:46:29 -0700 | [diff] [blame] | 341 | void LogMessage::UpdateMinLogSeverity() |
| 342 | RTC_EXCLUSIVE_LOCKS_REQUIRED(g_log_crit) { |
Jonas Olsson | 2b6f135 | 2018-02-15 11:57:03 +0100 | [diff] [blame] | 343 | LoggingSeverity min_sev = g_dbg_sev; |
Danil Chapovalov | b9f6902 | 2019-10-21 09:19:10 +0200 | [diff] [blame] | 344 | for (LogSink* entry = streams_; entry != nullptr; entry = entry->next_) { |
| 345 | min_sev = std::min(min_sev, entry->min_severity_); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 346 | } |
Jonas Olsson | 2b6f135 | 2018-02-15 11:57:03 +0100 | [diff] [blame] | 347 | g_min_sev = min_sev; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 348 | } |
| 349 | |
Tommi | e51a0a8 | 2018-02-27 15:30:29 +0100 | [diff] [blame] | 350 | #if defined(WEBRTC_ANDROID) |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 351 | void LogMessage::OutputToDebug(const std::string& str, |
jiayl | 66f0da2 | 2015-09-14 15:06:39 -0700 | [diff] [blame] | 352 | LoggingSeverity severity, |
Tommi | e51a0a8 | 2018-02-27 15:30:29 +0100 | [diff] [blame] | 353 | const char* tag) { |
| 354 | #else |
| 355 | void LogMessage::OutputToDebug(const std::string& str, |
| 356 | LoggingSeverity severity) { |
| 357 | #endif |
andrew | 88703d7 | 2015-09-07 00:34:56 -0700 | [diff] [blame] | 358 | bool log_to_stderr = log_to_stderr_; |
tfarina | a41ab93 | 2015-10-30 16:08:48 -0700 | [diff] [blame] | 359 | #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) && defined(NDEBUG) |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 360 | // On the Mac, all stderr output goes to the Console log and causes clutter. |
| 361 | // So in opt builds, don't log to stderr unless the user specifically sets |
| 362 | // a preference to do so. |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 363 | CFStringRef key = CFStringCreateWithCString( |
| 364 | kCFAllocatorDefault, "logToStdErr", kCFStringEncodingUTF8); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 365 | CFStringRef domain = CFBundleGetIdentifier(CFBundleGetMainBundle()); |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 366 | if (key != nullptr && domain != nullptr) { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 367 | Boolean exists_and_is_valid; |
| 368 | Boolean should_log = |
| 369 | CFPreferencesGetAppBooleanValue(key, domain, &exists_and_is_valid); |
| 370 | // If the key doesn't exist or is invalid or is false, we will not log to |
| 371 | // stderr. |
| 372 | log_to_stderr = exists_and_is_valid && should_log; |
| 373 | } |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 374 | if (key != nullptr) { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 375 | CFRelease(key); |
| 376 | } |
Tommi | e51a0a8 | 2018-02-27 15:30:29 +0100 | [diff] [blame] | 377 | #endif // defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) && defined(NDEBUG) |
| 378 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 379 | #if defined(WEBRTC_WIN) |
| 380 | // Always log to the debugger. |
| 381 | // Perhaps stderr should be controlled by a preference, as on Mac? |
| 382 | OutputDebugStringA(str.c_str()); |
| 383 | if (log_to_stderr) { |
| 384 | // This handles dynamically allocated consoles, too. |
| 385 | if (HANDLE error_handle = ::GetStdHandle(STD_ERROR_HANDLE)) { |
| 386 | log_to_stderr = false; |
| 387 | DWORD written = 0; |
| 388 | ::WriteFile(error_handle, str.data(), static_cast<DWORD>(str.size()), |
| 389 | &written, 0); |
| 390 | } |
| 391 | } |
Tommi | 0eefb4d | 2015-05-23 09:54:07 +0200 | [diff] [blame] | 392 | #endif // WEBRTC_WIN |
Tommi | e51a0a8 | 2018-02-27 15:30:29 +0100 | [diff] [blame] | 393 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 394 | #if defined(WEBRTC_ANDROID) |
| 395 | // Android's logging facility uses severity to log messages but we |
| 396 | // need to map libjingle's severity levels to Android ones first. |
| 397 | // Also write to stderr which maybe available to executable started |
| 398 | // from the shell. |
| 399 | int prio; |
| 400 | switch (severity) { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 401 | case LS_VERBOSE: |
| 402 | prio = ANDROID_LOG_VERBOSE; |
| 403 | break; |
| 404 | case LS_INFO: |
| 405 | prio = ANDROID_LOG_INFO; |
| 406 | break; |
| 407 | case LS_WARNING: |
| 408 | prio = ANDROID_LOG_WARN; |
| 409 | break; |
| 410 | case LS_ERROR: |
| 411 | prio = ANDROID_LOG_ERROR; |
| 412 | break; |
| 413 | default: |
| 414 | prio = ANDROID_LOG_UNKNOWN; |
| 415 | } |
| 416 | |
| 417 | int size = str.size(); |
| 418 | int line = 0; |
| 419 | int idx = 0; |
| 420 | const int max_lines = size / kMaxLogLineSize + 1; |
| 421 | if (max_lines == 1) { |
Tommi | e51a0a8 | 2018-02-27 15:30:29 +0100 | [diff] [blame] | 422 | __android_log_print(prio, tag, "%.*s", size, str.c_str()); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 423 | } else { |
| 424 | while (size > 0) { |
| 425 | const int len = std::min(size, kMaxLogLineSize); |
| 426 | // Use the size of the string in the format (str may have \0 in the |
| 427 | // middle). |
Tommi | e51a0a8 | 2018-02-27 15:30:29 +0100 | [diff] [blame] | 428 | __android_log_print(prio, tag, "[%d/%d] %.*s", line + 1, max_lines, len, |
| 429 | str.c_str() + idx); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 430 | idx += len; |
| 431 | size -= len; |
| 432 | ++line; |
| 433 | } |
| 434 | } |
| 435 | #endif // WEBRTC_ANDROID |
| 436 | if (log_to_stderr) { |
| 437 | fprintf(stderr, "%s", str.c_str()); |
| 438 | fflush(stderr); |
| 439 | } |
| 440 | } |
| 441 | |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 442 | // static |
| 443 | bool LogMessage::IsNoop(LoggingSeverity severity) { |
Jonas Olsson | d8c5078 | 2018-09-07 11:21:28 +0200 | [diff] [blame] | 444 | if (severity >= g_dbg_sev || severity >= g_min_sev) |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 445 | return false; |
| 446 | |
| 447 | // TODO(tommi): We're grabbing this lock for every LogMessage instance that |
| 448 | // is going to be logged. This introduces unnecessary synchronization for |
| 449 | // a feature that's mostly used for testing. |
Danil Chapovalov | ef98ae6 | 2019-10-11 17:18:29 +0200 | [diff] [blame] | 450 | GlobalLockScope cs(&g_log_crit); |
Danil Chapovalov | b9f6902 | 2019-10-21 09:19:10 +0200 | [diff] [blame] | 451 | return streams_ == nullptr; |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 452 | } |
| 453 | |
| 454 | void LogMessage::FinishPrintStream() { |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 455 | if (!extra_.empty()) |
| 456 | print_stream_ << " : " << extra_; |
Jonas Olsson | d8c5078 | 2018-09-07 11:21:28 +0200 | [diff] [blame] | 457 | print_stream_ << "\n"; |
Tommi | fef0500 | 2018-02-27 13:51:08 +0100 | [diff] [blame] | 458 | } |
| 459 | |
Karl Wiberg | cefc465 | 2018-05-23 23:20:38 +0200 | [diff] [blame] | 460 | namespace webrtc_logging_impl { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 461 | |
Karl Wiberg | cefc465 | 2018-05-23 23:20:38 +0200 | [diff] [blame] | 462 | void Log(const LogArgType* fmt, ...) { |
| 463 | va_list args; |
| 464 | va_start(args, fmt); |
| 465 | |
| 466 | LogMetadataErr meta; |
| 467 | const char* tag = nullptr; |
| 468 | switch (*fmt) { |
| 469 | case LogArgType::kLogMetadata: { |
| 470 | meta = {va_arg(args, LogMetadata), ERRCTX_NONE, 0}; |
| 471 | break; |
| 472 | } |
| 473 | case LogArgType::kLogMetadataErr: { |
| 474 | meta = va_arg(args, LogMetadataErr); |
| 475 | break; |
| 476 | } |
| 477 | #ifdef WEBRTC_ANDROID |
| 478 | case LogArgType::kLogMetadataTag: { |
| 479 | const LogMetadataTag tag_meta = va_arg(args, LogMetadataTag); |
| 480 | meta = {{nullptr, 0, tag_meta.severity}, ERRCTX_NONE, 0}; |
| 481 | tag = tag_meta.tag; |
| 482 | break; |
| 483 | } |
| 484 | #endif |
| 485 | default: { |
| 486 | RTC_NOTREACHED(); |
| 487 | va_end(args); |
| 488 | return; |
| 489 | } |
| 490 | } |
Jonas Olsson | d8c5078 | 2018-09-07 11:21:28 +0200 | [diff] [blame] | 491 | |
| 492 | if (LogMessage::IsNoop(meta.meta.Severity())) { |
| 493 | va_end(args); |
| 494 | return; |
| 495 | } |
| 496 | |
Karl Wiberg | cefc465 | 2018-05-23 23:20:38 +0200 | [diff] [blame] | 497 | LogMessage log_message(meta.meta.File(), meta.meta.Line(), |
| 498 | meta.meta.Severity(), meta.err_ctx, meta.err); |
| 499 | if (tag) { |
| 500 | log_message.AddTag(tag); |
| 501 | } |
| 502 | |
| 503 | for (++fmt; *fmt != LogArgType::kEnd; ++fmt) { |
| 504 | switch (*fmt) { |
| 505 | case LogArgType::kInt: |
| 506 | log_message.stream() << va_arg(args, int); |
| 507 | break; |
| 508 | case LogArgType::kLong: |
| 509 | log_message.stream() << va_arg(args, long); |
| 510 | break; |
| 511 | case LogArgType::kLongLong: |
| 512 | log_message.stream() << va_arg(args, long long); |
| 513 | break; |
| 514 | case LogArgType::kUInt: |
| 515 | log_message.stream() << va_arg(args, unsigned); |
| 516 | break; |
| 517 | case LogArgType::kULong: |
| 518 | log_message.stream() << va_arg(args, unsigned long); |
| 519 | break; |
| 520 | case LogArgType::kULongLong: |
| 521 | log_message.stream() << va_arg(args, unsigned long long); |
| 522 | break; |
| 523 | case LogArgType::kDouble: |
| 524 | log_message.stream() << va_arg(args, double); |
| 525 | break; |
| 526 | case LogArgType::kLongDouble: |
| 527 | log_message.stream() << va_arg(args, long double); |
| 528 | break; |
Niels Möller | 65835be | 2019-02-04 19:23:58 +0100 | [diff] [blame] | 529 | case LogArgType::kCharP: { |
| 530 | const char* s = va_arg(args, const char*); |
| 531 | log_message.stream() << (s ? s : "(null)"); |
Karl Wiberg | cefc465 | 2018-05-23 23:20:38 +0200 | [diff] [blame] | 532 | break; |
Niels Möller | 65835be | 2019-02-04 19:23:58 +0100 | [diff] [blame] | 533 | } |
Karl Wiberg | cefc465 | 2018-05-23 23:20:38 +0200 | [diff] [blame] | 534 | case LogArgType::kStdString: |
| 535 | log_message.stream() << *va_arg(args, const std::string*); |
| 536 | break; |
Jonas Olsson | f2ce37c | 2018-09-12 15:32:47 +0200 | [diff] [blame] | 537 | case LogArgType::kStringView: |
| 538 | log_message.stream() << *va_arg(args, const absl::string_view*); |
| 539 | break; |
Karl Wiberg | cefc465 | 2018-05-23 23:20:38 +0200 | [diff] [blame] | 540 | case LogArgType::kVoidP: |
Jonas Olsson | d8c5078 | 2018-09-07 11:21:28 +0200 | [diff] [blame] | 541 | log_message.stream() << rtc::ToHex( |
| 542 | reinterpret_cast<uintptr_t>(va_arg(args, const void*))); |
Karl Wiberg | cefc465 | 2018-05-23 23:20:38 +0200 | [diff] [blame] | 543 | break; |
| 544 | default: |
| 545 | RTC_NOTREACHED(); |
| 546 | va_end(args); |
| 547 | return; |
| 548 | } |
| 549 | } |
| 550 | |
| 551 | va_end(args); |
| 552 | } |
| 553 | |
| 554 | } // namespace webrtc_logging_impl |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 555 | } // namespace rtc |