Logging

ERS has built-in support to log messages at different levels of priority, enabling easy filtering of different messages. From least to most urgent, they are:

Name	Short name
Trace	`T`
Debug	`D`
Info	`I`
Warning	`W`
Error	`E`
Critical	`C`

To log to each of these levels, the following functions can be used. Additionally, the log level can be set to only show messages of a certain level or up in the output.

C++C#

// Only message of the info, warning, error and critical level are shown
Ers::Logger::SetLogLevel(Ers::Logger::LogLevel::Info);

Ers::Logger::Trace("Message");                                // Not shown
Ers::Logger::Debug("Message");                                // Not shown
Ers::Logger::Info(std::format("Message {}", 2));              // Logs: "Message 2"
Ers::Logger::Warning(std::format("Message {:.2f}", 1.2345f)); // Logs: "Message 1.23"
Ers::Logger::Error(std::format("{1} Message {0} {0}", 1, 2)); // Logs: "2 Message 1 1"
Ers::Logger::Critical("Message");                             // Logs: "Message"

// Only message of the info, warning, error and critical level are shown
Logger.SetLogLevel(LogLevel.Info);

Logger.Trace("Message");                   // Not shown
Logger.Debug("Message");                   // Not shown
Logger.Info("Message {0}", 2);             // Logs: "Message 2"
Logger.Warning("Message {0:F2}", 1.2345f); // Logs: "Message 1.23"
Logger.Error("{1} Message {0} {0}", 1, 2); // Logs: "2 Message 1 1"
Logger.Critical("Message");                // Logs: "Message"

C# tip

Notice how, in C#, it's possible to use the same features as the String.Format method to easily create a formatted string.

The output is formatted as the short name of the log level between square brackets, the thread ID, and then the log message.

[I] Thread [52044] Message 2
[W] Thread [52044] Message 1.23
[E] Thread [52044] 2 Message 1 1
[C] Thread [52044] Message

Extending the logging

Using the Ers::Logger::AddCallback function, it's possible to register a callback function that is called every time a message is logged in ERS. This can be useful when additional logic needs to be performed when a message is logged. For example, it may be used to write log messages to a file.

If a callback is no longer necessary, it can be removed again using the Logger::RemoveCallback function and the callback index that is returned by Logger::AddCallback.

C++C#

void HandleLogMessage(Ers::Logger::LogLevel level, const char* message)
{
    // Do something with the logged message here
}

int main()
{
    Ers::Initialize();

    const size_t callbackIndex = Ers::Logger::AddCallback(&HandleLogMessage);

    // Later
    Ers::Logger::RemoveCallback(callbackIndex);

    Ers::Uninitialize();
    return 0;
}

static void HandleLogMessage(LogLevel level, string message)
{
    // Do something with the logged message here
}

static void Main(string[] args)
{
    ERS.Initialize();

    nuint callbackIndex = Logger.AddCallback(HandleLogMessage);

    // Later
    Logger.RemoveCallback(callbackIndex);

    ERS.Uninitialize();
}