Branch data Line data Source code
1 : : // Copyright (c) 2009-2010 Satoshi Nakamoto
2 : : // Copyright (c) 2009-present The Bitcoin Core developers
3 : : // Distributed under the MIT software license, see the accompanying
4 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
5 : :
6 : : #include <logging.h>
7 : : #include <memusage.h>
8 : : #include <util/check.h>
9 : : #include <util/fs.h>
10 : : #include <util/string.h>
11 : : #include <util/threadnames.h>
12 : : #include <util/time.h>
13 : :
14 : : #include <array>
15 : : #include <map>
16 : : #include <optional>
17 : :
18 : : using util::Join;
19 : : using util::RemovePrefixView;
20 : :
21 : : const char * const DEFAULT_DEBUGLOGFILE = "debug.log";
22 : : constexpr auto MAX_USER_SETABLE_SEVERITY_LEVEL{BCLog::Level::Info};
23 : :
24 : 39232849 : BCLog::Logger& LogInstance()
25 : : {
26 : : /**
27 : : * NOTE: the logger instances is leaked on exit. This is ugly, but will be
28 : : * cleaned up by the OS/libc. Defining a logger as a global object doesn't work
29 : : * since the order of destruction of static/global objects is undefined.
30 : : * Consider if the logger gets destroyed, and then some later destructor calls
31 : : * LogPrintf, maybe indirectly, and you get a core dump at shutdown trying to
32 : : * access the logger. When the shutdown sequence is fully audited and tested,
33 : : * explicit destruction of these objects can be implemented by changing this
34 : : * from a raw pointer to a std::unique_ptr.
35 : : * Since the ~Logger() destructor is never called, the Logger class and all
36 : : * its subclasses must have implicitly-defined destructors.
37 : : *
38 : : * This method of initialization was originally introduced in
39 : : * ee3374234c60aba2cc4c5cd5cac1c0aefc2d817c.
40 : : */
41 [ + + + - : 39232849 : static BCLog::Logger* g_logger{new BCLog::Logger()};
+ - ]
42 : 39232849 : return *g_logger;
43 : : }
44 : :
45 : : bool fLogIPs = DEFAULT_LOGIPS;
46 : :
47 : 3900489 : static int FileWriteStr(std::string_view str, FILE *fp)
48 : : {
49 : 3900489 : return fwrite(str.data(), 1, str.size(), fp);
50 : : }
51 : :
52 : 1232 : bool BCLog::Logger::StartLogging()
53 : : {
54 : 1232 : StdLockGuard scoped_lock(m_cs);
55 : :
56 [ - + ]: 1232 : assert(m_buffering);
57 [ - + ]: 1232 : assert(m_fileout == nullptr);
58 : :
59 [ + + ]: 1232 : if (m_print_to_file) {
60 [ - + ]: 1149 : assert(!m_file_path.empty());
61 [ + - ]: 1149 : m_fileout = fsbridge::fopen(m_file_path, "a");
62 [ + - ]: 1149 : if (!m_fileout) {
63 : : return false;
64 : : }
65 : :
66 : 1149 : setbuf(m_fileout, nullptr); // unbuffered
67 : :
68 : : // Add newlines to the logfile to distinguish this execution from the
69 : : // last one.
70 [ + - ]: 1149 : FileWriteStr("\n\n\n\n\n", m_fileout);
71 : : }
72 : :
73 : : // dump buffered messages from before we opened the log
74 : 1232 : m_buffering = false;
75 [ - + ]: 1232 : if (m_buffer_lines_discarded > 0) {
76 [ # # # # ]: 0 : LogPrintStr_(strprintf("Early logging buffer overflowed, %d log lines discarded.\n", m_buffer_lines_discarded), __func__, __FILE__, __LINE__, BCLog::ALL, Level::Info);
77 : : }
78 [ + + ]: 5012 : while (!m_msgs_before_open.empty()) {
79 [ + - ]: 3780 : const auto& buflog = m_msgs_before_open.front();
80 [ + - ]: 3780 : std::string s{buflog.str};
81 [ + - ]: 3780 : FormatLogStrInPlace(s, buflog.category, buflog.level, buflog.source_file, buflog.source_line, buflog.logging_function, buflog.threadname, buflog.now, buflog.mocktime);
82 : 3780 : m_msgs_before_open.pop_front();
83 : :
84 [ + + + - ]: 3780 : if (m_print_to_file) FileWriteStr(s, m_fileout);
85 [ - + - - ]: 3780 : if (m_print_to_console) fwrite(s.data(), 1, s.size(), stdout);
86 [ - + ]: 3780 : for (const auto& cb : m_print_callbacks) {
87 [ # # ]: 0 : cb(s);
88 : : }
89 : 3780 : }
90 : 1232 : m_cur_buffer_memusage = 0;
91 [ - + - - ]: 1232 : if (m_print_to_console) fflush(stdout);
92 : :
93 : : return true;
94 : 1232 : }
95 : :
96 : 1232 : void BCLog::Logger::DisconnectTestLogger()
97 : : {
98 : 1232 : StdLockGuard scoped_lock(m_cs);
99 : 1232 : m_buffering = true;
100 [ + + + - ]: 1232 : if (m_fileout != nullptr) fclose(m_fileout);
101 : 1232 : m_fileout = nullptr;
102 : 1232 : m_print_callbacks.clear();
103 : 1232 : m_max_buffer_memusage = DEFAULT_MAX_LOG_BUFFER;
104 : 1232 : m_cur_buffer_memusage = 0;
105 : 1232 : m_buffer_lines_discarded = 0;
106 : 1232 : m_msgs_before_open.clear();
107 : 1232 : }
108 : :
109 : 0 : void BCLog::Logger::DisableLogging()
110 : : {
111 : 0 : {
112 : 0 : StdLockGuard scoped_lock(m_cs);
113 [ # # ]: 0 : assert(m_buffering);
114 [ # # ]: 0 : assert(m_print_callbacks.empty());
115 : 0 : }
116 : 0 : m_print_to_file = false;
117 : 0 : m_print_to_console = false;
118 : 0 : StartLogging();
119 : 0 : }
120 : :
121 : 1305 : void BCLog::Logger::EnableCategory(BCLog::LogFlags flag)
122 : : {
123 : 1305 : m_categories |= flag;
124 : 1305 : }
125 : :
126 : 1327 : bool BCLog::Logger::EnableCategory(std::string_view str)
127 : : {
128 : 1327 : BCLog::LogFlags flag;
129 [ + + ]: 1327 : if (!GetLogCategory(flag, str)) return false;
130 : 1305 : EnableCategory(flag);
131 : 1305 : return true;
132 : : }
133 : :
134 : 2609 : void BCLog::Logger::DisableCategory(BCLog::LogFlags flag)
135 : : {
136 : 2609 : m_categories &= ~flag;
137 : 2609 : }
138 : :
139 : 2622 : bool BCLog::Logger::DisableCategory(std::string_view str)
140 : : {
141 : 2622 : BCLog::LogFlags flag;
142 [ + + ]: 2622 : if (!GetLogCategory(flag, str)) return false;
143 : 2609 : DisableCategory(flag);
144 : 2609 : return true;
145 : : }
146 : :
147 : 29621880 : bool BCLog::Logger::WillLogCategory(BCLog::LogFlags category) const
148 : : {
149 : 29621880 : return (m_categories.load(std::memory_order_relaxed) & category) != 0;
150 : : }
151 : :
152 : 29549182 : bool BCLog::Logger::WillLogCategoryLevel(BCLog::LogFlags category, BCLog::Level level) const
153 : : {
154 : : // Log messages at Info, Warning and Error level unconditionally, so that
155 : : // important troubleshooting information doesn't get lost.
156 [ + + ]: 29549182 : if (level >= BCLog::Level::Info) return true;
157 : :
158 [ + + ]: 29548478 : if (!WillLogCategory(category)) return false;
159 : :
160 : 3615547 : StdLockGuard scoped_lock(m_cs);
161 : 3615547 : const auto it{m_category_log_levels.find(category)};
162 [ + - ]: 3615547 : return level >= (it == m_category_log_levels.end() ? LogLevel() : it->second);
163 : 3615547 : }
164 : :
165 : 0 : bool BCLog::Logger::DefaultShrinkDebugFile() const
166 : : {
167 : 0 : return m_categories == BCLog::NONE;
168 : : }
169 : :
170 : : static const std::map<std::string, BCLog::LogFlags, std::less<>> LOG_CATEGORIES_BY_STR{
171 : : {"net", BCLog::NET},
172 : : {"tor", BCLog::TOR},
173 : : {"mempool", BCLog::MEMPOOL},
174 : : {"http", BCLog::HTTP},
175 : : {"bench", BCLog::BENCH},
176 : : {"zmq", BCLog::ZMQ},
177 : : {"walletdb", BCLog::WALLETDB},
178 : : {"rpc", BCLog::RPC},
179 : : {"estimatefee", BCLog::ESTIMATEFEE},
180 : : {"addrman", BCLog::ADDRMAN},
181 : : {"selectcoins", BCLog::SELECTCOINS},
182 : : {"reindex", BCLog::REINDEX},
183 : : {"cmpctblock", BCLog::CMPCTBLOCK},
184 : : {"rand", BCLog::RAND},
185 : : {"prune", BCLog::PRUNE},
186 : : {"proxy", BCLog::PROXY},
187 : : {"mempoolrej", BCLog::MEMPOOLREJ},
188 : : {"libevent", BCLog::LIBEVENT},
189 : : {"coindb", BCLog::COINDB},
190 : : {"qt", BCLog::QT},
191 : : {"leveldb", BCLog::LEVELDB},
192 : : {"validation", BCLog::VALIDATION},
193 : : {"i2p", BCLog::I2P},
194 : : {"ipc", BCLog::IPC},
195 : : #ifdef DEBUG_LOCKCONTENTION
196 : : {"lock", BCLog::LOCK},
197 : : #endif
198 : : {"blockstorage", BCLog::BLOCKSTORAGE},
199 : : {"txreconciliation", BCLog::TXRECONCILIATION},
200 : : {"scan", BCLog::SCAN},
201 : : {"txpackages", BCLog::TXPACKAGES},
202 : : };
203 : :
204 : : static const std::unordered_map<BCLog::LogFlags, std::string> LOG_CATEGORIES_BY_FLAG{
205 : : // Swap keys and values from LOG_CATEGORIES_BY_STR.
206 : 205 : [](const auto& in) {
207 : 205 : std::unordered_map<BCLog::LogFlags, std::string> out;
208 [ + - + + ]: 5945 : for (const auto& [k, v] : in) {
209 : 5740 : const bool inserted{out.emplace(v, k).second};
210 [ - + ]: 5740 : assert(inserted);
211 : : }
212 : 205 : return out;
213 : 0 : }(LOG_CATEGORIES_BY_STR)
214 : : };
215 : :
216 : 3949 : bool GetLogCategory(BCLog::LogFlags& flag, std::string_view str)
217 : : {
218 [ + + + + : 3949 : if (str.empty() || str == "1" || str == "all") {
+ + ]
219 : 1426 : flag = BCLog::ALL;
220 : 1426 : return true;
221 : : }
222 : 2523 : auto it = LOG_CATEGORIES_BY_STR.find(str);
223 [ + + ]: 2523 : if (it != LOG_CATEGORIES_BY_STR.end()) {
224 : 2488 : flag = it->second;
225 : 2488 : return true;
226 : : }
227 : : return false;
228 : : }
229 : :
230 : 39328 : std::string BCLog::Logger::LogLevelToStr(BCLog::Level level)
231 : : {
232 [ + + + - : 39328 : switch (level) {
+ - ]
233 : 1232 : case BCLog::Level::Trace:
234 : 1232 : return "trace";
235 : 2464 : case BCLog::Level::Debug:
236 : 2464 : return "debug";
237 : 1232 : case BCLog::Level::Info:
238 : 1232 : return "info";
239 : 0 : case BCLog::Level::Warning:
240 : 0 : return "warning";
241 : 34400 : case BCLog::Level::Error:
242 : 34400 : return "error";
243 : : }
244 : 0 : assert(false);
245 : : }
246 : :
247 : 3614639 : static std::string LogCategoryToStr(BCLog::LogFlags category)
248 : : {
249 [ - + ]: 3614639 : if (category == BCLog::ALL) {
250 : 0 : return "all";
251 : : }
252 : 3614639 : auto it = LOG_CATEGORIES_BY_FLAG.find(category);
253 [ - + ]: 3614639 : assert(it != LOG_CATEGORIES_BY_FLAG.end());
254 : 3614639 : return it->second;
255 : : }
256 : :
257 : 1232 : static std::optional<BCLog::Level> GetLogLevel(std::string_view level_str)
258 : : {
259 [ + - ]: 1232 : if (level_str == "trace") {
260 : 1232 : return BCLog::Level::Trace;
261 [ # # ]: 0 : } else if (level_str == "debug") {
262 : 0 : return BCLog::Level::Debug;
263 [ # # ]: 0 : } else if (level_str == "info") {
264 : 0 : return BCLog::Level::Info;
265 [ # # ]: 0 : } else if (level_str == "warning") {
266 : 0 : return BCLog::Level::Warning;
267 [ # # ]: 0 : } else if (level_str == "error") {
268 : 0 : return BCLog::Level::Error;
269 : : } else {
270 : 0 : return std::nullopt;
271 : : }
272 : : }
273 : :
274 : 2621 : std::vector<LogCategory> BCLog::Logger::LogCategoriesList() const
275 : : {
276 : 2621 : std::vector<LogCategory> ret;
277 [ + - ]: 2621 : ret.reserve(LOG_CATEGORIES_BY_STR.size());
278 [ + - + + ]: 76009 : for (const auto& [category, flag] : LOG_CATEGORIES_BY_STR) {
279 [ + - + - : 73388 : ret.push_back(LogCategory{.category = category, .active = WillLogCategory(flag)});
+ - ]
280 : : }
281 : 2621 : return ret;
282 : 0 : }
283 : :
284 : : /** Log severity levels that can be selected by the user. */
285 : : static constexpr std::array<BCLog::Level, 3> LogLevelsList()
286 : : {
287 : : return {BCLog::Level::Info, BCLog::Level::Debug, BCLog::Level::Trace};
288 : : }
289 : :
290 : 1232 : std::string BCLog::Logger::LogLevelsString() const
291 : : {
292 : 1232 : const auto& levels = LogLevelsList();
293 [ + - + - ]: 6160 : return Join(std::vector<BCLog::Level>{levels.begin(), levels.end()}, ", ", [](BCLog::Level level) { return LogLevelToStr(level); });
294 : : }
295 : :
296 : 3899672 : std::string BCLog::Logger::LogTimestampStr(SystemClock::time_point now, std::chrono::seconds mocktime) const
297 : : {
298 [ + - ]: 3899672 : std::string strStamped;
299 : :
300 [ + - ]: 3899672 : if (!m_log_timestamps)
301 : : return strStamped;
302 : :
303 : 3899672 : const auto now_seconds{std::chrono::time_point_cast<std::chrono::seconds>(now)};
304 [ + - ]: 3899672 : strStamped = FormatISO8601DateTime(TicksSinceEpoch<std::chrono::seconds>(now_seconds));
305 [ + - + - ]: 3899672 : if (m_log_time_micros && !strStamped.empty()) {
306 : 3899672 : strStamped.pop_back();
307 [ + - ]: 7799344 : strStamped += strprintf(".%06dZ", Ticks<std::chrono::microseconds>(now - now_seconds));
308 : : }
309 [ - + ]: 3899672 : if (mocktime > 0s) {
310 [ # # # # : 0 : strStamped += " (mocktime: " + FormatISO8601DateTime(count_seconds(mocktime)) + ")";
# # ]
311 : : }
312 [ + - ]: 7799344 : strStamped += ' ';
313 : :
314 : : return strStamped;
315 : 0 : }
316 : :
317 : : namespace BCLog {
318 : : /** Belts and suspenders: make sure outgoing log messages don't contain
319 : : * potentially suspicious characters, such as terminal control codes.
320 : : *
321 : : * This escapes control characters except newline ('\n') in C syntax.
322 : : * It escapes instead of removes them to still allow for troubleshooting
323 : : * issues where they accidentally end up in strings.
324 : : */
325 : 3899796 : std::string LogEscapeMessage(std::string_view str) {
326 : 3899796 : std::string ret;
327 [ + + ]: 305545498 : for (char ch_in : str) {
328 : 301645702 : uint8_t ch = (uint8_t)ch_in;
329 [ + - + - ]: 301645702 : if ((ch >= 32 || ch == '\n') && ch != '\x7f') {
330 [ + - ]: 603291404 : ret += ch_in;
331 : : } else {
332 [ # # ]: 0 : ret += strprintf("\\x%02x", ch);
333 : : }
334 : : }
335 : 3899796 : return ret;
336 : 0 : }
337 : : } // namespace BCLog
338 : :
339 : 3899672 : std::string BCLog::Logger::GetLogPrefix(BCLog::LogFlags category, BCLog::Level level) const
340 : : {
341 [ - + ]: 3899672 : if (category == LogFlags::NONE) category = LogFlags::ALL;
342 : :
343 [ + - + + ]: 3899672 : const bool has_category{m_always_print_category_level || category != LogFlags::ALL};
344 : :
345 : : // If there is no category, Info is implied
346 [ + + ]: 3899672 : if (!has_category && level == Level::Info) return {};
347 : :
348 : 3649039 : std::string s{"["};
349 [ + + ]: 3649039 : if (has_category) {
350 [ + - ]: 7229278 : s += LogCategoryToStr(category);
351 : : }
352 : :
353 [ + - + + ]: 3649039 : if (m_always_print_category_level || !has_category || level != Level::Debug) {
354 : : // If there is a category, Debug is implied, so don't add the level
355 : :
356 : : // Only add separator if we have a category
357 [ - + - - ]: 34400 : if (has_category) s += ":";
358 [ + - ]: 68800 : s += Logger::LogLevelToStr(level);
359 : : }
360 : :
361 [ + - ]: 3649039 : s += "] ";
362 : 3649039 : return s;
363 : 3649039 : }
364 : :
365 : 3904 : static size_t MemUsage(const BCLog::Logger::BufferedLog& buflog)
366 : : {
367 : 3904 : return buflog.str.size() + buflog.logging_function.size() + buflog.source_file.size() + buflog.threadname.size() + memusage::MallocUsage(sizeof(memusage::list_node<BCLog::Logger::BufferedLog>));
368 : : }
369 : :
370 : 3899672 : void BCLog::Logger::FormatLogStrInPlace(std::string& str, BCLog::LogFlags category, BCLog::Level level, std::string_view source_file, int source_line, std::string_view logging_function, std::string_view threadname, SystemClock::time_point now, std::chrono::seconds mocktime) const
371 : : {
372 [ + - ]: 3899672 : if (!str.ends_with('\n')) str.push_back('\n');
373 : :
374 [ + - ]: 3899672 : str.insert(0, GetLogPrefix(category, level));
375 : :
376 [ + - ]: 3899672 : if (m_log_sourcelocations) {
377 [ + - ]: 7799344 : str.insert(0, strprintf("[%s:%d] [%s] ", RemovePrefixView(source_file, "./"), source_line, logging_function));
378 : : }
379 : :
380 [ + - ]: 3899672 : if (m_log_threadnames) {
381 [ + + + - ]: 7799344 : str.insert(0, strprintf("[%s] ", (threadname.empty() ? "unknown" : threadname)));
382 : : }
383 : :
384 [ + - ]: 3899672 : str.insert(0, LogTimestampStr(now, mocktime));
385 : 3899672 : }
386 : :
387 : 3899796 : void BCLog::Logger::LogPrintStr(std::string_view str, std::string_view logging_function, std::string_view source_file, int source_line, BCLog::LogFlags category, BCLog::Level level)
388 : : {
389 : 3899796 : StdLockGuard scoped_lock(m_cs);
390 [ + - ]: 3899796 : return LogPrintStr_(str, logging_function, source_file, source_line, category, level);
391 : 3899796 : }
392 : :
393 : 3899796 : void BCLog::Logger::LogPrintStr_(std::string_view str, std::string_view logging_function, std::string_view source_file, int source_line, BCLog::LogFlags category, BCLog::Level level)
394 : : {
395 : 3899796 : std::string str_prefixed = LogEscapeMessage(str);
396 : :
397 [ + + ]: 3899796 : if (m_buffering) {
398 : 3904 : {
399 : 3904 : BufferedLog buf{
400 : 3904 : .now=SystemClock::now(),
401 [ + - ]: 3904 : .mocktime=GetMockTime(),
402 : : .str=str_prefixed,
403 : : .logging_function=std::string(logging_function),
404 : 3904 : .source_file=std::string(source_file),
405 : : .threadname=util::ThreadGetInternalName(),
406 : : .source_line=source_line,
407 : : .category=category,
408 : : .level=level,
409 [ + - + - : 3904 : };
+ - + - +
- ]
410 : 3904 : m_cur_buffer_memusage += MemUsage(buf);
411 [ + - ]: 3904 : m_msgs_before_open.push_back(std::move(buf));
412 : 0 : }
413 : :
414 [ - + ]: 7808 : while (m_cur_buffer_memusage > m_max_buffer_memusage) {
415 [ # # ]: 0 : if (m_msgs_before_open.empty()) {
416 : 0 : m_cur_buffer_memusage = 0;
417 : 0 : break;
418 : : }
419 : 0 : m_cur_buffer_memusage -= MemUsage(m_msgs_before_open.front());
420 : 0 : m_msgs_before_open.pop_front();
421 : 0 : ++m_buffer_lines_discarded;
422 : : }
423 : :
424 : 3904 : return;
425 : : }
426 : :
427 [ + - + - : 3895892 : FormatLogStrInPlace(str_prefixed, category, level, source_file, source_line, logging_function, util::ThreadGetInternalName(), SystemClock::now(), GetMockTime());
+ - ]
428 : :
429 [ - + ]: 3895892 : if (m_print_to_console) {
430 : : // print to console
431 [ # # ]: 0 : fwrite(str_prefixed.data(), 1, str_prefixed.size(), stdout);
432 [ # # ]: 0 : fflush(stdout);
433 : : }
434 [ - + ]: 3895892 : for (const auto& cb : m_print_callbacks) {
435 [ # # ]: 0 : cb(str_prefixed);
436 : : }
437 [ + - ]: 3895892 : if (m_print_to_file) {
438 [ - + ]: 3895892 : assert(m_fileout != nullptr);
439 : :
440 : : // reopen the log file, if requested
441 [ - + ]: 3895892 : if (m_reopen_file) {
442 [ # # ]: 0 : m_reopen_file = false;
443 [ # # ]: 0 : FILE* new_fileout = fsbridge::fopen(m_file_path, "a");
444 [ # # ]: 0 : if (new_fileout) {
445 : 0 : setbuf(new_fileout, nullptr); // unbuffered
446 [ # # ]: 0 : fclose(m_fileout);
447 : 0 : m_fileout = new_fileout;
448 : : }
449 : : }
450 [ + - ]: 3895892 : FileWriteStr(str_prefixed, m_fileout);
451 : : }
452 : 3899796 : }
453 : :
454 : 0 : void BCLog::Logger::ShrinkDebugFile()
455 : : {
456 : : // Amount of debug.log to save at end when shrinking (must fit in memory)
457 : 0 : constexpr size_t RECENT_DEBUG_HISTORY_SIZE = 10 * 1000000;
458 : :
459 [ # # ]: 0 : assert(!m_file_path.empty());
460 : :
461 : : // Scroll debug.log if it's getting too big
462 : 0 : FILE* file = fsbridge::fopen(m_file_path, "r");
463 : :
464 : : // Special files (e.g. device nodes) may not have a size.
465 : 0 : size_t log_size = 0;
466 : 0 : try {
467 [ # # ]: 0 : log_size = fs::file_size(m_file_path);
468 [ - - ]: 0 : } catch (const fs::filesystem_error&) {}
469 : :
470 : : // If debug.log file is more than 10% bigger the RECENT_DEBUG_HISTORY_SIZE
471 : : // trim it down by saving only the last RECENT_DEBUG_HISTORY_SIZE bytes
472 [ # # ]: 0 : if (file && log_size > 11 * (RECENT_DEBUG_HISTORY_SIZE / 10))
473 : : {
474 : : // Restart the file with some of the end
475 : 0 : std::vector<char> vch(RECENT_DEBUG_HISTORY_SIZE, 0);
476 [ # # ]: 0 : if (fseek(file, -((long)vch.size()), SEEK_END)) {
477 [ # # ]: 0 : LogPrintf("Failed to shrink debug log file: fseek(...) failed\n");
478 [ # # ]: 0 : fclose(file);
479 : 0 : return;
480 : : }
481 [ # # ]: 0 : int nBytes = fread(vch.data(), 1, vch.size(), file);
482 [ # # ]: 0 : fclose(file);
483 : :
484 [ # # ]: 0 : file = fsbridge::fopen(m_file_path, "w");
485 [ # # ]: 0 : if (file)
486 : : {
487 [ # # ]: 0 : fwrite(vch.data(), 1, nBytes, file);
488 [ # # ]: 0 : fclose(file);
489 : : }
490 : 0 : }
491 [ # # ]: 0 : else if (file != nullptr)
492 : 0 : fclose(file);
493 : : }
494 : :
495 : 1232 : bool BCLog::Logger::SetLogLevel(std::string_view level_str)
496 : : {
497 : 1232 : const auto level = GetLogLevel(level_str);
498 [ + - + - ]: 1232 : if (!level.has_value() || level.value() > MAX_USER_SETABLE_SEVERITY_LEVEL) return false;
499 : 1232 : m_log_level = level.value();
500 : 1232 : return true;
501 : : }
502 : :
503 : 0 : bool BCLog::Logger::SetCategoryLogLevel(std::string_view category_str, std::string_view level_str)
504 : : {
505 : 0 : BCLog::LogFlags flag;
506 [ # # ]: 0 : if (!GetLogCategory(flag, category_str)) return false;
507 : :
508 : 0 : const auto level = GetLogLevel(level_str);
509 [ # # # # ]: 0 : if (!level.has_value() || level.value() > MAX_USER_SETABLE_SEVERITY_LEVEL) return false;
510 : :
511 : 0 : StdLockGuard scoped_lock(m_cs);
512 [ # # ]: 0 : m_category_log_levels[flag] = level.value();
513 : 0 : return true;
514 : 0 : }
|
