Commit | Line | Data |
---|---|---|
7a72f18a PP |
1 | /* |
2 | * SPDX-FileCopyrightText: 2023 Philippe Proulx <pproulx@efficios.com> | |
3 | * SPDX-License-Identifier: MIT | |
4 | */ | |
5 | ||
6 | #ifndef BABELTRACE_CPP_COMMON_BT2C_LOGGING_HPP | |
7 | #define BABELTRACE_CPP_COMMON_BT2C_LOGGING_HPP | |
8 | ||
9 | #include <cstring> | |
10 | #include <iterator> | |
11 | #include <string> | |
12 | #include <utility> | |
13 | #include <vector> | |
14 | ||
15 | #include <babeltrace2/babeltrace.h> | |
16 | ||
17 | #include "common/assert.h" | |
18 | #include "cpp-common/bt2/private-query-executor.hpp" | |
19 | #include "cpp-common/bt2/self-component-class.hpp" | |
20 | #include "cpp-common/bt2/self-component-port.hpp" | |
21 | #include "cpp-common/bt2/self-message-iterator.hpp" | |
22 | #include "cpp-common/bt2s/optional.hpp" | |
23 | #include "cpp-common/vendor/fmt/core.h" | |
24 | #include "logging/log-api.h" | |
25 | ||
26 | namespace bt2c { | |
27 | ||
28 | /* | |
29 | * A logger contains an actor (self component class, self component, | |
30 | * self message iterator, or simple module name), a current logging | |
31 | * level, and a logging tag. | |
32 | * | |
33 | * It offers the logNoThrow(), logMemNoThrow(), logErrnoNoThrow(), | |
34 | * logErrorAndThrow(), logErrorAndRethrow(), logErrorErrnoAndThrow(), | |
35 | * and logErrorErrnoAndRethrow() method templates to log using a given | |
36 | * level, optionally append a cause to the error of the current thread | |
37 | * using the correct actor, and optionally throw or rethrow. | |
38 | * | |
39 | * The methods above expect a format string and zero or more arguments | |
40 | * to be formatted with fmt::format(). | |
41 | */ | |
42 | class Logger final | |
43 | { | |
44 | public: | |
45 | /* Available log levels */ | |
46 | enum class Level | |
47 | { | |
48 | TRACE = BT_LOG_TRACE, | |
49 | DEBUG = BT_LOG_DEBUG, | |
50 | INFO = BT_LOG_INFO, | |
51 | WARNING = BT_LOG_WARNING, | |
52 | ERROR = BT_LOG_ERROR, | |
53 | FATAL = BT_LOG_FATAL, | |
54 | NONE = BT_LOG_NONE, | |
55 | }; | |
56 | ||
57 | /* | |
58 | * Builds a logger from the self component class `selfCompCls` using | |
59 | * the tag `tag` and the logging level of `privQueryExec`. | |
60 | */ | |
61 | explicit Logger(const bt2::SelfComponentClass selfCompCls, | |
62 | const bt2::PrivateQueryExecutor privQueryExec, std::string tag) noexcept : | |
63 | _mSelfCompCls {selfCompCls}, | |
64 | _mLevel {static_cast<Level>(privQueryExec.loggingLevel())}, _mTag {std::move(tag)} | |
65 | { | |
66 | } | |
67 | ||
68 | /* | |
69 | * Builds a logger from the self component `selfComp` using the tag | |
70 | * `tag`. | |
71 | */ | |
72 | explicit Logger(const bt2::SelfComponent selfComp, std::string tag) noexcept : | |
73 | _mSelfComp {selfComp}, _mLevel {static_cast<Level>(selfComp.loggingLevel())}, _mTag { | |
74 | std::move( | |
75 | tag)} | |
76 | { | |
77 | } | |
78 | ||
79 | /* | |
80 | * Builds a logger from the self source component `selfComp` using | |
81 | * the tag `tag`. | |
82 | */ | |
83 | explicit Logger(const bt2::SelfSourceComponent selfComp, std::string tag) noexcept : | |
84 | Logger { | |
85 | bt2::SelfComponent {bt_self_component_source_as_self_component(selfComp.libObjPtr())}, | |
86 | std::move(tag)} | |
87 | { | |
88 | } | |
89 | ||
90 | /* | |
91 | * Builds a logger from the self filter component `selfComp` using | |
92 | * the tag `tag`. | |
93 | */ | |
94 | explicit Logger(const bt2::SelfFilterComponent selfComp, std::string tag) noexcept : | |
95 | Logger { | |
96 | bt2::SelfComponent {bt_self_component_filter_as_self_component(selfComp.libObjPtr())}, | |
97 | std::move(tag)} | |
98 | { | |
99 | } | |
100 | ||
101 | /* | |
102 | * Builds a logger from the self sink component `selfComp` using the | |
103 | * tag `tag`. | |
104 | */ | |
105 | explicit Logger(const bt2::SelfSinkComponent selfComp, std::string tag) noexcept : | |
106 | Logger {bt2::SelfComponent {bt_self_component_sink_as_self_component(selfComp.libObjPtr())}, | |
107 | std::move(tag)} | |
108 | { | |
109 | } | |
110 | ||
111 | /* | |
112 | * Builds a logger from the self message iterator `selfMsgIter` | |
113 | * using the tag `tag`. | |
114 | */ | |
115 | explicit Logger(const bt2::SelfMessageIterator selfMsgIter, std::string tag) noexcept : | |
116 | Logger {selfMsgIter.component(), std::move(tag)} | |
117 | { | |
118 | _mSelfMsgIter = selfMsgIter; | |
119 | } | |
120 | ||
121 | /* | |
122 | * Builds a logger from the module named `moduleName` using the tag | |
123 | * `tag` and logging level `logLevel`. | |
124 | */ | |
125 | explicit Logger(std::string moduleName, std::string tag, const Level logLevel) noexcept : | |
126 | _mModuleName {std::move(moduleName)}, _mLevel {logLevel}, _mTag {std::move(tag)} | |
127 | { | |
128 | } | |
129 | ||
130 | /* | |
131 | * Builds a logger from another logger `other` using the new tag | |
132 | * `newTag`. | |
133 | */ | |
134 | explicit Logger(const Logger& other, std::string newTag) : | |
135 | _mSelfComp {other._mSelfComp}, _mSelfMsgIter {other._mSelfMsgIter}, | |
136 | _mModuleName {other._mModuleName}, _mLevel {other._mLevel}, _mTag {std::move(newTag)} | |
137 | { | |
138 | } | |
139 | ||
140 | /* | |
141 | * Current logging level. | |
142 | */ | |
143 | Level level() const noexcept | |
144 | { | |
145 | return _mLevel; | |
146 | } | |
147 | ||
148 | /* | |
149 | * Current logging level converted to a `bt_log_level` value. | |
150 | * | |
151 | * For legacy code. | |
152 | */ | |
153 | bt_log_level cLevel() const noexcept | |
154 | { | |
155 | return static_cast<bt_log_level>(_mLevel); | |
156 | } | |
157 | ||
158 | /* | |
159 | * Whether or not this logger would log at the level `level`. | |
160 | */ | |
161 | bool wouldLog(const Level level) const noexcept | |
162 | { | |
163 | return BT_LOG_ON_CUR_LVL(static_cast<int>(level), static_cast<int>(_mLevel)); | |
164 | } | |
165 | ||
166 | /* | |
167 | * Whether or not this logger would log at the trace level. | |
168 | */ | |
169 | bool wouldLogT() const noexcept | |
170 | { | |
171 | return this->wouldLog(Level::TRACE); | |
172 | } | |
173 | ||
174 | /* | |
175 | * Whether or not this logger would log at the debug level. | |
176 | */ | |
177 | bool wouldLogD() const noexcept | |
178 | { | |
179 | return this->wouldLog(Level::DEBUG); | |
180 | } | |
181 | ||
182 | /* | |
183 | * Whether or not this logger would log at the info level. | |
184 | */ | |
185 | bool wouldLogI() const noexcept | |
186 | { | |
187 | return this->wouldLog(Level::INFO); | |
188 | } | |
189 | ||
190 | /* | |
191 | * Whether or not this logger would log at the warning level. | |
192 | */ | |
193 | bool wouldLogW() const noexcept | |
194 | { | |
195 | return this->wouldLog(Level::WARNING); | |
196 | } | |
197 | ||
198 | /* | |
199 | * Whether or not this logger would log at the error level. | |
200 | */ | |
201 | bool wouldLogE() const noexcept | |
202 | { | |
203 | return this->wouldLog(Level::ERROR); | |
204 | } | |
205 | ||
206 | /* | |
207 | * Whether or not this logger would log at the fatal level. | |
208 | */ | |
209 | bool wouldLogF() const noexcept | |
210 | { | |
211 | return this->wouldLog(Level::FATAL); | |
212 | } | |
213 | ||
214 | /* | |
215 | * Logging tag. | |
216 | */ | |
217 | const std::string& tag() const noexcept | |
218 | { | |
219 | return _mTag; | |
220 | } | |
221 | ||
222 | /* | |
223 | * Self component class actor, or `bt2s::nullopt` if none. | |
224 | */ | |
225 | const bt2s::optional<bt2::SelfComponentClass>& selfCompCls() const noexcept | |
226 | { | |
227 | return _mSelfCompCls; | |
228 | } | |
229 | ||
230 | /* | |
231 | * Self component actor, or `bt2s::nullopt` if none. | |
232 | */ | |
233 | const bt2s::optional<bt2::SelfComponent>& selfComp() const noexcept | |
234 | { | |
235 | return _mSelfComp; | |
236 | } | |
237 | ||
238 | /* | |
239 | * Self message iterator actor, or `bt2s::nullopt` if none. | |
240 | */ | |
241 | const bt2s::optional<bt2::SelfMessageIterator>& selfMsgIter() const noexcept | |
242 | { | |
243 | return _mSelfMsgIter; | |
244 | } | |
245 | ||
246 | /* | |
247 | * Name of module actor, or `bt2s::nullopt` if none. | |
248 | */ | |
249 | const bt2s::optional<std::string>& moduleName() const noexcept | |
250 | { | |
251 | return _mModuleName; | |
252 | } | |
253 | ||
254 | private: | |
255 | struct _StdLogWriter final | |
256 | { | |
257 | static void write(const char * const fileName, const char * const funcName, | |
258 | const unsigned lineNo, const Level level, const char * const tag, | |
259 | const void *, unsigned int, const char *, const char * const msg) noexcept | |
260 | { | |
261 | bt_log_write(fileName, funcName, lineNo, static_cast<bt_log_level>(level), tag, msg); | |
262 | } | |
263 | }; | |
264 | ||
265 | public: | |
266 | /* | |
267 | * Logs using the level `LevelV`. | |
268 | * | |
269 | * This method forwards `fmt` and `args` to fmt::format() to create | |
270 | * the log message. | |
271 | * | |
272 | * If `AppendCauseV` is true, this method also appends a cause to | |
273 | * the error of the current thread using the same message. | |
274 | */ | |
275 | template <Level LevelV, bool AppendCauseV, typename... ArgTs> | |
276 | void logNoThrow(const char * const fileName, const char * const funcName, | |
277 | const unsigned int lineNo, const char * const fmt, ArgTs&&...args) const | |
278 | { | |
279 | this->_logNoThrow<_StdLogWriter, LevelV, AppendCauseV>( | |
280 | fileName, funcName, lineNo, nullptr, 0, nullptr, fmt, std::forward<ArgTs>(args)...); | |
281 | } | |
282 | ||
283 | /* | |
284 | * Logs `msg` using the level `LevelV`. | |
285 | * | |
286 | * If `AppendCauseV` is true, this method also appends a cause to | |
287 | * the error of the current thread using the same message. | |
288 | */ | |
289 | template <Level LevelV, bool AppendCauseV> | |
290 | void logStrNoThrow(const char * const fileName, const char * const funcName, | |
291 | const unsigned int lineNo, const char * const msg) const | |
292 | { | |
293 | this->_logStrNoThrow<_StdLogWriter, LevelV, AppendCauseV>(fileName, funcName, lineNo, | |
294 | nullptr, 0, nullptr, msg); | |
295 | } | |
296 | ||
297 | /* | |
298 | * Like logAndNoThrow() with the `Level::ERROR` level, but also | |
299 | * throws a default-constructed instance of `ExcT`. | |
300 | */ | |
301 | template <bool AppendCauseV, typename ExcT, typename... ArgTs> | |
302 | [[noreturn]] void logErrorAndThrow(const char * const fileName, const char * const funcName, | |
303 | const unsigned int lineNo, const char * const fmt, | |
304 | ArgTs&&...args) const | |
305 | { | |
306 | this->logNoThrow<Level::ERROR, AppendCauseV>(fileName, funcName, lineNo, fmt, | |
307 | std::forward<ArgTs>(args)...); | |
308 | throw ExcT {}; | |
309 | } | |
310 | ||
311 | /* | |
312 | * Like logStrAndNoThrow() with the `Level::ERROR` level, but also | |
313 | * throws a default-constructed instance of `ExcT`. | |
314 | */ | |
315 | template <bool AppendCauseV, typename ExcT> | |
316 | [[noreturn]] void logErrorStrAndThrow(const char * const fileName, const char * const funcName, | |
317 | const unsigned int lineNo, const char * const msg) const | |
318 | { | |
319 | this->logStrNoThrow<Level::ERROR, AppendCauseV>(fileName, funcName, lineNo, msg); | |
320 | throw ExcT {}; | |
321 | } | |
322 | ||
323 | /* | |
324 | * Like logAndNoThrow() with the `Level::ERROR` level, but also | |
325 | * rethrows. | |
326 | */ | |
327 | template <bool AppendCauseV, typename... ArgTs> | |
328 | [[noreturn]] void logErrorAndRethrow(const char * const fileName, const char * const funcName, | |
329 | const unsigned int lineNo, const char * const fmt, | |
330 | ArgTs&&...args) const | |
331 | { | |
332 | this->logNoThrow<Level::ERROR, AppendCauseV>(fileName, funcName, lineNo, fmt, | |
333 | std::forward<ArgTs>(args)...); | |
334 | throw; | |
335 | } | |
336 | ||
337 | /* | |
338 | * Like logStrAndNoThrow() with the `Level::ERROR` level, but also | |
339 | * rethrows. | |
340 | */ | |
341 | template <bool AppendCauseV> | |
342 | [[noreturn]] void logErrorStrAndRethrow(const char * const fileName, | |
343 | const char * const funcName, const unsigned int lineNo, | |
344 | const char * const msg) const | |
345 | { | |
346 | this->logStrNoThrow<Level::ERROR, AppendCauseV>(fileName, funcName, lineNo, msg); | |
347 | throw; | |
348 | } | |
349 | ||
350 | private: | |
351 | struct _ErrnoLogWriter final | |
352 | { | |
353 | static void write(const char * const fileName, const char * const funcName, | |
354 | const unsigned lineNo, const Level level, const char * const tag, | |
355 | const void *, unsigned int, const char * const initMsg, | |
356 | const char * const msg) noexcept | |
357 | { | |
358 | bt_log_write_errno(funcName, fileName, lineNo, static_cast<bt_log_level>(level), tag, | |
359 | initMsg, msg); | |
360 | } | |
361 | }; | |
362 | ||
363 | public: | |
364 | /* | |
365 | * Logs the message of `errno` using the level `LevelV`. | |
366 | * | |
367 | * The log message starts with `initMsg`, is followed with the | |
368 | * message for `errno`, and then with what fmt::format() creates | |
369 | * given `fmt` and `args`. | |
370 | * | |
371 | * If `AppendCauseV` is true, this method also appends a cause to | |
372 | * the error of the current thread using the same message. | |
373 | */ | |
374 | template <Level LevelV, bool AppendCauseV, typename... ArgTs> | |
375 | void logErrnoNoThrow(const char * const fileName, const char * const funcName, | |
376 | const unsigned int lineNo, const char * const initMsg, | |
377 | const char * const fmt, ArgTs&&...args) const | |
378 | { | |
379 | this->_logNoThrow<_ErrnoLogWriter, LevelV, AppendCauseV>( | |
380 | fileName, funcName, lineNo, nullptr, 0, initMsg, fmt, std::forward<ArgTs>(args)...); | |
381 | } | |
382 | ||
383 | /* | |
384 | * Logs the message of `errno` using the level `LevelV`. | |
385 | * | |
386 | * The log message starts with `initMsg`, is followed with the | |
387 | * message for `errno`, and then with `msg`. | |
388 | * | |
389 | * If `AppendCauseV` is true, this method also appends a cause to | |
390 | * the error of the current thread using the same message. | |
391 | */ | |
392 | template <Level LevelV, bool AppendCauseV> | |
393 | void logErrnoStrNoThrow(const char * const fileName, const char * const funcName, | |
394 | const unsigned int lineNo, const char * const initMsg, | |
395 | const char * const msg) const | |
396 | { | |
397 | this->_logStrNoThrow<_ErrnoLogWriter, LevelV, AppendCauseV>(fileName, funcName, lineNo, | |
398 | nullptr, 0, initMsg, msg); | |
399 | } | |
400 | ||
401 | /* | |
402 | * Like logErrnoNoThrow() with the `Level::ERROR` level, but also | |
403 | * throws a default-constructed instance of `ExcT`. | |
404 | */ | |
405 | template <bool AppendCauseV, typename ExcT, typename... ArgTs> | |
406 | [[noreturn]] void logErrorErrnoAndThrow(const char * const fileName, | |
407 | const char * const funcName, const unsigned int lineNo, | |
408 | const char * const initMsg, const char * const fmt, | |
409 | ArgTs&&...args) const | |
410 | { | |
411 | this->logErrnoNoThrow<Level::ERROR, AppendCauseV>(fileName, funcName, lineNo, initMsg, fmt, | |
412 | std::forward<ArgTs>(args)...); | |
413 | throw ExcT {}; | |
414 | } | |
415 | ||
416 | /* | |
417 | * Like logErrnoStrNoThrow() with the `Level::ERROR` level, but also | |
418 | * throws a default-constructed instance of `ExcT`. | |
419 | */ | |
420 | template <bool AppendCauseV, typename ExcT> | |
421 | [[noreturn]] void | |
422 | logErrorErrnoStrAndThrow(const char * const fileName, const char * const funcName, | |
423 | const unsigned int lineNo, const char * const initMsg, | |
424 | const char * const msg) const | |
425 | { | |
426 | this->logErrnoStrNoThrow<Level::ERROR, AppendCauseV>(fileName, funcName, lineNo, initMsg, | |
427 | msg); | |
428 | throw ExcT {}; | |
429 | } | |
430 | ||
431 | /* | |
432 | * Like logErrnoNoThrow() with the `Level::ERROR` level, but also | |
433 | * rethrows. | |
434 | */ | |
435 | template <bool AppendCauseV, typename... ArgTs> | |
436 | [[noreturn]] void logErrorErrnoAndRethrow(const char * const fileName, | |
437 | const char * const funcName, | |
438 | const unsigned int lineNo, const char * const initMsg, | |
439 | const char * const fmt, ArgTs&&...args) const | |
440 | { | |
441 | this->logErrnoNoThrow<Level::ERROR, AppendCauseV>(fileName, funcName, lineNo, initMsg, fmt, | |
442 | std::forward<ArgTs>(args)...); | |
443 | throw; | |
444 | } | |
445 | ||
446 | /* | |
447 | * Like logErrnoStrNoThrow() with the `Level::ERROR` level, but also | |
448 | * rethrows. | |
449 | */ | |
450 | template <bool AppendCauseV> | |
451 | [[noreturn]] void | |
452 | logErrorErrnoStrAndRethrow(const char * const fileName, const char * const funcName, | |
453 | const unsigned int lineNo, const char * const initMsg, | |
454 | const char * const msg) const | |
455 | { | |
456 | this->logErrnoStrNoThrow<Level::ERROR, AppendCauseV>(fileName, funcName, lineNo, initMsg, | |
457 | msg); | |
458 | throw; | |
459 | } | |
460 | ||
461 | private: | |
462 | struct _MemLogWriter final | |
463 | { | |
464 | static void write(const char * const fileName, const char * const funcName, | |
465 | const unsigned lineNo, const Level level, const char * const tag, | |
466 | const void * const memData, const unsigned int memLen, const char *, | |
467 | const char * const msg) noexcept | |
468 | { | |
469 | bt_log_write_mem(funcName, fileName, lineNo, static_cast<bt_log_level>(level), tag, | |
470 | memData, memLen, msg); | |
471 | } | |
472 | }; | |
473 | ||
474 | public: | |
475 | /* | |
476 | * Logs memory data using the level `LevelV`. | |
477 | * | |
478 | * This method forwards `fmt` and `args` to fmt::format() to create | |
479 | * the log message. | |
480 | */ | |
481 | template <Level LevelV, typename... ArgTs> | |
482 | void logMemNoThrow(const char * const fileName, const char * const funcName, | |
483 | const unsigned int lineNo, const void * const memData, | |
484 | const unsigned int memLen, const char * const fmt, ArgTs&&...args) const | |
485 | { | |
486 | this->_logNoThrow<_MemLogWriter, LevelV, false>(fileName, funcName, lineNo, memData, memLen, | |
487 | nullptr, fmt, std::forward<ArgTs>(args)...); | |
488 | } | |
489 | ||
490 | /* | |
491 | * Logs memory data using the level `LevelV`, starting with the | |
492 | * message `msg`. | |
493 | */ | |
494 | template <Level LevelV> | |
495 | void logMemStrNoThrow(const char * const fileName, const char * const funcName, | |
496 | const unsigned int lineNo, const void * const memData, | |
497 | const unsigned int memLen, const char * const msg) const | |
498 | { | |
499 | this->_logStrNoThrow<_MemLogWriter, LevelV, false>(fileName, funcName, lineNo, memData, | |
500 | memLen, nullptr, msg); | |
501 | } | |
502 | ||
503 | private: | |
504 | /* | |
505 | * Formats a log message with fmt::format() given `fmt` and `args`, | |
506 | * and the forwards everything to _logStrNoThrow(). | |
507 | */ | |
508 | template <typename LogWriterT, Level LevelV, bool AppendCauseV, typename... ArgTs> | |
509 | void _logNoThrow(const char * const fileName, const char * const funcName, | |
510 | const unsigned int lineNo, const void * const memData, | |
511 | const std::size_t memLen, const char * const initMsg, const char * const fmt, | |
512 | ArgTs&&...args) const | |
513 | { | |
514 | /* Only format arguments if logging or appending an error cause */ | |
515 | if (G_UNLIKELY(this->wouldLog(LevelV) || AppendCauseV)) { | |
516 | /* | |
517 | * Format arguments to our buffer (fmt::format_to() doesn't | |
518 | * append a null character). | |
519 | */ | |
520 | _mBuf.clear(); | |
521 | fmt::format_to(std::back_inserter(_mBuf), fmt, std::forward<ArgTs>(args)...); | |
522 | _mBuf.push_back('\0'); | |
523 | } | |
524 | ||
525 | this->_logStrNoThrow<LogWriterT, LevelV, AppendCauseV>(fileName, funcName, lineNo, memData, | |
526 | memLen, initMsg, _mBuf.data()); | |
527 | } | |
528 | ||
529 | /* | |
530 | * Logs `msg` using the level `LevelV`. | |
531 | * | |
532 | * Calls LogWriterT::write() to write the actual log. | |
533 | * | |
534 | * If `AppendCauseV` is true, this method also appends a cause to | |
535 | * the error of the current thread using the same message. | |
536 | */ | |
537 | template <typename LogWriterT, Level LevelV, bool AppendCauseV> | |
538 | void _logStrNoThrow(const char * const fileName, const char * const funcName, | |
539 | const unsigned int lineNo, const void * const memData, | |
540 | const std::size_t memLen, const char * const initMsg, | |
541 | const char * const msg) const | |
542 | { | |
543 | /* Log if needed */ | |
544 | if (this->wouldLog(LevelV)) { | |
545 | LogWriterT::write(fileName, funcName, lineNo, LevelV, _mTag.data(), memData, memLen, | |
546 | initMsg, msg); | |
547 | } | |
548 | ||
549 | /* Append an error cause if needed */ | |
550 | if (AppendCauseV) { | |
551 | if (_mSelfMsgIter) { | |
552 | bt_current_thread_error_append_cause_from_message_iterator( | |
553 | _mSelfMsgIter->libObjPtr(), fileName, lineNo, "%s", _mBuf.data()); | |
554 | } else if (_mSelfComp) { | |
555 | bt_current_thread_error_append_cause_from_component( | |
556 | _mSelfComp->libObjPtr(), fileName, lineNo, "%s", _mBuf.data()); | |
557 | } else if (_mSelfCompCls) { | |
558 | bt_current_thread_error_append_cause_from_component_class( | |
559 | _mSelfCompCls->libObjPtr(), fileName, lineNo, "%s", _mBuf.data()); | |
560 | } else { | |
561 | BT_ASSERT_DBG(_mModuleName); | |
562 | bt_current_thread_error_append_cause_from_unknown(_mModuleName->data(), fileName, | |
563 | lineNo, "%s", _mBuf.data()); | |
564 | } | |
565 | } | |
566 | } | |
567 | ||
568 | /* At least one of the following four members has a value */ | |
569 | bt2s::optional<bt2::SelfComponentClass> _mSelfCompCls; | |
570 | bt2s::optional<bt2::SelfComponent> _mSelfComp; | |
571 | bt2s::optional<bt2::SelfMessageIterator> _mSelfMsgIter; | |
572 | bt2s::optional<std::string> _mModuleName; | |
573 | ||
574 | /* Current logging level */ | |
575 | Level _mLevel; | |
576 | ||
577 | /* Logging tag */ | |
578 | std::string _mTag; | |
579 | ||
580 | /* Formatting buffer */ | |
581 | mutable std::vector<char> _mBuf; | |
582 | }; | |
583 | ||
584 | } /* namespace bt2c */ | |
585 | ||
586 | /* Internal: default logger name */ | |
587 | #define _BT_CPPLOG_DEF_LOGGER _mLogger | |
588 | ||
589 | /* | |
590 | * Calls logNoThrow() on `_logger` to log using the level `_lvl` without | |
591 | * appending nor throwing. | |
592 | */ | |
593 | #define BT_CPPLOG_EX(_lvl, _logger, _fmt, ...) \ | |
594 | do { \ | |
595 | if (G_UNLIKELY((_logger).wouldLog(_lvl))) { \ | |
596 | (_logger).logNoThrow<(_lvl), false>(__FILE__, __func__, __LINE__, (_fmt), \ | |
597 | ##__VA_ARGS__); \ | |
598 | } \ | |
599 | } while (0) | |
600 | ||
601 | /* | |
602 | * BT_CPPLOG_EX() with specific logging levels. | |
603 | */ | |
604 | #define BT_CPPLOGT_SPEC(_logger, _fmt, ...) \ | |
605 | BT_CPPLOG_EX(bt2c::Logger::Level::TRACE, (_logger), (_fmt), ##__VA_ARGS__) | |
606 | #define BT_CPPLOGD_SPEC(_logger, _fmt, ...) \ | |
607 | BT_CPPLOG_EX(bt2c::Logger::Level::DEBUG, (_logger), (_fmt), ##__VA_ARGS__) | |
608 | #define BT_CPPLOGI_SPEC(_logger, _fmt, ...) \ | |
609 | BT_CPPLOG_EX(bt2c::Logger::Level::INFO, (_logger), (_fmt), ##__VA_ARGS__) | |
610 | #define BT_CPPLOGW_SPEC(_logger, _fmt, ...) \ | |
611 | BT_CPPLOG_EX(bt2c::Logger::Level::WARNING, (_logger), (_fmt), ##__VA_ARGS__) | |
612 | #define BT_CPPLOGE_SPEC(_logger, _fmt, ...) \ | |
613 | BT_CPPLOG_EX(bt2c::Logger::Level::ERROR, (_logger), (_fmt), ##__VA_ARGS__) | |
614 | #define BT_CPPLOGF_SPEC(_logger, _fmt, ...) \ | |
615 | BT_CPPLOG_EX(bt2c::Logger::Level::FATAL, (_logger), (_fmt), ##__VA_ARGS__) | |
616 | ||
617 | /* | |
618 | * BT_CPPLOG_EX() with specific logging levels and using the default | |
619 | * logger. | |
620 | */ | |
621 | #define BT_CPPLOGT(_fmt, ...) BT_CPPLOGT_SPEC(_BT_CPPLOG_DEF_LOGGER, (_fmt), ##__VA_ARGS__) | |
622 | #define BT_CPPLOGD(_fmt, ...) BT_CPPLOGD_SPEC(_BT_CPPLOG_DEF_LOGGER, (_fmt), ##__VA_ARGS__) | |
623 | #define BT_CPPLOGI(_fmt, ...) BT_CPPLOGI_SPEC(_BT_CPPLOG_DEF_LOGGER, (_fmt), ##__VA_ARGS__) | |
624 | #define BT_CPPLOGW(_fmt, ...) BT_CPPLOGW_SPEC(_BT_CPPLOG_DEF_LOGGER, (_fmt), ##__VA_ARGS__) | |
625 | #define BT_CPPLOGE(_fmt, ...) BT_CPPLOGE_SPEC(_BT_CPPLOG_DEF_LOGGER, (_fmt), ##__VA_ARGS__) | |
626 | #define BT_CPPLOGF(_fmt, ...) BT_CPPLOGF_SPEC(_BT_CPPLOG_DEF_LOGGER, (_fmt), ##__VA_ARGS__) | |
627 | ||
628 | /* | |
629 | * Calls logStrNoThrow() on `_logger` to log using the level `_lvl` | |
630 | * without appending nor throwing. | |
631 | */ | |
632 | #define BT_CPPLOG_STR_EX(_lvl, _logger, _msg) \ | |
633 | (_logger).logStrNoThrow<(_lvl), false>(__FILE__, __func__, __LINE__, (_msg)) | |
634 | ||
635 | /* | |
636 | * BT_CPPLOG_STR_EX() with specific logging levels. | |
637 | */ | |
638 | #define BT_CPPLOGT_STR_SPEC(_logger, _msg) \ | |
639 | BT_CPPLOG_STR_EX(bt2c::Logger::Level::TRACE, (_logger), (_msg)) | |
640 | #define BT_CPPLOGD_STR_SPEC(_logger, _msg) \ | |
641 | BT_CPPLOG_STR_EX(bt2c::Logger::Level::DEBUG, (_logger), (_msg)) | |
642 | #define BT_CPPLOGI_STR_SPEC(_logger, _msg) \ | |
643 | BT_CPPLOG_STR_EX(bt2c::Logger::Level::INFO, (_logger), (_msg)) | |
644 | #define BT_CPPLOGW_STR_SPEC(_logger, _msg) \ | |
645 | BT_CPPLOG_STR_EX(bt2c::Logger::Level::WARNING, (_logger), (_msg)) | |
646 | #define BT_CPPLOGE_STR_SPEC(_logger, _msg) \ | |
647 | BT_CPPLOG_STR_EX(bt2c::Logger::Level::ERROR, (_logger), (_msg)) | |
648 | #define BT_CPPLOGF_STR_SPEC(_logger, _msg) \ | |
649 | BT_CPPLOG_STR_EX(bt2c::Logger::Level::FATAL, (_logger), (_msg)) | |
650 | ||
651 | /* | |
652 | * BT_CPPLOG_STR_EX() with specific logging levels and using the default | |
653 | * logger. | |
654 | */ | |
655 | #define BT_CPPLOGT_STR(_msg) BT_CPPLOGT_STR_SPEC(_BT_CPPLOG_DEF_LOGGER, (_msg)) | |
656 | #define BT_CPPLOGD_STR(_msg) BT_CPPLOGD_STR_SPEC(_BT_CPPLOG_DEF_LOGGER, (_msg)) | |
657 | #define BT_CPPLOGI_STR(_msg) BT_CPPLOGI_STR_SPEC(_BT_CPPLOG_DEF_LOGGER, (_msg)) | |
658 | #define BT_CPPLOGW_STR(_msg) BT_CPPLOGW_STR_SPEC(_BT_CPPLOG_DEF_LOGGER, (_msg)) | |
659 | #define BT_CPPLOGE_STR(_msg) BT_CPPLOGE_STR_SPEC(_BT_CPPLOG_DEF_LOGGER, (_msg)) | |
660 | #define BT_CPPLOGF_STR(_msg) BT_CPPLOGF_STR_SPEC(_BT_CPPLOG_DEF_LOGGER, (_msg)) | |
661 | ||
662 | /* | |
663 | * Calls logMemNoThrow() on `_logger` to log using the level `_lvl` | |
664 | * without appending nor throwing. | |
665 | */ | |
666 | #define BT_CPPLOG_MEM_EX(_lvl, _logger, _mem_data, _mem_len, _fmt, ...) \ | |
667 | do { \ | |
668 | if (G_UNLIKELY((_logger).wouldLog(_lvl))) { \ | |
669 | (_logger).logMemNoThrow<(_lvl)>(__FILE__, __func__, __LINE__, (_mem_data), (_mem_len), \ | |
670 | (_fmt), ##__VA_ARGS__); \ | |
671 | } \ | |
672 | } while (0) | |
673 | ||
674 | /* | |
675 | * BT_CPPLOG_MEM_EX() with specific logging levels. | |
676 | */ | |
677 | #define BT_CPPLOGT_MEM_SPEC(_logger, _mem_data, _mem_len, _fmt, ...) \ | |
678 | BT_CPPLOG_MEM_EX(bt2c::Logger::Level::TRACE, (_logger), (_mem_data), (_mem_len), (_fmt), \ | |
679 | ##__VA_ARGS__) | |
680 | #define BT_CPPLOGD_MEM_SPEC(_logger, _mem_data, _mem_len, _fmt, ...) \ | |
681 | BT_CPPLOG_MEM_EX(bt2c::Logger::Level::DEBUG, (_logger), (_mem_data), (_mem_len), (_fmt), \ | |
682 | ##__VA_ARGS__) | |
683 | #define BT_CPPLOGI_MEM_SPEC(_logger, _mem_data, _mem_len, _fmt, ...) \ | |
684 | BT_CPPLOG_MEM_EX(bt2c::Logger::Level::INFO, (_logger), (_mem_data), (_mem_len), (_fmt), \ | |
685 | ##__VA_ARGS__) | |
686 | #define BT_CPPLOGW_MEM_SPEC(_logger, _mem_data, _mem_len, _fmt, ...) \ | |
687 | BT_CPPLOG_MEM_EX(bt2c::Logger::Level::WARNING, (_logger), (_mem_data), (_mem_len), (_fmt), \ | |
688 | ##__VA_ARGS__) | |
689 | #define BT_CPPLOGE_MEM_SPEC(_logger, _mem_data, _mem_len, _fmt, ...) \ | |
690 | BT_CPPLOG_MEM_EX(bt2c::Logger::Level::ERROR, (_logger), (_mem_data), (_mem_len), (_fmt), \ | |
691 | ##__VA_ARGS__) | |
692 | #define BT_CPPLOGF_MEM_SPEC(_logger, _mem_data, _mem_len, _fmt, ...) \ | |
693 | BT_CPPLOG_MEM_EX(bt2c::Logger::Level::FATAL, (_logger), (_mem_data), (_mem_len), (_fmt), \ | |
694 | ##__VA_ARGS__) | |
695 | ||
696 | /* | |
697 | * BT_CPPLOG_MEM_EX() with specific logging levels and using the default | |
698 | * logger. | |
699 | */ | |
700 | #define BT_CPPLOGT_MEM(_mem_data, _mem_len, _fmt, ...) \ | |
701 | BT_CPPLOGT_MEM_SPEC(_BT_CPPLOG_DEF_LOGGER, (_mem_data), (_mem_len), (_fmt), ##__VA_ARGS__) | |
702 | #define BT_CPPLOGD_MEM(_mem_data, _mem_len, _fmt, ...) \ | |
703 | BT_CPPLOGD_MEM_SPEC(_BT_CPPLOG_DEF_LOGGER, (_mem_data), (_mem_len), (_fmt), ##__VA_ARGS__) | |
704 | #define BT_CPPLOGI_MEM(_mem_data, _mem_len, _fmt, ...) \ | |
705 | BT_CPPLOGI_MEM_SPEC(_BT_CPPLOG_DEF_LOGGER, (_mem_data), (_mem_len), (_fmt), ##__VA_ARGS__) | |
706 | #define BT_CPPLOGW_MEM(_mem_data, _mem_len, _fmt, ...) \ | |
707 | BT_CPPLOGW_MEM_SPEC(_BT_CPPLOG_DEF_LOGGER, (_mem_data), (_mem_len), (_fmt), ##__VA_ARGS__) | |
708 | #define BT_CPPLOGE_MEM(_mem_data, _mem_len, _fmt, ...) \ | |
709 | BT_CPPLOGE_MEM_SPEC(_BT_CPPLOG_DEF_LOGGER, (_mem_data), (_mem_len), (_fmt), ##__VA_ARGS__) | |
710 | #define BT_CPPLOGF_MEM(_mem_data, _mem_len, _fmt, ...) \ | |
711 | BT_CPPLOGF_MEM_SPEC(_BT_CPPLOG_DEF_LOGGER, (_mem_data), (_mem_len), (_fmt), ##__VA_ARGS__) | |
712 | ||
713 | /* | |
714 | * Calls logMemStrNoThrow() on `_logger` to log using the level `_lvl` | |
715 | * without appending nor throwing. | |
716 | */ | |
717 | #define BT_CPPLOG_MEM_STR_EX(_lvl, _logger, _mem_data, _mem_len, _msg) \ | |
718 | (_logger).logMemStrNoThrow<(_lvl)>(__FILE__, __func__, __LINE__, (_mem_data), (_mem_len), \ | |
719 | (_msg)) | |
720 | ||
721 | /* | |
722 | * BT_CPPLOG_MEM_STR_EX() with specific logging levels. | |
723 | */ | |
724 | #define BT_CPPLOGT_MEM_STR_SPEC(_logger, _mem_data, _mem_len, _msg) \ | |
725 | BT_CPPLOG_MEM_STR_EX(bt2c::Logger::Level::TRACE, (_logger), (_mem_data), (_mem_len), (_msg)) | |
726 | #define BT_CPPLOGD_MEM_STR_SPEC(_logger, _mem_data, _mem_len, _msg) \ | |
727 | BT_CPPLOG_MEM_STR_EX(bt2c::Logger::Level::DEBUG, (_logger), (_mem_data), (_mem_len), (_msg)) | |
728 | #define BT_CPPLOGI_MEM_STR_SPEC(_logger, _mem_data, _mem_len, _msg) \ | |
729 | BT_CPPLOG_MEM_STR_EX(bt2c::Logger::Level::INFO, (_logger), (_mem_data), (_mem_len), (_msg)) | |
730 | #define BT_CPPLOGW_MEM_STR_SPEC(_logger, _mem_data, _mem_len, _msg) \ | |
731 | BT_CPPLOG_MEM_STR_EX(bt2c::Logger::Level::WARNING, (_logger), (_mem_data), (_mem_len), (_msg)) | |
732 | #define BT_CPPLOGE_MEM_STR_SPEC(_logger, _mem_data, _mem_len, _msg) \ | |
733 | BT_CPPLOG_MEM_STR_EX(bt2c::Logger::Level::ERROR, (_logger), (_mem_data), (_mem_len), (_msg)) | |
734 | #define BT_CPPLOGF_MEM_STR_SPEC(_logger, _mem_data, _mem_len, _msg) \ | |
735 | BT_CPPLOG_MEM_STR_EX(bt2c::Logger::Level::FATAL, (_logger), (_mem_data), (_mem_len), (_msg)) | |
736 | ||
737 | /* | |
738 | * BT_CPPLOG_MEM_STR_EX() with specific logging levels and using the | |
739 | * default logger. | |
740 | */ | |
741 | #define BT_CPPLOGT_MEM_STR(_mem_data, _mem_len, _msg) \ | |
742 | BT_CPPLOGT_MEM_STR_SPEC(_BT_CPPLOG_DEF_LOGGER, (_mem_data), (_mem_len), (_msg)) | |
743 | #define BT_CPPLOGD_MEM_STR(_mem_data, _mem_len, _msg) \ | |
744 | BT_CPPLOGD_MEM_STR_SPEC(_BT_CPPLOG_DEF_LOGGER, (_mem_data), (_mem_len), (_msg)) | |
745 | #define BT_CPPLOGI_MEM_STR(_mem_data, _mem_len, _msg) \ | |
746 | BT_CPPLOGI_MEM_STR_SPEC(_BT_CPPLOG_DEF_LOGGER, (_mem_data), (_mem_len), (_msg)) | |
747 | #define BT_CPPLOGW_MEM_STR(_mem_data, _mem_len, _msg) \ | |
748 | BT_CPPLOGW_MEM_STR_SPEC(_BT_CPPLOG_DEF_LOGGER, (_mem_data), (_mem_len), (_msg)) | |
749 | #define BT_CPPLOGE_MEM_STR(_mem_data, _mem_len, _msg) \ | |
750 | BT_CPPLOGE_MEM_STR_SPEC(_BT_CPPLOG_DEF_LOGGER, (_mem_data), (_mem_len), (_msg)) | |
751 | #define BT_CPPLOGF_MEM_STR(_mem_data, _mem_len, _msg) \ | |
752 | BT_CPPLOGF_MEM_STR_SPEC(_BT_CPPLOG_DEF_LOGGER, (_mem_data), (_mem_len), (_msg)) | |
753 | ||
754 | /* | |
755 | * Calls logErrnoNoThrow() on `_logger` to log using the level `_lvl` | |
756 | * and initial message `_init_msg` without appending nor throwing. | |
757 | */ | |
758 | #define BT_CPPLOG_ERRNO_EX(_lvl, _logger, _init_msg, _fmt, ...) \ | |
759 | do { \ | |
760 | if (G_UNLIKELY((_logger).wouldLog(_lvl))) { \ | |
761 | (_logger).logErrnoNoThrow<(_lvl), false>(__FILE__, __func__, __LINE__, (_init_msg), \ | |
762 | (_fmt), ##__VA_ARGS__); \ | |
763 | } \ | |
764 | } while (0) | |
765 | ||
766 | /* | |
767 | * BT_CPPLOG_ERRNO_EX() with specific logging levels. | |
768 | */ | |
769 | #define BT_CPPLOGT_ERRNO_SPEC(_logger, _init_msg, _fmt, ...) \ | |
770 | BT_CPPLOG_ERRNO_EX(bt2c::Logger::Level::TRACE, (_logger), (_init_msg), (_fmt), ##__VA_ARGS__) | |
771 | #define BT_CPPLOGD_ERRNO_SPEC(_logger, _init_msg, _fmt, ...) \ | |
772 | BT_CPPLOG_ERRNO_EX(bt2c::Logger::Level::DEBUG, (_logger), (_init_msg), (_fmt), ##__VA_ARGS__) | |
773 | #define BT_CPPLOGI_ERRNO_SPEC(_logger, _init_msg, _fmt, ...) \ | |
774 | BT_CPPLOG_ERRNO_EX(bt2c::Logger::Level::INFO, (_logger), (_init_msg), (_fmt), ##__VA_ARGS__) | |
775 | #define BT_CPPLOGW_ERRNO_SPEC(_logger, _init_msg, _fmt, ...) \ | |
776 | BT_CPPLOG_ERRNO_EX(bt2c::Logger::Level::WARNING, (_logger), (_init_msg), (_fmt), ##__VA_ARGS__) | |
777 | #define BT_CPPLOGE_ERRNO_SPEC(_logger, _init_msg, _fmt, ...) \ | |
778 | BT_CPPLOG_ERRNO_EX(bt2c::Logger::Level::ERROR, (_logger), (_init_msg), (_fmt), ##__VA_ARGS__) | |
779 | #define BT_CPPLOGF_ERRNO_SPEC(_logger, _init_msg, _fmt, ...) \ | |
780 | BT_CPPLOG_ERRNO_EX(bt2c::Logger::Level::FATAL, (_logger), (_init_msg), (_fmt), ##__VA_ARGS__) | |
781 | ||
782 | /* | |
783 | * BT_CPPLOG_ERRNO_EX() with specific logging levels and using the | |
784 | * default logger. | |
785 | */ | |
786 | #define BT_CPPLOGT_ERRNO(_init_msg, _fmt, ...) \ | |
787 | BT_CPPLOGT_ERRNO_SPEC(_BT_CPPLOG_DEF_LOGGER, (_init_msg), (_fmt), ##__VA_ARGS__) | |
788 | #define BT_CPPLOGD_ERRNO(_init_msg, _fmt, ...) \ | |
789 | BT_CPPLOGD_ERRNO_SPEC(_BT_CPPLOG_DEF_LOGGER, (_init_msg), (_fmt), ##__VA_ARGS__) | |
790 | #define BT_CPPLOGI_ERRNO(_init_msg, _fmt, ...) \ | |
791 | BT_CPPLOGI_ERRNO_SPEC(_BT_CPPLOG_DEF_LOGGER, (_init_msg), (_fmt), ##__VA_ARGS__) | |
792 | #define BT_CPPLOGW_ERRNO(_init_msg, _fmt, ...) \ | |
793 | BT_CPPLOGW_ERRNO_SPEC(_BT_CPPLOG_DEF_LOGGER, (_init_msg), (_fmt), ##__VA_ARGS__) | |
794 | #define BT_CPPLOGE_ERRNO(_init_msg, _fmt, ...) \ | |
795 | BT_CPPLOGE_ERRNO_SPEC(_BT_CPPLOG_DEF_LOGGER, (_init_msg), (_fmt), ##__VA_ARGS__) | |
796 | #define BT_CPPLOGF_ERRNO(_init_msg, _fmt, ...) \ | |
797 | BT_CPPLOGF_ERRNO_SPEC(_BT_CPPLOG_DEF_LOGGER, (_init_msg), (_fmt), ##__VA_ARGS__) | |
798 | ||
799 | /* | |
800 | * Calls logErrnoStrNoThrow() on `_logger` to log using the level `_lvl` | |
801 | * and initial message `_init_msg` without appending nor throwing. | |
802 | */ | |
803 | #define BT_CPPLOG_ERRNO_STR_EX(_lvl, _logger, _init_msg, _msg) \ | |
804 | (_logger).logErrnoStrNoThrow<(_lvl), false>(__FILE__, __func__, __LINE__, (_init_msg), (_msg)) | |
805 | ||
806 | /* | |
807 | * BT_CPPLOG_ERRNO_STR_EX() with specific logging levels. | |
808 | */ | |
809 | #define BT_CPPLOGT_ERRNO_STR_SPEC(_logger, _init_msg, _msg) \ | |
810 | BT_CPPLOG_ERRNO_STR_EX(bt2c::Logger::Level::TRACE, (_logger), (_init_msg), (_msg)) | |
811 | #define BT_CPPLOGD_ERRNO_STR_SPEC(_logger, _init_msg, _msg) \ | |
812 | BT_CPPLOG_ERRNO_STR_EX(bt2c::Logger::Level::DEBUG, (_logger), (_init_msg), (_msg)) | |
813 | #define BT_CPPLOGI_ERRNO_STR_SPEC(_logger, _init_msg, _msg) \ | |
814 | BT_CPPLOG_ERRNO_STR_EX(bt2c::Logger::Level::INFO, (_logger), (_init_msg), (_msg)) | |
815 | #define BT_CPPLOGW_ERRNO_STR_SPEC(_logger, _init_msg, _msg) \ | |
816 | BT_CPPLOG_ERRNO_STR_EX(bt2c::Logger::Level::WARNING, (_logger), (_init_msg), (_msg)) | |
817 | #define BT_CPPLOGE_ERRNO_STR_SPEC(_logger, _init_msg, _msg) \ | |
818 | BT_CPPLOG_ERRNO_STR_EX(bt2c::Logger::Level::ERROR, (_logger), (_init_msg), (_msg)) | |
819 | #define BT_CPPLOGF_ERRNO_STR_SPEC(_logger, _init_msg, _msg) \ | |
820 | BT_CPPLOG_ERRNO_STR_EX(bt2c::Logger::Level::FATAL, (_logger), (_init_msg), (_msg)) | |
821 | ||
822 | /* | |
823 | * BT_CPPLOG_ERRNO_STR_EX() with specific logging levels and using the | |
824 | * default logger. | |
825 | */ | |
826 | #define BT_CPPLOGT_ERRNO_STR(_init_msg, _msg) \ | |
827 | BT_CPPLOGT_ERRNO_STR_SPEC(_BT_CPPLOG_DEF_LOGGER, (_init_msg), (_msg)) | |
828 | #define BT_CPPLOGD_ERRNO_STR(_init_msg, _msg) \ | |
829 | BT_CPPLOGD_ERRNO_STR_SPEC(_BT_CPPLOG_DEF_LOGGER, (_init_msg), (_msg)) | |
830 | #define BT_CPPLOGI_ERRNO_STR(_init_msg, _msg) \ | |
831 | BT_CPPLOGI_ERRNO_STR_SPEC(_BT_CPPLOG_DEF_LOGGER, (_init_msg), (_msg)) | |
832 | #define BT_CPPLOGW_ERRNO_STR(_init_msg, _msg) \ | |
833 | BT_CPPLOGW_ERRNO_STR_SPEC(_BT_CPPLOG_DEF_LOGGER, (_init_msg), (_msg)) | |
834 | #define BT_CPPLOGE_ERRNO_STR(_init_msg, _msg) \ | |
835 | BT_CPPLOGE_ERRNO_STR_SPEC(_BT_CPPLOG_DEF_LOGGER, (_init_msg), (_msg)) | |
836 | #define BT_CPPLOGF_ERRNO_STR(_init_msg, _msg) \ | |
837 | BT_CPPLOGF_ERRNO_STR_SPEC(_BT_CPPLOG_DEF_LOGGER, (_init_msg), (_msg)) | |
838 | ||
839 | /* | |
840 | * Calls logErrorAndThrow() on `_logger` to log an error, append a cause | |
841 | * to the error of the current thread, and throw an instance of | |
842 | * `_exc_cls`. | |
843 | */ | |
844 | #define BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(_logger, _exc_cls, _fmt, ...) \ | |
845 | (_logger).logErrorAndThrow<true, _exc_cls>(__FILE__, __func__, __LINE__, (_fmt), ##__VA_ARGS__) | |
846 | ||
847 | /* | |
848 | * Calls logErrorAndThrow() on `_logger` to log an error, append a cause | |
849 | * to the error of the current thread, and throw an instance of | |
850 | * `_exc_cls`. | |
851 | */ | |
852 | #define BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(_logger, _exc_cls, _fmt, ...) \ | |
853 | (_logger).logErrorAndThrow<true, _exc_cls>(__FILE__, __func__, __LINE__, (_fmt), ##__VA_ARGS__) | |
854 | ||
855 | /* | |
856 | * BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC() using the default logger. | |
857 | */ | |
858 | #define BT_CPPLOGE_APPEND_CAUSE_AND_THROW(_exc_cls, _fmt, ...) \ | |
859 | BT_CPPLOGE_APPEND_CAUSE_AND_THROW_SPEC(_BT_CPPLOG_DEF_LOGGER, _exc_cls, (_fmt), ##__VA_ARGS__) | |
860 | ||
861 | /* | |
862 | * Calls logErrorStrAndThrow() on `_logger` to log an error, append a | |
863 | * cause to the error of the current thread, and throw an instance of | |
864 | * `_exc_cls`. | |
865 | */ | |
866 | #define BT_CPPLOGE_STR_APPEND_CAUSE_AND_THROW_SPEC(_logger, _exc_cls, _msg) \ | |
867 | (_logger).logErrorStrAndThrow<true, _exc_cls>(__FILE__, __func__, __LINE__, (_msg)) | |
868 | ||
869 | /* | |
870 | * BT_CPPLOGE_STR_APPEND_CAUSE_AND_THROW_SPEC() using the default | |
871 | * logger. | |
872 | */ | |
873 | #define BT_CPPLOGE_STR_APPEND_CAUSE_AND_THROW(_exc_cls, _msg) \ | |
874 | BT_CPPLOGE_STR_APPEND_CAUSE_AND_THROW_SPEC(_BT_CPPLOG_DEF_LOGGER, _exc_cls, (_msg)) | |
875 | ||
876 | /* | |
877 | * Calls logErrorAndRethrow() on `_logger` to log an error, append a | |
878 | * cause to the error of the current thread, and throw an instance of | |
879 | * `_exc_cls`. | |
880 | */ | |
881 | #define BT_CPPLOGE_APPEND_CAUSE_AND_RETHROW_SPEC(_logger, _fmt, ...) \ | |
882 | (_logger).logErrorAndRethrow<true>(__FILE__, __func__, __LINE__, (_fmt), ##__VA_ARGS__) | |
883 | ||
884 | /* | |
885 | * BT_CPPLOGE_APPEND_CAUSE_AND_RETHROW_SPEC() using the default logger. | |
886 | */ | |
887 | #define BT_CPPLOGE_APPEND_CAUSE_AND_RETHROW(_fmt, ...) \ | |
888 | BT_CPPLOGE_APPEND_CAUSE_AND_RETHROW_SPEC(_BT_CPPLOG_DEF_LOGGER, (_fmt), ##__VA_ARGS__) | |
889 | ||
890 | /* | |
891 | * Calls logErrorStrAndRethrow() on `_logger` to log an error, append a | |
892 | * cause to the error of the current thread, and throw an instance of | |
893 | * `_exc_cls`. | |
894 | */ | |
895 | #define BT_CPPLOGE_STR_APPEND_CAUSE_AND_RETHROW_SPEC(_logger, _msg) \ | |
896 | (_logger).logErrorStrAndRethrow<true>(__FILE__, __func__, __LINE__, (_msg)) | |
897 | ||
898 | /* | |
899 | * BT_CPPLOGE_STR_APPEND_CAUSE_AND_RETHROW_SPEC() using the default | |
900 | * logger. | |
901 | */ | |
902 | #define BT_CPPLOGE_STR_APPEND_CAUSE_AND_RETHROW(_msg) \ | |
903 | BT_CPPLOGE_STR_APPEND_CAUSE_AND_RETHROW_SPEC(_BT_CPPLOG_DEF_LOGGER, (_msg)) | |
904 | ||
905 | /* | |
906 | * Calls logErrorErrnoAndThrow() on `_logger` to log an error, append a | |
907 | * cause to the error of the current thread, and throw an instance of | |
908 | * `_exc_cls`. | |
909 | */ | |
910 | #define BT_CPPLOGE_ERRNO_APPEND_CAUSE_AND_THROW_SPEC(_logger, _exc_cls, _init_msg, _fmt, ...) \ | |
911 | (_logger).logErrorErrnoAndThrow<true, _exc_cls>(__FILE__, __func__, __LINE__, (_init_msg), \ | |
912 | (_fmt), ##__VA_ARGS__) | |
913 | ||
914 | /* | |
915 | * BT_CPPLOGE_ERRNO_APPEND_CAUSE_AND_THROW_SPEC() using the default | |
916 | * logger. | |
917 | */ | |
918 | #define BT_CPPLOGE_ERRNO_APPEND_CAUSE_AND_THROW(_exc_cls, _init_msg, _fmt, ...) \ | |
919 | BT_CPPLOGE_ERRNO_APPEND_CAUSE_AND_THROW_SPEC(_BT_CPPLOG_DEF_LOGGER, _exc_cls, (_init_msg), \ | |
920 | (_fmt), ##__VA_ARGS__) | |
921 | ||
922 | /* | |
923 | * Calls logErrorErrnoStrAndThrow() on `_logger` to log an error, append | |
924 | * a cause to the error of the current thread, and throw an instance of | |
925 | * `_exc_cls`. | |
926 | */ | |
927 | #define BT_CPPLOGE_ERRNO_STR_APPEND_CAUSE_AND_THROW_SPEC(_logger, _exc_cls, _init_msg, _msg) \ | |
928 | (_logger).logErrorErrnoStrAndThrow<true, _exc_cls>(__FILE__, __func__, __LINE__, (_init_msg), \ | |
929 | (_msg)) | |
930 | ||
931 | /* | |
932 | * BT_CPPLOGE_ERRNO_STR_APPEND_CAUSE_AND_THROW_SPEC() using the default | |
933 | * logger. | |
934 | */ | |
935 | #define BT_CPPLOGE_ERRNO_STR_APPEND_CAUSE_AND_THROW(_exc_cls, _init_msg, _msg) \ | |
936 | BT_CPPLOGE_ERRNO_STR_APPEND_CAUSE_AND_THROW_SPEC(_BT_CPPLOG_DEF_LOGGER, _exc_cls, (_init_msg), \ | |
937 | (_msg)) | |
938 | ||
939 | /* | |
940 | * Calls logErrorErrnoAndRethrow() on `_logger` to log an error, append | |
941 | * a cause to the error of the current thread, and throw an instance of | |
942 | * `_exc_cls`. | |
943 | */ | |
944 | #define BT_CPPLOGE_ERRNO_APPEND_CAUSE_AND_RETHROW_SPEC(_logger, _init_msg, _fmt, ...) \ | |
945 | (_logger).logErrorErrnoAndRethrow<true>(__FILE__, __func__, __LINE__, (_init_msg), (_fmt), \ | |
946 | ##__VA_ARGS__) | |
947 | ||
948 | /* | |
949 | * BT_CPPLOGE_ERRNO_APPEND_CAUSE_AND_RETHROW_SPEC() using the default | |
950 | * logger. | |
951 | */ | |
952 | #define BT_CPPLOGE_ERRNO_APPEND_CAUSE_AND_RETHROW(_init_msg, _fmt, ...) \ | |
953 | BT_CPPLOGE_ERRNO_APPEND_CAUSE_AND_RETHROW_SPEC(_BT_CPPLOG_DEF_LOGGER, (_init_msg), (_fmt), \ | |
954 | ##__VA_ARGS__) | |
955 | ||
956 | /* | |
957 | * Calls logErrorErrnoStrAndRethrow() on `_logger` to log an error, | |
958 | * append a cause to the error of the current thread, and throw an | |
959 | * instance of `_exc_cls`. | |
960 | */ | |
961 | #define BT_CPPLOGE_ERRNO_STR_APPEND_CAUSE_AND_RETHROW_SPEC(_logger, _init_msg, _msg) \ | |
962 | (_logger).logErrorErrnoStrAndRethrow<true>(__FILE__, __func__, __LINE__, (_init_msg), (_msg)) | |
963 | ||
964 | /* | |
965 | * BT_CPPLOGE_ERRNO_STR_APPEND_CAUSE_AND_RETHROW_SPEC() using the | |
966 | * default logger. | |
967 | */ | |
968 | #define BT_CPPLOGE_ERRNO_STR_APPEND_CAUSE_AND_RETHROW(_init_msg, _msg) \ | |
969 | BT_CPPLOGE_ERRNO_STR_APPEND_CAUSE_AND_RETHROW_SPEC(_BT_CPPLOG_DEF_LOGGER, (_init_msg), (_msg)) | |
970 | ||
971 | #endif /* BABELTRACE_CPP_COMMON_BT2C_LOGGING_HPP */ |