logger.hpp File Reference

uatools logging abstraction. More...

#include <memory>
#include <string>
#include <string_view>
#include <fmt/format.h>
#include <eso/uatools/protocol/base/base.hpp>

Go to the source code of this file.

Classes
class	eso::uatools::protocol::base::Logger
	Abstract logger; downstream supplies an implementation. More...

Namespaces
namespace	eso
namespace	eso::uatools
namespace	eso::uatools::protocol
namespace	eso::uatools::protocol::base

Macros
Logging macros
Usage: UATINFO("connected to {} on port {}", host, port); UATERROR("call failed: {}", status); UATTHROW("invalid argument: {}", arg); // logs ERROR then throws Each macro performs a single early-out level test before formatting, so disabled-level calls are essentially free. UATTHROW does not early-out — a throw must happen unconditionally.
#define	UAT_LOG_IMPL_(level_, fmt_str_, ...)
#define	UATTRACE(...)
	Trace macro.
#define	UATDEBUG(fmt_str, ...)
#define	UATINFO(fmt_str, ...)
#define	UATWARNING(fmt_str, ...)
#define	UATERROR(fmt_str, ...)
#define	UATTHROW(fmt_str, ...)

Enumerations
enum class	eso::uatools::protocol::base::LogLevel : int {   eso::uatools::protocol::base::TRACE = 0 , eso::uatools::protocol::base::DEBUG = 10 , eso::uatools::protocol::base::INFO = 20 , eso::uatools::protocol::base::WARNING = 30 ,   eso::uatools::protocol::base::ERROR = 40 , eso::uatools::protocol::base::OFF = 100 }
	Log severity, lowest to highest. More...

Functions
void	eso::uatools::protocol::base::InstallLogger (std::unique_ptr< Logger > logger) noexcept
	Install the process-wide logger.
Logger &	eso::uatools::protocol::base::Log ()
	Access the installed logger.
bool	eso::uatools::protocol::base::HasLogger () noexcept
	true iff a logger has been installed.
std::unique_ptr< Logger >	eso::uatools::protocol::base::MakeStdoutLogger ()
	Factory: a logger that prints to stdout.
std::unique_ptr< Logger >	eso::uatools::protocol::base::MakeNullLogger ()
	Factory: a logger that discards everything.
std::string_view	eso::uatools::protocol::base::LogLevelName (LogLevel level) noexcept
	Render a LogLevel as a short uppercase string.
std::string	eso::uatools::protocol::base::TraceExtra ()
	Helper used by UATTRACE.
template<typename... Args>
std::string	eso::uatools::protocol::base::TraceExtra (fmt::string_view fmt_str, Args &&... args)

Detailed Description

uatools logging abstraction.

Copyright

SPDX-FileCopyrightText: 2026 European Southern Observatory (ESO) SPDX-License-Identifier: LGPL-3.0-only

uatools must build and run on both ELT and VLTSW. ELT applications want their logs routed through CII; VLTSW applications want them routed through the VLT logging system; standalone tools may just want stdout. The uatools libraries themselves must therefore not depend on any particular logging implementation.

This header defines an abstract Logger interface. Downstream applications subclass it, instantiate one logger object, and hand ownership to uatools at startup via InstallLogger(). Until a logger has been installed, calls to Log() throw — uatools refuses to silently swallow log output. Two ready-made implementations are provided as convenience: a stdout logger and a null (silent) logger.

Call sites use the UATTRACE / UATDEBUG / UATINFO / UATWARNING / UATERROR / UATTHROW macros. Each macro is fmt-style and includes an early-out test on the configured log level, so disabled-level calls cost a single integer compare.

Macro Definition Documentation

UAT_LOG_IMPL_

#define UAT_LOG_IMPL_	(		level_,
			fmt_str_,
			... )

Value:

    do { \
        auto& _uat_log = ::eso::uatools::protocol::base::Log(); \
        if (_uat_log.GetLogLevel() <= (level_)) { \
            _uat_log.Emit((level_), \
                UATLOC + ": " + \
                ::fmt::format( \
                    ::fmt::runtime(std::string(fmt_str_)) \
                    __VA_OPT__(,) __VA_ARGS__)); \
        } \
    } while (0)

UATDEBUG

#define UATDEBUG	(		fmt_str,
			... )

Value:

    UAT_LOG_IMPL_(::eso::uatools::protocol::base::LogLevel::DEBUG,   fmt_str __VA_OPT__(,) __VA_ARGS__)

UATERROR

#define UATERROR	(		fmt_str,
			... )

Value:

    UAT_LOG_IMPL_(::eso::uatools::protocol::base::LogLevel::ERROR,   fmt_str __VA_OPT__(,) __VA_ARGS__)

UATINFO

#define UATINFO	(		fmt_str,
			... )

Value:

    UAT_LOG_IMPL_(::eso::uatools::protocol::base::LogLevel::INFO,    fmt_str __VA_OPT__(,) __VA_ARGS__)

UATTHROW

#define UATTHROW	(		fmt_str,
			... )

Value:

    do { \
        ::eso::uatools::protocol::base::Log().Throw( \
            UATLOC + ": " + \
            ::fmt::format( \
                ::fmt::runtime(std::string(fmt_str)) \
                __VA_OPT__(,) __VA_ARGS__)); \
    } while (0)

UATTRACE

#define UATTRACE

(

...

)

Value:

    do { \
        auto& _uat_log = ::eso::uatools::protocol::base::Log(); \
        if (_uat_log.GetLogLevel() <= ::eso::uatools::protocol::base::LogLevel::TRACE) { \
            _uat_log.Emit(::eso::uatools::protocol::base::LogLevel::TRACE, \
                UATLOC + ": " + std::string(__PRETTY_FUNCTION__) + \
                ::eso::uatools::protocol::base::TraceExtra(__VA_ARGS__)); \
        } \
    } while (0)

Trace macro.

Always logs the calling function (via __PRETTY_FUNCTION__). UATTRACE() alone emits just the function name; passing a format string and arguments appends an extra note:

UATTRACE();                    // -> "<loc>: <fn>"
UATTRACE("about to do X");     // -> "<loc>: <fn>: about to do X"
UATTRACE("got {}", n);         // -> "<loc>: <fn>: got 42"

UATWARNING

#define UATWARNING	(		fmt_str,
			... )

Value:

    UAT_LOG_IMPL_(::eso::uatools::protocol::base::LogLevel::WARNING, fmt_str __VA_OPT__(,) __VA_ARGS__)