Logger.hpp

Go to the documentation of this file.

// @formatter:off
//
// Balau core C++ library
//
// Copyright (C) 2008 Bora Software (contact@borasoftware.com)
//
// Licensed under the Boost Software License - Version 1.0 - August 17th, 2003.
// See the LICENSE file for the full license text.
//


#ifndef COM_BORA_SOFTWARE__BALAU_LOGGING__LOGGER
#define COM_BORA_SOFTWARE__BALAU_LOGGING__LOGGER

#include <Balau/Application/Impl/BindingKey.hpp>
#include <Balau/Logging/LoggingLevel.hpp>
#include <Balau/Logging/Impl/LoggerAllocator.hpp>
#include <Balau/Logging/Impl/LoggerForwardDeclarations.hpp>
#include <Balau/Type/SourceCodeLocation.hpp>

#include <atomic>
#include <functional>

namespace Balau {

class EnvironmentProperties;

namespace LoggingSystem {

class LoggerConfigurationVisitor;
class LoggerPropertyVisitor;

} // namespace LoggingSystem


class LoggingStream {
    public: virtual void write(const LoggingSystem::LoggerString & str) = 0;

    public: virtual void flush() = 0;

    public: virtual ~LoggingStream() = default;
};

using LoggingStreamFactory = LoggingStream * (*)(std::string_view uri);


class Logger {

    public: static Logger & getLogger(std::string_view loggingNamespace) noexcept;

    public: static void flushAll();

    public: static Logger & globalLogger();

    public: static void configure(const std::string & configurationText,
                                  const std::map<std::string, std::string> & placeholders = std::map<std::string, std::string>());

    public: static void configure(const std::shared_ptr<EnvironmentProperties> & configuration,
                                  const std::map<std::string, std::string> & placeholders = std::map<std::string, std::string>());

    public: static void resetConfiguration();

    public: static void lockConfiguration(bool throwOnReconfigure = false);

    public: static void registerLoggingStreamFactory(const std::string & scheme, LoggingStreamFactory factory);


    public: LoggingLevel getLevel() const noexcept {
        return level.load(std::memory_order_relaxed);
    }

    public: bool flushes() const noexcept {
        return shouldFlush.load(std::memory_order_relaxed);
    }

    public: void flush() const;

    public: std::string getNamespace() const {
        return nameSpace;
    }

    public: std::string getConfiguration() const;

    public: bool operator == (const Logger & logger) const {
        return nameSpace == logger.nameSpace;
    }


    public: bool traceEnabled() const {
        return getLevel() >= LoggingLevel::TRACE;
    }

    public: bool debugEnabled() const {
        return getLevel() >= LoggingLevel::DEBUG;
    }

    public: bool infoEnabled() const {
        return getLevel() >= LoggingLevel::INFO;
    }

    public: bool warnEnabled() const {
        return getLevel() >= LoggingLevel::WARN;
    }

    public: bool errorEnabled() const {
        return getLevel() >= LoggingLevel::ERROR;
    }

    public: bool enabled(LoggingLevel level) const {
        return getLevel() >= level;
    }


