[WIP] Cache time only once

spdlog/src/formatter/local_time_cacher.rs

@@ -1,4 +1,4 @@
-use std::time::SystemTime;
+use std::{fmt, time::SystemTime};
 
 use chrono::prelude::*;
 use once_cell::sync::Lazy;
@@ -20,6 +20,12 @@ pub(crate) struct TimeDate<'a> {
     millisecond: u32,
 }
 
+impl fmt::Debug for TimeDate<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("TimeDate").finish()
+    }
+}
+
 #[derive(Clone, Eq, PartialEq)]
 enum CacheKey {
     NonLeap(i64),

spdlog/src/formatter/mod.rs

@@ -95,15 +95,19 @@ clone_trait_object!(Formatter);
 
 /// Provides context for formatters.
 #[derive(Debug, Default)]
-pub struct FormatterContext {
+pub struct FormatterContext<'a> {
     style_range: Option<Range<usize>>,
+    time_date: Option<TimeDate<'a>>,
 }
 
-impl FormatterContext {
+impl FormatterContext<'_> {
     /// Constructs a `FormatterContext`.
     #[must_use]
     pub fn new() -> Self {
-        Self { style_range: None }
+        Self {
+            style_range: None,
+            time_date: None,
+        }
     }
 
     /// Sets style range (in bytes) of the formatted text.

spdlog/src/formatter/pattern_formatter/mod.rs

@@ -5,14 +5,17 @@ pub mod __pattern;
 #[cfg(feature = "runtime-pattern")]
 mod runtime;
 
-use std::{fmt::Write, sync::Arc};
+use std::{
+    fmt::{self, Write},
+    sync::Arc,
+};
 
 use dyn_clone::*;
 #[cfg(feature = "runtime-pattern")]
 pub use runtime::*;
 
 use crate::{
-    formatter::{Formatter, FormatterContext},
+    formatter::{Formatter, FormatterContext, TimeDate, LOCAL_TIME_CACHER},
     Error, Record, StringBuf,
 };
 
@@ -373,15 +376,19 @@ where
         &self,
         record: &Record,
         dest: &mut StringBuf,
-        ctx: &mut FormatterContext,
+        fmt_ctx: &mut FormatterContext,
     ) -> crate::Result<()> {
         cfg_if::cfg_if! {
             if #[cfg(not(feature = "flexible-string"))] {
                 dest.reserve(crate::string_buf::RESERVE_SIZE);
             }
         };
 
-        let mut ctx = PatternContext::new(ctx);
+        let mut local_time_cacher = LOCAL_TIME_CACHER.lock();
+        let mut ctx = PatternContext {
+            fmt_ctx,
+            time_date: local_time_cacher.get(record.time()),
+        };
         self.pattern.format(record, dest, &mut ctx)?;
         Ok(())
     }
@@ -392,15 +399,8 @@ where
 /// There is nothing to set up here at the moment, reserved for future use.
 #[derive(Debug)]
 pub struct PatternContext<'a> {
-    fmt_ctx: &'a mut FormatterContext,
-}
-
-impl<'a> PatternContext<'a> {
-    /// Creates a new `PatternContext` object.
-    #[must_use]
-    fn new(fmt_ctx: &'a mut FormatterContext) -> Self {
-        Self { fmt_ctx }
-    }
+    fmt_ctx: &'a mut FormatterContext<'a>,
+    time_date: TimeDate<'a>,
 }
 
 /// Represents a pattern for replacing a placeholder in templates.
@@ -1221,7 +1221,11 @@ pub mod tests {
         let record = get_mock_record();
         let mut output = StringBuf::new();
         let mut fmt_ctx = FormatterContext::new();
-        let mut pat_ctx = PatternContext::new(&mut fmt_ctx);
+        let mut local_time_cacher = LOCAL_TIME_CACHER.lock();
+        let mut pat_ctx = PatternContext {
+            fmt_ctx: &mut fmt_ctx,
+            time_date: local_time_cacher.get(record.time()),
+        };
 
         let format_result = pattern.format(&record, &mut output, &mut pat_ctx);
         assert!(format_result.is_ok());