Global singleton logger with three output styles and pluggable backends. More...

#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <memory>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include "./exception.h"
#include "./fast_stream.h"
#include "./format.h"
#include "./macros.h"

Include dependency graph for logger.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	vlink::Logger
	Global singleton logger supporting three output styles and configurable log levels. More...
struct	vlink::Logger::NoDetail
	Sentinel type indicating that no file/line detail is attached. More...
class	vlink::Logger::WrapperStream< LevelT >
	RAII stream wrapper that accumulates tokens and flushes on destruction. More...

Namespaces
namespace	vlink

Macros
#define	VLINK_LOG_GET_DETAIL(level)
	Macro Definitions.
#define	VLINK_LOG_HEX(offset)
#define	VLINK_LOG_HEXSS(offset)
#define	VLINK_LOG_IF_T VLinkLogger::is_writable(VLinkLogger::kTrace)
#define	VLINK_LOG_IF_D VLinkLogger::is_writable(VLinkLogger::kDebug)
#define	VLINK_LOG_IF_I VLinkLogger::is_writable(VLinkLogger::kInfo)
#define	VLINK_LOG_IF_W VLinkLogger::is_writable(VLinkLogger::kWarn)
#define	VLINK_LOG_IF_E VLinkLogger::is_writable(VLinkLogger::kError)
#define	VLINK_LOG_IF_F VLinkLogger::is_writable(VLinkLogger::kFatal)
#define	VLINK_LOG_T(...)
#define	VLINK_LOG_D(...)
#define	VLINK_LOG_I(...)
#define	VLINK_LOG_W(...)
#define	VLINK_LOG_E(...)
#define	VLINK_LOG_F(...)
#define	VLINK_MLOG_T(...)
#define	VLINK_MLOG_D(...)
#define	VLINK_MLOG_I(...)
#define	VLINK_MLOG_W(...)
#define	VLINK_MLOG_E(...)
#define	VLINK_MLOG_F(...)
#define	VLINK_CLOG_T(...)
#define	VLINK_CLOG_D(...)
#define	VLINK_CLOG_I(...)
#define	VLINK_CLOG_W(...)
#define	VLINK_CLOG_E(...)
#define	VLINK_CLOG_F(...)
#define	VLINK_SLOG_T VLinkLogger::WrapperStream<VLinkLogger::kTrace>(VLINK_LOG_GET_DETAIL(VLinkLogger::kTrace))
#define	VLINK_SLOG_D VLinkLogger::WrapperStream<VLinkLogger::kDebug>(VLINK_LOG_GET_DETAIL(VLinkLogger::kDebug))
#define	VLINK_SLOG_I VLinkLogger::WrapperStream<VLinkLogger::kInfo>(VLINK_LOG_GET_DETAIL(VLinkLogger::kInfo))
#define	VLINK_SLOG_W VLinkLogger::WrapperStream<VLinkLogger::kWarn>(VLINK_LOG_GET_DETAIL(VLinkLogger::kWarn))
#define	VLINK_SLOG_E VLinkLogger::WrapperStream<VLinkLogger::kError>(VLINK_LOG_GET_DETAIL(VLinkLogger::kError))
#define	VLINK_SLOG_F VLinkLogger::WrapperStream<VLinkLogger::kFatal>(VLINK_LOG_GET_DETAIL(VLinkLogger::kFatal))
#define	VLOG_T(...)
#define	VLOG_D(...)
#define	VLOG_I(...)
#define	VLOG_W(...)
#define	VLOG_E(...)
#define	VLOG_F(...)
#define	CLOG_T(...)
#define	CLOG_D(...)
#define	CLOG_I(...)
#define	CLOG_W(...)
#define	CLOG_E(...)
#define	CLOG_F(...)
#define	MLOG_T(...)
#define	MLOG_D(...)
#define	MLOG_I(...)
#define	MLOG_W(...)
#define	MLOG_E(...)
#define	MLOG_F(...)
#define	SLOG_T VLINK_SLOG_T
#define	SLOG_D VLINK_SLOG_D
#define	SLOG_I VLINK_SLOG_I
#define	SLOG_W VLINK_SLOG_W
#define	SLOG_E VLINK_SLOG_E
#define	SLOG_F VLINK_SLOG_F

Typedefs
using	VLinkLogger = vlink::Logger

Detailed Description

Global singleton logger with three output styles and pluggable backends.

Logger is the central logging facility in VLink. It is a singleton accessed via Logger::get() and initialised once with Logger::init(). Log messages can be written to a console sink and/or a file sink, each with an independently configured minimum level.

Output styles:

