Merge branch 'main' into RobertJacobsonCDC-upendra1997-adding-wasm-as-target

Author: RobertJacobsonCDC

CHANGELOG.md

@@ -1,5 +1,33 @@
 # Change Log
 
+## [1.4.0]
+
+### Fixed
+
+* Two minor typo fixes in `Configuration.md`. (#425 @RobertJacobsonCDC)
+
+### New
+
+* Support for Key-Value pairs (#362 @ellttBen)
+* Add time serialization into log file (#374 @TuEmb)
+* Public `TimeTriggerConfig` fields (#370 @Dirreke)
+* Left truncation unicode support (#285 @moh-eulith)
+* Zstd compression for log files (#363 @cristian-prato)
+* Add onstartup trigger (#343 @Dirreke)
+* Add config parsing tests (#357 @bconn98)
+* Add handle retrieval after log initialization (#393 @izolyomi)
+
+### Changed
+
+* update mock_instant and small refactor (#424 @CosminPerRam)
+* remove oncecell dependency (#423 @CosminPerRam)
+* MSRV to 1.75
+* Update deps: (thread-id, thiserror, mock_instant, rand)
+* Remove derivative crate (#408 @royb3)
+* Remove where_clauses_object_safety lint allow (#377 @Dirreke)
+* Refactor of time trigger logic (#347 @Dirreke)
+* Readme updated (#361 @bconn98)
+
 ## [1.4.0-rc2]
 
 ### Changed

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "log4rs"
-version = "1.4.0-rc2"
+version = "1.4.0"
 authors = [
     "Steven Fackler <[email protected]>",
     "Evan Simmons <[email protected]>",
@@ -48,7 +48,7 @@ console_writer = ["ansi_writer", "libc", "winapi"]
 simple_writer = []
 threshold_filter = []
 background_rotation = []
-log_kv = ["log/kv"]
+log_kv = ["log/kv", "log/kv_serde"]
 
 all_components = [
     "console_appender",

src/append/console.rs

@@ -52,7 +52,7 @@ enum Writer {
 }
 
 impl Writer {
-    fn lock(&self) -> WriterLock {
+    fn lock(&self) -> WriterLock<'_> {
         match *self {
             Writer::Tty(ref w) => WriterLock::Tty(w.lock()),
             Writer::Raw(ref w) => WriterLock::Raw(SimpleWriter(w.lock())),

src/encode/json.rs

@@ -189,7 +189,7 @@ mod kv {
             value: log::kv::Value<'kvs>,
         ) -> Result<(), log::kv::Error> {
             self.0
-                .serialize_entry(key.as_str(), &value.to_string())
+                .serialize_entry(key.as_str(), &value)
                 .map_err(|e| log::kv::Error::boxed(e.to_string()))?;
             Ok(())
         }
@@ -213,7 +213,7 @@ mod kv {
 mod test {
     #[cfg(feature = "chrono")]
     use chrono::{DateTime, Local};
-    use log::Level;
+    use log::{Level, Record};
 
     use super::*;
     use crate::encode::writer::simple::SimpleWriter;
@@ -232,6 +232,15 @@ mod test {
         let thread = "encode::json::test::default";
         log_mdc::insert("foo", "bar");
 
+        #[cfg(feature = "log_kv")]
+        #[derive(serde::Serialize)]
+        struct SerdeValue {
+            id: u32,
+        }
+
+        #[cfg(feature = "log_kv")]
+        let serde_value = SerdeValue { id: 42 };
+
         let encoder = JsonEncoder::new();
 
         let mut record_builder = Record::builder();
@@ -243,19 +252,25 @@ mod test {
             .line(Some(line));
 
         #[cfg(feature = "log_kv")]
-        record_builder.key_values(&[("log_foo", "log_bar")]);
+        let kvs = [
+            ("log_foo", log::kv::Value::from("log_bar")),
+            ("serde_val", log::kv::Value::from_serde(&serde_value)),
+        ];
+        #[cfg(feature = "log_kv")]
+        record_builder.key_values(&kvs);
 
         let mut buf = vec![];
         encoder
             .encode_inner(
                 &mut SimpleWriter(&mut buf),
                 time,
-                &record_builder.args(format_args!("{}", message)).build(),
+                &record_builder.args(format_args!("{message}")).build(),
             )
             .unwrap();
 
         #[cfg(feature = "log_kv")]
-        let expected_attributes = ",\"attributes\":{\"log_foo\":\"log_bar\"}";
+        let expected_attributes =
+            ",\"attributes\":{\"log_foo\":\"log_bar\",\"serde_val\":{\"id\":42}}";
         #[cfg(not(feature = "log_kv"))]
         let expected_attributes = "";
 

src/encode/writer/console.rs

@@ -67,7 +67,7 @@ impl ConsoleWriter {
     }
 
     /// Locks the console, preventing other threads from writing concurrently.
-    pub fn lock(&self) -> ConsoleWriterLock {
+    pub fn lock(&self) -> ConsoleWriterLock<'_> {
         ConsoleWriterLock(self.0.lock())
     }
 }
@@ -172,7 +172,7 @@ mod imp {
             }
         }
 
-        pub fn lock(&self) -> WriterLock {
+        pub fn lock(&self) -> WriterLock<'_> {
             WriterLock(AnsiWriter((self.0).0.lock()))
         }
     }
@@ -410,9 +410,13 @@ mod imp {
     }
 
     impl Writer {
-        pub fn stdout() -> Option<Writer> {
+        fn create_writer(inner_writer: StdWriter) -> Option<Writer> {
             unsafe {
-                let handle = processenv::GetStdHandle(winbase::STD_OUTPUT_HANDLE);
+                let handle = match inner_writer {
+                    StdWriter::Stdout(_) => processenv::GetStdHandle(winbase::STD_OUTPUT_HANDLE),
+                    StdWriter::Stderr(_) => processenv::GetStdHandle(winbase::STD_ERROR_HANDLE),
+                };
+
                 if handle.is_null() || handle == handleapi::INVALID_HANDLE_VALUE {
                     return None;
                 }
@@ -427,7 +431,7 @@ mod imp {
                         handle,
                         defaults: info.wAttributes,
                     },
-                    inner: StdWriter::stdout(),
+                    inner: inner_writer,
                 };
 
                 match color_mode() {
@@ -437,31 +441,12 @@ mod imp {
             }
         }
 
-        pub fn stderr() -> Option<Writer> {
-            unsafe {
-                let handle = processenv::GetStdHandle(winbase::STD_ERROR_HANDLE);
-                if handle.is_null() || handle == handleapi::INVALID_HANDLE_VALUE {
-                    return None;
-                }
-
-                let mut info = mem::zeroed();
-                if wincon::GetConsoleScreenBufferInfo(handle, &mut info) == 0 {
-                    return None;
-                }
-
-                let writer = Writer {
-                    console: RawConsole {
-                        handle,
-                        defaults: info.wAttributes,
-                    },
-                    inner: StdWriter::stdout(),
-                };
+        pub fn stdout() -> Option<Writer> {
+            Self::create_writer(StdWriter::stdout())
+        }
 
-                match color_mode() {
-                    ColorMode::Auto | ColorMode::Always => Some(writer),
-                    ColorMode::Never => None,
-                }
-            }
+        pub fn stderr() -> Option<Writer> {
+            Self::create_writer(StdWriter::stderr())
         }
 
         pub fn lock<'a>(&'a self) -> WriterLock<'a> {

src/priv_io.rs

@@ -17,7 +17,7 @@ impl StdWriter {
         StdWriter::Stderr(io::stderr())
     }
 
-    pub fn lock(&self) -> StdWriterLock {
+    pub fn lock(&self) -> StdWriterLock<'_> {
         match *self {
             StdWriter::Stdout(ref w) => StdWriterLock::Stdout(w.lock()),
             StdWriter::Stderr(ref w) => StdWriterLock::Stderr(w.lock()),