logger.hpp

Go to the documentation of this file.

/*
 Copyright (c) 2026 ETIB Corporation
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
 the Software without restriction, including without limitation the rights to
 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
 of the Software, and to permit persons to whom the Software is furnished to do
 so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 
#pragma once
 
#include <atomic>
#include <limits>
#include <memory>
#include <mutex>
#include <source_location>
#include <sstream>
#include <string>
#include <type_traits>
#include <utility>
 
namespace utility::logging
{
 
    enum class LogLevel {
        DEBUG_LEVEL,      
        INFO_LEVEL,       
        WARNING_LEVEL,    
        ERROR_LEVEL       
    };
 
    enum class FlushPolicy {
        BUFFERED,   
        ALWAYS,     
        NEVER       
    };
 
    struct LogRecord {
        LogLevel level;           
        std::string message;      
        std::string timestamp;    
        std::string
            loggerName;          
        std::string file;        
        int line = 0;            
        std::string function;    
    };
 
    class Logger
    {
        private:
        std::string _name;    
        std::atomic<LogLevel> _minLevel {
            defaultMinLevel()
        };    
        std::atomic<FlushPolicy> _flushPolicy {
            FlushPolicy::BUFFERED
        };    
 
        bool isEnabled(LogLevel level) const noexcept
        {
            return levelValue(level)
                >= levelValue(_minLevel.load(std::memory_order_relaxed));
        }
 
        protected:
        mutable std::mutex _mutex;    
 
        public:
        class LogMessage
        {
            private:
            Logger *_logger;                   
            LogLevel _level;                   
            std::source_location _location;    
            std::unique_ptr<std::ostringstream>
                _stream;     
            bool _active;    
 
            std::ostringstream &ensureStream(void)
            {
                if (!_stream) {
                    _stream = std::make_unique<std::ostringstream>();
                }
                return *_stream;
            }
 
            public:
            LogMessage(Logger *logger, LogLevel level, std::source_location loc,
                       bool active)
                : _logger(logger)
                , _level(level)
                , _location(loc)
                , _active(active)
            {
            }
 
            template<typename T> LogMessage &operator<<(T &&value)
            {
                if (_active) {
                    ensureStream() << std::forward<T>(value);
                }
                return *this;
            }
 
            LogMessage &operator<<(std::ostream &(*manip)(std::ostream &))
            {
                if (_active) {
                    ensureStream() << manip;
                }
                return *this;
            }
 
            ~LogMessage()
            {
                if (!_active || !_logger || !_stream) {
                    return;
                }
                // `str() &&` (C++20) moves the buffer out of the stream, avoiding
                // a copy; the stream is not read again afterwards. On toolchains
                // without the rvalue overload this falls back to a copy.
                LogRecord record {
                    .level      = _level,
                    .message    = std::move(*_stream).str(),
                    .timestamp  = Logger::getTimestamp(),
                    .loggerName = _logger->getName(),
                };
                if (_level == LogLevel::DEBUG_LEVEL) {
                    record.file     = _location.file_name();
                    record.line     = static_cast<int>(_location.line());
                    record.function = _location.function_name();
                }
                std::lock_guard<std::mutex> guard(_logger->_mutex);
                try {
                    _logger->output(record);
                } catch (...) {
                    // Logging must never become a terminate path.
                }
            }
        };
 
        public:
        Logger(const std::string &name);
 
        virtual ~Logger(void) = default;
 
        static constexpr LogLevel defaultMinLevel(void) noexcept
        {
#if defined(NDEBUG)
            return LogLevel::WARNING_LEVEL;
#else
            return LogLevel::DEBUG_LEVEL;
#endif
        }
 
        void setMinLevel(LogLevel level) noexcept;
 
        LogLevel getMinLevel(void) const noexcept;
 
        void setFlushPolicy(FlushPolicy policy) noexcept;
 
        FlushPolicy getFlushPolicy(void) const noexcept;
 
        static std::string levelToString(LogLevel level);
 
        static std::string getTimestamp(void);
 
        static constexpr int levelValue(LogLevel level) noexcept
        {
            switch (level) {
                case LogLevel::DEBUG_LEVEL:
                    return 0;
                case LogLevel::INFO_LEVEL:
                    return 1;
                case LogLevel::WARNING_LEVEL:
                    return 2;
                case LogLevel::ERROR_LEVEL:
                    return 3;
                default:
                    // Return a high sentinel so an unknown/future level is
                    // treated as most severe and never silently dropped.
                    return std::numeric_limits<int>::max();
            }
        }
 
        LogMessage
            debug(std::source_location loc = std::source_location::current())
        {
            return LogMessage(this, LogLevel::DEBUG_LEVEL, loc,
                              isEnabled(LogLevel::DEBUG_LEVEL));
        }
 
        LogMessage
            info(std::source_location loc = std::source_location::current())
        {
            return LogMessage(this, LogLevel::INFO_LEVEL, loc,
                              isEnabled(LogLevel::INFO_LEVEL));
        }
 
        LogMessage
            warning(std::source_location loc = std::source_location::current())
        {
            return LogMessage(this, LogLevel::WARNING_LEVEL, loc,
                              isEnabled(LogLevel::WARNING_LEVEL));
        }
 
        LogMessage
            error(std::source_location loc = std::source_location::current())
        {
            return LogMessage(this, LogLevel::ERROR_LEVEL, loc,
                              isEnabled(LogLevel::ERROR_LEVEL));
        }
 
        LogMessage
            log(LogLevel level,
                std::source_location loc = std::source_location::current())
        {
            return LogMessage(this, level, loc, isEnabled(level));
        }
 
        virtual void output(const LogRecord &record) = 0;
 
        const std::string &getName(void) const
        {
            return _name;
        }
    };
 
    template<typename Type>
    concept InheritFromLogger = std::is_base_of_v<Logger, Type>;
 
}    // namespace utility::logging