Style	Syntax	Notes
Stream style (LOG)	`VLOG_I`("x=", x)	Uses `FastStream` operator<<, zero allocation
Format style (MLOG)	`MLOG_I`("x={}", x)	Uses VLink `format::format_to_n`
C style (CLOG)	`CLOG_I`("x=%d", x)	Uses `std::snprintf`
RAII stream (SLOG)	`SLOG_I` << "x=" << x	WrapperStream, flushed on destruction

Log levels:

Value	Name	Use case
0	kTrace	Verbose internals
1	kDebug	Developer diagnostics
2	kInfo	Normal operational messages
3	kWarn	Unusual but recoverable conditions
4	kError	Errors that may affect operation
5	kFatal	Unrecoverable errors; throws RuntimeError
6	kOff	Disables all output

Detail annotation: When the log level is >= kDetailLevel (default: kWarn), the macro automatically prepends {filename:line} to the message to aid in debugging.

Compile-time filtering:

Define VLINK_LOG_LEVEL=N to strip levels below N at compile time (zero overhead).
Define VLINK_LOG_DETAIL_LEVEL=N to change the threshold at which file/line is shown.
Define VLINK_LOG_DISABLE_SHORT to suppress the short VLOG_* aliases.

Backtrace support: When enabled via enable_backtrace(n), the last n log messages are kept in a ring buffer and can be flushed on demand with dump_backtrace().

Backend support: The logger dispatches to spdlog, quill, DLT (automotive), Android logcat, QNX slog2, or kmsg depending on compile-time configuration. Custom backends can be registered with register_console_handler() / register_file_handler().

Note

kFatal logs flush the logger and then throw Exception::RuntimeError.
The WrapperStream class is template-based; unused log levels are compiled away.

Example: vlink::Logger::init("my_app", "/var/log/my_app.log");

vlink::Logger::set_console_level(vlink::Logger::kInfo);

VLOG_I("node started, id=", node_id);

MLOG_W("temperature is {} C", temp);

CLOG_E("errno=%d", errno);

SLOG_D << "values: " << a << " " << b;

vlink::Logger::set_console_level
static void set_console_level(Level level) noexcept
Sets the minimum level for the console sink.

vlink::Logger::kInfo
@ kInfo
Definition logger.h:151

vlink::Logger::init
static void init(const std::string &app_name="", const std::string &log_path="") noexcept
Initialises the logger singleton.

CLOG_E
#define CLOG_E(...)
Definition logger.h:866

SLOG_D
#define SLOG_D
Definition logger.h:884

VLOG_I
#define VLOG_I(...)
Definition logger.h:850

MLOG_W
#define MLOG_W(...)
Definition logger.h:876

Macro Definition Documentation

◆ CLOG_D

#define CLOG_D ( ... )

Value:

VLINK_CLOG_D(__VA_ARGS__)

VLINK_CLOG_D

#define VLINK_CLOG_D(...)

Definition logger.h:817

◆ CLOG_E

#define CLOG_E ( ... )

Value:

VLINK_CLOG_E(__VA_ARGS__)

VLINK_CLOG_E

#define VLINK_CLOG_E(...)

Definition logger.h:826

◆ CLOG_F

#define CLOG_F ( ... )

Value:

VLINK_CLOG_F(__VA_ARGS__)

VLINK_CLOG_F

#define VLINK_CLOG_F(...)

Definition logger.h:829

◆ CLOG_I

#define CLOG_I ( ... )

Value:

VLINK_CLOG_I(__VA_ARGS__)

VLINK_CLOG_I

#define VLINK_CLOG_I(...)

Definition logger.h:820

◆ CLOG_T

#define CLOG_T ( ... )

Value:

VLINK_CLOG_T(__VA_ARGS__)

VLINK_CLOG_T

#define VLINK_CLOG_T(...)

Definition logger.h:814

◆ CLOG_W

#define CLOG_W ( ... )

Value:

VLINK_CLOG_W(__VA_ARGS__)

VLINK_CLOG_W

#define VLINK_CLOG_W(...)

Definition logger.h:823

◆ MLOG_D

#define MLOG_D ( ... )

Value:

VLINK_MLOG_D(__VA_ARGS__)

VLINK_MLOG_D

#define VLINK_MLOG_D(...)

Definition logger.h:799

◆ MLOG_E

#define MLOG_E ( ... )

Value:

VLINK_MLOG_E(__VA_ARGS__)

VLINK_MLOG_E

#define VLINK_MLOG_E(...)

Definition logger.h:808

◆ MLOG_F

#define MLOG_F ( ... )

Value:

VLINK_MLOG_F(__VA_ARGS__)

VLINK_MLOG_F

#define VLINK_MLOG_F(...)

Definition logger.h:811

◆ MLOG_I

#define MLOG_I ( ... )

Value:

VLINK_MLOG_I(__VA_ARGS__)

VLINK_MLOG_I

