Bitcoin Core 29.99.0
P2P Digital Currency
logging.h
Go to the documentation of this file.
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#ifndef BITCOIN_LOGGING_H
7#define BITCOIN_LOGGING_H
8
9#include <crypto/siphash.h>
10#include <threadsafety.h>
11#include <tinyformat.h>
12#include <util/fs.h>
13#include <util/string.h>
14#include <util/time.h>
15
16#include <atomic>
17#include <cstdint>
18#include <cstring>
19#include <functional>
20#include <list>
21#include <memory>
22#include <mutex>
23#include <source_location>
24#include <string>
25#include <unordered_map>
26#include <unordered_set>
27#include <vector>
28
29static const bool DEFAULT_LOGTIMEMICROS = false;
30static const bool DEFAULT_LOGIPS = false;
31static const bool DEFAULT_LOGTIMESTAMPS = true;
32static const bool DEFAULT_LOGTHREADNAMES = false;
33static const bool DEFAULT_LOGSOURCELOCATIONS = false;
34static constexpr bool DEFAULT_LOGLEVELALWAYS = false;
35extern const char * const DEFAULT_DEBUGLOGFILE;
36
37extern bool fLogIPs;
38
40 bool operator()(const std::source_location& lhs, const std::source_location& rhs) const noexcept
41 {
42 return lhs.line() == rhs.line() && std::string_view(lhs.file_name()) == std::string_view(rhs.file_name());
43 }
44};
45
47 size_t operator()(const std::source_location& s) const noexcept
48 {
49 // Use CSipHasher(0, 0) as a simple way to get uniform distribution.
50 return size_t(CSipHasher(0, 0)
51 .Write(s.line())
52 .Write(MakeUCharSpan(std::string_view{s.file_name()}))
53 .Finalize());
54 }
55};
56
58 std::string category;
59 bool active;
60};
61
62namespace BCLog {
63 using CategoryMask = uint64_t;
66 NET = (CategoryMask{1} << 0),
67 TOR = (CategoryMask{1} << 1),
68 MEMPOOL = (CategoryMask{1} << 2),
69 HTTP = (CategoryMask{1} << 3),
70 BENCH = (CategoryMask{1} << 4),
71 ZMQ = (CategoryMask{1} << 5),
73 RPC = (CategoryMask{1} << 7),
75 ADDRMAN = (CategoryMask{1} << 9),
77 REINDEX = (CategoryMask{1} << 11),
79 RAND = (CategoryMask{1} << 13),
80 PRUNE = (CategoryMask{1} << 14),
81 PROXY = (CategoryMask{1} << 15),
83 LIBEVENT = (CategoryMask{1} << 17),
84 COINDB = (CategoryMask{1} << 18),
85 QT = (CategoryMask{1} << 19),
86 LEVELDB = (CategoryMask{1} << 20),
88 I2P = (CategoryMask{1} << 22),
89 IPC = (CategoryMask{1} << 23),
90#ifdef DEBUG_LOCKCONTENTION
91 LOCK = (CategoryMask{1} << 24),
92#endif
95 SCAN = (CategoryMask{1} << 27),
98 };
99 enum class Level {
100 Trace = 0, // High-volume or detailed logging for development/debugging
101 Debug, // Reasonably noisy logging, but still usable in production
102 Info, // Default
103 Warning,
104 Error,
105 };
107 constexpr size_t DEFAULT_MAX_LOG_BUFFER{1'000'000}; // buffer up to 1MB of log data prior to StartLogging
108 constexpr uint64_t RATELIMIT_MAX_BYTES{1024 * 1024}; // maximum number of bytes per source location that can be logged within the RATELIMIT_WINDOW
109 constexpr auto RATELIMIT_WINDOW{1h}; // time window after which log ratelimit stats are reset
110 constexpr bool DEFAULT_LOGRATELIMIT{true};
111
114 {
115 public:
117 struct Stats {
121 uint64_t m_dropped_bytes{0};
122
123 Stats(uint64_t max_bytes) : m_available_bytes{max_bytes} {}
125 bool Consume(uint64_t bytes);
126 };
127
128 private:
130
132 std::unordered_map<std::source_location, Stats, SourceLocationHasher, SourceLocationEqual> m_source_locations GUARDED_BY(m_mutex);
134 std::atomic<bool> m_suppression_active{false};
135 LogRateLimiter(uint64_t max_bytes, std::chrono::seconds reset_window);
136
137 public:
138 using SchedulerFunction = std::function<void(std::function<void()>, std::chrono::milliseconds)>;
147 static std::shared_ptr<LogRateLimiter> Create(
148 SchedulerFunction&& scheduler_func,
149 uint64_t max_bytes,
150 std::chrono::seconds reset_window);
152 const uint64_t m_max_bytes;
154 const std::chrono::seconds m_reset_window;
156 enum class Status {
157 UNSUPPRESSED, // string fits within the limit
158 NEWLY_SUPPRESSED, // suppression has started since this string
159 STILL_SUPPRESSED, // suppression is still ongoing
160 };
163 [[nodiscard]] Status Consume(
164 const std::source_location& source_loc,
165 const std::string& str) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
170 };
171
172 class Logger
173 {
174 public:
175 struct BufferedLog {
176 SystemClock::time_point now;
177 std::chrono::seconds mocktime;
178 std::string str, threadname;
179 std::source_location source_loc;
182 };
183
184 private:
185 mutable StdMutex m_cs; // Can not use Mutex from sync.h because in debug mode it would cause a deadlock when a potential deadlock was detected
186
187 FILE* m_fileout GUARDED_BY(m_cs) = nullptr;
188 std::list<BufferedLog> m_msgs_before_open GUARDED_BY(m_cs);
189 bool m_buffering GUARDED_BY(m_cs) = true;
190 size_t m_max_buffer_memusage GUARDED_BY(m_cs){DEFAULT_MAX_LOG_BUFFER};
191 size_t m_cur_buffer_memusage GUARDED_BY(m_cs){0};
192 size_t m_buffer_lines_discarded GUARDED_BY(m_cs){0};
193
195 std::shared_ptr<LogRateLimiter> m_limiter GUARDED_BY(m_cs);
196
198 std::unordered_map<LogFlags, Level> m_category_log_levels GUARDED_BY(m_cs);
199
202 std::atomic<Level> m_log_level{DEFAULT_LOG_LEVEL};
203
205 std::atomic<CategoryMask> m_categories{BCLog::NONE};
206
207 void FormatLogStrInPlace(std::string& str, LogFlags category, Level level, const std::source_location& source_loc, std::string_view threadname, SystemClock::time_point now, std::chrono::seconds mocktime) const;
208
209 std::string LogTimestampStr(SystemClock::time_point now, std::chrono::seconds mocktime) const;
210
212 std::list<std::function<void(const std::string&)>> m_print_callbacks GUARDED_BY(m_cs) {};
213
215 void LogPrintStr_(std::string_view str, std::source_location&& source_loc, BCLog::LogFlags category, BCLog::Level level, bool should_ratelimit)
217
218 std::string GetLogPrefix(LogFlags category, Level level) const;
219
220 public:
221 bool m_print_to_console = false;
222 bool m_print_to_file = false;
223
229
230 fs::path m_file_path;
231 std::atomic<bool> m_reopen_file{false};
232
234 void LogPrintStr(std::string_view str, std::source_location&& source_loc, BCLog::LogFlags category, BCLog::Level level, bool should_ratelimit)
236
239 {
240 StdLockGuard scoped_lock(m_cs);
241 return m_buffering || m_print_to_console || m_print_to_file || !m_print_callbacks.empty();
242 }
243
245 std::list<std::function<void(const std::string&)>>::iterator PushBackCallback(std::function<void(const std::string&)> fun) EXCLUSIVE_LOCKS_REQUIRED(!m_cs)
246 {
247 StdLockGuard scoped_lock(m_cs);
248 m_print_callbacks.push_back(std::move(fun));
249 return --m_print_callbacks.end();
250 }
251
253 void DeleteCallback(std::list<std::function<void(const std::string&)>>::iterator it) EXCLUSIVE_LOCKS_REQUIRED(!m_cs)
254 {
255 StdLockGuard scoped_lock(m_cs);
256 m_print_callbacks.erase(it);
257 }
258
263
265 {
266 StdLockGuard scoped_lock(m_cs);
267 m_limiter = std::move(limiter);
268 }
269
277
278 void ShrinkDebugFile();
279
281 {
282 StdLockGuard scoped_lock(m_cs);
283 return m_category_log_levels;
284 }
285 void SetCategoryLogLevel(const std::unordered_map<LogFlags, Level>& levels) EXCLUSIVE_LOCKS_REQUIRED(!m_cs)
286 {
287 StdLockGuard scoped_lock(m_cs);
288 m_category_log_levels = levels;
289 }
290 bool SetCategoryLogLevel(std::string_view category_str, std::string_view level_str) EXCLUSIVE_LOCKS_REQUIRED(!m_cs);
291
292 Level LogLevel() const { return m_log_level.load(); }
293 void SetLogLevel(Level level) { m_log_level = level; }
294 bool SetLogLevel(std::string_view level);
295
296 CategoryMask GetCategoryMask() const { return m_categories.load(); }
297
298 void EnableCategory(LogFlags flag);
299 bool EnableCategory(std::string_view str);
300 void DisableCategory(LogFlags flag);
301 bool DisableCategory(std::string_view str);
302
303 bool WillLogCategory(LogFlags category) const;
305
307 std::vector<LogCategory> LogCategoriesList() const;
309 std::string LogCategoriesString() const
310 {
311 return util::Join(LogCategoriesList(), ", ", [&](const LogCategory& i) { return i.category; });
312 };
313
315 std::string LogLevelsString() const;
316
318 static std::string LogLevelToStr(BCLog::Level level);
319
320 bool DefaultShrinkDebugFile() const;
321 };
322
323} // namespace BCLog
324
326
328static inline bool LogAcceptCategory(BCLog::LogFlags category, BCLog::Level level)
329{
330 return LogInstance().WillLogCategoryLevel(category, level);
331}
332
334bool GetLogCategory(BCLog::LogFlags& flag, std::string_view str);
335
336template <typename... Args>
337inline void LogPrintFormatInternal(std::source_location&& source_loc, BCLog::LogFlags flag, BCLog::Level level, bool should_ratelimit, util::ConstevalFormatString<sizeof...(Args)> fmt, const Args&... args)
338{
339 if (LogInstance().Enabled()) {
340 std::string log_msg;
341 try {
342 log_msg = tfm::format(fmt, args...);
343 } catch (tinyformat::format_error& fmterr) {
344 log_msg = "Error \"" + std::string{fmterr.what()} + "\" while formatting log message: " + fmt.fmt;
345 }
346 LogInstance().LogPrintStr(log_msg, std::move(source_loc), flag, level, should_ratelimit);
347 }
348}
349
350#define LogPrintLevel_(category, level, should_ratelimit, ...) LogPrintFormatInternal(std::source_location::current(), category, level, should_ratelimit, __VA_ARGS__)
351
352// Log unconditionally. Uses basic rate limiting to mitigate disk filling attacks.
353// Be conservative when using functions that unconditionally log to debug.log!
354// It should not be the case that an inbound peer can fill up a user's storage
355// with debug.log entries.
356#define LogInfo(...) LogPrintLevel_(BCLog::LogFlags::ALL, BCLog::Level::Info, /*should_ratelimit=*/true, __VA_ARGS__)
357#define LogWarning(...) LogPrintLevel_(BCLog::LogFlags::ALL, BCLog::Level::Warning, /*should_ratelimit=*/true, __VA_ARGS__)
358#define LogError(...) LogPrintLevel_(BCLog::LogFlags::ALL, BCLog::Level::Error, /*should_ratelimit=*/true, __VA_ARGS__)
359
360// Deprecated unconditional logging.
361#define LogPrintf(...) LogInfo(__VA_ARGS__)
362
363// Use a macro instead of a function for conditional logging to prevent
364// evaluating arguments when logging for the category is not enabled.
365
366// Log by prefixing the output with the passed category name and severity level. This can either
367// log conditionally if the category is allowed or unconditionally if level >= BCLog::Level::Info
368// is passed. If this function logs unconditionally, logging to disk is rate-limited. This is
369// important so that callers don't need to worry about accidentally introducing a disk-fill
370// vulnerability if level >= Info is used. Additionally, users specifying -debug are assumed to be
371// developers or power users who are aware that -debug may cause excessive disk usage due to logging.
372#define LogPrintLevel(category, level, ...) \
373 do { \
374 if (LogAcceptCategory((category), (level))) { \
375 bool rate_limit{level >= BCLog::Level::Info}; \
376 LogPrintLevel_(category, level, rate_limit, __VA_ARGS__); \
377 } \
378 } while (0)
379
380// Log conditionally, prefixing the output with the passed category name.
381#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__)
382#define LogTrace(category, ...) LogPrintLevel(category, BCLog::Level::Trace, __VA_ARGS__)
383
384#endif // BITCOIN_LOGGING_H
ArgsManager & args
Definition: bitcoind.cpp:277
Fixed window rate limiter for logging.
Definition: logging.h:114
std::unordered_map< std::source_location, Stats, SourceLocationHasher, SourceLocationEqual > m_source_locations GUARDED_BY(m_mutex)
Stats for each source location that has attempted to log something.
static std::shared_ptr< LogRateLimiter > Create(SchedulerFunction &&scheduler_func, uint64_t max_bytes, std::chrono::seconds reset_window)
Definition: logging.cpp:377
std::function< void(std::function< void()>, std::chrono::milliseconds)> SchedulerFunction
Definition: logging.h:138
const uint64_t m_max_bytes
Maximum number of bytes logged per location per window.
Definition: logging.h:152
LogRateLimiter(uint64_t max_bytes, std::chrono::seconds reset_window)
Definition: logging.cpp:374
Status Consume(const std::source_location &source_loc, const std::string &str) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Consumes source_loc's available bytes corresponding to the size of the (formatted) str and returns it...
Definition: logging.cpp:389
bool SuppressionsActive() const
Returns true if any log locations are currently being suppressed.
Definition: logging.h:169
const std::chrono::seconds m_reset_window
Interval after which the window is reset.
Definition: logging.h:154
Status
Suppression status of a source log location.
Definition: logging.h:156
void Reset() EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
Resets all usage to zero. Called periodically by the scheduler.
Definition: logging.cpp:553
std::atomic< bool > m_suppression_active
Whether any log locations are suppressed. Cached view on m_source_locations for performance reasons.
Definition: logging.h:134
static std::string LogLevelToStr(BCLog::Level level)
Returns the string representation of a log level.
Definition: logging.cpp:232
bool m_always_print_category_level
Definition: logging.h:228
size_t m_buffer_lines_discarded GUARDED_BY(m_cs)
Definition: logging.h:192
FILE *m_fileout GUARDED_BY(m_cs)
bool m_buffering GUARDED_BY(m_cs)
Buffer messages before logging can be started.
bool WillLogCategory(LogFlags category) const
Definition: logging.cpp:149
void LogPrintStr(std::string_view str, std::source_location &&source_loc, BCLog::LogFlags category, BCLog::Level level, bool should_ratelimit) EXCLUSIVE_LOCKS_REQUIRED(!m_cs)
Send a string to the log output.
Definition: logging.cpp:422
std::list< BufferedLog > m_msgs_before_open GUARDED_BY(m_cs)
std::atomic< CategoryMask > m_categories
Log categories bitfield.
Definition: logging.h:205
std::string LogTimestampStr(SystemClock::time_point now, std::chrono::seconds mocktime) const
Definition: logging.cpp:298
size_t m_cur_buffer_memusage GUARDED_BY(m_cs)
Definition: logging.h:191
bool DefaultShrinkDebugFile() const
Definition: logging.cpp:167
std::unordered_map< LogFlags, Level > m_category_log_levels GUARDED_BY(m_cs)
Category-specific log level. Overrides m_log_level.
bool m_log_sourcelocations
Definition: logging.h:227
void SetCategoryLogLevel(const std::unordered_map< LogFlags, Level > &levels) EXCLUSIVE_LOCKS_REQUIRED(!m_cs)
Definition: logging.h:285
void SetLogLevel(Level level)
Definition: logging.h:293
std::atomic< Level > m_log_level
If there is no category-specific log level, all logs with a severity level lower than m_log_level wil...
Definition: logging.h:202
Level LogLevel() const
Definition: logging.h:292
CategoryMask GetCategoryMask() const
Definition: logging.h:296
bool WillLogCategoryLevel(LogFlags category, Level level) const EXCLUSIVE_LOCKS_REQUIRED(!m_cs)
Definition: logging.cpp:154
fs::path m_file_path
Definition: logging.h:230
bool m_log_time_micros
Definition: logging.h:225
bool m_log_threadnames
Definition: logging.h:226
std::list< std::function< void(conststd::string &)> >::iterator PushBackCallback(std::function< void(const std::string &)> fun) EXCLUSIVE_LOCKS_REQUIRED(!m_cs)
Connect a slot to the print signal and return the connection.
Definition: logging.h:245
void SetRateLimiting(std::shared_ptr< LogRateLimiter > limiter) EXCLUSIVE_LOCKS_REQUIRED(!m_cs)
Definition: logging.h:264
void DisableLogging() EXCLUSIVE_LOCKS_REQUIRED(!m_cs)
Disable logging This offers a slight speedup and slightly smaller memory usage compared to leaving th...
Definition: logging.cpp:111
std::vector< LogCategory > LogCategoriesList() const
Returns a vector of the log categories in alphabetical order.
Definition: logging.cpp:276
bool StartLogging() EXCLUSIVE_LOCKS_REQUIRED(!m_cs)
Start logging (and flush all buffered messages)
Definition: logging.cpp:54
void EnableCategory(LogFlags flag)
Definition: logging.cpp:123
size_t m_max_buffer_memusage GUARDED_BY(m_cs)
Definition: logging.h:190
bool m_log_timestamps
Definition: logging.h:224
void DeleteCallback(std::list< std::function< void(const std::string &)> >::iterator it) EXCLUSIVE_LOCKS_REQUIRED(!m_cs)
Delete a connection.
Definition: logging.h:253
std::string GetLogPrefix(LogFlags category, Level level) const
Definition: logging.cpp:341
void LogPrintStr_(std::string_view str, std::source_location &&source_loc, BCLog::LogFlags category, BCLog::Level level, bool should_ratelimit) EXCLUSIVE_LOCKS_REQUIRED(m_cs)
Send a string to the log output (internal)
Definition: logging.cpp:429
void DisconnectTestLogger() EXCLUSIVE_LOCKS_REQUIRED(!m_cs)
Only for testing.
Definition: logging.cpp:98
std::string LogLevelsString() const
Returns a string with all user-selectable log levels.
Definition: logging.cpp:292
std::atomic< bool > m_reopen_file
Definition: logging.h:231
void ShrinkDebugFile()
Definition: logging.cpp:512
bool m_print_to_file
Definition: logging.h:222
void FormatLogStrInPlace(std::string &str, LogFlags category, Level level, const std::source_location &source_loc, std::string_view threadname, SystemClock::time_point now, std::chrono::seconds mocktime) const
Definition: logging.cpp:405
std::unordered_map< LogFlags, Level > CategoryLevels() const EXCLUSIVE_LOCKS_REQUIRED(!m_cs)
Definition: logging.h:280
bool m_print_to_console
Definition: logging.h:221
std::shared_ptr< LogRateLimiter > m_limiter GUARDED_BY(m_cs)
Manages the rate limiting of each log location.
std::list< std::function< void(const std::string &)> > m_print_callbacks GUARDED_BY(m_cs)
Slots that connect to the print signal.
Definition: logging.h:212
StdMutex m_cs
Definition: logging.h:185
bool Enabled() const EXCLUSIVE_LOCKS_REQUIRED(!m_cs)
Returns whether logs will be written to any output.
Definition: logging.h:238
std::string LogCategoriesString() const
Returns a string with the log categories in alphabetical order.
Definition: logging.h:309
void DisableCategory(LogFlags flag)
Definition: logging.cpp:136
SipHash-2-4.
Definition: siphash.h:15
CSipHasher & Write(uint64_t data)
Hash a 64-bit integer worth of data It is treated as if this was the little-endian interpretation of ...
Definition: siphash.cpp:28
static const bool DEFAULT_LOGTIMESTAMPS
Definition: logging.h:31
bool GetLogCategory(BCLog::LogFlags &flag, std::string_view str)
Return true if str parses as a log category and set the flag.
Definition: logging.cpp:218
static const bool DEFAULT_LOGIPS
Definition: logging.h:30
static const bool DEFAULT_LOGTHREADNAMES
Definition: logging.h:32
static bool LogAcceptCategory(BCLog::LogFlags category, BCLog::Level level)
Return true if log accepts specified category, at the specified level.
Definition: logging.h:328
BCLog::Logger & LogInstance()
Definition: logging.cpp:26
static const bool DEFAULT_LOGSOURCELOCATIONS
Definition: logging.h:33
bool fLogIPs
Definition: logging.cpp:47
static const bool DEFAULT_LOGTIMEMICROS
Definition: logging.h:29
const char *const DEFAULT_DEBUGLOGFILE
Definition: logging.cpp:23
void LogPrintFormatInternal(std::source_location &&source_loc, BCLog::LogFlags flag, BCLog::Level level, bool should_ratelimit, util::ConstevalFormatString< sizeof...(Args)> fmt, const Args &... args)
Definition: logging.h:337
static constexpr bool DEFAULT_LOGLEVELALWAYS
Definition: logging.h:34
constexpr auto RATELIMIT_WINDOW
Definition: logging.h:109
Level
Definition: logging.h:99
constexpr bool DEFAULT_LOGRATELIMIT
Definition: logging.h:110
constexpr uint64_t RATELIMIT_MAX_BYTES
Definition: logging.h:108
constexpr size_t DEFAULT_MAX_LOG_BUFFER
Definition: logging.h:107
uint64_t CategoryMask
Definition: logging.h:63
constexpr auto DEFAULT_LOG_LEVEL
Definition: logging.h:106
LogFlags
Definition: logging.h:64
@ ESTIMATEFEE
Definition: logging.h:74
@ TXRECONCILIATION
Definition: logging.h:94
@ RAND
Definition: logging.h:79
@ BLOCKSTORAGE
Definition: logging.h:93
@ COINDB
Definition: logging.h:84
@ REINDEX
Definition: logging.h:77
@ TXPACKAGES
Definition: logging.h:96
@ WALLETDB
Definition: logging.h:72
@ SCAN
Definition: logging.h:95
@ ADDRMAN
Definition: logging.h:75
@ ALL
Definition: logging.h:97
@ RPC
Definition: logging.h:73
@ HTTP
Definition: logging.h:69
@ LEVELDB
Definition: logging.h:86
@ NONE
Definition: logging.h:65
@ VALIDATION
Definition: logging.h:87
@ MEMPOOLREJ
Definition: logging.h:82
@ PRUNE
Definition: logging.h:80
@ TOR
Definition: logging.h:67
@ LIBEVENT
Definition: logging.h:83
@ CMPCTBLOCK
Definition: logging.h:78
@ PROXY
Definition: logging.h:81
@ ZMQ
Definition: logging.h:71
@ IPC
Definition: logging.h:89
@ MEMPOOL
Definition: logging.h:68
@ SELECTCOINS
Definition: logging.h:76
@ I2P
Definition: logging.h:88
@ BENCH
Definition: logging.h:70
@ NET
Definition: logging.h:66
@ QT
Definition: logging.h:85
void format(std::ostream &out, FormatStringCheck< sizeof...(Args)> fmt, const Args &... args)
Format list of arguments to the stream according to given format string.
Definition: tinyformat.h:1079
auto Join(const C &container, const S &separator, UnaryOp unary_op)
Join all container items.
Definition: string.h:204
constexpr auto MakeUCharSpan(const V &v) -> decltype(UCharSpanCast(std::span{v}))
Like the std::span constructor, but for (const) unsigned char member types only.
Definition: span.h:111
Keeps track of an individual source location and how many available bytes are left for logging from i...
Definition: logging.h:117
uint64_t m_available_bytes
Remaining bytes.
Definition: logging.h:119
Stats(uint64_t max_bytes)
Definition: logging.h:123
bool Consume(uint64_t bytes)
Updates internal accounting and returns true if enough available_bytes were remaining.
Definition: logging.cpp:571
uint64_t m_dropped_bytes
Number of bytes that were consumed but didn't fit in the available bytes.
Definition: logging.h:121
std::chrono::seconds mocktime
Definition: logging.h:177
std::string threadname
Definition: logging.h:178
std::source_location source_loc
Definition: logging.h:179
SystemClock::time_point now
Definition: logging.h:176
bool active
Definition: logging.h:59
std::string category
Definition: logging.h:58
bool operator()(const std::source_location &lhs, const std::source_location &rhs) const noexcept
Definition: logging.h:40
size_t operator()(const std::source_location &s) const noexcept
Definition: logging.h:47
A wrapper for a compile-time partially validated format string.
Definition: string.h:92
#define LOCK(cs)
Definition: sync.h:259
#define EXCLUSIVE_LOCKS_REQUIRED(...)
Definition: threadsafety.h:51