Merge branch 'gabime:v1.x' into v1.x

MaxwellGengYF · web-flow · commit 0343542bf835 · 2026-01-08T10:17:11.000+08:00
diff --git a/include/spdlog/details/os-inl.h b/include/spdlog/details/os-inl.h
@@ -243,31 +243,29 @@ SPDLOG_INLINE size_t filesize(FILE *f) {
 #pragma warning(pop)
 #endif
 
-// Return utc offset in minutes or throw spdlog_ex on failure
 #if !defined(SPDLOG_NO_TZ_OFFSET)
-SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm) {
 #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);
+// 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
+    }
 
-    int offset = -tzinfo.Bias;
-    if (tm.tm_isdst) {
-        offset -= tzinfo.DaylightBias;
-    } else {
-        offset -= tzinfo.StandardBias;
+    std::time_t utc_time_t = _mkgmtime(&local_tm);
+    if (utc_time_t == -1) {
+        return 0; // fallback
     }
-    return offset;
-#else
-    auto offset_seconds = tm.tm_gmtoff;
+    auto offset_seconds = utc_time_t - local_time_t;
     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
diff --git a/include/spdlog/details/udp_client.h b/include/spdlog/details/udp_client.h
@@ -69,10 +69,9 @@ class udp_client {
     // Send exactly n_bytes of the given data.
     // On error close the connection and throw.
     void send(const char *data, size_t n_bytes) {
-        ssize_t toslen = 0;
-        socklen_t tolen = sizeof(struct sockaddr);
-        if ((toslen = ::sendto(socket_, data, n_bytes, 0, (struct sockaddr *)&sockAddr_, tolen)) ==
-            -1) {
+        socklen_t tolen = sizeof(sockAddr_);
+        if (::sendto(socket_, data, n_bytes, 0, reinterpret_cast<const sockaddr *>(&sockAddr_),
+                     tolen) == -1) {
             throw_spdlog_ex("sendto(2) failed", errno);
         }
     }
diff --git a/include/spdlog/pattern_formatter-inl.h b/include/spdlog/pattern_formatter-inl.h
@@ -514,8 +514,9 @@ class T_formatter final : public flag_formatter {
 template <typename ScopedPadder>
 class z_formatter final : public flag_formatter {
 public:
-    explicit z_formatter(padding_info padinfo)
-        : flag_formatter(padinfo) {}
+    explicit z_formatter(padding_info padinfo, pattern_time_type time_type)
+        : flag_formatter(padinfo),
+          time_type_(time_type) {}
 
     z_formatter() = default;
     z_formatter(const z_formatter &) = delete;
@@ -524,11 +525,15 @@ class z_formatter final : public flag_formatter {
     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) {
@@ -545,6 +550,7 @@ class z_formatter final : public flag_formatter {
     }
 
 private:
+    pattern_time_type time_type_;
     log_clock::time_point last_update_{std::chrono::seconds(0)};
     int offset_minutes_{0};
 
@@ -1161,7 +1167,8 @@ 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));
+            formatters_.push_back(
+                details::make_unique<details::z_formatter<Padder>>(padding, pattern_time_type_));
             need_localtime_ = true;
             break;
         case ('P'):  // pid
diff --git 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 16
+#define SPDLOG_VER_MINOR 17
 #define SPDLOG_VER_PATCH 0
 
 #define SPDLOG_TO_VERSION(major, minor, patch) (major * 10000 + minor * 100 + patch)
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
@@ -50,7 +50,9 @@ set(SPDLOG_UTESTS_SOURCES
     test_stopwatch.cpp
     test_circular_q.cpp
     test_bin_to_hex.cpp
-    test_ringbuffer.cpp)
+    test_ringbuffer.cpp
+    test_timezone.cpp
+)
 
 if(NOT SPDLOG_NO_EXCEPTIONS)
     list(APPEND SPDLOG_UTESTS_SOURCES test_errors.cpp)
diff --git a/tests/test_pattern_formatter.cpp b/tests/test_pattern_formatter.cpp
@@ -1,6 +1,6 @@
 #include "includes.h"
 #include "test_sink.h"
-
+#include <regex>
 #include <chrono>
 
 using spdlog::memory_buf_t;
@@ -77,18 +77,20 @@ TEST_CASE("date MM/DD/YY ", "[pattern_formatter]") {
             oss.str());
 }
 
-TEST_CASE("GMT offset ", "[pattern_formatter]") {
+// see test_timezone.cpp for actual UTC offset calculation tests
+TEST_CASE("UTC offset", "[pattern_formatter]") {
     using namespace std::chrono_literals;
     const auto now = std::chrono::system_clock::now();
-    const auto yesterday = now - 24h;
+    std::string result =
+        log_to_str_with_time(now, "Some message", "%z", spdlog::pattern_time_type::local, "\n");
 
 #ifndef SPDLOG_NO_TZ_OFFSET
-    const std::string expected_result = "+00:00\n";
+    // Match format: +HH:MM or -HH:MM
+    std::regex re(R"([+-]\d{2}:[0-5]\d\n)");
+    REQUIRE(std::regex_match(result, re));
 #else
-    const std::string expected_result = "+??:??\n";
+    REQUIRE(result == "+??:??\n");
 #endif
-    REQUIRE(log_to_str_with_time(yesterday, "Some message", "%z", spdlog::pattern_time_type::utc,
-                                 "\n") == expected_result);
 }
 
 TEST_CASE("color range test1", "[pattern_formatter]") {
diff --git a/tests/test_timezone.cpp b/tests/test_timezone.cpp
@@ -0,0 +1,146 @@
+#ifndef SPDLOG_NO_TZ_OFFSET
+
+#include "includes.h"
+#include <ctime>
+#include <cstdlib>
+#include <cstring>
+
+// Helper to construct a simple std::tm from components
+std::tm make_tm(int year, int month, int day, int hour, int minute) {
+    std::tm t;
+    std::memset(&t, 0, sizeof(t));
+    t.tm_year = year - 1900;
+    t.tm_mon = month - 1;
+    t.tm_mday = day;
+    t.tm_hour = hour;
+    t.tm_min = minute;
+    t.tm_sec = 0;
+    t.tm_isdst = -1;
+    std::mktime(&t);
+    return t;
+}
+
+// Cross-platform RAII Helper to safely set/restore process timezone
+class ScopedTZ {
+    std::string original_tz_;
+    bool has_original_ = false;
+
+public:
+    explicit ScopedTZ(const std::string& tz_name) {
+        // save current TZ
+#ifdef _WIN32
+        char* buf = nullptr;
+        size_t len = 0;
+        if (_dupenv_s(&buf, &len, "TZ") == 0 && buf != nullptr) {
+            original_tz_ = std::string(buf);
+            has_original_ = true;
+            free(buf);
+        }
+#else
+        const char* tz = std::getenv("TZ");
+        if (tz) {
+            original_tz_ = tz;
+            has_original_ = true;
+        }
+#endif
+
+        // set new TZ
+#ifdef _WIN32
+        _putenv_s("TZ", tz_name.c_str());
+        _tzset();
+#else
+        setenv("TZ", tz_name.c_str(), 1);
+        tzset();
+#endif
+    }
+
+    ~ScopedTZ() {
+        // restore original TZ
+#ifdef _WIN32
+        if (has_original_) {
+            _putenv_s("TZ", original_tz_.c_str());
+        } else {
+            _putenv_s("TZ", "");
+        }
+        _tzset();
+#else
+        if (has_original_) {
+            setenv("TZ", original_tz_.c_str(), 1);
+        } else {
+            unsetenv("TZ");
+        }
+        tzset();
+#endif
+    }
+};
+
+using spdlog::details::os::utc_minutes_offset;
+
+TEST_CASE("UTC Offset - Western Hemisphere (USA - Standard Time)", "[timezone][west]") {
+    // EST5EDT: Eastern Standard Time (UTC-5)
+    ScopedTZ tz("EST5EDT");
+
+    // Jan 15th (Winter)
+    auto tm = make_tm(2023, 1, 15, 12, 0);
+    REQUIRE(utc_minutes_offset(tm) == -300);
+}
+
+TEST_CASE("UTC Offset - Eastern Hemisphere (Europe/Israel - Standard Time)", "[timezone][east]") {
+    // IST-2IDT: Israel Standard Time (UTC+2)
+    ScopedTZ tz("IST-2IDT");
+
+    // Jan 15th (Winter)
+    auto tm = make_tm(2023, 1, 15, 12, 0);
+    REQUIRE(utc_minutes_offset(tm) == 120);
+}
+
+TEST_CASE("UTC Offset - Zero Offset (UTC/GMT)", "[timezone][utc]") {
+    ScopedTZ tz("GMT0");
+
+    // Check Winter
+    auto tm_winter = make_tm(2023, 1, 15, 12, 0);
+    REQUIRE(utc_minutes_offset(tm_winter) == 0);
+
+    // Check Summer (GMT never shifts, so this should also be 0)
+    auto tm_summer = make_tm(2023, 7, 15, 12, 0);
+    REQUIRE(utc_minutes_offset(tm_summer) == 0);
+}
+
+TEST_CASE("UTC Offset - Non-Integer Hour Offsets (India)", "[timezone][partial]") {
+    // IST-5:30: India Standard Time (UTC+5:30)
+    ScopedTZ tz("IST-5:30");
+
+    auto tm = make_tm(2023, 1, 15, 12, 0);
+    REQUIRE(utc_minutes_offset(tm) == 330);
+}
+
+TEST_CASE("UTC Offset - Edge Case: Negative Offset Crossing Midnight", "[timezone][edge]") {
+    ScopedTZ tz("EST5EDT");
+    // Late night Dec 31st, 2023
+    auto tm = make_tm(2023, 12, 31, 23, 59);
+    REQUIRE(utc_minutes_offset(tm) == -300);
+}
+
+TEST_CASE("UTC Offset - Edge Case: Leap Year", "[timezone][edge]") {
+    ScopedTZ tz("EST5EDT");
+    // Feb 29, 2024 (Leap Day) - Winter
+    auto tm = make_tm(2024, 2, 29, 12, 0);
+    REQUIRE(utc_minutes_offset(tm) == -300);
+}
+
+TEST_CASE("UTC Offset - Edge Case: Invalid Date (Pre-Epoch)", "[timezone][edge]") {
+#ifdef _WIN32
+    // Windows mktime returns -1 for dates before 1970.
+    // We expect the function to safely return 0 (fallback).
+    auto tm = make_tm(1960, 1, 1, 12, 0);
+    REQUIRE(utc_minutes_offset(tm) == 0);
+#else
+    // Unix mktime handles pre-1970 dates correctly.
+    // We expect the actual historical offset (EST was UTC-5 in 1960).
+    ScopedTZ tz("EST5EDT");
+    auto tm = make_tm(1960, 1, 1, 12, 0);
+    REQUIRE(utc_minutes_offset(tm) == -300);
+#endif
+}
+
+#endif  // !SPDLOG_NO_TZ_OFFSET

Original file line number	Diff line number	Diff line change
`@@ -69,10 +69,9 @@ class udp_client {`
`69`	`69`	`// Send exactly n_bytes of the given data.`
`70`	`70`	`// On error close the connection and throw.`
`71`	`71`	`void send(const char *data, size_t n_bytes) {`
`72`		`- ssize_t toslen = 0;`
`73`		`- socklen_t tolen = sizeof(struct sockaddr);`
`74`		`- if ((toslen = ::sendto(socket_, data, n_bytes, 0, (struct sockaddr *)&sockAddr_, tolen)) ==`
`75`		`- -1) {`
	`72`	`+ socklen_t tolen = sizeof(sockAddr_);`
	`73`	`+ if (::sendto(socket_, data, n_bytes, 0, reinterpret_cast<const sockaddr *>(&sockAddr_),`
	`74`	`+ tolen) == -1) {`
`76`	`75`	`throw_spdlog_ex("sendto(2) failed", errno);`
`77`	`76`	`}`
`78`	`77`	`}`