    public: void trace(const char * message) const {
        if (getLevel() >= LoggingLevel::TRACE) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), LoggingLevel::TRACE, *this, message);
        }
    }

    public: void trace(std::string_view message) const {
        if (getLevel() >= LoggingLevel::TRACE) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), LoggingLevel::TRACE, *this, message);
        }
    }

    public: template <typename ... ObjectT>
    void trace(const char * message, const ObjectT & ... object) const {
        if (getLevel() >= LoggingLevel::TRACE) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), LoggingLevel::TRACE, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: template <typename ... ObjectT>
    void trace(std::string_view message, const ObjectT & ... object) const {
        if (getLevel() >= LoggingLevel::TRACE) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), LoggingLevel::TRACE, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: void trace(const std::function<std::string ()> & function) const {
        if (getLevel() >= LoggingLevel::TRACE) {
            LoggingSystem::startLogAllocation();
            const std::string message = function();
            logMessage(SourceCodeLocation(), LoggingLevel::TRACE, *this, message);
        }
    }

    public: void trace(const SourceCodeLocation & location, const char * message) const {
        if (getLevel() >= LoggingLevel::TRACE) {
            LoggingSystem::startLogAllocation();
            logMessage(location, LoggingLevel::TRACE, *this, message);
        }
    }

    public: void trace(const SourceCodeLocation & location, std::string_view message) const {
        if (getLevel() >= LoggingLevel::TRACE) {
            LoggingSystem::startLogAllocation();
            logMessage(location, LoggingLevel::TRACE, *this, message);
        }
    }

    public: template <typename ... ObjectT>
    void trace(const SourceCodeLocation & location, const char * message, const ObjectT & ... object) const {
        if (getLevel() >= LoggingLevel::TRACE) {
            LoggingSystem::startLogAllocation();
            logMessage(location, LoggingLevel::TRACE, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: template <typename ... ObjectT>
    void trace(const SourceCodeLocation & location, std::string_view message, const ObjectT & ... object) const {
        if (getLevel() >= LoggingLevel::TRACE) {
            LoggingSystem::startLogAllocation();
            logMessage(location, LoggingLevel::TRACE, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: void trace(const SourceCodeLocation & location, const std::function<std::string ()> & function) const {
        if (getLevel() >= LoggingLevel::TRACE) {
            LoggingSystem::startLogAllocation();
            const std::string message = function();
            logMessage(location, LoggingLevel::TRACE, *this, message);
        }
    }


    public: void debug(const char * message) const {
        if (getLevel() >= LoggingLevel::DEBUG) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), LoggingLevel::DEBUG, *this, message);
        }
    }

    public: void debug(std::string_view message) const {
        if (getLevel() >= LoggingLevel::DEBUG) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), LoggingLevel::DEBUG, *this, message);
        }
    }

    public: template <typename ... ObjectT>
    void debug(const char * message, const ObjectT & ... object) const {
        if (getLevel() >= LoggingLevel::DEBUG) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), LoggingLevel::DEBUG, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: template <typename ... ObjectT>
    void debug(std::string_view message, const ObjectT & ... object) const {
        if (getLevel() >= LoggingLevel::DEBUG) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), LoggingLevel::DEBUG, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: void debug(const std::function<std::string ()> & function) const {
        if (getLevel() >= LoggingLevel::DEBUG) {
            LoggingSystem::startLogAllocation();
            const std::string message = function();
            logMessage(SourceCodeLocation(), LoggingLevel::DEBUG, *this, message);
        }
    }

    public: void debug(const SourceCodeLocation & location, const char * message) const {
        if (getLevel() >= LoggingLevel::DEBUG) {
            LoggingSystem::startLogAllocation();
            logMessage(location, LoggingLevel::DEBUG, *this, message);
        }
    }

    public: void debug(const SourceCodeLocation & location, std::string_view message) const {
        if (getLevel() >= LoggingLevel::DEBUG) {
            LoggingSystem::startLogAllocation();
            logMessage(location, LoggingLevel::DEBUG, *this, message);
        }
    }

    public: template <typename ... ObjectT>
    void debug(const SourceCodeLocation & location, const char * message, const ObjectT & ... object) const {
        if (getLevel() >= LoggingLevel::DEBUG) {
            LoggingSystem::startLogAllocation();
            logMessage(location, LoggingLevel::DEBUG, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: template <typename ... ObjectT>
    void debug(const SourceCodeLocation & location, std::string_view message, const ObjectT & ... object) const {
        if (getLevel() >= LoggingLevel::DEBUG) {
            LoggingSystem::startLogAllocation();
            logMessage(location, LoggingLevel::DEBUG, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: void debug(const SourceCodeLocation & location, const std::function<std::string ()> & function) const {
        if (getLevel() >= LoggingLevel::DEBUG) {
            LoggingSystem::startLogAllocation();
            const std::string message = function();
            logMessage(location, LoggingLevel::DEBUG, *this, message);
        }
    }


    public: void info(const char * message) const {
        if (getLevel() >= LoggingLevel::INFO) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), LoggingLevel::INFO, *this, message);
        }
    }

    public: void info(std::string_view message) const {
        if (getLevel() >= LoggingLevel::INFO) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), LoggingLevel::INFO, *this, message);
        }
    }

    public: template <typename ... ObjectT>
    void info(const char * message, const ObjectT & ... object) const {
        if (getLevel() >= LoggingLevel::INFO) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), LoggingLevel::INFO, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: template <typename ... ObjectT>
    void info(std::string_view message, const ObjectT & ... object) const {
        if (getLevel() >= LoggingLevel::INFO) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), LoggingLevel::INFO, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: void info(const std::function<std::string ()> & function) const {
        if (getLevel() >= LoggingLevel::INFO) {
            LoggingSystem::startLogAllocation();
            const std::string message = function();
            logMessage(SourceCodeLocation(), LoggingLevel::INFO, *this, message);
        }
    }

    public: void info(const SourceCodeLocation & location, const char * message) const {
        if (getLevel() >= LoggingLevel::INFO) {
            LoggingSystem::startLogAllocation();
            logMessage(location, LoggingLevel::INFO, *this, message);
        }
    }

    public: void info(const SourceCodeLocation & location, std::string_view message) const {
        if (getLevel() >= LoggingLevel::INFO) {
            LoggingSystem::startLogAllocation();
            logMessage(location, LoggingLevel::INFO, *this, message);
        }
    }

    public: template <typename ... ObjectT>
    void info(const SourceCodeLocation & location, const char * message, const ObjectT & ... object) const {
        if (getLevel() >= LoggingLevel::INFO) {
            LoggingSystem::startLogAllocation();
            logMessage(location, LoggingLevel::INFO, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: template <typename ... ObjectT>
    void info(const SourceCodeLocation & location, std::string_view message, const ObjectT & ... object) const {
        if (getLevel() >= LoggingLevel::INFO) {
            LoggingSystem::startLogAllocation();
            logMessage(location, LoggingLevel::INFO, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: void info(const SourceCodeLocation & location, const std::function<std::string ()> & function) const {
        if (getLevel() >= LoggingLevel::INFO) {
            LoggingSystem::startLogAllocation();
            const std::string message = function();
            logMessage(location, LoggingLevel::INFO, *this, message);
        }
    }


    public: void warn(const char * message) const {
        if (getLevel() >= LoggingLevel::WARN) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), LoggingLevel::WARN, *this, message);
        }
    }

    public: void warn(std::string_view message) const {
        if (getLevel() >= LoggingLevel::WARN) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), LoggingLevel::WARN, *this, message);
        }
    }

    public: template <typename ... ObjectT>
    void warn(const char * message, const ObjectT & ... object) const {
        if (getLevel() >= LoggingLevel::WARN) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), LoggingLevel::WARN, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: template <typename ... ObjectT>
    void warn(std::string_view message, const ObjectT & ... object) const {
        if (getLevel() >= LoggingLevel::WARN) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), LoggingLevel::WARN, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: void warn(const std::function<std::string ()> & function) const {
        if (getLevel() >= LoggingLevel::WARN) {
            LoggingSystem::startLogAllocation();
            const std::string message = function();
            logMessage(SourceCodeLocation(), LoggingLevel::WARN, *this, message);
        }
    }

    public: void warn(const SourceCodeLocation & location, const char * message) const {
        if (getLevel() >= LoggingLevel::WARN) {
            LoggingSystem::startLogAllocation();
            logMessage(location, LoggingLevel::WARN, *this, message);
        }
    }

    public: void warn(const SourceCodeLocation & location, std::string_view message) const {
        if (getLevel() >= LoggingLevel::WARN) {
            LoggingSystem::startLogAllocation();
            logMessage(location, LoggingLevel::WARN, *this, message);
        }
    }

    public: template <typename ... ObjectT>
    void warn(const SourceCodeLocation & location, const char * message, const ObjectT & ... object) const {
        if (getLevel() >= LoggingLevel::WARN) {
            LoggingSystem::startLogAllocation();
            logMessage(location, LoggingLevel::WARN, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: template <typename ... ObjectT>
    void warn(const SourceCodeLocation & location, std::string_view message, const ObjectT & ... object) const {
        if (getLevel() >= LoggingLevel::WARN) {
            LoggingSystem::startLogAllocation();
            logMessage(location, LoggingLevel::WARN, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: void warn(const SourceCodeLocation & location, const std::function<std::string ()> & function) const {
        if (getLevel() >= LoggingLevel::WARN) {
            LoggingSystem::startLogAllocation();
            const std::string message = function();
            logMessage(location, LoggingLevel::WARN, *this, message);
        }
    }


    public: void error(const char * message) const {
        if (getLevel() >= LoggingLevel::ERROR) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), LoggingLevel::ERROR, *this, message);
        }
    }

    public: void error(std::string_view message) const {
        if (getLevel() >= LoggingLevel::ERROR) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), LoggingLevel::ERROR, *this, message);
        }
    }

    public: template <typename ... ObjectT>
    void error(const char * message, const ObjectT & ... object) const {
        if (getLevel() >= LoggingLevel::ERROR) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), LoggingLevel::ERROR, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: template <typename ... ObjectT>
    void error(std::string_view message, const ObjectT & ... object) const {
        if (getLevel() >= LoggingLevel::ERROR) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), LoggingLevel::ERROR, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: void error(const std::function<std::string ()> & function) const {
        if (getLevel() >= LoggingLevel::ERROR) {
            LoggingSystem::startLogAllocation();
            const std::string message = function();
            logMessage(SourceCodeLocation(), LoggingLevel::ERROR, *this, message);
        }
    }

    public: void error(const SourceCodeLocation & location, const char * message) const {
        if (getLevel() >= LoggingLevel::ERROR) {
            LoggingSystem::startLogAllocation();
            logMessage(location, LoggingLevel::ERROR, *this, message);
        }
    }

    public: void error(const SourceCodeLocation & location, std::string_view message) const {
        if (getLevel() >= LoggingLevel::ERROR) {
            LoggingSystem::startLogAllocation();
            logMessage(location, LoggingLevel::ERROR, *this, message);
        }
    }

    public: template <typename ... ObjectT>
    void error(const SourceCodeLocation & location, const char * message, const ObjectT & ... object) const {
        if (getLevel() >= LoggingLevel::ERROR) {
            LoggingSystem::startLogAllocation();
            logMessage(location, LoggingLevel::ERROR, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: template <typename ... ObjectT>
    void error(const SourceCodeLocation & location, std::string_view message, const ObjectT & ... object) const {
        if (getLevel() >= LoggingLevel::ERROR) {
            LoggingSystem::startLogAllocation();
            logMessage(location, LoggingLevel::ERROR, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: void error(const SourceCodeLocation & location, const std::function<std::string ()> & function) const {
        if (getLevel() >= LoggingLevel::ERROR) {
            LoggingSystem::startLogAllocation();
            const std::string message = function();
            logMessage(location, LoggingLevel::ERROR, *this, message);
        }
    }


    public: void log(LoggingLevel specifiedLevel, const char * message) const {
        if (getLevel() >= specifiedLevel) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), specifiedLevel, *this, message);
        }
    }

    public: void log(LoggingLevel specifiedLevel, std::string_view message) const {
        if (getLevel() >= specifiedLevel) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), specifiedLevel, *this, message);
        }
    }

    public: template <typename ... ObjectT>
    void log(LoggingLevel specifiedLevel, const char * message, const ObjectT & ... object) const {
        if (getLevel() >= specifiedLevel) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), specifiedLevel, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: template <typename ... ObjectT>
    void log(LoggingLevel specifiedLevel, std::string_view message, const ObjectT & ... object) const {
        if (getLevel() >= specifiedLevel) {
            LoggingSystem::startLogAllocation();
            logMessage(SourceCodeLocation(), specifiedLevel, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: void log(LoggingLevel specifiedLevel, const std::function<std::string ()> & function) const {
        if (getLevel() >= specifiedLevel) {
            LoggingSystem::startLogAllocation();
            const std::string message = function();
            logMessage(SourceCodeLocation(), specifiedLevel, *this, message);
        }
    }

    public: void log(LoggingLevel specifiedLevel, const SourceCodeLocation & location, const char * message) const {
        if (getLevel() >= specifiedLevel) {
            LoggingSystem::startLogAllocation();
            logMessage(location, specifiedLevel, *this, message);
        }
    }

    public: void log(LoggingLevel specifiedLevel, const SourceCodeLocation & location, std::string_view message) const {
        if (getLevel() >= specifiedLevel) {
            LoggingSystem::startLogAllocation();
            logMessage(location, specifiedLevel, *this, message);
        }
    }

    public: template <typename ... ObjectT>
    void log(LoggingLevel specifiedLevel, const SourceCodeLocation & location, const char * message, const ObjectT & ... object) const {
        if (getLevel() >= specifiedLevel) {
            LoggingSystem::startLogAllocation();
            logMessage(location, specifiedLevel, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: template <typename ... ObjectT>
    void log(LoggingLevel specifiedLevel, const SourceCodeLocation & location, std::string_view message, const ObjectT & ... object) const {
        if (getLevel() >= specifiedLevel) {
            LoggingSystem::startLogAllocation();
            logMessage(location, specifiedLevel, *this, message, LoggingSystem::makeStringVector(object ... ));
        }
    }

    public: void log(LoggingLevel specifiedLevel, const SourceCodeLocation & location, const std::function<std::string ()> & function) const {
        if (getLevel() >= specifiedLevel) {
            LoggingSystem::startLogAllocation();
            const std::string message = function();
            logMessage(location, specifiedLevel, *this, message);
        }
    }


    // Local identifier of this logger.
    // Not const in order to support move semantics only.
    private: std::string identifier;

    // Full namespace of this logger.
    // Not const in order to support move semantics only.
    private: std::string nameSpace;

    // Abbreviated namespace of this logger.
    // Not const in order to support move semantics only.
    private: std::string ns;

    //
    // The logging level of this logger.
    //
    // Reads on this atomic are free on x86/x64.
    //
    private: std::atomic<LoggingLevel> level = { LoggingLevel::NONE };

    //
    // Indicates whether messages from this logger should flush the stream after each message.
    //
    // Reads on this atomic are free on x86/x64.
    //
    private: std::atomic_bool shouldFlush { true };

    //
    // The log items for which this logger is configured.
    //
    // The log item vector is a pointer in order to allow reconfiguration to occur
    // during logging, without the need for synchronisation.
    //
    // Log item vector instances are kept in the global logging system state and
    // are not deleted until exit.
    //
    // Apart from compiler ordering restrictions, reads on these atomics are
    // free on x86/x64.
    //
    private: std::atomic<std::vector<std::shared_ptr<LoggingSystem::LogItem>> *> logItems {};

    //
    // The streams to which this logger writes.
    // The array contains one stream pointer for each logging level (0 = error, 4 = trace).
    //
    // The streams are pointer in order to allow reconfiguration to occur during logging,
    // without the need for synchronisation.
    //
    // Stream instances are kept in the global logging system state and are not
    // deleted until exit.
    //
    // Apart from compiler ordering restrictions, reads on these atomics are
    // free on x86/x64.
    //
    private: std::array<std::atomic<LoggingStream *>, _BalauLoggingLevelCount> streams {};

    friend class LoggingSystem::LoggerConfigurationVisitor;
    friend class LoggingSystem::LoggerPropertyVisitor;

    //
    // This logger's configuration properties.
    //
    // This is the complete set of configuration properties for this logger,
    // including the ones inherited from the parent logger.
    //
    // This field is not used during logging. It is only used at configuration
    // time, protected by the global logging mutex.
    //
    private: std::map<std::string, std::string> properties;

    private: Logger(std::string identifier_,
                    std::string nameSpace_,
                    std::string ns_,
                    const std::initializer_list<std::string> & propertyPairs);

    private: Logger() = default;
    private: Logger(Logger && rhs) noexcept;
    private: Logger(std::string && identifier_, std::string && nameSpace_, std::string && ns_) noexcept;

    public: Logger(const Logger &) = delete;
    public: Logger & operator = (const Logger &) = delete;

    private: void inheritConfiguration(const Logger & copy);

    // Non-parameter version.
    private: static void logMessage(const SourceCodeLocation & location,
                                    LoggingLevel level,
                                    const Logger & logger,
                                    std::string_view message);

    // Parameter version.
    private: static void logMessage(const SourceCodeLocation & location,
                                    LoggingLevel level,
                                    const Logger & logger,
                                    std::string_view message,
                                    const LoggingSystem::LoggerStringVector & parameters);

    friend class LoggingSystem::LoggerHolder;
    friend class LoggingSystem::LoggingState;
    friend class BalauLogger;
};

} // namespace Balau


#define BalauLogTrace(LOGGER, ...) LOGGER.trace(SourceCodeLocation(__FILE__, __LINE__), __VA_ARGS__)

#define BalauLogDebug(LOGGER, ...) LOGGER.debug(SourceCodeLocation(__FILE__, __LINE__), __VA_ARGS__)

#define BalauLogInfo(LOGGER, ...)  LOGGER.info(SourceCodeLocation(__FILE__, __LINE__), __VA_ARGS__)

#define BalauLogWarn(LOGGER, ...)  LOGGER.warn(SourceCodeLocation(__FILE__, __LINE__), __VA_ARGS__)

#define BalauLogError(LOGGER, ...) LOGGER.error(SourceCodeLocation(__FILE__, __LINE__), __VA_ARGS__)

#endif // COM_BORA_SOFTWARE__BALAU_LOGGING__LOGGER