Logger.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstdio>
#include <utility>
 
#include "corium/logging/LogEvent.hpp"
#include "corium/logging/sinks/ConsoleLogSink.hpp"
#include "corium/logging/sinks/FileLogSink.hpp"
#include "corium/logging/sinks/NullLogSink.hpp"
 
namespace corium::logging {
 
template <typename LogSink = sinks::ConsoleLogSink, std::size_t MaxMessageSize = 256>
class LoggerT {
public:
    using EventType = LogEventT<MaxMessageSize>;
 
    explicit LoggerT(const char* category = "App", LogLevel minLevel = LogLevel::Info, LogSink sink = LogSink{})
        : _category(category ? category : "App"), _minLevel(minLevel), _sink(std::move(sink))
    {}
 
    void setMinLevel(LogLevel level) noexcept
    {
        _minLevel = level;
    }
 
    [[nodiscard]] LogLevel minLevel() const noexcept
    {
        return _minLevel;
    }
 
    void setCategory(const char* category) noexcept
    {
        _category = category ? category : "App";
    }
 
    [[nodiscard]] const char* category() const noexcept
    {
        return _category;
    }
 
    [[nodiscard]] LogSink& sink() noexcept { return _sink; }
    [[nodiscard]] const LogSink& sink() const noexcept { return _sink; }
 
    template <typename... Args>
    void log(LogLevel level, const char* fmt, Args&&... args) const
    {
        if (level < _minLevel || _minLevel == LogLevel::Off) {
            return;
        }
 
        EventType event{};
        event.level = level;
        event.category = _category;
 
        if constexpr (sizeof...(Args) == 0) {
            event.setMessage(fmt);
        } else {
            int written = std::snprintf(event.message.data(), MaxMessageSize, fmt, std::forward<Args>(args)...);
            if (written > 0) {
                event.length = static_cast<std::size_t>(written) < MaxMessageSize ? static_cast<std::size_t>(written) : (MaxMessageSize - 1);
            }
        }
 
        _sink.write(event);
    }
 
    template <typename TargetEventSink, typename... Args>
    void logToSink(TargetEventSink&& targetSink, LogLevel level, const char* fmt, Args&&... args) const
    {
        if (level < _minLevel || _minLevel == LogLevel::Off) {
            return;
        }
 
        EventType event{};
        event.level = level;
        event.category = _category;
 
        if constexpr (sizeof...(Args) == 0) {
            event.setMessage(fmt);
        } else {
            int written = std::snprintf(event.message.data(), MaxMessageSize, fmt, std::forward<Args>(args)...);
            if (written > 0) {
                event.length = static_cast<std::size_t>(written) < MaxMessageSize ? static_cast<std::size_t>(written) : (MaxMessageSize - 1);
            }
        }
 
        targetSink.post(std::move(event));
    }
 
    template <typename... Args>
    void trace(const char* fmt, Args&&... args) const { log(LogLevel::Trace, fmt, std::forward<Args>(args)...); }
 
    template <typename... Args>
    void debug(const char* fmt, Args&&... args) const { log(LogLevel::Debug, fmt, std::forward<Args>(args)...); }
 
    template <typename... Args>
    void info(const char* fmt, Args&&... args) const { log(LogLevel::Info, fmt, std::forward<Args>(args)...); }
 
    template <typename... Args>
    void warn(const char* fmt, Args&&... args) const { log(LogLevel::Warn, fmt, std::forward<Args>(args)...); }
 
    template <typename... Args>
    void error(const char* fmt, Args&&... args) const { log(LogLevel::Error, fmt, std::forward<Args>(args)...); }
 
    template <typename... Args>
    void critical(const char* fmt, Args&&... args) const { log(LogLevel::Critical, fmt, std::forward<Args>(args)...); }
 
private:
    const char* _category = "App";
    LogLevel _minLevel = LogLevel::Info;
    LogSink _sink{};
};
 
using ConsoleLogger = LoggerT<sinks::ConsoleLogSink>;
 
using FileLogger = LoggerT<sinks::FileLogSink>;
 
using NullLogger = LoggerT<sinks::NullLogSink>;
 
} // namespace corium::logging