• Fixed UBSAN warning when logging empty std::string_view (#885)
• Updated ConsoleSink constructor to accept an optional FileEventNotifier parameter for consistency with other
  sinks (#886)

• Fix BacktraceStorage index reset to prevent SIGSEGV when using LOG_BACKTRACE

• Update bundled libfmt to v12.1.0
• Minor correction to _last_sink_flush_time update when fflush() fails
• Added retry logic and shared access handling for file open and rotation on Windows
• Use ::WriteFile instead of fwrite to prevent \r\r\n line endings on Windows
• Avoid file descriptor leaks by setting O_CLOEXEC on Unix and HANDLE_FLAG_INHERIT on Windows
• Added SimpleSetup.h convenience header for trivial program cases to easily setup a logger. For example

   #include "quill/SimpleSetup.h"
   #include "quill/LogMacros.h"
  
   int main()
   {
     auto* logger = quill::simple_logger();
     LOG_INFO(logger, "Hello from {}!", "Quill");
  
     auto* logger2 = quill::simple_logger("test.log");
     LOG_INFO(logger2, "This message goes to a file");
   }

• Fixed argument forwarding when encoding user-defined types with DeferredFormatCodec or STL containers to properly
  handle rvalue references. For example, the following move-only type will now work correctly:

  class MoveOnlyType {
  public:
    MoveOnlyType(std::string name, std::string value, uint32_t count)
      : name(std::move(name)), value(std::move(value)), count(count) {}
    MoveOnlyType(MoveOnlyType&&) = default;
    MoveOnlyType(MoveOnlyType const&) = delete;
    std::string name;
    std::string value;
    uint32_t count;
  };
  
  template <>
  struct fmtquill::formatter<MoveOnlyType> {
    constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
    auto format(MoveOnlyType const& obj, format_context& ctx) const {
      return fmtquill::format_to(ctx.out(), "MoveOnlyType(name: {}, value: {}, count: {})",
                                 obj.name, obj.value, obj.count);
    }
  };
  
  template <>
  struct quill::Codec<MoveOnlyType> : quill::DeferredFormatCodec<MoveOnlyType> {};
  
  MoveOnlyType obj{"Test", "Value1", 42};
  LOG_INFO(logger, "obj: {}", std::move(obj));  // Properly forwards and moves

• Added fuzzing tests to CI to catch memory and undefined behavior issues
• Fixed PatternFormatter automatic newline appending by making the suffix ('\n') configurable or optionally disabled via PatternFormatterOptions
• Fixed segmentation fault when DirectFormatCodec was used with enums types (#848)
• Fixed segmentation fault when DirectFormatCodec was used with STL containers of enums
• Fixed a compiler error when LOG_DYNAMIC is used with QUILL_DISABLE_FILE_INFO (#847)
• Fixed process ID capture in BackendWorker to support fork() correctly (#860)
• Fixed undefined behavior caused by passing nullptr to memcpy when encoding an empty std::vector
• Updated BackendOptions::check_printable_char to allow tab (\t) and carriage return (\r) characters by default (#856)
• Increased RdtscClock resync lag thresholds to improve cross-system compatibility
• Added QUILL_ENABLE_ASSERTIONS CMake option and preprocessor flag to enable assertions in release builds
• Allow RotatingSink to rotate the file on creation with rotation_on_creation()
• Improved SignalHandlerOptions configurability by replacing hardcoded logger exclusion string with excluded_logger_substrings option
• Silence MSVC warnings (4324, 4996) in source code instead of CMake

• Fixed potential conflicts by adding unique prefixes to internal macro variables to prevent conflicts with user variable names in the same scope. (#799)
• Fixed potential UBSan warnings by adding overflow check when doubling resync interval in RdtscClock::resync() (#809)
• Minor improvements in Utility::to_hex function and StringFromTime
• Fixed an issue where BackendWorker::_exit was always executed during destruction, even when the backend thread had already stopped (#815)
• Fixed RotatingFileSink to correctly handle FilenameAppendOption::StartDate configuration (#822)
• Fixed unnecessary allocation caused by empty std::vector while BackendWorker is idle on Windows (#827)
• Fixed FileSink::open_mode string comparison for file mode flags
• Adjusted default BackendOptions values for broader system compatibility

• Fixed PatternFormatter test to work with any repository name instead of hardcoded quill (#795)
• Fixed Windows compiler warnings when clang-cl >= 19 is used

New Features

• There is a new macro-free mode that allows logging without macros. You have two options: either #include "quill/LogMacros.h" or #include "quill/LogFunctions.h". The macro mode still remains the recommended and main method for logging. The new macro-free log has higher overhead than using macros. To use the macro-free mode, for example:

  quill::debug(logger, "A {} message with number {}", "test", 123);

  See macro-free mode documentation here for details.

• Added BinaryDataDeferredFormatCodec for efficient binary data logging. This codec allows efficient logging of variable-sized binary data by copying the raw bytes on the hot path and deferring the formatting to the backend thread. This is particularly useful for logging binary protocol messages (like SBE or custom binary formats), network packets, and raw binary data without impacting application performance. See the example sbe_logging and binary_protocol_logging for details. For documentation, see here.

• The immediate flush feature has been enhanced to support interval-based flushing and moved to runtime. This feature helps with debugging by ensuring log statements are flushed to the sink, blocking the caller thread. (#660)

• Added the QUILL_DISABLE_FILE_INFO preprocessor flag and CMake option. This disables __FILE__ and __LINE__ information in log statements at compile time when location-related patterns (%(file_name), %(line_number), %(short_source_location), %(source_location)) are not needed in the PatternFormatter. This removes embedded source path strings from built binaries from the security viewpoint.

• Added the QUILL_DETAILED_FUNCTION_NAME CMake option. When enabled, this option uses compiler-specific detailed function signatures (such as __PRETTY_FUNCTION__ on GCC/Clang or __FUNCSIG__ on MSVC) instead of the standard __FUNCTION__ in log macros. This provides more complete function information, including return types, namespaces, and parameter types. This option is only relevant when %(caller_function) is used in the pattern formatter. (#785)

• Added source_location_path_strip_prefix option in PatternFormatterOptions to customize the display of the %(source_location) attribute of PatternFormatter. When set, any paths that contain this prefix will have the prefix and everything before it stripped from the displayed path. For example, with prefix "projects", a source location like "/home/user/projects/app/main.cpp:5" would be displayed as "app/main.cpp:5". (#772)

• Added source_location_remove_relative_paths option in PatternFormatterOptions to remove relative path components from the %(source_location) attribute of PatternFormatter. When enabled, relative path components like "../" are processed and removed, simplifying paths from __FILE__ which might contain relative paths like "../../../test/main.cpp". (#778)

• Added process_function_name customisation point in PatternFormatterOptions. This function allows custom processing of the function signature before it's displayed in logs. This makes more sense to use when QUILL_DETAILED_FUNCTION_NAME is used. This provides flexibility to trim, format, or otherwise modify function signatures to improve readability in log output when using the %(caller_function) pattern. (#785)

• Added helper macros for easy logging of user-defined types. Two new macros are available in quill/HelperMacros.h:

  • QUILL_LOGGABLE_DIRECT_FORMAT(Type): For types that contain pointers or have lifetime dependencies
  • QUILL_LOGGABLE_DEFERRED_FORMAT(Type): For types that only contain value types and are safe to copy

  Note that these macros require you to provide either an operator<< for your type and they are just shortcuts to existing functionality. (#777)

  Example usage:

  class User { /* ... */ };
  std::ostream& operator<<(std::ostream& os, User const& user) { /* ... */ }
  
  // For types with pointers - will format immediately
  QUILL_LOGGABLE_DIRECT_FORMAT(User)
  
  class Product { /* ... */ };
  std::ostream& operator<<(std::ostream& os, Product const& product) { /* ... */ }
  
  // For types with only value members - can format asynchronously
  QUILL_LOGGABLE_DEFERRED_FORMAT(Product)

Improvements

• Internally, refactored how runtime metadata are handled for more flexibility, providing three macros for logging with runtime metadata:

  • QUILL_LOG_RUNTIME_METADATA_DEEP - Takes a deep copy of fmt, file, function and tags. Most flexible
    option, useful for forwarding logs from another logging library.
  • QUILL_LOG_RUNTIME_METADATA_HYBRID - Will take a deep copy of fmt and tags and will take file and
    function as reference. This is used for the new macro-free mode.
  • QUILL_LOG_RUNTIME_METADATA_SHALLOW - Will take everything as reference. This is used when logging with
    compile-time metadata and using, for example, a dynamic log-level such as LOG_DYNAMIC.

• When using a sink with overridden PatternFormatterOptions, the option add_metadata_to_multi_line_logs will now be correctly applied at the Sink level. Previously, this option was only available and effective at the Logger level PatternFormatter.

• When a Sink with override PatternFormatterOptions is used and if no other sink exists using the Logger PatternFormatterOptions, then the backend thread will no longer perform a redundant format log statement.

• When using a sink with overridden PatternFormatterOptions, the log_statement that is passed to the Filter::filter() will now be formatted based on the overridden options instead of using the Logger PatternFormatterOptions.

• Update bundled libfmt to v11.2.0

API Changes

• If you were previously setting QUILL_ENABLE_IMMEDIATE_FLUSH to 1, this functionality has been moved to runtime with more flexibility. Instead of using a boolean flag, you can now specify the flush interval by calling logger->set_immediate_flush(flush_every_n_messages) on each logger instance. Set it to 1 for per-message flushing, or to a higher value to flush after that many messages. Setting it to 0 disables flushing which is the default behaviour. QUILL_ENABLE_IMMEDIATE_FLUSH still exists as a compile-time preprocessor flag and is set to 1 by default. Setting QUILL_ENABLE_IMMEDIATE_FLUSH 0 in the preprocessor will eliminate the if branch from the hot path and disable this feature entirely, regardless of the value passed to set_immediate_flush(flush_every_n_messages).

• The QUILL_LOG_RUNTIME_METADATA macro requires file, function and fmt to be passed as char const* and line_number as uint32_t. This is a breaking change from the previous version.

• Add support for void* formatting (#759)
• Fix a bug in RotatingJsonFileSink.h where file size-based rotation wasn't triggering
  properly (#767)
• Fix false positive -Wstringop-overread warning in GCC (#766)

Add missing namespace in QUILL_LOG_RUNTIME_METADATA (#743)

• Fix crash when LOG_BACKTRACE is used (#744)
• Add missing namespace in QUILL_LOG_RUNTIME_METADATA (#743)
• Check for nullptr Logger* before setting log level via QUILL_LOG_LEVEL environment variable (#749)
• Change default mode of FileSink fopen to a to avoid overwriting existing files