#define VLINK_MLOG_I(...)

Definition logger.h:802

◆ MLOG_T

#define MLOG_T ( ... )

Value:

VLINK_MLOG_T(__VA_ARGS__)

VLINK_MLOG_T

#define VLINK_MLOG_T(...)

Definition logger.h:796

◆ MLOG_W

#define MLOG_W ( ... )

Value:

VLINK_MLOG_W(__VA_ARGS__)

VLINK_MLOG_W

#define VLINK_MLOG_W(...)

Definition logger.h:805

◆ SLOG_D

#define SLOG_D VLINK_SLOG_D

◆ SLOG_E

#define SLOG_E VLINK_SLOG_E

◆ SLOG_F

#define SLOG_F VLINK_SLOG_F

◆ SLOG_I

#define SLOG_I VLINK_SLOG_I

◆ SLOG_T

#define SLOG_T VLINK_SLOG_T

◆ SLOG_W

#define SLOG_W VLINK_SLOG_W

◆ VLINK_CLOG_D

#define VLINK_CLOG_D ( ... )

Value:

VLinkLogger::print_c_style<VLinkLogger::kDebug>(VLINK_LOG_GET_DETAIL(VLinkLogger::kDebug), __VA_ARGS__)

vlink::Logger::kDebug

@ kDebug

Definition logger.h:150

vlink::Logger::print_c_style

static void print_c_style(DetailT &&detail, FormatT &&format, ArgsT &&... args)

Logs using C-style printf format string.

Definition logger.h:654

VLINK_LOG_GET_DETAIL

#define VLINK_LOG_GET_DETAIL(level)

Macro Definitions.

Definition logger.h:753

◆ VLINK_CLOG_E

#define VLINK_CLOG_E ( ... )

Value:

VLinkLogger::print_c_style<VLinkLogger::kError>(VLINK_LOG_GET_DETAIL(VLinkLogger::kError), __VA_ARGS__)

vlink::Logger::kError

@ kError

Definition logger.h:153

◆ VLINK_CLOG_F

#define VLINK_CLOG_F ( ... )

Value:

VLinkLogger::print_c_style<VLinkLogger::kFatal>(VLINK_LOG_GET_DETAIL(VLinkLogger::kFatal), __VA_ARGS__)

vlink::Logger::kFatal

@ kFatal

Definition logger.h:154

◆ VLINK_CLOG_I

#define VLINK_CLOG_I ( ... )

Value:

VLinkLogger::print_c_style<VLinkLogger::kInfo>(VLINK_LOG_GET_DETAIL(VLinkLogger::kInfo), __VA_ARGS__)

◆ VLINK_CLOG_T

#define VLINK_CLOG_T ( ... )

Value:

VLinkLogger::print_c_style<VLinkLogger::kTrace>(VLINK_LOG_GET_DETAIL(VLinkLogger::kTrace), __VA_ARGS__)

vlink::Logger::kTrace

@ kTrace

Definition logger.h:149

◆ VLINK_CLOG_W

#define VLINK_CLOG_W ( ... )

Value:

VLinkLogger::print_c_style<VLinkLogger::kWarn>(VLINK_LOG_GET_DETAIL(VLinkLogger::kWarn), __VA_ARGS__)

vlink::Logger::kWarn

@ kWarn

Definition logger.h:152

◆ VLINK_LOG_D

#define VLINK_LOG_D ( ... )

Value:

VLinkLogger::print_stream_style<VLinkLogger::kDebug>(VLINK_LOG_GET_DETAIL(VLinkLogger::kDebug), __VA_ARGS__)

vlink::Logger::print_stream_style

static void print_stream_style(DetailT &&detail, ArgsT &&... args)

Logs using stream-style composition (operator<<).

Definition logger.h:616

◆ VLINK_LOG_E

#define VLINK_LOG_E ( ... )

Value:

VLinkLogger::print_stream_style<VLinkLogger::kError>(VLINK_LOG_GET_DETAIL(VLinkLogger::kError), __VA_ARGS__)

◆ VLINK_LOG_F

#define VLINK_LOG_F ( ... )

Value:

VLinkLogger::print_stream_style<VLinkLogger::kFatal>(VLINK_LOG_GET_DETAIL(VLinkLogger::kFatal), __VA_ARGS__)

◆ VLINK_LOG_GET_DETAIL

#define VLINK_LOG_GET_DETAIL ( level )

Value:

([]() -> auto {                                                                        \
  if constexpr ((level) >= VLinkLogger::kDetailLevel) {                                \
    return VLinkLogger::DetailInfo{VLinkLogger::extract_filename(__FILE__), __LINE__}; \
  } else {                                                                             \
    return VLinkLogger::NoDetail{};                                                    \
  }                                                                                    \
})()