Logger Class Reference

Singleton logger class for deltaFlow. More...

#include <Logger.H>

Public Member Functions
void	log (const std::string &msg, const Level &level)
	Log a message at a given severity level.

Static Public Member Functions
static Logger &	getLogger ()
	Get the singleton Logger instance.

Private Member Functions
	Logger (const std::string &name, Level level)
	Construct a logger with file name and log level.
	~Logger ()
	Destructor flushes and closes log file.
	Logger (const Logger &)=delete
Logger &	operator= (const Logger &)=delete

Private Attributes
Level	m_Level
	Minimum logging level.
std::string	m_FilePath
	Path to the log file.
std::ofstream	file
	Output file stream.

Detailed Description

Singleton logger class for deltaFlow.

Provides methods for logging messages at various severity levels to a file and/or console. Usage is typically via the provided macros.

Definition at line 99 of file Logger.H.

Constructor & Destructor Documentation

Logger() [1/2]

Logger::Logger ( const std::string &  name, Level  level  )

private

Construct a logger with file name and log level.

Parameters

name	Name or file path for the logger.
level	Minimum severity level to log.

Definition at line 34 of file Logger.C.

                                                 : m_FilePath(name), m_Level(level) {
    file.open(m_FilePath);
    if (!file.is_open()) {
        std::cerr << "Failed to open log file: " << m_FilePath << std::endl;
    }
 
    // Write banner to log file
    if (file.is_open()) {
        file << Display::fileBanner();
        auto now = std::time(nullptr);
        auto ts = fmt::format("{:%d-%b-%Y %H:%M:%S}", fmt::localtime(now));
        file << fmt::format("\n   Log started: {}\n", ts);
        file << "   " << Display::separator('-') << "\n\n";
        file.flush();
    }
}

References file, Display::fileBanner(), m_FilePath, and Display::separator().

Here is the call graph for this function:

~Logger()

Logger::~Logger ( )

private

Destructor flushes and closes log file.

Definition at line 51 of file Logger.C.

                {
    if (file.is_open()) {
        auto now = std::time(nullptr);
        auto ts = fmt::format("{:%d-%b-%Y %H:%M:%S}", fmt::localtime(now));
        file << "\n   " << Display::separator('-') << "\n";
        file << fmt::format("   Log ended: {}\n", ts);
        file.close();
    }
}

References file, and Display::separator().

Here is the call graph for this function:

Logger() [2/2]

Logger::Logger ( const Logger &  )

privatedelete

Member Function Documentation

getLogger()

Logger & Logger::getLogger ( )

static

Get the singleton Logger instance.

Returns

Reference to the Logger instance.

Definition at line 29 of file Logger.C.

                          {
    static Logger instance("deltaFlow.log", Level::DEBUG);
    return instance;
}

References DEBUG.

log()

void Logger::log	(	const std::string &	msg,
		const Level &	level
	)

Log a message at a given severity level.

Parameters

msg	The message to log.
level	The severity level.

Definition at line 61 of file Logger.C.

                                                         {
    std::string levelStr;
    m_Level = level;
    fmt::color levelColor = fmt::color::white;
 
    switch (m_Level) {
        case Level::DEBUG:
            levelStr = "DEBUG"; levelColor = fmt::color::light_blue; break;
        case Level::INFO:
            levelStr = "INFO"; levelColor = fmt::color::green; break;
        case Level::WARN:
            levelStr = "WARN"; levelColor = fmt::color::yellow; break;
        case Level::ERROR:
            levelStr = "ERROR"; levelColor = fmt::color::orange_red; break;
        case Level::CRITICAL:
            levelStr = "CRITICAL"; levelColor = fmt::color::red; break;
        default:
            levelStr = "LOG"; break;
    }
 
    auto now = std::time(nullptr);
    auto timestamp = fmt::format("{:%d-%m-%Y %H:%M:%S}", fmt::localtime(now));
 
    // Plain text to log file
    std::string logMessage = fmt::format(
        "{} :: {:<8} :: {}\n", timestamp, levelStr, msg
    );
 
    if (file.is_open()) {
        file << logMessage;
        file.flush();
    }
 
    // Colored output to terminal
    logMessage = fmt::format(
        "{} :: {} :: {}\n",
        timestamp,
        fmt::format(fg(levelColor) | fmt::emphasis::bold, "{:<8}", levelStr),
        msg
    );
 
    fmt::print("{}", logMessage);
}

References CRITICAL, DEBUG, ERROR, file, INFO, m_Level, and WARN.

operator=()

Logger & Logger::operator= ( const Logger &  )

privatedelete

Member Data Documentation

file

std::ofstream Logger::file

private

Output file stream.

Definition at line 117 of file Logger.H.

m_FilePath

std::string Logger::m_FilePath

private

Path to the log file.

Definition at line 116 of file Logger.H.

m_Level

Level Logger::m_Level

private

Minimum logging level.

Definition at line 115 of file Logger.H.

---

The documentation for this class was generated from the following files:

• src/logging/Logger.H
• src/logging/Logger.C