Add full date to stdout tests

clang-format
2026-04-10 11:34:29 +08:00 · 2025-11-28 17:30:23 +02:00 · 2025-11-28 17:21:14 +02:00 · 2025-11-28 17:10:57 +02:00 · 2025-11-28 15:48:07 +02:00
107 changed files with 749 additions and 1050 deletions
--- a/.clang-format
+++ b/.clang-format
@@ -13,6 +13,7 @@ AlignEscapedNewlines: Left
 AlwaysBreakTemplateDeclarations: Yes
 PackConstructorInitializers: Never
 BreakConstructorInitializersBeforeComma: false
-IndentPPDirectives: None
+IndentPPDirectives: BeforeHash
 SortIncludes:    Never
 ...
+
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -199,7 +199,7 @@ spdlog_enable_warnings(spdlog)

 set_target_properties(spdlog PROPERTIES VERSION ${SPDLOG_VERSION} SOVERSION
                                                                  ${SPDLOG_VERSION_MAJOR}.${SPDLOG_VERSION_MINOR})
-set_target_properties(spdlog PROPERTIES DEBUG_POSTFIX "${SPDLOG_DEBUG_POSTFIX}")
+set_target_properties(spdlog PROPERTIES DEBUG_POSTFIX ${SPDLOG_DEBUG_POSTFIX})

 if(COMMAND target_precompile_headers AND SPDLOG_ENABLE_PCH)
    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/pch.h.in ${PROJECT_BINARY_DIR}/spdlog_pch.h @ONLY)
--- a/51
+++ b/51
@@ -1,25 +1,26 @@
-The MIT License (MIT)
-
-Copyright (c) 2016 - present, Gabi Melman and spdlog contributors.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
-- NOTE: Third party dependency used by this software --
-This software depends on the fmt lib (MIT License),
-and users must comply to its license: https://raw.githubusercontent.com/fmtlib/fmt/master/LICENSE
+The MIT License (MIT)
+
+Copyright (c) 2016 Gabi Melman.                                       
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+-- NOTE: Third party dependency used by this software --
+This software depends on the fmt lib (MIT License),
+and users must comply to its license: https://raw.githubusercontent.com/fmtlib/fmt/master/LICENSE
+
--- a/bench/async_bench.cpp
+++ b/bench/async_bench.cpp
@@ -11,11 +11,11 @@
 #include "spdlog/sinks/basic_file_sink.h"

 #if defined(SPDLOG_USE_STD_FORMAT)
-#include <format>
+    #include <format>
 #elif defined(SPDLOG_FMT_EXTERNAL)
-#include <fmt/format.h>
+    #include <fmt/format.h>
 #else
-#include "spdlog/fmt/bundled/format.h"
+    #include "spdlog/fmt/bundled/format.h"
 #endif

 #include "utils.h"
@@ -34,9 +34,9 @@ using namespace utils;
 void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count);

 #ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4996)  // disable fopen warning under msvc
