Fix endless loop if a single log message is bigger than buffer_writer's overall limit

Author: emabee

CHANGELOG.md

@@ -5,6 +5,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) and this
 project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.30.1] - 2025-04-02
+
+Fix endless loop if a single log message is bigger than `buffer_writer`'s overall limit.
+
 ## [0.30.0] - 2025-04-01
 
 Added non-default feature 'buffer_writer', which adds an in-memory log target with limited size and FIFO-logic.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "flexi_logger"
-version = "0.30.0"
+version = "0.30.1"
 authors = ["emabee <[email protected]>"]
 categories = ["development-tools::debugging"]
 description = """

src/logger.rs

@@ -233,6 +233,9 @@ impl Logger {
     /// The buffer has a maximum size (counting the bytes of the buffered message Strings)
     /// and drops the oldest messages when needed to observe the limit.
     ///
+    /// Once filled, the buffer will always contain at least the latest message,
+    /// even if this message is bigger than the limit.
+    ///
     /// The buffer content can be retrieved with [`LoggerHandle::update_snapshot`].
     ///
     /// # Errors

src/writers/buffer_writer.rs

@@ -12,7 +12,7 @@ use std::{
     time::Instant,
 };
 
-/// Allows logging to a memory buffer with limited size.
+// Allows logging to a memory buffer with limited size.
 pub struct BufferWriter {
     state: Arc<Mutex<State>>,
 }
@@ -24,29 +24,6 @@ struct State {
     format: FormatFunction,
 }
 
-/// Allows getting the current content of the memory buffer.
-#[derive(Clone)]
-pub struct Snapshot {
-    /// The latest snapshot of the memory buffer.
-    pub text: String,
-    last_update: Instant,
-}
-impl Snapshot {
-    /// Constructor.
-    #[must_use]
-    pub fn new() -> Self {
-        Self {
-            text: String::new(),
-            last_update: Instant::now(),
-        }
-    }
-}
-impl Default for Snapshot {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl BufferWriter {
     /// Create a new instance.
     pub fn new(max_size: usize, format: FormatFunction) -> Self {
@@ -61,7 +38,7 @@ impl BufferWriter {
         }
     }
 
-    fn lock_inner(&self) -> Result<std::sync::MutexGuard<'_, State>, std::io::Error> {
+    fn lock_state(&self) -> Result<std::sync::MutexGuard<'_, State>, std::io::Error> {
         self.state
             .lock()
             .map_err(|e| std::io::Error::other(e.to_string()))
@@ -77,41 +54,46 @@ impl BufferWriter {
     ///
     /// `FlexiLoggerError::Poison` if some mutex is poisoned.
     pub fn update_snapshot(&self, snapshot: &mut Snapshot) -> Result<bool, FlexiLoggerError> {
-        let inner = self.lock_inner()?;
-        if snapshot.last_update == inner.last_update {
+        let state = self.lock_state()?;
+        if snapshot.last_update == state.last_update {
             Ok(false)
         } else {
             snapshot.text.clear();
-            for bufline in &inner.buffer {
+            for bufline in &state.buffer {
                 snapshot.text.push_str(bufline);
                 snapshot.text.push('\n');
             }
-            snapshot.last_update = inner.last_update;
+            snapshot.last_update = state.last_update;
             Ok(true)
         }
     }
 }
 impl LogWriter for BufferWriter {
     fn write(&self, now: &mut DeferredNow, record: &Record) -> std::io::Result<()> {
-        let mut inner = self.lock_inner()?;
+        let mut state = self.lock_state()?;
 
         let mut logline = Vec::<u8>::with_capacity(80);
-        (inner.format)(&mut logline, now, record).inspect_err(|e| {
+        (state.format)(&mut logline, now, record).inspect_err(|e| {
             eprint_err(ErrorCode::Format, "formatting failed", &e);
         })?;
 
         if !logline.is_empty() {
-            while inner.size + logline.len() > inner.max_size {
-                if let Some(line) = inner.buffer.pop_front() {
-                    inner.size -= line.len();
+            if logline.len() > state.max_size {
+                state.buffer.clear();
+                state.size = 0;
+            } else {
+                while state.size + logline.len() > state.max_size {
+                    if let Some(line) = state.buffer.pop_front() {
+                        state.size -= line.len();
+                    }
                 }
             }
 
-            (inner)
+            (state)
                 .buffer
                 .push_back(String::from_utf8_lossy(&logline).to_string());
-            inner.size += logline.len();
-            inner.last_update = Instant::now();
+            state.size += logline.len();
+            state.last_update = Instant::now();
         }
         Ok(())
     }
@@ -121,3 +103,26 @@ impl LogWriter for BufferWriter {
         Ok(())
     }
 }
+
+/// Allows getting the current content of the memory buffer.
+#[derive(Clone)]
+pub struct Snapshot {
+    /// The latest snapshot of the memory buffer.
+    pub text: String,
+    last_update: Instant,
+}
+impl Snapshot {
+    /// Constructor.
+    #[must_use]
+    pub fn new() -> Self {
+        Self {
+            text: String::new(),
+            last_update: Instant::now(),
+        }
+    }
+}
+impl Default for Snapshot {
+    fn default() -> Self {
+        Self::new()
+    }
+}