Serenity API

Serenity is a C++20 logging framework library that takes inspiration from spdlog for its user customizable aspect in logging and fmtlib for its highly flexible and efficient formatting of arguments. Serenity includes a native formatter in the form of ArgFormatter, which is a fully compliant but limited scope, drop-in replacement for the standard's <format> and Victor's fmtlib that is used for its relatively faster formatting times at the cost of some robustness that the other two provide. As a framework library, the backend formatter can be swapped between any three of these without any issues.

What sets Serenity apart is that this library offers very fast single threaded log calls alongside Unicode support via UTF-Utils, which allows the input paths for files and any string-type argument provided to a log call to be automatically decoded and encoded so that you don't have to worry so much about the headache of text encodings and can just log what you need to log. What this also means is that, by default, any derived extension to log targets that you may create will inherently achieve this as well. The internal log calls also use this functionality, so writing logs to char-type based containers from your derived class just got a whole lot easier on top of having stress-free log calls.

To start using any of the logging targets, simply `#include` any of the targets found under `serenity/Targets`.
The available targets for out-of-the-box usage are:

There are three total constructors for `FileTarget`:

 1.) explicit FileTarget(std::string_view fileName, bool replaceIfExists = false);
 2.) explicit FileTarget(std::string_view name, std::string_view filePath, bool replaceIfExists = false);
 3.) explicit FileTarget(std::string_view name, std::string_view formatPattern, std::string_view filePath, bool replaceIfExists = false);
                    

There are three total constructors for `RotatingTarget`:

 1.) explicit RotatingTarget();
 2.) explicit RotatingTarget(std::string_view name, std::string_view filePath, bool replaceIfExists = false);
 3.) explicit RotatingTarget(std::string_view name, std::string_view formatPattern, std::string_view filePath, bool replaceIfExists = false);
                    

There are three total constructors for `ConsoleTarget`:

 1.) ConsoleTarget();
 2.) explicit ConsoleTarget(std::string_view name );
 3.) explicit ConsoleTarget(std::string_view name, std::string_view msgPattern );
                    

      #include <serenity/Color/Color.h>

      namespace color = serenity::se_colors::bright_colors;
      namespace target = serenity::targets;
      // Create the console target with default format pattern and user-defined name
      target::ConsoleTarget example("Example_Logger");
      // Set the message level to any ansi-supported code (using helper header here)
      example.SetMsgColor(LoggerLevel::trace, color::foreground::grey);
                    

Once you decide what logger(s) you would like to use, all that's left to do to start using them is to call their respective log functions:

  template <typename... Args> void Trace(MsgWithLoc formatString, Args&&... args);
 template <typename... Args> void Info(MsgWithLoc formatString, Args&&... args);
  template <typename... Args> void Debug(MsgWithLoc formatString, Args&&... args);
 template <typename... Args> void Warn(MsgWithLoc formatString, Args&&... args);
  template <typename... Args> void Error(MsgWithLoc formatString, Args&&... args);
  template <typename... Args> void Fatal(MsgWithLoc formatString, Args&&... args);
                

Where the format string is your message to log. The loggers use the active backend formatter to format any log message with the arguments provided so long as there are substitution brackets present in the form of "{}". If unfamiliar with what the message formatting grammar is, I would highly recommend checking out the grammar specification outlined HERE. "ArgFormatter" and "<format>" are modeled after "fmtlib" and thus use Victor's grammar spec.

 #include <serenity/Targets/FileTarget.h>

 using namespace serenity::targets;
 FileTarget basicFileLogger("My_File_Logger", "[%L] %c [%N]: %+", "Sandbox/Logs/My_Log.txt", true);
 basicFileLogger.Trace("This is how {0} log message might look with an integer formatted to hex: [{1:X}]", "a simple", 42);
                

[Long_Logger_Level] ddd mmm dd HH:MM:SS YYYY [My_File_Logger]: Log_Message + Platform_Line_Ending
                                            

[Info] Mon Nov 28 20:35:32 2022 [My_File_Logger]: This is how a simple log message might look with an integer formatted to hex: [0X2A] \r\n