improve LOG_EVERY_N logic

[Besroy]

As #874 discussed, there are two improvements for xxx_LOG_EVERY_N can do:

1. add log_per_time
2. add log cleanup

[xiaoxichen]

  Summary

  Refactor check_logged_already() to reduce memory footprint and enable time-based rate limiting

  Current Issues

  1. Memory leak: Map entries never deleted, only counters reset every 300s
    - High-cardinality logging (many chunk IDs, request IDs) causes unbounded growth
    - Each entry stores full message string (~124 bytes/entry)
    - Thread-local storage means memory scales with thread count
  2. Missing first occurrence: Current implementation logs at 100th, 200th, 300th... but skips the 1st occurrence
    - Users miss initial error that triggered the issue
  3. Limited rate-limiting options: Only supports count-based throttling (every N occurrences)
    - No time-based throttling (every N seconds)

  Proposed Improvements

  1. Periodic map cleanup (critical fix)

  - Clear entire map every 300s instead of just resetting counters
  - Prevents unbounded memory growth

  2. Use hash as map key

  - Hash the formatted message instead of storing full string
  - Reduces key size from ~100 bytes to 8 bytes

  3. Store millisecond offset instead of absolute timestamp

  - Track time since last cleanup (uint32_t milliseconds)
  - Reduces value from 24 bytes to 12 bytes (4 bytes timestamp + 8 bytes count)
  - Enables time-based rate limiting

  4. Log first occurrence

  - Change condition from if (count % N == 0) to if (count == 1 || count % N == 0)
  - Ensures critical first error is always visible

  5. Support time-based rate limiting (new capability)

  - Return both count and elapsed_ms
  - Enable new macros: HS_LOG_EVERY_N_SEC, HS_LOG_EVERY_N_OR_SEC

  Benefits

  - Memory reduction: ~124 bytes/entry → ~20 bytes/entry (6x improvement)
  - No memory leaks: Bounded memory usage via periodic cleanup
  - Better diagnostics: First occurrence always logged
  - More flexible rate limiting: Time-based and hybrid options
  - Production-safe: Handles high-cardinality scenarios without memory explosion

  Estimated Impact

  - 1000 unique messages: 124 KB → 20 KB per thread
  - Production systems with millions of log variations: Memory leak → bounded 20 KB baseline

[xiaoxichen]

  Proposed Design

  static std::pair<uint64_t, uint32_t> check_logged_already(const fmt::memory_buffer& buf) {
      static constexpr uint64_t COUNTER_RESET_SEC{300};
      static thread_local Clock::time_point last_cleanup{Clock::now()};
      static thread_local std::unordered_map<size_t, std::pair<uint32_t, uint64_t>> log_map{};
      // hash -> (last_log_ms, count)

      const auto now = Clock::now();
      if (get_elapsed_time_sec(last_cleanup) > COUNTER_RESET_SEC) {
          log_map.clear();
          last_cleanup = now;
      }

      const std::string_view msg{buf.data(), buf.size()};
      const size_t msg_hash = std::hash<std::string_view>{}(msg);

      // Milliseconds since last cleanup (max ~49 days with uint32_t)
      const uint32_t now_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
          now - last_cleanup).count();

      auto [it, happened] = log_map.emplace(msg_hash, std::make_pair(now_ms, 1));
      uint32_t elapsed_ms = 0;
      if (!happened) {
          elapsed_ms = now_ms - it->second.first;  // Time since last log
          it->second.first = now_ms;                // Update last log time
          it->second.second++;                      // Increment count
      }

      return {it->second.second, elapsed_ms};  // (count, ms_since_last_log)
  }

  Memory Usage

  - Key: size_t (8 bytes)
  - Value: std::pair<uint32_t, uint64_t> (4 + 8 = 12 bytes)
  - Total: 20 bytes/entry (still ~6x better than original 124 bytes!)

  New Capabilities

  1. Original LOG_EVERY_N

  const auto [count, _] = check_logged_already(buf);
  if (count % freq == 0) {
      return true;  // Log every N occurrences
  }

  2. New LOG_EVERY_N_SECONDS

  #define HS_LOG_EVERY_N_SEC(level, mod, interval_sec, msg, ...)
      const auto [count, elapsed_ms] = check_logged_already(buf);
      if (count == 1 || elapsed_ms >= interval_sec * 1000) {
          if (count > 1) {
              fmt::vformat_to(buf, " ...Last logged {:.1f}s ago, count={}",
                             elapsed_ms / 1000.0, count);
          }
          return true;
      }

[Besroy]

Another AI proposal:

 [[maybe_unused]] static bool should_log_by_interval(const fmt::memory_buffer& buf, uint64_t interval_sec) {
      static thread_local std::unordered_map<std::string, Clock::time_point> log_time_map{};

      const std::string_view msg{buf.data()};
      auto now = Clock::now();

      if (log_time_map.size() > 1000) {
          for (auto it = log_time_map.begin(); it != log_time_map.end();) {
              if (get_elapsed_time_sec(it->second) > 600) {
                  it = log_time_map.erase(it);
              } else {
                  ++it;
              }
          }
      }

      auto [it, is_new] = log_time_map.try_emplace(std::string{msg}, now);

      if (is_new) return true;

      if (get_elapsed_time_sec(it->second) >= interval_sec) {
          it->second = now;
          return true;
      }

      return false;
  }