-#endif                           // _MSC_VER
+    #pragma warning(push)
+    #pragma warning(disable : 4996)  // disable fopen warning under msvc
+#endif                               // _MSC_VER

 int count_lines(const char *filename) {
    int counter = 0;
@@ -62,7 +62,7 @@ void verify_file(const char *filename, int expected_count) {
 }

 #ifdef _MSC_VER
-#pragma warning(pop)
+    #pragma warning(pop)
 #endif

 int main(int argc, char *argv[]) {
--- a/bench/bench.cpp
+++ b/bench/bench.cpp
@@ -13,11 +13,11 @@
 #include "spdlog/sinks/rotating_file_sink.h"

 #if defined(SPDLOG_USE_STD_FORMAT)
-#include <format>
+    #include <format>
 #elif defined(SPDLOG_FMT_EXTERNAL)
-#include <fmt/format.h>
+    #include <fmt/format.h>
 #else
-#include "spdlog/fmt/bundled/format.h"
+    #include "spdlog/fmt/bundled/format.h"
 #endif

 #include "utils.h"
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -183,7 +183,7 @@ void async_example() {
 // {:n} - don't split the output to lines.

 #if !defined SPDLOG_USE_STD_FORMAT || defined(_MSC_VER)
-#include "spdlog/fmt/bin_to_hex.h"
+    #include "spdlog/fmt/bin_to_hex.h"
 void binary_example() {
    std::vector<char> buf;
    for (int i = 0; i < 80; i++) {
@@ -207,7 +207,7 @@ void binary_example() {

 // Log a vector of numbers
 #ifndef SPDLOG_USE_STD_FORMAT
-#include "spdlog/fmt/ranges.h"
+    #include "spdlog/fmt/ranges.h"
 void vector_example() {
    std::vector<int> vec = {1, 2, 3};
    spdlog::info("Vector example: {}", vec);
@@ -267,16 +267,16 @@ void multi_sink_example() {

 // User defined types logging
 struct my_type {
-    int value_ = 0;
-    explicit my_type(int value)
-        : value_(value) {}
+    int i = 0;
+    explicit my_type(int i)
+        : i(i) {}
 };

 #ifndef SPDLOG_USE_STD_FORMAT  // when using fmtlib
 template <>
 struct fmt::formatter<my_type> : fmt::formatter<std::string> {
    auto format(my_type my, format_context &ctx) const -> decltype(ctx.out()) {
-        return fmt::format_to(ctx.out(), "[my_type value={}]", my.value_);
+        return fmt::format_to(ctx.out(), "[my_type i={}]", my.i);
    }
 };

@@ -284,7 +284,7 @@ struct fmt::formatter<my_type> : fmt::formatter<std::string> {
 template <>
 struct std::formatter<my_type> : std::formatter<std::string> {
    auto format(my_type my, format_context &ctx) const -> decltype(ctx.out()) {
-        return std::format_to(ctx.out(), "[my_type value={}]", my.value_);
+        return std::format_to(ctx.out(), "[my_type i={}]", my.i);
    }
 };
 #endif
@@ -301,7 +301,7 @@ void err_handler_example() {

 // syslog example (linux/osx/freebsd)
 #ifndef _WIN32
-#include "spdlog/sinks/syslog_sink.h"
+    #include "spdlog/sinks/syslog_sink.h"
 void syslog_example() {
    std::string ident = "spdlog-example";
    auto syslog_logger = spdlog::syslog_logger_mt("syslog", ident, LOG_PID);
@@ -311,7 +311,7 @@ void syslog_example() {

 // Android example.
 #if defined(__ANDROID__)
-#include "spdlog/sinks/android_sink.h"
+    #include "spdlog/sinks/android_sink.h"
 void android_example() {
    std::string tag = "spdlog-android";
    auto android_logger = spdlog::android_logger_mt("android", tag);
@@ -386,7 +386,7 @@ void replace_default_logger_example() {
 // thread-local storage.

 #ifndef SPDLOG_NO_TLS
-#include "spdlog/mdc.h"
+    #include "spdlog/mdc.h"
 void mdc_example() {
    spdlog::mdc::put("key1", "value1");
    spdlog::mdc::put("key2", "value2");
--- a/include/spdlog/async_logger-inl.h
+++ b/include/spdlog/async_logger-inl.h
@@ -4,7 +4,7 @@
 #pragma once

 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/async_logger.h>
+    #include <spdlog/async_logger.h>
 #endif

 #include <spdlog/details/thread_pool.h>
@@ -57,15 +57,15 @@ SPDLOG_LOGGER_CATCH(source_loc())
 //
 // backend functions - called from the thread pool to do the actual job
 //
-SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg &incoming_log_msg) {
+SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg) {
    for (auto &sink : sinks_) {
-        if (sink->should_log(incoming_log_msg.level)) {
-            SPDLOG_TRY { sink->log(incoming_log_msg); }
-            SPDLOG_LOGGER_CATCH(incoming_log_msg.source)
+        if (sink->should_log(msg.level)) {
+            SPDLOG_TRY { sink->log(msg); }
+            SPDLOG_LOGGER_CATCH(msg.source)
        }
    }

-    if (should_flush_(incoming_log_msg)) {
+    if (should_flush_(msg)) {
        backend_flush_();
    }
 }
--- a/include/spdlog/async_logger.h
+++ b/include/spdlog/async_logger.h
@@ -70,5 +70,5 @@ private:
 }  // namespace spdlog

 #ifdef SPDLOG_HEADER_ONLY
-#include "async_logger-inl.h"
+    #include "async_logger-inl.h"
 #endif
--- a/include/spdlog/cfg/argv.h
+++ b/include/spdlog/cfg/argv.h
@@ -26,8 +26,8 @@ inline void load_argv_levels(int argc, const char **argv) {
    for (int i = 1; i < argc; i++) {
        std::string arg = argv[i];
        if (arg.find(spdlog_level_prefix) == 0) {
-            const auto levels_spec = arg.substr(spdlog_level_prefix.size());
-            helpers::load_levels(levels_spec);
+            auto levels_string = arg.substr(spdlog_level_prefix.size());
+            helpers::load_levels(levels_string);
        }
    }
 }
--- a/include/spdlog/cfg/env.h
+++ b/include/spdlog/cfg/env.h
@@ -17,7 +17,7 @@
 // export SPDLOG_LEVEL=debug
 //
 // turn off all logging except for logger1:
-// export SPDLOG_LEVEL="off,logger1=debug"
+// export SPDLOG_LEVEL="*=off,logger1=debug"
 //

 // turn off all logging except for logger1 and logger2:
@@ -26,9 +26,9 @@
 namespace spdlog {
 namespace cfg {
 inline void load_env_levels(const char* var = "SPDLOG_LEVEL") {
-    const auto levels_spec = details::os::getenv(var);
-    if (!levels_spec.empty()) {
-        helpers::load_levels(levels_spec);
+    auto env_val = details::os::getenv(var);
+    if (!env_val.empty()) {
+        helpers::load_levels(env_val);
    }
 }

--- a/include/spdlog/cfg/helpers-inl.h
+++ b/include/spdlog/cfg/helpers-inl.h
@@ -4,7 +4,7 @@
 #pragma once

 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/cfg/helpers.h>
+    #include <spdlog/cfg/helpers.h>
 #endif

 #include <spdlog/details/os.h>
@@ -70,12 +70,12 @@ inline std::unordered_map<std::string, std::string> extract_key_vals_(const std:
    return rv;
 }

-SPDLOG_INLINE void load_levels(const std::string &levels_spec) {
-    if (levels_spec.empty() || levels_spec.size() >= 32768) {
+SPDLOG_INLINE void load_levels(const std::string &input) {
+    if (input.empty() || input.size() >= 32768) {
        return;
    }

-    auto key_vals = extract_key_vals_(levels_spec);
+    auto key_vals = extract_key_vals_(input);
    std::unordered_map<std::string, level::level_enum> levels;
    level::level_enum global_level = level::info;
    bool global_level_found = false;
@@ -83,7 +83,7 @@ SPDLOG_INLINE void load_levels(const std::string &levels_spec) {
    for (auto &name_level : key_vals) {
        const auto &logger_name = name_level.first;
        const auto &level_name = to_lower_(name_level.second);
-        const auto level = level::from_str(level_name);
+        auto level = level::from_str(level_name);
        // ignore unrecognized level names
        if (level == level::off && level_name != "off") {
            continue;
--- a/include/spdlog/cfg/helpers.h
+++ b/include/spdlog/cfg/helpers.h
@@ -18,12 +18,12 @@ namespace helpers {
 // turn off all logging except for logger1: "off,logger1=debug"
 // turn off all logging except for logger1 and logger2: "off,logger1=debug,logger2=info"
 //
-SPDLOG_API void load_levels(const std::string &levels_spec);
+SPDLOG_API void load_levels(const std::string &txt);
 }  // namespace helpers

 }  // namespace cfg
 }  // namespace spdlog

 #ifdef SPDLOG_HEADER_ONLY
-#include "helpers-inl.h"
+    #include "helpers-inl.h"
 #endif  // SPDLOG_HEADER_ONLY
--- a/include/spdlog/common-inl.h
+++ b/include/spdlog/common-inl.h
@@ -4,12 +4,11 @@
 #pragma once

 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/common.h>
+    #include <spdlog/common.h>
 #endif

 #include <algorithm>
 #include <iterator>
-#include <cctype>

 namespace spdlog {
 namespace level {
@@ -30,31 +29,15 @@ SPDLOG_INLINE const char *to_short_c_str(spdlog::level::level_enum l) SPDLOG_NOE
 }

 SPDLOG_INLINE spdlog::level::level_enum from_str(const std::string &name) SPDLOG_NOEXCEPT {
-    auto it = std::find_if(std::begin(level_string_views), std::end(level_string_views),
-                           [&name](const string_view_t &level_name) {
-                               return level_name.size() == name.size() &&
-                                      std::equal(name.begin(), name.end(), level_name.begin(),
-                                                 [](char a, char b) {
-                                                     return std::tolower(static_cast<unsigned char>(a)) ==
-                                                            std::tolower(static_cast<unsigned char>(b));
-                                                 });
-                           });
+    auto it = std::find(std::begin(level_string_views), std::end(level_string_views), name);
    if (it != std::end(level_string_views))
        return static_cast<level::level_enum>(std::distance(std::begin(level_string_views), it));

    // check also for "warn" and "err" before giving up..
-    auto iequals = [](const std::string &a, const std::string &b) {
-        return a.size() == b.size() &&
-               std::equal(a.begin(), a.end(), b.begin(), [](char ac, char bc) {
-                   return std::tolower(static_cast<unsigned char>(ac)) ==
-                          std::tolower(static_cast<unsigned char>(bc));
-               });
-    };
-
-    if (iequals(name, "warn")) {
+    if (name == "warn") {
        return level::warn;
    }
-    if (iequals(name, "err")) {
+    if (name == "err") {
        return level::err;
    }
    return level::off;
--- a/include/spdlog/common.h
+++ b/include/spdlog/common.h
@@ -17,57 +17,57 @@
 #include <type_traits>

 #ifdef SPDLOG_USE_STD_FORMAT
-#include <version>
-#if __cpp_lib_format >= 202207L
-#include <format>
-#else
-#include <string_view>
-#endif
+    #include <version>
+    #if __cpp_lib_format >= 202207L
+        #include <format>
+    #else
+        #include <string_view>
+    #endif
 #endif

 #ifdef SPDLOG_COMPILED_LIB
-#undef SPDLOG_HEADER_ONLY
-#if defined(SPDLOG_SHARED_LIB)
-#if defined(_WIN32)
-#ifdef spdlog_EXPORTS
-#define SPDLOG_API __declspec(dllexport)
-#else  // !spdlog_EXPORTS
-#define SPDLOG_API __declspec(dllimport)
-#endif
-#else  // !defined(_WIN32)
-#define SPDLOG_API __attribute__((visibility("default")))
-#endif
-#else  // !defined(SPDLOG_SHARED_LIB)
-#define SPDLOG_API
-#endif
-#define SPDLOG_INLINE
+    #undef SPDLOG_HEADER_ONLY
+    #if defined(SPDLOG_SHARED_LIB)
+        #if defined(_WIN32)
+            #ifdef spdlog_EXPORTS
+                #define SPDLOG_API __declspec(dllexport)
+            #else  // !spdlog_EXPORTS
+                #define SPDLOG_API __declspec(dllimport)
+            #endif
+        #else  // !defined(_WIN32)
+            #define SPDLOG_API __attribute__((visibility("default")))
+        #endif
+    #else  // !defined(SPDLOG_SHARED_LIB)
+        #define SPDLOG_API
+    #endif
+    #define SPDLOG_INLINE
 #else  // !defined(SPDLOG_COMPILED_LIB)
-#define SPDLOG_API
-#define SPDLOG_HEADER_ONLY
-#define SPDLOG_INLINE inline
+    #define SPDLOG_API
+    #define SPDLOG_HEADER_ONLY
+    #define SPDLOG_INLINE inline
 #endif  // #ifdef SPDLOG_COMPILED_LIB

 #include <spdlog/fmt/fmt.h>

 #if !defined(SPDLOG_USE_STD_FORMAT) && \
    FMT_VERSION >= 80000  // backward compatibility with fmt versions older than 8
-#define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string)
-#define SPDLOG_FMT_STRING(format_string) FMT_STRING(format_string)
-#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
-#include <spdlog/fmt/xchar.h>
-#endif
+    #define SPDLOG_FMT_RUNTIME(format_string) fmt::runtime(format_string)
+    #define SPDLOG_FMT_STRING(format_string) FMT_STRING(format_string)
+    #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+        #include <spdlog/fmt/xchar.h>
+    #endif
 #else
-#define SPDLOG_FMT_RUNTIME(format_string) format_string
-#define SPDLOG_FMT_STRING(format_string) format_string
+    #define SPDLOG_FMT_RUNTIME(format_string) format_string
+    #define SPDLOG_FMT_STRING(format_string) format_string
 #endif

 // visual studio up to 2013 does not support noexcept nor constexpr
 #if defined(_MSC_VER) && (_MSC_VER < 1900)
-#define SPDLOG_NOEXCEPT _NOEXCEPT
-#define SPDLOG_CONSTEXPR
+    #define SPDLOG_NOEXCEPT _NOEXCEPT
+    #define SPDLOG_CONSTEXPR
 #else
-#define SPDLOG_NOEXCEPT noexcept
-#define SPDLOG_CONSTEXPR constexpr
+    #define SPDLOG_NOEXCEPT noexcept
+    #define SPDLOG_CONSTEXPR constexpr
 #endif

 // If building with std::format, can just use constexpr, otherwise if building with fmt
@@ -76,48 +76,48 @@
 // depending on the compiler
 // If fmt determines it can't use constexpr, we should inline the function instead
 #ifdef SPDLOG_USE_STD_FORMAT
-#define SPDLOG_CONSTEXPR_FUNC constexpr
+    #define SPDLOG_CONSTEXPR_FUNC constexpr
 #else  // Being built with fmt
-#if FMT_USE_CONSTEXPR
-#define SPDLOG_CONSTEXPR_FUNC FMT_CONSTEXPR
-#else
-#define SPDLOG_CONSTEXPR_FUNC inline
-#endif
+    #if FMT_USE_CONSTEXPR
+        #define SPDLOG_CONSTEXPR_FUNC FMT_CONSTEXPR
+    #else
+        #define SPDLOG_CONSTEXPR_FUNC inline
+    #endif
 #endif

 #if defined(__GNUC__) || defined(__clang__)
-#define SPDLOG_DEPRECATED __attribute__((deprecated))
+    #define SPDLOG_DEPRECATED __attribute__((deprecated))
 #elif defined(_MSC_VER)
-#define SPDLOG_DEPRECATED __declspec(deprecated)
+    #define SPDLOG_DEPRECATED __declspec(deprecated)
 #else
-#define SPDLOG_DEPRECATED
+    #define SPDLOG_DEPRECATED
 #endif

 // disable thread local on msvc 2013
 #ifndef SPDLOG_NO_TLS
-#if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt)
-#define SPDLOG_NO_TLS 1
-#endif
+    #if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__cplusplus_winrt)
+        #define SPDLOG_NO_TLS 1
+    #endif
 #endif

 #ifndef SPDLOG_FUNCTION
-#define SPDLOG_FUNCTION static_cast<const char *>(__FUNCTION__)
+    #define SPDLOG_FUNCTION static_cast<const char *>(__FUNCTION__)
 #endif

 #ifdef SPDLOG_NO_EXCEPTIONS
-#define SPDLOG_TRY
-#define SPDLOG_THROW(ex)                               \
-    do {                                               \
-        printf("spdlog fatal error: %s\n", ex.what()); \
-        std::abort();                                  \
-    } while (0)
-#define SPDLOG_CATCH_STD
+    #define SPDLOG_TRY
+    #define SPDLOG_THROW(ex)                               \
+        do {                                               \
+            printf("spdlog fatal error: %s\n", ex.what()); \
+            std::abort();                                  \
+        } while (0)
+    #define SPDLOG_CATCH_STD
 #else
-#define SPDLOG_TRY try
-#define SPDLOG_THROW(ex) throw(ex)
-#define SPDLOG_CATCH_STD             \
-    catch (const std::exception &) { \
-    }
+    #define SPDLOG_TRY try
+    #define SPDLOG_THROW(ex) throw(ex)
+    #define SPDLOG_CATCH_STD             \
+        catch (const std::exception &) { \
+        }
 #endif

 namespace spdlog {
@@ -130,12 +130,12 @@ class sink;

 #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
 using filename_t = std::wstring;
-// allow macro expansion to occur in SPDLOG_FILENAME_T
-#define SPDLOG_FILENAME_T_INNER(s) L##s
-#define SPDLOG_FILENAME_T(s) SPDLOG_FILENAME_T_INNER(s)
+    // allow macro expansion to occur in SPDLOG_FILENAME_T
+    #define SPDLOG_FILENAME_T_INNER(s) L##s
+    #define SPDLOG_FILENAME_T(s) SPDLOG_FILENAME_T_INNER(s)
 #else
 using filename_t = std::string;
-#define SPDLOG_FILENAME_T(s) s
+    #define SPDLOG_FILENAME_T(s) s
 #endif

 using log_clock = std::chrono::system_clock;
@@ -149,28 +149,28 @@ using string_view_t = std::string_view;
 using memory_buf_t = std::string;

 template <typename... Args>
-#if __cpp_lib_format >= 202207L
+    #if __cpp_lib_format >= 202207L
 using format_string_t = std::format_string<Args...>;
-#else
+    #else
 using format_string_t = std::string_view;
-#endif
+    #endif

 template <class T, class Char = char>
 struct is_convertible_to_basic_format_string
    : std::integral_constant<bool, std::is_convertible<T, std::basic_string_view<Char>>::value> {};

-#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+    #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
 using wstring_view_t = std::wstring_view;
 using wmemory_buf_t = std::wstring;

 template <typename... Args>
-#if __cpp_lib_format >= 202207L
+        #if __cpp_lib_format >= 202207L
 using wformat_string_t = std::wformat_string<Args...>;
-#else
+        #else
 using wformat_string_t = std::wstring_view;
-#endif
-#endif
-#define SPDLOG_BUF_TO_STRING(x) x
+        #endif
+    #endif
+    #define SPDLOG_BUF_TO_STRING(x) x
 #else  // use fmt lib instead of std::format
 namespace fmt_lib = fmt;

@@ -184,11 +184,11 @@ template <class T>
 using remove_cvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;

 template <typename Char>
-#if FMT_VERSION >= 90101
+    #if FMT_VERSION >= 90101
 using fmt_runtime_string = fmt::runtime_format_string<Char>;
-#else
+    #else
 using fmt_runtime_string = fmt::basic_runtime<Char>;
-#endif
+    #endif

 // clang doesn't like SFINAE disabled constructor in std::is_convertible<> so have to repeat the
 // condition from basic_format_string here, in addition, fmt::basic_runtime<Char> is only
@@ -200,21 +200,21 @@ struct is_convertible_to_basic_format_string
                                 std::is_same<remove_cvref_t<T>, fmt_runtime_string<Char>>::value> {
 };

-#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+    #if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
 using wstring_view_t = fmt::basic_string_view<wchar_t>;
 using wmemory_buf_t = fmt::basic_memory_buffer<wchar_t, 250>;

 template <typename... Args>
 using wformat_string_t = fmt::wformat_string<Args...>;
-#endif
-#define SPDLOG_BUF_TO_STRING(x) fmt::to_string(x)
+    #endif
+    #define SPDLOG_BUF_TO_STRING(x) fmt::to_string(x)
 #endif

 #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
-#ifndef _WIN32
-#error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows
-#endif  // _WIN32
-#endif  // SPDLOG_WCHAR_TO_UTF8_SUPPORT
+    #ifndef _WIN32
+        #error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows
+    #endif  // _WIN32
+#endif      // SPDLOG_WCHAR_TO_UTF8_SUPPORT

 template <class T>
 struct is_convertible_to_any_format_string
@@ -237,7 +237,7 @@ using level_t = std::atomic<int>;
 #define SPDLOG_LEVEL_OFF 6

 #if !defined(SPDLOG_ACTIVE_LEVEL)
-#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO
+    #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO
 #endif

 // Log level enum
@@ -262,18 +262,18 @@ enum level_enum : int {
 #define SPDLOG_LEVEL_NAME_OFF spdlog::string_view_t("off", 3)

 #if !defined(SPDLOG_LEVEL_NAMES)
-#define SPDLOG_LEVEL_NAMES                                                                  \
-    {                                                                                       \
-        SPDLOG_LEVEL_NAME_TRACE, SPDLOG_LEVEL_NAME_DEBUG, SPDLOG_LEVEL_NAME_INFO,           \
-            SPDLOG_LEVEL_NAME_WARNING, SPDLOG_LEVEL_NAME_ERROR, SPDLOG_LEVEL_NAME_CRITICAL, \
-            SPDLOG_LEVEL_NAME_OFF                                                           \
-    }
+    #define SPDLOG_LEVEL_NAMES                                                                  \
+        {                                                                                       \
+            SPDLOG_LEVEL_NAME_TRACE, SPDLOG_LEVEL_NAME_DEBUG, SPDLOG_LEVEL_NAME_INFO,           \
+                SPDLOG_LEVEL_NAME_WARNING, SPDLOG_LEVEL_NAME_ERROR, SPDLOG_LEVEL_NAME_CRITICAL, \
+                SPDLOG_LEVEL_NAME_OFF                                                           \
+        }
 #endif

 #if !defined(SPDLOG_SHORT_LEVEL_NAMES)

-#define SPDLOG_SHORT_LEVEL_NAMES \
-    { "T", "D", "I", "W", "E", "C", "O" }
+    #define SPDLOG_SHORT_LEVEL_NAMES \
+        { "T", "D", "I", "W", "E", "C", "O" }
 #endif

 SPDLOG_API const string_view_t &to_string_view(spdlog::level::level_enum l) SPDLOG_NOEXCEPT;
@@ -340,6 +340,38 @@ struct file_event_handlers {

 namespace details {

+// to_string_view
+
+SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(const memory_buf_t &buf)
+    SPDLOG_NOEXCEPT {
+    return spdlog::string_view_t{buf.data(), buf.size()};
+}
+
+SPDLOG_CONSTEXPR_FUNC spdlog::string_view_t to_string_view(spdlog::string_view_t str)
+    SPDLOG_NOEXCEPT {
+    return str;
+}
+
+#if defined(SPDLOG_WCHAR_FILENAMES) || defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(const wmemory_buf_t &buf)
+    SPDLOG_NOEXCEPT {
+    return spdlog::wstring_view_t{buf.data(), buf.size()};
+}
+
+SPDLOG_CONSTEXPR_FUNC spdlog::wstring_view_t to_string_view(spdlog::wstring_view_t str)
+    SPDLOG_NOEXCEPT {
+    return str;
+}
+#endif
+
+#if defined(SPDLOG_USE_STD_FORMAT) && __cpp_lib_format >= 202207L
+template <typename T, typename... Args>
+SPDLOG_CONSTEXPR_FUNC std::basic_string_view<T> to_string_view(
+    std::basic_format_string<T, Args...> fmt) SPDLOG_NOEXCEPT {
+    return fmt.get();
+}
+#endif
+
 // make_unique support for pre c++14
 #if __cplusplus >= 201402L  // C++14 and beyond
 using std::enable_if_t;
@@ -370,5 +402,5 @@ constexpr T conditional_static_cast(U value) {
 }  // namespace spdlog

 #ifdef SPDLOG_HEADER_ONLY
-#include "common-inl.h"
+    #include "common-inl.h"
 #endif
--- a/include/spdlog/details/backtracer-inl.h
+++ b/include/spdlog/details/backtracer-inl.h
@@ -4,7 +4,7 @@
 #pragma once

 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/details/backtracer.h>
+    #include <spdlog/details/backtracer.h>
 #endif
 namespace spdlog {
 namespace details {
--- a/include/spdlog/details/backtracer.h
+++ b/include/spdlog/details/backtracer.h
@@ -41,5 +41,5 @@ public:
 }  // namespace spdlog

 #ifdef SPDLOG_HEADER_ONLY
-#include "backtracer-inl.h"
+    #include "backtracer-inl.h"
 #endif
--- a/include/spdlog/details/file_helper-inl.h
+++ b/include/spdlog/details/file_helper-inl.h
@@ -4,7 +4,7 @@
 #pragma once

 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/details/file_helper.h>
+    #include <spdlog/details/file_helper.h>
 #endif

 #include <spdlog/common.h>
--- a/include/spdlog/details/file_helper.h
+++ b/include/spdlog/details/file_helper.h
@@ -57,5 +57,5 @@ private:
 }  // namespace spdlog

 #ifdef SPDLOG_HEADER_ONLY
-#include "file_helper-inl.h"
+    #include "file_helper-inl.h"
 #endif
--- a/include/spdlog/details/fmt_helper.h
+++ b/include/spdlog/details/fmt_helper.h
@@ -9,8 +9,8 @@
 #include <type_traits>

 #ifdef SPDLOG_USE_STD_FORMAT
-#include <charconv>
-#include <limits>
+    #include <charconv>
+    #include <limits>
 #endif

 // Some fmt helpers to efficiently format and pad ints and strings
@@ -70,13 +70,13 @@ inline unsigned int count_digits(T n) {
    return count_digits_fallback(static_cast<count_type>(n));
 #else
    return static_cast<unsigned int>(fmt::
-// fmt 7.0.0 renamed the internal namespace to detail.
-// See: https://github.com/fmtlib/fmt/issues/1538
-#if FMT_VERSION < 70000
+    // fmt 7.0.0 renamed the internal namespace to detail.
+    // See: https://github.com/fmtlib/fmt/issues/1538
+    #if FMT_VERSION < 70000
                                         internal
-#else
+    #else
                                         detail
-#endif
+    #endif
                                     ::count_digits(static_cast<count_type>(n)));
 #endif
 }
--- a/include/spdlog/details/log_msg-inl.h
+++ b/include/spdlog/details/log_msg-inl.h
@@ -4,7 +4,7 @@
 #pragma once

 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/details/log_msg.h>
+    #include <spdlog/details/log_msg.h>
 #endif

 #include <spdlog/details/os.h>
--- a/include/spdlog/details/log_msg.h
+++ b/include/spdlog/details/log_msg.h
@@ -36,5 +36,5 @@ struct SPDLOG_API log_msg {
 }  // namespace spdlog

 #ifdef SPDLOG_HEADER_ONLY
-#include "log_msg-inl.h"
+    #include "log_msg-inl.h"
 #endif
--- a/include/spdlog/details/log_msg_buffer-inl.h
+++ b/include/spdlog/details/log_msg_buffer-inl.h
@@ -4,7 +4,7 @@
 #pragma once

 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/details/log_msg_buffer.h>
+    #include <spdlog/details/log_msg_buffer.h>
 #endif

 namespace spdlog {
--- a/include/spdlog/details/log_msg_buffer.h
+++ b/include/spdlog/details/log_msg_buffer.h
@@ -28,5 +28,5 @@ public:
 }  // namespace spdlog

 #ifdef SPDLOG_HEADER_ONLY
-#include "log_msg_buffer-inl.h"
+    #include "log_msg_buffer-inl.h"
 #endif
--- a/include/spdlog/details/mpmc_blocking_q.h
+++ b/include/spdlog/details/mpmc_blocking_q.h
@@ -5,8 +5,8 @@

 // multi producer-multi consumer blocking queue.
 // enqueue(..) - will block until room found to put the new message.
-// enqueue_nowait(..) - enqueue immediately. overruns oldest message if no 
-// room left.
+// enqueue_nowait(..) - will return immediately with false if no room left in
+// the queue.
 // dequeue_for(..) - will block until the queue is not empty or timeout have
 // passed.

--- a/include/spdlog/details/null_mutex.h
+++ b/include/spdlog/details/null_mutex.h
@@ -15,7 +15,7 @@ struct null_mutex {
 };

 struct null_atomic_int {
-    int value{0};
+    int value;
    null_atomic_int() = default;

    explicit null_atomic_int(int new_value)
--- a/include/spdlog/details/os-inl.h
+++ b/include/spdlog/details/os-inl.h
@@ -4,7 +4,7 @@
 #pragma once

 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/details/os.h>
+    #include <spdlog/details/os.h>
 #endif

 #include <spdlog/common.h>
@@ -22,50 +22,50 @@
 #include <thread>

 #ifdef _WIN32
-#include <spdlog/details/windows_include.h>
-#include <io.h>       // for _get_osfhandle, _isatty, _fileno
-#include <process.h>  // for _get_pid
+    #include <spdlog/details/windows_include.h>
+    #include <io.h>       // for _get_osfhandle, _isatty, _fileno
+    #include <process.h>  // for _get_pid

-#ifdef __MINGW32__
-#include <share.h>
-#endif
+    #ifdef __MINGW32__
+        #include <share.h>
+    #endif

-#if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)
-#include <cassert>
-#include <limits>
-#endif
+    #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)
+        #include <cassert>
+        #include <limits>
+    #endif

-#include <direct.h>  // for _mkdir/_wmkdir
+    #include <direct.h>  // for _mkdir/_wmkdir

 #else  // unix

-#include <fcntl.h>
-#include <unistd.h>
+    #include <fcntl.h>
+    #include <unistd.h>

-#ifdef __linux__
-#include <sys/syscall.h>  //Use gettid() syscall under linux to get thread id
+    #ifdef __linux__
+        #include <sys/syscall.h>  //Use gettid() syscall under linux to get thread id

-#elif defined(_AIX)
-#include <pthread.h>  // for pthread_getthrds_np
+    #elif defined(_AIX)
+        #include <pthread.h>  // for pthread_getthrds_np

-#elif defined(__DragonFly__) || defined(__FreeBSD__)
-#include <pthread_np.h>  // for pthread_getthreadid_np
+    #elif defined(__DragonFly__) || defined(__FreeBSD__)
+        #include <pthread_np.h>  // for pthread_getthreadid_np

-#elif defined(__NetBSD__)
-#include <lwp.h>  // for _lwp_self
+    #elif defined(__NetBSD__)
+        #include <lwp.h>  // for _lwp_self

-#elif defined(__sun)
-#include <thread.h>  // for thr_self
-#endif
+    #elif defined(__sun)
+        #include <thread.h>  // for thr_self
+    #endif

 #endif  // unix

 #if defined __APPLE__
-#include <AvailabilityMacros.h>
+    #include <AvailabilityMacros.h>
 #endif

-#ifndef __has_feature       // Clang - feature checking macros.
-#define __has_feature(x) 0  // Compatibility with non-clang compilers.
+#ifndef __has_feature           // Clang - feature checking macros.
+    #define __has_feature(x) 0  // Compatibility with non-clang compilers.
 #endif

 namespace spdlog {
@@ -119,12 +119,12 @@ SPDLOG_INLINE std::tm gmtime() SPDLOG_NOEXCEPT {
 // fopen_s on non windows for writing
 SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode) {
 #ifdef _WIN32
-#ifdef SPDLOG_WCHAR_FILENAMES
+    #ifdef SPDLOG_WCHAR_FILENAMES
    *fp = ::_wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
-#else
+    #else
    *fp = ::_fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
-#endif
-#if defined(SPDLOG_PREVENT_CHILD_FD)
+    #endif
+    #if defined(SPDLOG_PREVENT_CHILD_FD)
    if (*fp != nullptr) {
        auto file_handle = reinterpret_cast<HANDLE>(_get_osfhandle(::_fileno(*fp)));
        if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0)) {
@@ -132,9 +132,9 @@ SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename
            *fp = nullptr;
        }
    }
-#endif
+    #endif
 #else  // unix
-#if defined(SPDLOG_PREVENT_CHILD_FD)
+    #if defined(SPDLOG_PREVENT_CHILD_FD)
    const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC;
    const int fd =
        ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644));
@@ -145,9 +145,9 @@ SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename
    if (*fp == nullptr) {
        ::close(fd);
    }
-#else
+    #else
    *fp = ::fopen((filename.c_str()), mode.c_str());
-#endif
+    #endif
 #endif

    return *fp == nullptr;
@@ -177,11 +177,11 @@ SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename
 SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT {
 #ifdef _WIN32
    struct _stat buffer;
-#ifdef SPDLOG_WCHAR_FILENAMES
+    #ifdef SPDLOG_WCHAR_FILENAMES
    return (::_wstat(filename.c_str(), &buffer) == 0);
-#else
+    #else
    return (::_stat(filename.c_str(), &buffer) == 0);
-#endif
+    #endif
 #else  // common linux/unix all have the stat system call
    struct stat buffer;
    return (::stat(filename.c_str(), &buffer) == 0);
@@ -189,9 +189,9 @@ SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT {
 }

 #ifdef _MSC_VER
-// avoid warning about unreachable statement at the end of filesize()
-#pragma warning(push)
-#pragma warning(disable : 4702)
+    // avoid warning about unreachable statement at the end of filesize()
+    #pragma warning(push)
+    #pragma warning(disable : 4702)
 #endif

 // Return file size according to open FILE* object
@@ -201,71 +201,73 @@ SPDLOG_INLINE size_t filesize(FILE *f) {
    }
 #if defined(_WIN32) && !defined(__CYGWIN__)
    int fd = ::_fileno(f);
-#if defined(_WIN64)  // 64 bits
+    #if defined(_WIN64)  // 64 bits
    __int64 ret = ::_filelengthi64(fd);
    if (ret >= 0) {
        return static_cast<size_t>(ret);
    }

-#else  // windows 32 bits
+    #else  // windows 32 bits
    long ret = ::_filelength(fd);
    if (ret >= 0) {
        return static_cast<size_t>(ret);
    }
-#endif
+    #endif

 #else  // unix
-// OpenBSD and AIX doesn't compile with :: before the fileno(..)
-#if defined(__OpenBSD__) || defined(_AIX)
+    // OpenBSD and AIX doesn't compile with :: before the fileno(..)
+    #if defined(__OpenBSD__) || defined(_AIX)
    int fd = fileno(f);
-#else
+    #else
    int fd = ::fileno(f);
-#endif
-// 64 bits(but not in osx, linux/musl or cygwin, where fstat64 is deprecated)
-#if ((defined(__linux__) && defined(__GLIBC__)) || defined(__sun) || defined(_AIX)) && \
-    (defined(__LP64__) || defined(_LP64))
+    #endif
+    // 64 bits(but not in osx, linux/musl or cygwin, where fstat64 is deprecated)
+    #if ((defined(__linux__) && defined(__GLIBC__)) || defined(__sun) || defined(_AIX)) && \
+        (defined(__LP64__) || defined(_LP64))
    struct stat64 st;
    if (::fstat64(fd, &st) == 0) {
        return static_cast<size_t>(st.st_size);
    }
-#else  // other unix or linux 32 bits or cygwin
+    #else  // other unix or linux 32 bits or cygwin
    struct stat st;
    if (::fstat(fd, &st) == 0) {
        return static_cast<size_t>(st.st_size);
    }
-#endif
+    #endif
 #endif
    throw_spdlog_ex("Failed getting file size from fd", errno);
    return 0;  // will not be reached.
 }

 #ifdef _MSC_VER
-#pragma warning(pop)
+    #pragma warning(pop)
 #endif

+// Return utc offset in minutes or throw spdlog_ex on failure
 #if !defined(SPDLOG_NO_TZ_OFFSET)
-#ifdef _WIN32
-// Compare the timestamp as Local (mktime) vs UTC (_mkgmtime) to get the offset.
 SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) {
-    std::tm local_tm = tm;  // copy since mktime might adjust it (normalize dates, set tm_isdst)
-    std::time_t local_time_t = std::mktime(&local_tm);
-    if (local_time_t == -1) {
-        return 0; // fallback
-    }
+    #ifdef _WIN32
+        #if _WIN32_WINNT < _WIN32_WINNT_WS08
+    TIME_ZONE_INFORMATION tzinfo;
+    auto rv = ::GetTimeZoneInformation(&tzinfo);
+        #else
+    DYNAMIC_TIME_ZONE_INFORMATION tzinfo;
+    auto rv = ::GetDynamicTimeZoneInformation(&tzinfo);
+        #endif
+    if (rv == TIME_ZONE_ID_INVALID) throw_spdlog_ex("Failed getting timezone info. ", errno);

-    std::time_t utc_time_t = _mkgmtime(&local_tm);
-    if (utc_time_t == -1) {
-        return 0; // fallback
+    int offset = -tzinfo.Bias;
+    if (tm.tm_isdst) {
+        offset -= tzinfo.DaylightBias;
+    } else {
+        offset -= tzinfo.StandardBias;
    }
-    auto offset_seconds = utc_time_t - local_time_t;
+    return offset;
+    #else
+    auto offset_seconds = tm.tm_gmtoff;
    return static_cast<int>(offset_seconds / 60);
+    #endif
 }
-#else
-// On unix simply use tm_gmtoff
-SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) {
-    return static_cast<int>(tm.tm_gmtoff / 60);
-}
-#endif  // _WIN32
 #endif  // SPDLOG_NO_TZ_OFFSET

 // Return current thread id as size_t
@@ -275,9 +277,9 @@ SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT {
 #ifdef _WIN32
    return static_cast<size_t>(::GetCurrentThreadId());
 #elif defined(__linux__)
-#if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
-#define SYS_gettid __NR_gettid
-#endif
+    #if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
+        #define SYS_gettid __NR_gettid
+    #endif
    return static_cast<size_t>(::syscall(SYS_gettid));
 #elif defined(_AIX)
    struct __pthrdsinfo buf;
@@ -296,25 +298,25 @@ SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT {
    return static_cast<size_t>(::thr_self());
 #elif __APPLE__
    uint64_t tid;
-// There is no pthread_threadid_np prior to Mac OS X 10.6, and it is not supported on any PPC,
-// including 10.6.8 Rosetta. __POWERPC__ is Apple-specific define encompassing ppc and ppc64.
-#ifdef MAC_OS_X_VERSION_MAX_ALLOWED
+    // There is no pthread_threadid_np prior to Mac OS X 10.6, and it is not supported on any PPC,
+    // including 10.6.8 Rosetta. __POWERPC__ is Apple-specific define encompassing ppc and ppc64.
+    #ifdef MAC_OS_X_VERSION_MAX_ALLOWED
    {
-#if (MAC_OS_X_VERSION_MAX_ALLOWED < 1060) || defined(__POWERPC__)
+        #if (MAC_OS_X_VERSION_MAX_ALLOWED < 1060) || defined(__POWERPC__)
        tid = pthread_mach_thread_np(pthread_self());
-#elif MAC_OS_X_VERSION_MIN_REQUIRED < 1060
+        #elif MAC_OS_X_VERSION_MIN_REQUIRED < 1060
        if (&pthread_threadid_np) {
            pthread_threadid_np(nullptr, &tid);
        } else {
            tid = pthread_mach_thread_np(pthread_self());
        }
-#else
+        #else
        pthread_threadid_np(nullptr, &tid);
-#endif
+        #endif
    }
-#else
+    #else
    pthread_threadid_np(nullptr, &tid);
-#endif
+    #endif
    return static_cast<size_t>(tid);
 #else  // Default to standard C++11 (other Unix)
    return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
@@ -467,11 +469,11 @@ SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target) {
 // return true on success
 static SPDLOG_INLINE bool mkdir_(const filename_t &path) {
 #ifdef _WIN32
-#ifdef SPDLOG_WCHAR_FILENAMES
+    #ifdef SPDLOG_WCHAR_FILENAMES
    return ::_wmkdir(path.c_str()) == 0;
-#else
+    #else
    return ::_mkdir(path.c_str()) == 0;
-#endif
+    #endif
 #else
    return ::mkdir(path.c_str(), mode_t(0755)) == 0;
 #endif
@@ -527,12 +529,11 @@ SPDLOG_INLINE filename_t dir_name(const filename_t &path) {
 }

 #ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4996)
+    #pragma warning(push)
+    #pragma warning(disable : 4996)
 #endif  // _MSC_VER
 std::string SPDLOG_INLINE getenv(const char *field) {
-#if defined(_MSC_VER) && defined(WINAPI_FAMILY) && defined(WINAPI_FAMILY_DESKTOP_APP) && \
-    (WINAPI_FAMILY != WINAPI_FAMILY_DESKTOP_APP)
+#if defined(_MSC_VER) && defined(__cplusplus_winrt)
    return std::string{};  // not supported under uwp
 #else
    char *buf = std::getenv(field);
@@ -540,7 +541,7 @@ std::string SPDLOG_INLINE getenv(const char *field) {
 #endif
 }
 #ifdef _MSC_VER
-#pragma warning(pop)
+    #pragma warning(pop)
 #endif  // _MSC_VER

 // Do fsync by FILE handlerpointer
--- a/include/spdlog/details/os.h
+++ b/include/spdlog/details/os.h
@@ -22,22 +22,22 @@ SPDLOG_API std::tm gmtime() SPDLOG_NOEXCEPT;

 // eol definition
 #if !defined(SPDLOG_EOL)
-#ifdef _WIN32
-#define SPDLOG_EOL "\r\n"
-#else
-#define SPDLOG_EOL "\n"
-#endif
+    #ifdef _WIN32
+        #define SPDLOG_EOL "\r\n"
+    #else
+        #define SPDLOG_EOL "\n"
+    #endif
 #endif

 SPDLOG_CONSTEXPR static const char *default_eol = SPDLOG_EOL;

 // folder separator
 #if !defined(SPDLOG_FOLDER_SEPS)
-#ifdef _WIN32
-#define SPDLOG_FOLDER_SEPS "\\/"
-#else
-#define SPDLOG_FOLDER_SEPS "/"
-#endif
+    #ifdef _WIN32
+        #define SPDLOG_FOLDER_SEPS "\\/"
+    #else
+        #define SPDLOG_FOLDER_SEPS "/"
+    #endif
 #endif

 SPDLOG_CONSTEXPR static const char folder_seps[] = SPDLOG_FOLDER_SEPS;
@@ -123,5 +123,5 @@ SPDLOG_API bool fwrite_bytes(const void *ptr, const size_t n_bytes, FILE *fp);
 }  // namespace spdlog

 #ifdef SPDLOG_HEADER_ONLY
-#include "os-inl.h"
+    #include "os-inl.h"
 #endif
--- a/include/spdlog/details/periodic_worker-inl.h
+++ b/include/spdlog/details/periodic_worker-inl.h
@@ -4,7 +4,7 @@
 #pragma once

 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/details/periodic_worker.h>
+    #include <spdlog/details/periodic_worker.h>
 #endif

 namespace spdlog {
--- a/include/spdlog/details/periodic_worker.h
+++ b/include/spdlog/details/periodic_worker.h
@@ -54,5 +54,5 @@ private:
 }  // namespace spdlog

 #ifdef SPDLOG_HEADER_ONLY
-#include "periodic_worker-inl.h"
+    #include "periodic_worker-inl.h"
 #endif
--- a/include/spdlog/details/registry-inl.h
+++ b/include/spdlog/details/registry-inl.h
@@ -4,7 +4,7 @@
 #pragma once

 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/details/registry.h>
+    #include <spdlog/details/registry.h>
 #endif

 #include <spdlog/common.h>
@@ -13,12 +13,12 @@
 #include <spdlog/pattern_formatter.h>

 #ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
-// support for the default stdout color logger
-#ifdef _WIN32
-#include <spdlog/sinks/wincolor_sink.h>
-#else
-#include <spdlog/sinks/ansicolor_sink.h>
-#endif
+    // support for the default stdout color logger
+    #ifdef _WIN32
+        #include <spdlog/sinks/wincolor_sink.h>
+    #else
+        #include <spdlog/sinks/ansicolor_sink.h>
+    #endif
 #endif  // SPDLOG_DISABLE_DEFAULT_LOGGER

 #include <chrono>
@@ -33,12 +33,12 @@ namespace details {
 SPDLOG_INLINE registry::registry()
    : formatter_(new pattern_formatter()) {
 #ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
-// create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows).
-#ifdef _WIN32
+    // create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows).
+    #ifdef _WIN32
    auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>();
-#else
+    #else
    auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>();
-#endif
+    #endif

    const char *default_logger_name = "";
    default_logger_ = std::make_shared<spdlog::logger>(default_logger_name, std::move(color_sink));
@@ -257,7 +257,7 @@ SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name) {
 }

 SPDLOG_INLINE void registry::register_logger_(std::shared_ptr<logger> new_logger) {
-    const auto &logger_name = new_logger->name();
+    auto &logger_name = new_logger->name();
    throw_if_exists_(logger_name);
    loggers_[logger_name] = std::move(new_logger);
 }
--- a/include/spdlog/details/registry.h
+++ b/include/spdlog/details/registry.h
@@ -127,5 +127,5 @@ private:
 }  // namespace spdlog

 #ifdef SPDLOG_HEADER_ONLY
-#include "registry-inl.h"
+    #include "registry-inl.h"
 #endif
--- a/include/spdlog/details/tcp_client.h
+++ b/include/spdlog/details/tcp_client.h
@@ -4,7 +4,7 @@
 #pragma once

 #ifdef _WIN32
-#error include tcp_client-windows.h instead
+    #error include tcp_client-windows.h instead
 #endif

 // tcp client helper
@@ -17,7 +17,6 @@
 #include <netinet/tcp.h>
 #include <sys/socket.h>
 #include <unistd.h>
-#include <fcntl.h>

 #include <string>

@@ -170,7 +169,7 @@ public:
 #endif

 #if !defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL)
-#error "tcp_sink would raise SIGPIPE since neither SO_NOSIGPIPE nor MSG_NOSIGNAL are available"
+    #error "tcp_sink would raise SIGPIPE since neither SO_NOSIGPIPE nor MSG_NOSIGNAL are available"
 #endif
    }

--- a/include/spdlog/details/thread_pool-inl.h
+++ b/include/spdlog/details/thread_pool-inl.h
@@ -4,7 +4,7 @@
 #pragma once

 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/details/thread_pool.h>
+    #include <spdlog/details/thread_pool.h>
 #endif

 #include <cassert>
--- a/include/spdlog/details/thread_pool.h
+++ b/include/spdlog/details/thread_pool.h
@@ -113,5 +113,5 @@ private:
 }  // namespace spdlog

 #ifdef SPDLOG_HEADER_ONLY
-#include "thread_pool-inl.h"
+    #include "thread_pool-inl.h"
 #endif
--- a/include/spdlog/details/udp_client-windows.h
+++ b/include/spdlog/details/udp_client-windows.h
@@ -16,9 +16,9 @@
 #include <ws2tcpip.h>

 #if defined(_MSC_VER)
-#pragma comment(lib, "Ws2_32.lib")
-#pragma comment(lib, "Mswsock.lib")
-#pragma comment(lib, "AdvApi32.lib")
+    #pragma comment(lib, "Ws2_32.lib")
+    #pragma comment(lib, "Mswsock.lib")
+    #pragma comment(lib, "AdvApi32.lib")
 #endif

 namespace spdlog {
--- a/include/spdlog/details/udp_client.h
+++ b/include/spdlog/details/udp_client.h
@@ -7,7 +7,7 @@
 // Will throw on construction if the socket creation failed.

 #ifdef _WIN32
-#error "include udp_client-windows.h instead"
+    #error "include udp_client-windows.h instead"
 #endif

 #include <arpa/inet.h>
@@ -69,9 +69,10 @@ public:
    // Send exactly n_bytes of the given data.
    // On error close the connection and throw.
    void send(const char *data, size_t n_bytes) {
-        socklen_t tolen = sizeof(sockAddr_);
-        if (::sendto(socket_, data, n_bytes, 0, reinterpret_cast<const sockaddr *>(&sockAddr_),
-                     tolen) == -1) {
+        ssize_t toslen = 0;
+        socklen_t tolen = sizeof(struct sockaddr);
+        if ((toslen = ::sendto(socket_, data, n_bytes, 0, (struct sockaddr *)&sockAddr_, tolen)) ==
+            -1) {
            throw_spdlog_ex("sendto(2) failed", errno);
        }
    }
--- a/include/spdlog/details/windows_include.h
+++ b/include/spdlog/details/windows_include.h
@@ -1,11 +1,11 @@
 #pragma once

 #ifndef NOMINMAX
-#define NOMINMAX  // prevent windows redefining min/max
+    #define NOMINMAX  // prevent windows redefining min/max
 #endif

 #ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
+    #define WIN32_LEAN_AND_MEAN
 #endif

 #include <windows.h>
--- a/include/spdlog/fmt/bin_to_hex.h
+++ b/include/spdlog/fmt/bin_to_hex.h
@@ -9,13 +9,13 @@
 #include <spdlog/common.h>

 #if defined(__has_include)
-#if __has_include(<version>)
-#include <version>
-#endif
+    #if __has_include(<version>)
+        #include <version>
+    #endif
 #endif

 #if __cpp_lib_span >= 202002L
-#include <span>
+    #include <span>
 #endif

 //
--- a/include/spdlog/fmt/bundled/base.h
+++ b/include/spdlog/fmt/bundled/base.h
@@ -21,7 +21,7 @@
 #endif

 // The fmt library version in the form major * 10000 + minor * 100 + patch.
-#define FMT_VERSION 120100
+#define FMT_VERSION 120000

 // Detect compiler versions.
 #if defined(__clang__) && !defined(__ibmxl__)
@@ -114,9 +114,7 @@
 #endif

 // Detect consteval, C++20 constexpr extensions and std::is_constant_evaluated.
-#ifdef FMT_USE_CONSTEVAL
-// Use the provided definition.
-#elif !defined(__cpp_lib_is_constant_evaluated)
+#if !defined(__cpp_lib_is_constant_evaluated)
 #  define FMT_USE_CONSTEVAL 0
 #elif FMT_CPLUSPLUS < 201709L
 #  define FMT_USE_CONSTEVAL 0
@@ -236,7 +234,6 @@ FMT_PRAGMA_GCC(optimize("Og"))
 #  define FMT_GCC_OPTIMIZED
 #endif
 FMT_PRAGMA_CLANG(diagnostic push)
-FMT_PRAGMA_GCC(diagnostic push)

 #ifdef FMT_ALWAYS_INLINE
 // Use the provided definition.
@@ -417,12 +414,8 @@ inline auto map(int128_opt) -> monostate { return {}; }
 inline auto map(uint128_opt) -> monostate { return {}; }
 #endif

-#ifdef FMT_USE_BITINT
-// Use the provided definition.
-#elif FMT_CLANG_VERSION >= 1500 && !defined(__CUDACC__)
-#  define FMT_USE_BITINT 1
-#else
-#  define FMT_USE_BITINT 0
+#ifndef FMT_USE_BITINT
+#  define FMT_USE_BITINT (FMT_CLANG_VERSION >= 1500)
 #endif

 #if FMT_USE_BITINT
@@ -925,10 +918,7 @@ class locale_ref {
  constexpr locale_ref() : locale_(nullptr) {}

  template <typename Locale, FMT_ENABLE_IF(sizeof(Locale::collate) != 0)>
-  locale_ref(const Locale& loc) : locale_(&loc) {
-    // Check if std::isalpha is found via ADL to reduce the chance of misuse.
-    detail::ignore_unused(isalpha('x', loc));
-  }
+  locale_ref(const Locale& loc);

  inline explicit operator bool() const noexcept { return locale_ != nullptr; }
 #endif  // FMT_USE_LOCALE
@@ -1854,17 +1844,12 @@ template <typename T> class buffer {
      void
      append(const U* begin, const U* end) {
    while (begin != end) {
-      auto size = size_;
-      auto free_cap = capacity_ - size;
      auto count = to_unsigned(end - begin);
-      if (free_cap < count) {
-        grow_(*this, size + count);
-        size = size_;
-        free_cap = capacity_ - size;
-        count = count < free_cap ? count : free_cap;
-      }
+      try_reserve(size_ + count);
+      auto free_cap = capacity_ - size_;
+      if (free_cap < count) count = free_cap;
      // A loop is faster than memcpy on small sizes.
-      T* out = ptr_ + size;
+      T* out = ptr_ + size_;
      for (size_t i = 0; i < count; ++i) out[i] = begin[i];
      size_ += count;
      begin += count;
@@ -2998,7 +2983,6 @@ FMT_INLINE void println(format_string<T...> fmt, T&&... args) {
  return fmt::println(stdout, fmt, static_cast<T&&>(args)...);
 }

-FMT_PRAGMA_GCC(diagnostic pop)
 FMT_PRAGMA_CLANG(diagnostic pop)
 FMT_PRAGMA_GCC(pop_options)
 FMT_END_EXPORT
--- a/include/spdlog/fmt/bundled/chrono.h
+++ b/include/spdlog/fmt/bundled/chrono.h
@@ -1594,13 +1594,8 @@ class get_locale {

 public:
  inline get_locale(bool localized, locale_ref loc) : has_locale_(localized) {
-    if (!localized) return;
-    ignore_unused(loc);
-    ::new (&locale_) std::locale(
-#if FMT_USE_LOCALE
-        loc.template get<std::locale>()
-#endif
-    );
+    if (localized)
+      ::new (&locale_) std::locale(loc.template get<std::locale>());
  }
  inline ~get_locale() {
    if (has_locale_) locale_.~locale();
--- a/include/spdlog/fmt/bundled/color.h
+++ b/include/spdlog/fmt/bundled/color.h
@@ -429,7 +429,7 @@ template <typename Char> struct ansi_color_escape {

 private:
  static constexpr size_t num_emphases = 8;
-  Char buffer[7u + 4u * num_emphases] = {};
+  Char buffer[7u + 4u * num_emphases];
  size_t size = 0;

  static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out,
--- a/include/spdlog/fmt/bundled/compile.h
+++ b/include/spdlog/fmt/bundled/compile.h
@@ -15,10 +15,9 @@
 #include "format.h"

 FMT_BEGIN_NAMESPACE
-FMT_BEGIN_EXPORT

 // A compile-time string which is compiled into fast formatting code.
-class compiled_string {};
+FMT_EXPORT class compiled_string {};

 template <typename S>
 struct is_compiled_string : std::is_base_of<compiled_string, S> {};
@@ -60,8 +59,6 @@ template <detail::fixed_string Str> constexpr auto operator""_cf() {
 }  // namespace literals
 #endif

-FMT_END_EXPORT
-
 namespace detail {

 template <typename T, typename... Tail>
--- a/include/spdlog/fmt/bundled/format-inl.h
+++ b/include/spdlog/fmt/bundled/format-inl.h
@@ -36,7 +36,7 @@ FMT_BEGIN_NAMESPACE
 FMT_FUNC void assert_fail(const char* file, int line, const char* message) {
  // Use unchecked std::fprintf to avoid triggering another assertion when
  // writing to stderr fails.
-  std::fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message);
+  fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message);
  abort();
 }
 #endif
@@ -47,6 +47,11 @@ using std::locale;
 using std::numpunct;
 using std::use_facet;
 }  // namespace detail
+
+template <typename Locale, enable_if_t<(sizeof(Locale::collate) != 0), int>>
+locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
+  static_assert(std::is_same<Locale, std::locale>::value, "");
+}
 #else
 namespace detail {
 struct locale {};
--- a/include/spdlog/fmt/bundled/format.h
+++ b/include/spdlog/fmt/bundled/format.h
@@ -40,18 +40,11 @@

 #include "base.h"

-// libc++ supports string_view in pre-c++17.
-#if FMT_HAS_INCLUDE(<string_view>) && \
-    (FMT_CPLUSPLUS >= 201703L || defined(_LIBCPP_VERSION))
-#  define FMT_USE_STRING_VIEW
-#endif
-
 #ifndef FMT_MODULE
-#  include <stdlib.h>  // malloc, free
-
 #  include <cmath>    // std::signbit
 #  include <cstddef>  // std::byte
 #  include <cstdint>  // uint32_t
+#  include <cstdlib>  // std::malloc, std::free
 #  include <cstring>  // std::memcpy
 #  include <limits>   // std::numeric_limits
 #  include <new>      // std::bad_alloc
@@ -68,8 +61,11 @@
 #    include <bit>  // std::bit_cast
 #  endif

-#  if defined(FMT_USE_STRING_VIEW)
+// libc++ supports string_view in pre-c++17.
+#  if FMT_HAS_INCLUDE(<string_view>) && \
+      (FMT_CPLUSPLUS >= 201703L || defined(_LIBCPP_VERSION))
 #    include <string_view>
+#    define FMT_USE_STRING_VIEW
 #  endif

 #  if FMT_MSC_VERSION
@@ -748,12 +744,12 @@ template <typename T> struct allocator : private std::decay<void> {

  auto allocate(size_t n) -> T* {
    FMT_ASSERT(n <= max_value<size_t>() / sizeof(T), "");
-    T* p = static_cast<T*>(malloc(n * sizeof(T)));
+    T* p = static_cast<T*>(std::malloc(n * sizeof(T)));
    if (!p) FMT_THROW(std::bad_alloc());
    return p;
  }

-  void deallocate(T* p, size_t) { free(p); }
+  void deallocate(T* p, size_t) { std::free(p); }

  constexpr friend auto operator==(allocator, allocator) noexcept -> bool {
    return true;  // All instances of this allocator are equivalent.
@@ -763,14 +759,6 @@ template <typename T> struct allocator : private std::decay<void> {
  }
 };

-template <typename Formatter>
-FMT_CONSTEXPR auto maybe_set_debug_format(Formatter& f, bool set)
-    -> decltype(f.set_debug_format(set)) {
-  f.set_debug_format(set);
-}
-template <typename Formatter>
-FMT_CONSTEXPR void maybe_set_debug_format(Formatter&, ...) {}
-
 }  // namespace detail

 FMT_BEGIN_EXPORT
@@ -2518,7 +2506,7 @@ FMT_CONSTEXPR20 auto write_fixed(OutputIt out, const DecimalFP& f,
    auto grouping = Grouping(loc, specs.localized());
    size += grouping.count_separators(exp);
    return write_padded<Char, align::right>(
-        out, specs, static_cast<size_t>(size), [&](iterator it) {
+        out, specs, to_unsigned(size), [&](iterator it) {
          if (s != sign::none) *it++ = detail::getsign<Char>(s);
          it = write_significand<Char>(it, f.significand, significand_size,
                                       f.exponent, grouping);
--- a/include/spdlog/fmt/bundled/os.h
+++ b/include/spdlog/fmt/bundled/os.h
@@ -136,9 +136,10 @@ FMT_API std::system_error vwindows_error(int error_code, string_view fmt,
 * **Example**:
 *
 *     // This throws a system_error with the description
- *     //   cannot open file 'foo': The system cannot find the file specified.
- *     // or similar (system message may vary) if the file doesn't exist.
- *     const char *filename = "foo";
+ *     //   cannot open file 'madeup': The system cannot find the file
+ * specified.
+ *     // or similar (system message may vary).
+ *     const char *filename = "madeup";
 *     LPOFSTRUCT of = LPOFSTRUCT();
 *     HFILE file = OpenFile(filename, &of, OF_READ);
 *     if (file == HFILE_ERROR) {
@@ -364,17 +365,17 @@ FMT_INLINE_VARIABLE constexpr auto buffer_size = detail::buffer_size();

 /// A fast buffered output stream for writing from a single thread. Writing from
 /// multiple threads without external synchronization may result in a data race.
-class ostream : private detail::buffer<char> {
+class FMT_API ostream : private detail::buffer<char> {
 private:
  file file_;

-  FMT_API ostream(cstring_view path, const detail::ostream_params& params);
+  ostream(cstring_view path, const detail::ostream_params& params);

-  FMT_API static void grow(buffer<char>& buf, size_t);
+  static void grow(buffer<char>& buf, size_t);

 public:
-  FMT_API ostream(ostream&& other) noexcept;
-  FMT_API ~ostream();
+  ostream(ostream&& other) noexcept;
+  ~ostream();

  operator writer() {
    detail::buffer<char>& buf = *this;
--- a/include/spdlog/fmt/bundled/ranges.h
+++ b/include/spdlog/fmt/bundled/ranges.h
@@ -18,13 +18,6 @@

 #include "format.h"

-#if FMT_HAS_CPP_ATTRIBUTE(clang::lifetimebound)
-#  define FMT_LIFETIMEBOUND [[clang::lifetimebound]]
-#else
-#  define FMT_LIFETIMEBOUND
-#endif
-FMT_PRAGMA_CLANG(diagnostic error "-Wreturn-stack-address")
-
 FMT_BEGIN_NAMESPACE

 FMT_EXPORT
@@ -241,6 +234,14 @@ using range_reference_type =
 template <typename Range>
 using uncvref_type = remove_cvref_t<range_reference_type<Range>>;

+template <typename Formatter>
+FMT_CONSTEXPR auto maybe_set_debug_format(Formatter& f, bool set)
+    -> decltype(f.set_debug_format(set)) {
+  f.set_debug_format(set);
+}
+template <typename Formatter>
+FMT_CONSTEXPR void maybe_set_debug_format(Formatter&, ...) {}
+
 template <typename T>
 struct range_format_kind_
    : std::integral_constant<range_format,
@@ -820,12 +821,12 @@ auto join(Range&& r, string_view sep)
 *
 * **Example**:
 *
- *     auto t = std::tuple<int, char>(1, 'a');
+ *     auto t = std::tuple<int, char>{1, 'a'};
 *     fmt::print("{}", fmt::join(t, ", "));
 *     // Output: 1, a
 */
 template <typename Tuple, FMT_ENABLE_IF(is_tuple_like<Tuple>::value)>
-FMT_CONSTEXPR auto join(const Tuple& tuple FMT_LIFETIMEBOUND, string_view sep)
+FMT_CONSTEXPR auto join(const Tuple& tuple, string_view sep)
    -> tuple_join_view<Tuple, char> {
  return {tuple, sep};
 }
--- a/include/spdlog/fmt/bundled/std.h
+++ b/include/spdlog/fmt/bundled/std.h
@@ -111,17 +111,12 @@ void write_escaped_path(basic_memory_buffer<Char>& quoted,
 #endif  // FMT_CPP_LIB_FILESYSTEM

 #if defined(__cpp_lib_expected) || FMT_CPP_LIB_VARIANT
-
-template <typename Char, typename OutputIt, typename T, typename FormatContext>
-auto write_escaped_alternative(OutputIt out, const T& v, FormatContext& ctx)
-    -> OutputIt {
+template <typename Char, typename OutputIt, typename T>
+auto write_escaped_alternative(OutputIt out, const T& v) -> OutputIt {
  if constexpr (has_to_string_view<T>::value)
    return write_escaped_string<Char>(out, detail::to_string_view(v));
  if constexpr (std::is_same_v<T, Char>) return write_escaped_char(out, v);
-
-  formatter<std::remove_cv_t<T>, Char> underlying;
-  maybe_set_debug_format(underlying, true);
-  return underlying.format(v, ctx);
+  return write<Char>(out, v);
 }
 #endif

@@ -144,39 +139,50 @@ template <typename Variant, typename Char> class is_variant_formattable {
 #endif  // FMT_CPP_LIB_VARIANT

 #if FMT_USE_RTTI
-inline auto normalize_libcxx_inline_namespaces(string_view demangled_name_view,
-                                               char* begin) -> string_view {
-  // Normalization of stdlib inline namespace names.
-  // libc++ inline namespaces.
-  //  std::__1::*       -> std::*
-  //  std::__1::__fs::* -> std::*
-  // libstdc++ inline namespaces.
-  //  std::__cxx11::*             -> std::*
-  //  std::filesystem::__cxx11::* -> std::filesystem::*
-  if (demangled_name_view.starts_with("std::")) {
-    char* to = begin + 5;  // std::
-    for (const char *from = to, *end = begin + demangled_name_view.size();
-         from < end;) {
-      // This is safe, because demangled_name is NUL-terminated.
-      if (from[0] == '_' && from[1] == '_') {
-        const char* next = from + 1;
-        while (next < end && *next != ':') next++;
-        if (next[0] == ':' && next[1] == ':') {
-          from = next + 2;
-          continue;
-        }
-      }
-      *to++ = *from++;
-    }
-    demangled_name_view = {begin, detail::to_unsigned(to - begin)};
-  }
-  return demangled_name_view;
-}

-template <class OutputIt>
-auto normalize_msvc_abi_name(string_view abi_name_view, OutputIt out)
-    -> OutputIt {
-  const string_view demangled_name(abi_name_view);
+template <typename OutputIt>
+auto write_demangled_name(OutputIt out, const std::type_info& ti) -> OutputIt {
+#  ifdef FMT_HAS_ABI_CXA_DEMANGLE
+  int status = 0;
+  size_t size = 0;
+  std::unique_ptr<char, void (*)(void*)> demangled_name_ptr(
+      abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free);
+
+  string_view demangled_name_view;
+  if (demangled_name_ptr) {
+    demangled_name_view = demangled_name_ptr.get();
+
+    // Normalization of stdlib inline namespace names.
+    // libc++ inline namespaces.
+    //  std::__1::*       -> std::*
+    //  std::__1::__fs::* -> std::*
+    // libstdc++ inline namespaces.
+    //  std::__cxx11::*             -> std::*
+    //  std::filesystem::__cxx11::* -> std::filesystem::*
+    if (demangled_name_view.starts_with("std::")) {
+      char* begin = demangled_name_ptr.get();
+      char* to = begin + 5;  // std::
+      for (char *from = to, *end = begin + demangled_name_view.size();
+           from < end;) {
+        // This is safe, because demangled_name is NUL-terminated.
+        if (from[0] == '_' && from[1] == '_') {
+          char* next = from + 1;
+          while (next < end && *next != ':') next++;
+          if (next[0] == ':' && next[1] == ':') {
+            from = next + 2;
+            continue;
+          }
+        }
+        *to++ = *from++;
+      }
+      demangled_name_view = {begin, detail::to_unsigned(to - begin)};
+    }
+  } else {
+    demangled_name_view = string_view(ti.name());
+  }
+  return detail::write_bytes<char>(out, demangled_name_view);
+#  elif FMT_MSC_VERSION
+  const string_view demangled_name(ti.name());
  for (size_t i = 0; i < demangled_name.size(); ++i) {
    auto sub = demangled_name;
    sub.remove_prefix(i);
@@ -195,39 +201,6 @@ auto normalize_msvc_abi_name(string_view abi_name_view, OutputIt out)
    if (*sub.begin() != ' ') *out++ = *sub.begin();
  }
  return out;
-}
-
-template <typename OutputIt>
-auto write_demangled_name(OutputIt out, const std::type_info& ti) -> OutputIt {
-#  ifdef FMT_HAS_ABI_CXA_DEMANGLE
-  int status = 0;
-  size_t size = 0;
-  std::unique_ptr<char, void (*)(void*)> demangled_name_ptr(
-      abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &free);
-
-  string_view demangled_name_view;
-  if (demangled_name_ptr) {
-    demangled_name_view = normalize_libcxx_inline_namespaces(
-        demangled_name_ptr.get(), demangled_name_ptr.get());
-  } else {
-    demangled_name_view = string_view(ti.name());
-  }
-  return detail::write_bytes<char>(out, demangled_name_view);
-#  elif FMT_MSC_VERSION && defined(_MSVC_STL_UPDATE)
-  return normalize_msvc_abi_name(ti.name(), out);
-#  elif FMT_MSC_VERSION && defined(_LIBCPP_VERSION)
-  const string_view demangled_name = ti.name();
-  std::string name_copy(demangled_name.size(), '\0');
-  // normalize_msvc_abi_name removes class, struct, union etc that MSVC has in
-  // front of types
-  name_copy.erase(normalize_msvc_abi_name(demangled_name, name_copy.begin()),
-                  name_copy.end());
-  // normalize_libcxx_inline_namespaces removes the inline __1, __2, etc
-  // namespaces libc++ uses for ABI versioning On MSVC ABI + libc++
-  // environments, we need to eliminate both of them.
-  const string_view normalized_name =
-      normalize_libcxx_inline_namespaces(name_copy, name_copy.data());
-  return detail::write_bytes<char>(out, normalized_name);
 #  else
  return detail::write_bytes<char>(out, string_view(ti.name()));
 #  endif
@@ -282,6 +255,21 @@ template <typename T> auto ptr(const std::shared_ptr<T>& p) -> const void* {

 #if FMT_CPP_LIB_FILESYSTEM

+class path : public std::filesystem::path {
+ public:
+  auto display_string() const -> std::string {
+    const std::filesystem::path& base = *this;
+    return fmt::format(FMT_STRING("{}"), base);
+  }
+  auto system_string() const -> std::string { return string(); }
+
+  auto generic_display_string() const -> std::string {
+    const std::filesystem::path& base = *this;
+    return fmt::format(FMT_STRING("{:g}"), base);
+  }
+  auto generic_system_string() const -> std::string { return generic_string(); }
+};
+
 template <typename Char> struct formatter<std::filesystem::path, Char> {
 private:
  format_specs specs_;
@@ -331,21 +319,6 @@ template <typename Char> struct formatter<std::filesystem::path, Char> {
  }
 };

-class path : public std::filesystem::path {
- public:
-  auto display_string() const -> std::string {
-    const std::filesystem::path& base = *this;
-    return fmt::format(FMT_STRING("{}"), base);
-  }
-  auto system_string() const -> std::string { return string(); }
-
-  auto generic_display_string() const -> std::string {
-    const std::filesystem::path& base = *this;
-    return fmt::format(FMT_STRING("{:g}"), base);
-  }
-  auto generic_system_string() const -> std::string { return generic_string(); }
-};
-
 #endif  // FMT_CPP_LIB_FILESYSTEM

 template <size_t N, typename Char>
@@ -380,16 +353,25 @@ template <typename T, typename Char>
 struct formatter<std::optional<T>, Char,
                 std::enable_if_t<is_formattable<T, Char>::value>> {
 private:
-  formatter<std::remove_cv_t<T>, Char> underlying_;
+  formatter<T, Char> underlying_;
  static constexpr basic_string_view<Char> optional =
      detail::string_literal<Char, 'o', 'p', 't', 'i', 'o', 'n', 'a', 'l',
                             '('>{};
  static constexpr basic_string_view<Char> none =
      detail::string_literal<Char, 'n', 'o', 'n', 'e'>{};

+  template <class U>
+  FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, bool set)
+      -> decltype(u.set_debug_format(set)) {
+    u.set_debug_format(set);
+  }
+
+  template <class U>
+  FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {}
+
 public:
  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) {
-    detail::maybe_set_debug_format(underlying_, true);
+    maybe_set_debug_format(underlying_, true);
    return underlying_.parse(ctx);
  }

@@ -425,10 +407,10 @@ struct formatter<std::expected<T, E>, Char,
    if (value.has_value()) {
      out = detail::write<Char>(out, "expected(");
      if constexpr (!std::is_void<T>::value)
-        out = detail::write_escaped_alternative<Char>(out, *value, ctx);
+        out = detail::write_escaped_alternative<Char>(out, *value);
    } else {
      out = detail::write<Char>(out, "unexpected(");
-      out = detail::write_escaped_alternative<Char>(out, value.error(), ctx);
+      out = detail::write_escaped_alternative<Char>(out, value.error());
    }
    *out++ = ')';
    return out;
@@ -492,7 +474,7 @@ struct formatter<Variant, Char,
    FMT_TRY {
      std::visit(
          [&](const auto& v) {
-            out = detail::write_escaped_alternative<Char>(out, v, ctx);
+            out = detail::write_escaped_alternative<Char>(out, v);
          },
          value);
    }
@@ -513,8 +495,6 @@ template <> struct formatter<std::error_code> {
  bool debug_ = false;

 public:
-  FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; }
-
  FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* {
    auto it = ctx.begin(), end = ctx.end();
    if (it == end) return it;
--- a/include/spdlog/fmt/chrono.h
+++ b/include/spdlog/fmt/chrono.h
@@ -10,14 +10,14 @@
 #include <spdlog/tweakme.h>

 #if !defined(SPDLOG_USE_STD_FORMAT)
-#if !defined(SPDLOG_FMT_EXTERNAL)
-#ifdef SPDLOG_HEADER_ONLY
-#ifndef FMT_HEADER_ONLY
-#define FMT_HEADER_ONLY
-#endif
-#endif
-#include <spdlog/fmt/bundled/chrono.h>
-#else
-#include <fmt/chrono.h>
-#endif
+    #if !defined(SPDLOG_FMT_EXTERNAL)
+        #ifdef SPDLOG_HEADER_ONLY
+            #ifndef FMT_HEADER_ONLY
+                #define FMT_HEADER_ONLY
+            #endif
+        #endif
+        #include <spdlog/fmt/bundled/chrono.h>
+    #else
+        #include <fmt/chrono.h>
+    #endif
 #endif
--- a/include/spdlog/fmt/compile.h
+++ b/include/spdlog/fmt/compile.h
@@ -10,14 +10,14 @@
 #include <spdlog/tweakme.h>

 #if !defined(SPDLOG_USE_STD_FORMAT)
-#if !defined(SPDLOG_FMT_EXTERNAL)
-#ifdef SPDLOG_HEADER_ONLY
-#ifndef FMT_HEADER_ONLY
-#define FMT_HEADER_ONLY
-#endif
-#endif
-#include <spdlog/fmt/bundled/compile.h>
-#else
-#include <fmt/compile.h>
-#endif
+    #if !defined(SPDLOG_FMT_EXTERNAL)
+        #ifdef SPDLOG_HEADER_ONLY
+            #ifndef FMT_HEADER_ONLY
+                #define FMT_HEADER_ONLY
+            #endif
+        #endif
+        #include <spdlog/fmt/bundled/compile.h>
+    #else
+        #include <fmt/compile.h>
+    #endif
 #endif
--- a/include/spdlog/fmt/fmt.h
+++ b/include/spdlog/fmt/fmt.h
@@ -12,15 +12,15 @@
 #include <spdlog/tweakme.h>

 #if defined(SPDLOG_USE_STD_FORMAT)  // SPDLOG_USE_STD_FORMAT is defined - use std::format
-#include <format>
+    #include <format>
 #elif !defined(SPDLOG_FMT_EXTERNAL)
-#if !defined(SPDLOG_COMPILED_LIB) && !defined(FMT_HEADER_ONLY)
-#define FMT_HEADER_ONLY
-#endif
-#ifndef FMT_USE_WINDOWS_H
-#define FMT_USE_WINDOWS_H 0
-#endif
-#include <spdlog/fmt/bundled/format.h>
+    #if !defined(SPDLOG_COMPILED_LIB) && !defined(FMT_HEADER_ONLY)
+        #define FMT_HEADER_ONLY
+    #endif
+    #ifndef FMT_USE_WINDOWS_H
+        #define FMT_USE_WINDOWS_H 0
+    #endif
+    #include <spdlog/fmt/bundled/format.h>
 #else  // SPDLOG_FMT_EXTERNAL is defined - use external fmtlib
-#include <fmt/format.h>
+    #include <fmt/format.h>
 #endif
--- a/include/spdlog/fmt/ostr.h
+++ b/include/spdlog/fmt/ostr.h
@@ -10,14 +10,14 @@
 #include <spdlog/tweakme.h>

 #if !defined(SPDLOG_USE_STD_FORMAT)
-#if !defined(SPDLOG_FMT_EXTERNAL)
-#ifdef SPDLOG_HEADER_ONLY
-#ifndef FMT_HEADER_ONLY
-#define FMT_HEADER_ONLY
-#endif
-#endif
-#include <spdlog/fmt/bundled/ostream.h>
-#else
-#include <fmt/ostream.h>
-#endif
+    #if !defined(SPDLOG_FMT_EXTERNAL)
+        #ifdef SPDLOG_HEADER_ONLY
+            #ifndef FMT_HEADER_ONLY
+                #define FMT_HEADER_ONLY
+            #endif
+        #endif
+        #include <spdlog/fmt/bundled/ostream.h>
+    #else
+        #include <fmt/ostream.h>
+    #endif
 #endif
--- a/include/spdlog/fmt/ranges.h
+++ b/include/spdlog/fmt/ranges.h
@@ -10,14 +10,14 @@
 #include <spdlog/tweakme.h>

 #if !defined(SPDLOG_USE_STD_FORMAT)
-#if !defined(SPDLOG_FMT_EXTERNAL)
-#ifdef SPDLOG_HEADER_ONLY
-#ifndef FMT_HEADER_ONLY
-#define FMT_HEADER_ONLY
-#endif
-#endif
-#include <spdlog/fmt/bundled/ranges.h>
-#else
-#include <fmt/ranges.h>
-#endif
+    #if !defined(SPDLOG_FMT_EXTERNAL)
+        #ifdef SPDLOG_HEADER_ONLY
+            #ifndef FMT_HEADER_ONLY
+                #define FMT_HEADER_ONLY
+            #endif
+        #endif
+        #include <spdlog/fmt/bundled/ranges.h>
+    #else
+        #include <fmt/ranges.h>
+    #endif
 #endif
--- a/include/spdlog/fmt/std.h
+++ b/include/spdlog/fmt/std.h
@@ -11,14 +11,14 @@
 #include <spdlog/tweakme.h>

 #if !defined(SPDLOG_USE_STD_FORMAT)
-#if !defined(SPDLOG_FMT_EXTERNAL)
-#ifdef SPDLOG_HEADER_ONLY
-#ifndef FMT_HEADER_ONLY
-#define FMT_HEADER_ONLY
-#endif
-#endif
-#include <spdlog/fmt/bundled/std.h>
-#else
-#include <fmt/std.h>
-#endif
+    #if !defined(SPDLOG_FMT_EXTERNAL)
+        #ifdef SPDLOG_HEADER_ONLY
+            #ifndef FMT_HEADER_ONLY
+                #define FMT_HEADER_ONLY
+            #endif
+        #endif
+        #include <spdlog/fmt/bundled/std.h>
+    #else
+        #include <fmt/std.h>
+    #endif
 #endif
--- a/include/spdlog/fmt/xchar.h
+++ b/include/spdlog/fmt/xchar.h
@@ -10,14 +10,14 @@
 #include <spdlog/tweakme.h>

 #if !defined(SPDLOG_USE_STD_FORMAT)
-#if !defined(SPDLOG_FMT_EXTERNAL)
-#ifdef SPDLOG_HEADER_ONLY
-#ifndef FMT_HEADER_ONLY
-#define FMT_HEADER_ONLY
-#endif
-#endif
-#include <spdlog/fmt/bundled/xchar.h>
-#else
-#include <fmt/xchar.h>
-#endif
+    #if !defined(SPDLOG_FMT_EXTERNAL)
+        #ifdef SPDLOG_HEADER_ONLY
+            #ifndef FMT_HEADER_ONLY
+                #define FMT_HEADER_ONLY
+            #endif
+        #endif
+        #include <spdlog/fmt/bundled/xchar.h>
+    #else
+        #include <fmt/xchar.h>
+    #endif
 #endif
--- a/include/spdlog/logger-inl.h
+++ b/include/spdlog/logger-inl.h
@@ -4,7 +4,7 @@
 #pragma once

 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/logger.h>
+    #include <spdlog/logger.h>
 #endif

 #include <spdlog/details/backtracer.h>
@@ -164,7 +164,8 @@ SPDLOG_INLINE void logger::dump_backtrace_() {
 }

 SPDLOG_INLINE bool logger::should_flush_(const details::log_msg &msg) const {
-    return (msg.level >= flush_level()) && (msg.level != level::off);
+    auto flush_level = flush_level_.load(std::memory_order_relaxed);
+    return (msg.level >= flush_level) && (msg.level != level::off);
 }

 SPDLOG_INLINE void logger::err_handler_(const std::string &msg) const {
--- a/include/spdlog/logger.h
+++ b/include/spdlog/logger.h
@@ -19,30 +19,30 @@
 #include <spdlog/details/log_msg.h>

 #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
-#ifndef _WIN32
-#error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows
-#endif
-#include <spdlog/details/os.h>
+    #ifndef _WIN32
+        #error SPDLOG_WCHAR_TO_UTF8_SUPPORT only supported on windows
+    #endif
+    #include <spdlog/details/os.h>
 #endif

 #include <vector>

 #ifndef SPDLOG_NO_EXCEPTIONS
-#define SPDLOG_LOGGER_CATCH(location)                                                 \
-    catch (const std::exception &ex) {                                                \
-        if (location.filename) {                                                      \
-            err_handler_(fmt_lib::format(SPDLOG_FMT_STRING("{} [{}({})]"), ex.what(), \
-                                         location.filename, location.line));          \
-        } else {                                                                      \
-            err_handler_(ex.what());                                                  \
-        }                                                                             \
-    }                                                                                 \
-    catch (...) {                                                                     \
-        err_handler_("Rethrowing unknown exception in logger");                       \
-        throw;                                                                        \
-    }
+    #define SPDLOG_LOGGER_CATCH(location)                                                 \
+        catch (const std::exception &ex) {                                                \
+            if (location.filename) {                                                      \
+                err_handler_(fmt_lib::format(SPDLOG_FMT_STRING("{} [{}({})]"), ex.what(), \
+                                             location.filename, location.line));          \
+            } else {                                                                      \
+                err_handler_(ex.what());                                                  \
+            }                                                                             \
+        }                                                                                 \
+        catch (...) {                                                                     \
+            err_handler_("Rethrowing unknown exception in logger");                       \
+            throw;                                                                        \
+        }
 #else
-#define SPDLOG_LOGGER_CATCH(location)
+    #define SPDLOG_LOGGER_CATCH(location)
 #endif

 namespace spdlog {
@@ -77,11 +77,7 @@ public:

    template <typename... Args>
    void log(source_loc loc, level::level_enum lvl, format_string_t<Args...> fmt, Args &&...args) {
-#if defined(SPDLOG_USE_STD_FORMAT) && __cpp_lib_format < 202207L
-        log_(loc, lvl, fmt, std::forward<Args>(args)...);
-#else
-        log_(loc, lvl, fmt.get(), std::forward<Args>(args)...);
-#endif
+        log_(loc, lvl, details::to_string_view(fmt), std::forward<Args>(args)...);
    }

    template <typename... Args>
@@ -162,11 +158,7 @@ public:
 #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
    template <typename... Args>
    void log(source_loc loc, level::level_enum lvl, wformat_string_t<Args...> fmt, Args &&...args) {
-#if defined(SPDLOG_USE_STD_FORMAT) && __cpp_lib_format < 202207L
-        log_(loc, lvl, fmt, std::forward<Args>(args)...);
-#else
-        log_(loc, lvl, fmt.get(), std::forward<Args>(args)...);
-#endif
+        log_(loc, lvl, details::to_string_view(fmt), std::forward<Args>(args)...);
    }

    template <typename... Args>
@@ -266,7 +258,7 @@ public:
        log(level::critical, msg);
    }

-    // return true if logging is enabled for the given level.
+    // return true logging is enabled for the given level.
    bool should_log(level::level_enum msg_level) const {
        return msg_level >= level_.load(std::memory_order_relaxed);
    }
@@ -383,5 +375,5 @@ void swap(logger &a, logger &b) noexcept;
 }  // namespace spdlog

 #ifdef SPDLOG_HEADER_ONLY
-#include "logger-inl.h"
+    #include "logger-inl.h"
 #endif
--- a/include/spdlog/mdc.h
+++ b/include/spdlog/mdc.h
@@ -4,7 +4,7 @@
 #pragma once

 #if defined(SPDLOG_NO_TLS)
-#error "This header requires thread local storage support, but SPDLOG_NO_TLS is defined."
+    #error "This header requires thread local storage support, but SPDLOG_NO_TLS is defined."
 #endif

 #include <map>
--- a/include/spdlog/pattern_formatter-inl.h
+++ b/include/spdlog/pattern_formatter-inl.h
@@ -4,7 +4,7 @@
 #pragma once

 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/pattern_formatter.h>
+    #include <spdlog/pattern_formatter.h>
 #endif

 #include <spdlog/details/fmt_helper.h>
@@ -12,7 +12,7 @@
 #include <spdlog/details/os.h>

 #ifndef SPDLOG_NO_TLS
-#include <spdlog/mdc.h>
+    #include <spdlog/mdc.h>
 #endif

 #include <spdlog/fmt/fmt.h>
@@ -514,9 +514,8 @@ public:
 template <typename ScopedPadder>
 class z_formatter final : public flag_formatter {
 public:
-    explicit z_formatter(padding_info padinfo, pattern_time_type time_type)
-        : flag_formatter(padinfo),
-          time_type_(time_type) {}
+    explicit z_formatter(padding_info padinfo)
+        : flag_formatter(padinfo) {}

    z_formatter() = default;
    z_formatter(const z_formatter &) = delete;
@@ -525,15 +524,11 @@ public:
    void format(const details::log_msg &msg, const std::tm &tm_time, memory_buf_t &dest) override {
        const size_t field_size = 6;
        ScopedPadder p(field_size, padinfo_, dest);
+
 #ifdef SPDLOG_NO_TZ_OFFSET
        const char *str = "+??:??";
        dest.append(str, str + 6);
 #else
-        if (time_type_ == pattern_time_type::utc) {
-            const char *zeroes = "+00:00";
-            dest.append(zeroes, zeroes + 6);
-            return;
-        }
        auto total_minutes = get_cached_offset(msg, tm_time);
        bool is_negative = total_minutes < 0;
        if (is_negative) {
@@ -550,7 +545,6 @@ public:
    }

 private:
-    pattern_time_type time_type_;
    log_clock::time_point last_update_{std::chrono::seconds(0)};
    int offset_minutes_{0};

@@ -708,9 +702,9 @@ public:
        : flag_formatter(padinfo) {}

 #ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4127)  // consider using 'if constexpr' instead
-#endif                           // _MSC_VER
+    #pragma warning(push)
+    #pragma warning(disable : 4127)  // consider using 'if constexpr' instead
+#endif                               // _MSC_VER
    static const char *basename(const char *filename) {
        // if the size is 2 (1 character + null terminator) we can use the more efficient strrchr
        // the branch will be elided by optimizations
@@ -727,7 +721,7 @@ public:
        }
    }
 #ifdef _MSC_VER
-#pragma warning(pop)
+    #pragma warning(pop)
 #endif  // _MSC_VER

    void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override {
@@ -813,7 +807,7 @@ public:
        : flag_formatter(padinfo) {}

    void format(const details::log_msg &, const std::tm &, memory_buf_t &dest) override {
-        const auto &mdc_map = mdc::get_context();
+        auto &mdc_map = mdc::get_context();
        if (mdc_map.empty()) {
            ScopedPadder p(0, padinfo_, dest);
            return;
@@ -823,10 +817,11 @@ public:
    }

    void format_mdc(const mdc::mdc_map_t &mdc_map, memory_buf_t &dest) {
-        const auto last_element = std::prev(mdc_map.end());
+        auto last_element = --mdc_map.end();
        for (auto it = mdc_map.begin(); it != mdc_map.end(); ++it) {
-            const auto &key = it->first;
-            const auto &value = it->second;
+            auto &pair = *it;
+            const auto &key = pair.first;
+            const auto &value = pair.second;
            size_t content_size = key.size() + value.size() + 1;  // 1 for ':'

            if (it != last_element) {
@@ -1011,7 +1006,7 @@ SPDLOG_INLINE void pattern_formatter::set_pattern(std::string pattern) {

 SPDLOG_INLINE void pattern_formatter::need_localtime(bool need) { need_localtime_ = need; }

-SPDLOG_INLINE std::tm pattern_formatter::get_time_(const details::log_msg &msg) const {
+SPDLOG_INLINE std::tm pattern_formatter::get_time_(const details::log_msg &msg) {
    if (pattern_time_type_ == pattern_time_type::local) {
        return details::os::localtime(log_clock::to_time_t(msg.time));
    }
@@ -1166,8 +1161,7 @@ SPDLOG_INLINE void pattern_formatter::handle_flag_(char flag, details::padding_i
            need_localtime_ = true;
            break;
        case ('z'):  // timezone
-            formatters_.push_back(
-                details::make_unique<details::z_formatter<Padder>>(padding, pattern_time_type_));
+            formatters_.push_back(details::make_unique<details::z_formatter<Padder>>(padding));
            need_localtime_ = true;
            break;
        case ('P'):  // pid
--- a/include/spdlog/pattern_formatter.h
+++ b/include/spdlog/pattern_formatter.h
@@ -99,7 +99,7 @@ private:
    std::vector<std::unique_ptr<details::flag_formatter>> formatters_;
    custom_flags custom_handlers_;

-    std::tm get_time_(const details::log_msg &msg) const;
+    std::tm get_time_(const details::log_msg &msg);
    template <typename Padder>
    void handle_flag_(char flag, details::padding_info padding);

@@ -114,5 +114,5 @@ private:
 }  // namespace spdlog

 #ifdef SPDLOG_HEADER_ONLY
-#include "pattern_formatter-inl.h"
+    #include "pattern_formatter-inl.h"
 #endif
--- a/include/spdlog/sinks/android_sink.h
+++ b/include/spdlog/sinks/android_sink.h
@@ -5,22 +5,22 @@

 #ifdef __ANDROID__

-#include <spdlog/details/fmt_helper.h>
-#include <spdlog/details/null_mutex.h>
-#include <spdlog/details/os.h>
-#include <spdlog/details/synchronous_factory.h>
-#include <spdlog/sinks/base_sink.h>
+    #include <spdlog/details/fmt_helper.h>
+    #include <spdlog/details/null_mutex.h>
+    #include <spdlog/details/os.h>
+    #include <spdlog/details/synchronous_factory.h>
+    #include <spdlog/sinks/base_sink.h>

-#include <android/log.h>
-#include <chrono>
-#include <mutex>
-#include <string>
-#include <thread>
-#include <type_traits>
+    #include <android/log.h>
+    #include <chrono>
+    #include <mutex>
+    #include <string>
+    #include <thread>
+    #include <type_traits>

-#if !defined(SPDLOG_ANDROID_RETRIES)
-#define SPDLOG_ANDROID_RETRIES 2
-#endif
+    #if !defined(SPDLOG_ANDROID_RETRIES)
+        #define SPDLOG_ANDROID_RETRIES 2
+    #endif

 namespace spdlog {
 namespace sinks {
--- a/include/spdlog/sinks/ansicolor_sink-inl.h
+++ b/include/spdlog/sinks/ansicolor_sink-inl.h
@@ -4,7 +4,7 @@
 #pragma once

 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/sinks/ansicolor_sink.h>
+    #include <spdlog/sinks/ansicolor_sink.h>
 #endif

 #include <spdlog/details/os.h>
--- a/include/spdlog/sinks/ansicolor_sink.h
+++ b/include/spdlog/sinks/ansicolor_sink.h
@@ -78,10 +78,8 @@ public:
    const string_view_t red_bold = "\033[31m\033[1m";
    const string_view_t bold_on_red = "\033[1m\033[41m";

-protected:
-    FILE *target_file_;
-
 private:
+    FILE *target_file_;
    mutex_t &mutex_;
    bool should_do_colors_;
    std::unique_ptr<spdlog::formatter> formatter_;
@@ -114,5 +112,5 @@ using ansicolor_stderr_sink_st = ansicolor_stderr_sink<details::console_nullmute
 }  // namespace spdlog

 #ifdef SPDLOG_HEADER_ONLY
-#include "ansicolor_sink-inl.h"
+    #include "ansicolor_sink-inl.h"
 #endif
--- a/include/spdlog/sinks/base_sink-inl.h
+++ b/include/spdlog/sinks/base_sink-inl.h
@@ -4,7 +4,7 @@
 #pragma once

 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/sinks/base_sink.h>
+    #include <spdlog/sinks/base_sink.h>
 #endif

 #include <spdlog/common.h>
--- a/include/spdlog/sinks/base_sink.h
+++ b/include/spdlog/sinks/base_sink.h
@@ -47,5 +47,5 @@ protected:
 }  // namespace spdlog

 #ifdef SPDLOG_HEADER_ONLY
-#include "base_sink-inl.h"
+    #include "base_sink-inl.h"
 #endif
--- a/include/spdlog/sinks/basic_file_sink-inl.h
+++ b/include/spdlog/sinks/basic_file_sink-inl.h
@@ -4,7 +4,7 @@
 #pragma once

 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/sinks/basic_file_sink.h>
+    #include <spdlog/sinks/basic_file_sink.h>
 #endif

 #include <spdlog/common.h>
--- a/include/spdlog/sinks/basic_file_sink.h
+++ b/include/spdlog/sinks/basic_file_sink.h
@@ -62,5 +62,5 @@ inline std::shared_ptr<logger> basic_logger_st(const std::string &logger_name,
 }  // namespace spdlog

 #ifdef SPDLOG_HEADER_ONLY
-#include "basic_file_sink-inl.h"
+    #include "basic_file_sink-inl.h"
 #endif
--- a/include/spdlog/sinks/daily_file_sink.h
+++ b/include/spdlog/sinks/daily_file_sink.h
@@ -88,8 +88,8 @@ public:
        }

        auto now = log_clock::now();
-        const auto new_filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));
-        file_helper_.open(new_filename, truncate_);
+        auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));
+        file_helper_.open(filename, truncate_);
        rotation_tp_ = next_rotation_tp_();

        if (max_files_ > 0) {
@@ -107,8 +107,8 @@ protected:
        auto time = msg.time;
        bool should_rotate = time >= rotation_tp_;
        if (should_rotate) {
-            const auto new_filename = FileNameCalc::calc_filename(base_filename_, now_tm(time));
-            file_helper_.open(new_filename, truncate_);
+            auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(time));
+            file_helper_.open(filename, truncate_);
            rotation_tp_ = next_rotation_tp_();
        }
        memory_buf_t formatted;
@@ -131,11 +131,11 @@ private:
        std::vector<filename_t> filenames;
        auto now = log_clock::now();
        while (filenames.size() < max_files_) {
-            const auto new_filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));
-            if (!path_exists(new_filename)) {
+            auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));
+            if (!path_exists(filename)) {
                break;
            }
-            filenames.emplace_back(new_filename);
+            filenames.emplace_back(filename);
            now -= std::chrono::hours(24);
        }
        for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) {
--- a/include/spdlog/sinks/dist_sink.h
+++ b/include/spdlog/sinks/dist_sink.h
@@ -24,7 +24,7 @@ class dist_sink : public base_sink<Mutex> {
 public:
    dist_sink() = default;
    explicit dist_sink(std::vector<std::shared_ptr<sink>> sinks)
-        : sinks_(std::move(sinks)) {}
+        : sinks_(sinks) {}

    dist_sink(const dist_sink &) = delete;
    dist_sink &operator=(const dist_sink &) = delete;
--- a/include/spdlog/sinks/dup_filter_sink.h
+++ b/include/spdlog/sinks/dup_filter_sink.h
@@ -43,11 +43,6 @@ public:
    explicit dup_filter_sink(std::chrono::duration<Rep, Period> max_skip_duration)
        : max_skip_duration_{max_skip_duration} {}

-    template <class Rep, class Period>
-    explicit dup_filter_sink(std::chrono::duration<Rep, Period> max_skip_duration, std::vector<std::shared_ptr<sink>> sinks)
-        : max_skip_duration_{max_skip_duration}
-        , dist_sink<Mutex>(std::move(sinks)) {}
-
 protected:
    std::chrono::microseconds max_skip_duration_;
    log_clock::time_point last_msg_time_;
@@ -83,8 +78,8 @@ protected:
    }

    // return whether the log msg should be displayed (true) or skipped (false)
-    bool filter_(const details::log_msg &msg) const {
-        const auto filter_duration = msg.time - last_msg_time_;
+    bool filter_(const details::log_msg &msg) {
+        auto filter_duration = msg.time - last_msg_time_;
        return (filter_duration > max_skip_duration_) || (msg.payload != last_msg_payload_);
    }
 };
--- a/include/spdlog/sinks/msvc_sink.h
+++ b/include/spdlog/sinks/msvc_sink.h
@@ -5,21 +5,21 @@

 #if defined(_WIN32)

-#include <spdlog/details/null_mutex.h>
-#if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
-#include <spdlog/details/os.h>
-#endif
-#include <spdlog/sinks/base_sink.h>
+    #include <spdlog/details/null_mutex.h>
+    #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+        #include <spdlog/details/os.h>
+    #endif
+    #include <spdlog/sinks/base_sink.h>

-#include <mutex>
-#include <string>
+    #include <mutex>
+    #include <string>

-// Avoid including windows.h (https://stackoverflow.com/a/30741042)
-#if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+    // Avoid including windows.h (https://stackoverflow.com/a/30741042)
+    #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
 extern "C" __declspec(dllimport) void __stdcall OutputDebugStringW(const wchar_t *lpOutputString);
-#else
+    #else
 extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA(const char *lpOutputString);
-#endif
+    #endif
 extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();

 namespace spdlog {
@@ -42,13 +42,13 @@ protected:
        memory_buf_t formatted;
        base_sink<Mutex>::formatter_->format(msg, formatted);
        formatted.push_back('\0');  // add a null terminator for OutputDebugString
-#if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+    #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
        wmemory_buf_t wformatted;
        details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), wformatted);
        OutputDebugStringW(wformatted.data());
-#else
+    #else
        OutputDebugStringA(formatted.data());
-#endif
+    #endif
    }

    void flush_() override {}
--- a/include/spdlog/sinks/qt_sinks.h
+++ b/include/spdlog/sinks/qt_sinks.h
@@ -160,24 +160,20 @@ protected:
            payload = QString::fromUtf8(str.data(), static_cast<int>(str.size()));
            // convert color ranges from byte index to character index.
            if (msg.color_range_start < msg.color_range_end) {
-                color_range_start =
-                    QString::fromUtf8(str.data(), static_cast<qsizetype>(msg.color_range_start))
-                        .size();
-                color_range_end =
-                    QString::fromUtf8(str.data(), static_cast<qsizetype>(msg.color_range_end))
-                        .size();
+                color_range_start = QString::fromUtf8(str.data(), msg.color_range_start).size();
+                color_range_end = QString::fromUtf8(str.data(), msg.color_range_end).size();
            }
        } else {
            payload = QString::fromLatin1(str.data(), static_cast<int>(str.size()));
        }

-        invoke_params params{max_lines_,                                  // max lines
-                             qt_text_edit_,                               // text edit to append to
-                             std::move(payload),                          // text to append
-                             default_color_,                              // default color
-                             colors_.at(static_cast<size_t>(msg.level)),  // color to apply
-                             color_range_start,                           // color range start
-                             color_range_end};                            // color range end
+        invoke_params params{max_lines_,             // max lines
+                             qt_text_edit_,          // text edit to append to
+                             std::move(payload),     // text to append
+                             default_color_,         // default color
+                             colors_.at(msg.level),  // color to apply
+                             color_range_start,      // color range start
+                             color_range_end};       // color range end

        QMetaObject::invokeMethod(
            qt_text_edit_, [params]() { invoke_method_(params); }, Qt::AutoConnection);
--- a/include/spdlog/sinks/rotating_file_sink-inl.h
+++ b/include/spdlog/sinks/rotating_file_sink-inl.h
@@ -4,7 +4,7 @@
 #pragma once

 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/sinks/rotating_file_sink.h>
+    #include <spdlog/sinks/rotating_file_sink.h>
 #endif

 #include <spdlog/common.h>
--- a/include/spdlog/sinks/rotating_file_sink.h
+++ b/include/spdlog/sinks/rotating_file_sink.h
@@ -89,5 +89,5 @@ std::shared_ptr<logger> rotating_logger_st(const std::string &logger_name,
 }  // namespace spdlog

 #ifdef SPDLOG_HEADER_ONLY
-#include "rotating_file_sink-inl.h"
+    #include "rotating_file_sink-inl.h"
 #endif
--- a/include/spdlog/sinks/sink-inl.h
+++ b/include/spdlog/sinks/sink-inl.h
@@ -4,7 +4,7 @@
 #pragma once

 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/sinks/sink.h>
+    #include <spdlog/sinks/sink.h>
 #endif

 #include <spdlog/common.h>
--- a/include/spdlog/sinks/sink.h
+++ b/include/spdlog/sinks/sink.h
@@ -30,5 +30,5 @@ protected:
 }  // namespace spdlog

 #ifdef SPDLOG_HEADER_ONLY
-#include "sink-inl.h"
+    #include "sink-inl.h"
 #endif
--- a/include/spdlog/sinks/stdout_color_sinks-inl.h
+++ b/include/spdlog/sinks/stdout_color_sinks-inl.h
@@ -4,7 +4,7 @@
 #pragma once

 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/sinks/stdout_color_sinks.h>
+    #include <spdlog/sinks/stdout_color_sinks.h>
 #endif

 #include <spdlog/common.h>
--- a/include/spdlog/sinks/stdout_color_sinks.h
+++ b/include/spdlog/sinks/stdout_color_sinks.h
@@ -4,9 +4,9 @@
 #pragma once

 #ifdef _WIN32
-#include <spdlog/sinks/wincolor_sink.h>
+    #include <spdlog/sinks/wincolor_sink.h>
 #else
-#include <spdlog/sinks/ansicolor_sink.h>
+    #include <spdlog/sinks/ansicolor_sink.h>
 #endif

 #include <spdlog/details/synchronous_factory.h>
@@ -45,5 +45,5 @@ std::shared_ptr<logger> stderr_color_st(const std::string &logger_name,
 }  // namespace spdlog

 #ifdef SPDLOG_HEADER_ONLY
-#include "stdout_color_sinks-inl.h"
+    #include "stdout_color_sinks-inl.h"
 #endif
--- a/include/spdlog/sinks/stdout_sinks-inl.h
+++ b/include/spdlog/sinks/stdout_sinks-inl.h
@@ -4,7 +4,7 @@
 #pragma once

 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/sinks/stdout_sinks.h>
+    #include <spdlog/sinks/stdout_sinks.h>
 #endif

 #include <memory>
@@ -13,17 +13,17 @@
 #include <spdlog/details/os.h>

 #ifdef _WIN32
-// under windows using fwrite to non-binary stream results in \r\r\n (see issue #1675)
-// so instead we use ::FileWrite
-#include <spdlog/details/windows_include.h>
+    // under windows using fwrite to non-binary stream results in \r\r\n (see issue #1675)
+    // so instead we use ::FileWrite
+    #include <spdlog/details/windows_include.h>

-#ifndef _USING_V110_SDK71_  // fileapi.h doesn't exist in winxp
-#include <fileapi.h>        // WriteFile (..)
-#endif
+    #ifndef _USING_V110_SDK71_  // fileapi.h doesn't exist in winxp
+        #include <fileapi.h>    // WriteFile (..)
+    #endif

-#include <io.h>     // _get_osfhandle(..)
-#include <stdio.h>  // _fileno(..)
-#endif              // _WIN32
+    #include <io.h>     // _get_osfhandle(..)
+    #include <stdio.h>  // _fileno(..)
+#endif                  // _WIN32

 namespace spdlog {

--- a/include/spdlog/sinks/stdout_sinks.h
+++ b/include/spdlog/sinks/stdout_sinks.h
@@ -9,7 +9,7 @@
 #include <spdlog/sinks/sink.h>

 #ifdef _WIN32
-#include <spdlog/details/windows_include.h>
+    #include <spdlog/details/windows_include.h>
 #endif

 namespace spdlog {
@@ -80,5 +80,5 @@ std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name);
 }  // namespace spdlog

 #ifdef SPDLOG_HEADER_ONLY
-#include "stdout_sinks-inl.h"
+    #include "stdout_sinks-inl.h"
 #endif
--- a/include/spdlog/sinks/systemd_sink.h
+++ b/include/spdlog/sinks/systemd_sink.h
@@ -10,7 +10,7 @@

 #include <array>
 #ifndef SD_JOURNAL_SUPPRESS_LOCATION
-#define SD_JOURNAL_SUPPRESS_LOCATION
+    #define SD_JOURNAL_SUPPRESS_LOCATION
 #endif
 #include <systemd/sd-journal.h>

--- a/include/spdlog/sinks/tcp_sink.h
+++ b/include/spdlog/sinks/tcp_sink.h
@@ -7,9 +7,9 @@
 #include <spdlog/details/null_mutex.h>
 #include <spdlog/sinks/base_sink.h>
 #ifdef _WIN32
-#include <spdlog/details/tcp_client-windows.h>
+    #include <spdlog/details/tcp_client-windows.h>
 #else
-#include <spdlog/details/tcp_client.h>
+    #include <spdlog/details/tcp_client.h>
 #endif

 #include <chrono>
--- a/include/spdlog/sinks/udp_sink.h
+++ b/include/spdlog/sinks/udp_sink.h
@@ -7,9 +7,9 @@
 #include <spdlog/details/null_mutex.h>
 #include <spdlog/sinks/base_sink.h>
 #ifdef _WIN32
-#include <spdlog/details/udp_client-windows.h>
+    #include <spdlog/details/udp_client-windows.h>
 #else
-#include <spdlog/details/udp_client.h>
+    #include <spdlog/details/udp_client.h>
 #endif

 #include <chrono>
@@ -36,7 +36,7 @@ template <typename Mutex>
 class udp_sink : public spdlog::sinks::base_sink<Mutex> {
 public:
    // host can be hostname or ip address
-    explicit udp_sink(const udp_sink_config& sink_config)
+    explicit udp_sink(udp_sink_config sink_config)
        : client_{sink_config.server_host, sink_config.server_port} {}

    ~udp_sink() override = default;
--- a/include/spdlog/sinks/wincolor_sink-inl.h
+++ b/include/spdlog/sinks/wincolor_sink-inl.h
@@ -4,7 +4,7 @@
 #pragma once

 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/sinks/wincolor_sink.h>
+    #include <spdlog/sinks/wincolor_sink.h>
 #endif

 #include <spdlog/details/windows_include.h>
--- a/include/spdlog/sinks/wincolor_sink.h
+++ b/include/spdlog/sinks/wincolor_sink.h
@@ -78,5 +78,5 @@ using wincolor_stderr_sink_st = wincolor_stderr_sink<details::console_nullmutex>
 }  // namespace spdlog

 #ifdef SPDLOG_HEADER_ONLY
-#include "wincolor_sink-inl.h"
+    #include "wincolor_sink-inl.h"
 #endif
--- a/include/spdlog/spdlog-inl.h
+++ b/include/spdlog/spdlog-inl.h
@@ -4,7 +4,7 @@
 #pragma once

 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/spdlog.h>
+    #include <spdlog/spdlog.h>
 #endif

 #include <spdlog/common.h>
--- a/include/spdlog/spdlog.h
+++ b/include/spdlog/spdlog.h
@@ -75,7 +75,7 @@ SPDLOG_API level::level_enum get_level();
 SPDLOG_API void set_level(level::level_enum log_level);

 // Determine whether the default logger should log messages with a certain level
-SPDLOG_API bool should_log(level::level_enum log_level);
+SPDLOG_API bool should_log(level::level_enum lvl);

 // Set a global flush level
 SPDLOG_API void flush_on(level::level_enum log_level);
@@ -289,66 +289,69 @@ inline void critical(const T &msg) {
 //

 #ifndef SPDLOG_NO_SOURCE_LOC
-#define SPDLOG_LOGGER_CALL(logger, level, ...) \
-    (logger)->log(spdlog::source_loc{__FILE__, __LINE__, SPDLOG_FUNCTION}, level, __VA_ARGS__)
+    #define SPDLOG_LOGGER_CALL(logger, level, ...) \
+        (logger)->log(spdlog::source_loc{__FILE__, __LINE__, SPDLOG_FUNCTION}, level, __VA_ARGS__)
 #else
-#define SPDLOG_LOGGER_CALL(logger, level, ...) \
-    (logger)->log(spdlog::source_loc{}, level, __VA_ARGS__)
+    #define SPDLOG_LOGGER_CALL(logger, level, ...) \
+        (logger)->log(spdlog::source_loc{}, level, __VA_ARGS__)
 #endif

 #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_TRACE
-#define SPDLOG_LOGGER_TRACE(logger, ...) \
-    SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__)
-#define SPDLOG_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), __VA_ARGS__)
+    #define SPDLOG_LOGGER_TRACE(logger, ...) \
+        SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__)
+    #define SPDLOG_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), __VA_ARGS__)
 #else
-#define SPDLOG_LOGGER_TRACE(logger, ...) (void)0
-#define SPDLOG_TRACE(...) (void)0
+    #define SPDLOG_LOGGER_TRACE(logger, ...) (void)0
+    #define SPDLOG_TRACE(...) (void)0
 #endif

 #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_DEBUG
-#define SPDLOG_LOGGER_DEBUG(logger, ...) \
-    SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__)
-#define SPDLOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), __VA_ARGS__)
+    #define SPDLOG_LOGGER_DEBUG(logger, ...) \
+        SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__)
+    #define SPDLOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), __VA_ARGS__)
 #else
-#define SPDLOG_LOGGER_DEBUG(logger, ...) (void)0
-#define SPDLOG_DEBUG(...) (void)0
+    #define SPDLOG_LOGGER_DEBUG(logger, ...) (void)0
+    #define SPDLOG_DEBUG(...) (void)0
 #endif

 #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_INFO
-#define SPDLOG_LOGGER_INFO(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__)
-#define SPDLOG_INFO(...) SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), __VA_ARGS__)
+    #define SPDLOG_LOGGER_INFO(logger, ...) \
+        SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__)
+    #define SPDLOG_INFO(...) SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), __VA_ARGS__)
 #else
-#define SPDLOG_LOGGER_INFO(logger, ...) (void)0
-#define SPDLOG_INFO(...) (void)0
+    #define SPDLOG_LOGGER_INFO(logger, ...) (void)0
+    #define SPDLOG_INFO(...) (void)0
 #endif

 #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_WARN
-#define SPDLOG_LOGGER_WARN(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__)
-#define SPDLOG_WARN(...) SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), __VA_ARGS__)
+    #define SPDLOG_LOGGER_WARN(logger, ...) \
+        SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__)
+    #define SPDLOG_WARN(...) SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), __VA_ARGS__)
 #else
-#define SPDLOG_LOGGER_WARN(logger, ...) (void)0
-#define SPDLOG_WARN(...) (void)0
+    #define SPDLOG_LOGGER_WARN(logger, ...) (void)0
+    #define SPDLOG_WARN(...) (void)0
 #endif

 #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_ERROR
-#define SPDLOG_LOGGER_ERROR(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__)
-#define SPDLOG_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), __VA_ARGS__)
+    #define SPDLOG_LOGGER_ERROR(logger, ...) \
+        SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__)
+    #define SPDLOG_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), __VA_ARGS__)
 #else
-#define SPDLOG_LOGGER_ERROR(logger, ...) (void)0
-#define SPDLOG_ERROR(...) (void)0
+    #define SPDLOG_LOGGER_ERROR(logger, ...) (void)0
+    #define SPDLOG_ERROR(...) (void)0
 #endif

 #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_CRITICAL
-#define SPDLOG_LOGGER_CRITICAL(logger, ...) \
-    SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__)
-#define SPDLOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), __VA_ARGS__)
+    #define SPDLOG_LOGGER_CRITICAL(logger, ...) \
+        SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__)
+    #define SPDLOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), __VA_ARGS__)
 #else
-#define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0
-#define SPDLOG_CRITICAL(...) (void)0
+    #define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0
+    #define SPDLOG_CRITICAL(...) (void)0
 #endif

 #ifdef SPDLOG_HEADER_ONLY
-#include "spdlog-inl.h"
+    #include "spdlog-inl.h"
 #endif

 #endif  // SPDLOG_H
--- a/include/spdlog/version.h
+++ b/include/spdlog/version.h
@@ -4,7 +4,7 @@
 #pragma once

 #define SPDLOG_VER_MAJOR 1
-#define SPDLOG_VER_MINOR 17
+#define SPDLOG_VER_MINOR 16
 #define SPDLOG_VER_PATCH 0

 #define SPDLOG_TO_VERSION(major, minor, patch) (major * 10000 + minor * 100 + patch)
--- a/src/async.cpp
+++ b/src/async.cpp
@@ -2,7 +2,7 @@
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)

 #ifndef SPDLOG_COMPILED_LIB
-#error Please define SPDLOG_COMPILED_LIB to compile this file.
+    #error Please define SPDLOG_COMPILED_LIB to compile this file.
 #endif

 #include <spdlog/async.h>
--- a/src/bundled_fmtlib_format.cpp
+++ b/src/bundled_fmtlib_format.cpp
@@ -3,17 +3,17 @@
 // All rights reserved.

 #ifndef SPDLOG_COMPILED_LIB
-#error Please define SPDLOG_COMPILED_LIB to compile this file.
+    #error Please define SPDLOG_COMPILED_LIB to compile this file.
 #endif

 #if !defined(SPDLOG_FMT_EXTERNAL) && !defined(SPDLOG_USE_STD_FORMAT)

-#include <spdlog/fmt/bundled/format-inl.h>
+    #include <spdlog/fmt/bundled/format-inl.h>

 FMT_BEGIN_NAMESPACE

 #if FMT_USE_LOCALE
-template FMT_API locale_ref::locale_ref(const std::locale& loc);  // DEPRECATED!
+template FMT_API locale_ref::locale_ref(const std::locale& loc);
 template FMT_API auto locale_ref::get<std::locale>() const -> std::locale;
 #endif

--- a/src/cfg.cpp
+++ b/src/cfg.cpp
@@ -2,7 +2,7 @@
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)

 #ifndef SPDLOG_COMPILED_LIB
-#error Please define SPDLOG_COMPILED_LIB to compile this file.
+    #error Please define SPDLOG_COMPILED_LIB to compile this file.
 #endif

 #include <spdlog/cfg/helpers-inl.h>
--- a/src/color_sinks.cpp
+++ b/src/color_sinks.cpp
@@ -2,7 +2,7 @@
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)

 #ifndef SPDLOG_COMPILED_LIB
-#error Please define SPDLOG_COMPILED_LIB to compile this file.
+    #error Please define SPDLOG_COMPILED_LIB to compile this file.
 #endif

 #include <mutex>
@@ -13,7 +13,7 @@
 // color sinks
 //
 #ifdef _WIN32
-#include <spdlog/sinks/wincolor_sink-inl.h>
+    #include <spdlog/sinks/wincolor_sink-inl.h>
 template class SPDLOG_API spdlog::sinks::wincolor_sink<spdlog::details::console_mutex>;
 template class SPDLOG_API spdlog::sinks::wincolor_sink<spdlog::details::console_nullmutex>;
 template class SPDLOG_API spdlog::sinks::wincolor_stdout_sink<spdlog::details::console_mutex>;
@@ -21,7 +21,7 @@ template class SPDLOG_API spdlog::sinks::wincolor_stdout_sink<spdlog::details::c
 template class SPDLOG_API spdlog::sinks::wincolor_stderr_sink<spdlog::details::console_mutex>;
 template class SPDLOG_API spdlog::sinks::wincolor_stderr_sink<spdlog::details::console_nullmutex>;
 #else
-#include "spdlog/sinks/ansicolor_sink-inl.h"
+    #include "spdlog/sinks/ansicolor_sink-inl.h"
 template class SPDLOG_API spdlog::sinks::ansicolor_sink<spdlog::details::console_mutex>;
 template class SPDLOG_API spdlog::sinks::ansicolor_sink<spdlog::details::console_nullmutex>;
 template class SPDLOG_API spdlog::sinks::ansicolor_stdout_sink<spdlog::details::console_mutex>;
--- a/src/file_sinks.cpp
+++ b/src/file_sinks.cpp
@@ -2,7 +2,7 @@
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)

 #ifndef SPDLOG_COMPILED_LIB
-#error Please define SPDLOG_COMPILED_LIB to compile this file.
+    #error Please define SPDLOG_COMPILED_LIB to compile this file.
 #endif

 #include <spdlog/details/file_helper-inl.h>
--- a/src/spdlog.cpp
+++ b/src/spdlog.cpp
@@ -2,7 +2,7 @@
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)

 #ifndef SPDLOG_COMPILED_LIB
-#error Please define SPDLOG_COMPILED_LIB to compile this file.
+    #error Please define SPDLOG_COMPILED_LIB to compile this file.
 #endif

 #include <spdlog/common-inl.h>
--- a/src/stdout_sinks.cpp
+++ b/src/stdout_sinks.cpp
@@ -2,7 +2,7 @@
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)

 #ifndef SPDLOG_COMPILED_LIB
-#error Please define SPDLOG_COMPILED_LIB to compile this file.
+    #error Please define SPDLOG_COMPILED_LIB to compile this file.
 #endif

 #include <mutex>
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -50,9 +50,7 @@ set(SPDLOG_UTESTS_SOURCES
    test_stopwatch.cpp
    test_circular_q.cpp
    test_bin_to_hex.cpp
-    test_ringbuffer.cpp
-    test_timezone.cpp
-)
+    test_ringbuffer.cpp)

 if(NOT SPDLOG_NO_EXCEPTIONS)
    list(APPEND SPDLOG_UTESTS_SOURCES test_errors.cpp)
--- a/tests/includes.h
+++ b/tests/includes.h
@@ -1,12 +1,12 @@
 #pragma once

 #if defined(__GNUC__) && __GNUC__ == 12
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"  // Workaround for GCC 12
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"  // Workaround for GCC 12
 #endif
 #include <catch2/catch_all.hpp>
 #if defined(__GNUC__) && __GNUC__ == 12
-#pragma GCC diagnostic pop
+    #pragma GCC diagnostic pop
 #endif

 #include "utils.h"
@@ -23,16 +23,13 @@

 #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG

-#undef SPDLOG_LEVEL_NAMES
-#undef SPDLOG_SHORT_LEVEL_NAMES
-
 #include "spdlog/spdlog.h"
 #include "spdlog/async.h"
 #include "spdlog/details/fmt_helper.h"
 #include "spdlog/details/os.h"

 #ifndef SPDLOG_NO_TLS
-#include "spdlog/mdc.h"
+    #include "spdlog/mdc.h"
 #endif

 #include "spdlog/sinks/basic_file_sink.h"
--- a/tests/main.cpp
+++ b/tests/main.cpp
@@ -1,10 +1,10 @@
 #if defined(__GNUC__) && __GNUC__ == 12
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"  // Workaround for GCC 12
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"  // Workaround for GCC 12
 #endif

 #include <catch2/catch_all.hpp>

 #if defined(__GNUC__) && __GNUC__ == 12
-#pragma GCC diagnostic pop
+    #pragma GCC diagnostic pop
 #endif
--- a/tests/test_cfg.cpp
+++ b/tests/test_cfg.cpp
@@ -176,33 +176,3 @@ TEST_CASE("restore-to-default", "[cfg]") {
    load_argv_levels(2, argv);
    REQUIRE(spdlog::default_logger()->level() == spdlog::level::info);
 }
-
-TEST_CASE("uppercase-level-names", "[cfg]") {
-    spdlog::drop("l1");
-    spdlog::drop("l2");
-    
-#ifdef CATCH_PLATFORM_WINDOWS
-    _putenv_s("SPDLOG_LEVEL", "l1=DEBUG,INFO");
-#else
-    setenv("SPDLOG_LEVEL", "l1=DEBUG,INFO", 1);
-#endif
-    load_env_levels();
-    auto l1 = spdlog::create<test_sink_st>("l1");
-    auto l2 = spdlog::create<test_sink_st>("l2");
-    
-    REQUIRE(l1->level() == spdlog::level::debug);
-    REQUIRE(l2->level() == spdlog::level::info);
-    REQUIRE(spdlog::default_logger()->level() == spdlog::level::info);
-    
-    // Test with argv
-    spdlog::drop("l3");
-    const char *argv[] = {"ignore", "SPDLOG_LEVEL=l3=WARN,ERROR"};
-    load_argv_levels(2, argv);
-    auto l3 = spdlog::create<test_sink_st>("l3");
-    
-    REQUIRE(l3->level() == spdlog::level::warn);
-    REQUIRE(spdlog::default_logger()->level() == spdlog::level::err);
-    
-    // Reset to info
-    spdlog::set_level(spdlog::level::info);
-}
--- a/tests/test_create_dir.cpp
+++ b/tests/test_create_dir.cpp
@@ -84,11 +84,11 @@ TEST_CASE("dir_name", "[create_dir]") {

 #ifdef _WIN32

-//
-// test windows cases when drive letter is given e.g. C:\\some-folder
-//
-#include <windows.h>
-#include <fileapi.h>
+    //
+    // test windows cases when drive letter is given e.g. C:\\some-folder
+    //
+    #include <windows.h>
+    #include <fileapi.h>

 std::string get_full_path(const std::string &relative_folder_path) {
    char full_path[MAX_PATH];
--- a/tests/test_daily_logger.cpp
+++ b/tests/test_daily_logger.cpp
@@ -98,7 +98,7 @@ TEST_CASE("rotating_file_sink::calc_filename3", "[rotating_file_sink]") {
 // regex supported only from gcc 4.9 and above
 #if defined(_MSC_VER) || !(__GNUC__ <= 4 && __GNUC_MINOR__ < 9)

-#include <regex>
+    #include <regex>

 TEST_CASE("daily_file_sink::daily_filename_calculator", "[daily_file_sink]") {
    // daily_YYYY-MM-DD_hh-mm.txt
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
gabime	2f10538576	Add full date to stdout tests	2025-11-28 17:30:23 +02:00
gabime	a2339c5463	Add full date to stdout tests	2025-11-28 17:21:14 +02:00
gabime	2a528b9068	clang-format	2025-11-28 17:10:57 +02:00
gabime	6af5c48d83	Fix issue #3483	2025-11-28 15:48:07 +02:00