appender: add size based rolling

Author: x3ccd4828

tracing-appender/src/rolling.rs

@@ -108,6 +108,7 @@ struct Inner {
     rotation: Rotation,
     next_date: AtomicUsize,
     max_files: Option<usize>,
+    max_file_size: Option<u64>,
 }
 
 // === impl RollingFileAppender ===
@@ -190,6 +191,7 @@ impl RollingFileAppender {
             ref prefix,
             ref suffix,
             ref max_files,
+            ref max_file_size,
         } = builder;
         let directory = directory.as_ref().to_path_buf();
         let now = OffsetDateTime::now_utc();
@@ -200,6 +202,7 @@ impl RollingFileAppender {
             prefix.clone(),
             suffix.clone(),
             *max_files,
+            *max_file_size,
         )?;
         Ok(Self {
             state,
@@ -227,6 +230,8 @@ impl io::Write for RollingFileAppender {
             let _did_cas = self.state.advance_date(now, current_time);
             debug_assert!(_did_cas, "if we have &mut access to the appender, no other thread can have advanced the timestamp...");
             self.state.refresh_writer(now, writer);
+        } else if self.state.should_rollover_due_to_size(writer) {
+            self.state.refresh_writer(now, writer);
         }
         writer.write(buf)
     }
@@ -248,6 +253,8 @@ impl<'a> tracing_subscriber::fmt::writer::MakeWriter<'a> for RollingFileAppender
             if self.state.advance_date(now, current_time) {
                 self.state.refresh_writer(now, &mut self.writer.write());
             }
+        } else if self.state.should_rollover_due_to_size(&self.writer.write()) {
+            self.state.refresh_writer(now, &mut self.writer.write());
         }
         RollingWriter(self.writer.read())
     }
@@ -406,6 +413,38 @@ pub fn weekly(
     RollingFileAppender::new(Rotation::WEEKLY, directory, file_name_prefix)
 }
 
+/// Creates a size based rolling file appender.
+///
+/// The appender returned by `rolling::size` can be used with `non_blocking` to create
+/// a non-blocking, size based rotating appender.
+///
+/// The location of the log file will be specified by the `directory` passed in.
+/// `file_name` specifies the complete name of the log file.
+/// `RollingFileAppender` automatically appends the current date in UTC.
+///
+/// # Examples
+///
+/// ``` rust
+/// # #[clippy::allow(needless_doctest_main)]
+/// fn main () {
+/// # fn doc() {
+///     let appender = tracing_appender::rolling::size("/some/path", "rolling.log");
+///     let (non_blocking_appender, _guard) = tracing_appender::non_blocking(appender);
+///
+///     let collector = tracing_subscriber::fmt().with_writer(non_blocking_appender);
+///
+///     tracing::collect::with_default(collector.finish(), || {
+///         tracing::event!(tracing::Level::INFO, "Hello");
+///     });
+/// # }
+/// }
+/// ```
+///
+/// This will result in a log file located at `/some/path/rolling.log`.
+pub fn size(directory: impl AsRef<Path>, file_name: impl AsRef<Path>) -> RollingFileAppender {
+    RollingFileAppender::new(Rotation::SIZE, directory, file_name)
+}
+
 /// Creates a non-rolling file appender.
 ///
 /// The appender returned by `rolling::never` can be used with `non_blocking` to create
@@ -473,6 +512,14 @@ pub fn never(directory: impl AsRef<Path>, file_name: impl AsRef<Path>) -> Rollin
 /// # }
 /// ```
 ///
+/// ### Size Rotation
+/// ```rust
+/// # fn docs() {
+/// use tracing_appender::rolling::Rotation;
+/// let rotation = tracing_appender::rolling::Rotation::SIZE;
+/// # }
+/// ```
+///
 /// ### No Rotation
 /// ```rust
 /// # fn docs() {
@@ -489,6 +536,7 @@ enum RotationKind {
     Hourly,
     Daily,
     Weekly,
+    Size,
     Never,
 }
 
@@ -501,6 +549,8 @@ impl Rotation {
     pub const DAILY: Self = Self(RotationKind::Daily);
     /// Provides a weekly rotation that rotates every Sunday at midnight UTC.
     pub const WEEKLY: Self = Self(RotationKind::Weekly);
+    /// Provides a size based rotation
+    pub const SIZE: Self = Self(RotationKind::Size);
     /// Provides a rotation that never rotates.
     pub const NEVER: Self = Self(RotationKind::Never);
 
@@ -511,6 +561,7 @@ impl Rotation {
             Rotation::HOURLY => *current_date + Duration::hours(1),
             Rotation::DAILY => *current_date + Duration::days(1),
             Rotation::WEEKLY => *current_date + Duration::weeks(1),
+            Rotation::SIZE => return None,
             Rotation::NEVER => return None,
         };
         Some(self.round_date(unrounded_next_date))
@@ -546,6 +597,10 @@ impl Rotation {
                 let date = date - Duration::days(days_since_sunday.into());
                 date.replace_time(zero_time)
             }
+            // Rotation::SIZE is impossible to round.
+            Rotation::SIZE => {
+                unreachable!("Rotation::SIZE is impossible to round.")
+            }
             // Rotation::NEVER is impossible to round.
             Rotation::NEVER => {
                 unreachable!("Rotation::NEVER is impossible to round.")
@@ -559,6 +614,9 @@ impl Rotation {
             Rotation::HOURLY => format_description::parse("[year]-[month]-[day]-[hour]"),
             Rotation::DAILY => format_description::parse("[year]-[month]-[day]"),
             Rotation::WEEKLY => format_description::parse("[year]-[month]-[day]"),
+            Rotation::SIZE => format_description::parse(
+                "[year]-[month]-[day]-[hour]-[minute]-[second]-[subsecond]",
+            ),
             Rotation::NEVER => format_description::parse("[year]-[month]-[day]"),
         }
         .expect("Unable to create a formatter; this is a bug in tracing-appender")
@@ -587,6 +645,7 @@ impl Inner {
         log_filename_prefix: Option<String>,
         log_filename_suffix: Option<String>,
         max_files: Option<usize>,
+        max_file_size: Option<u64>,
     ) -> Result<(Self, RwLock<File>), builder::InitError> {
         let log_directory = directory.as_ref().to_path_buf();
         let date_format = rotation.date_format();
@@ -604,6 +663,7 @@ impl Inner {
             ),
             rotation,
             max_files,
+            max_file_size,
         };
         let filename = inner.join_date(&now);
         let writer = RwLock::new(create_writer(inner.log_directory.as_ref(), &filename)?);
@@ -743,6 +803,23 @@ impl Inner {
         None
     }
 
+    /// Checks whether or not the file needs to rollover because it reached the size limit.
+    ///
+    /// If this method returns `true`, we should roll to a new log file.
+    /// Otherwise, if this returns `false` we should not rotate the log file.
+    fn should_rollover_due_to_size(&self, current_file: &File) -> bool {
+        current_file.sync_all().ok();
+        if let (Ok(file_metadata), Some(max_file_size), &Rotation::SIZE) =
+            (current_file.metadata(), self.max_file_size, &self.rotation)
+        {
+            if file_metadata.len() >= max_file_size {
+                return true;
+            }
+        }
+
+        false
+    }
+
     fn advance_date(&self, now: OffsetDateTime, current: usize) -> bool {
         let next_date = self
             .rotation
@@ -835,6 +912,11 @@ mod test {
         test_appender(Rotation::WEEKLY, "weekly.log");
     }
 
+    #[test]
+    fn write_size_log() {
+        test_appender(Rotation::SIZE, "size.log");
+    }
+
     #[test]
     fn write_never_log() {
         test_appender(Rotation::NEVER, "never.log");
@@ -863,6 +945,11 @@ mod test {
         let next = Rotation::WEEKLY.next_date(&now).unwrap();
         assert!(now_rounded < next);
 
+        // size
+        let now = OffsetDateTime::now_utc();
+        let next = Rotation::SIZE.next_date(&now);
+        assert!(next.is_none());
+
         // never
         let now = OffsetDateTime::now_utc();
         let next = Rotation::NEVER.next_date(&now);
@@ -940,6 +1027,7 @@ mod test {
                 test_case.prefix.map(ToString::to_string),
                 test_case.suffix.map(ToString::to_string),
                 None,
+                None,
             )
             .unwrap();
             let path = inner.join_date(&test_case.now);
@@ -988,6 +1076,7 @@ mod test {
                 prefix.map(ToString::to_string),
                 suffix.map(ToString::to_string),
                 None,
+                None,
             )
             .unwrap();
             let path = inner.join_date(&now);
@@ -1018,6 +1107,12 @@ mod test {
                 prefix: Some("app.log"),
                 suffix: None,
             },
+            TestCase {
+                expected: "app.log.2020-02-01-10-01-00-0",
+                rotation: Rotation::SIZE,
+                prefix: Some("app.log"),
+                suffix: None,
+            },
             TestCase {
                 expected: "app.log",
                 rotation: Rotation::NEVER,
@@ -1043,6 +1138,12 @@ mod test {
                 prefix: Some("app"),
                 suffix: Some("log"),
             },
+            TestCase {
+                expected: "app.2020-02-01-10-01-00-0.log",
+                rotation: Rotation::SIZE,
+                prefix: Some("app"),
+                suffix: Some("log"),
+            },
             TestCase {
                 expected: "app.log",
                 rotation: Rotation::NEVER,
@@ -1068,6 +1169,12 @@ mod test {
                 prefix: None,
                 suffix: Some("log"),
             },
+            TestCase {
+                expected: "2020-02-01-10-01-00-0.log",
+                rotation: Rotation::SIZE,
+                prefix: None,
+                suffix: Some("log"),
+            },
             TestCase {
                 expected: "log",
                 rotation: Rotation::NEVER,
@@ -1100,6 +1207,7 @@ mod test {
             Some("test_make_writer".to_string()),
             None,
             None,
+            None,
         )
         .unwrap();
 
@@ -1182,6 +1290,7 @@ mod test {
             Some("test_max_log_files".to_string()),
             None,
             Some(2),
+            None,
         )
         .unwrap();
 
@@ -1265,4 +1374,79 @@ mod test {
             }
         }
     }
+
+    #[test]
+    fn test_size_based_rolling() {
+        use std::sync::{Arc, Mutex};
+        use tracing_subscriber::prelude::*;
+
+        let format = format_description::parse(
+            "[year]-[month]-[day] [hour]:[minute]:[second] [offset_hour \
+         sign:mandatory]:[offset_minute]:[offset_second]",
+        )
+        .unwrap();
+
+        const MAX_FILE_SIZE: u64 = 1024;
+        let now = OffsetDateTime::parse("2020-02-01 10:01:00 +00:00:00", &format).unwrap();
+        let directory = tempfile::tempdir().expect("failed to create tempdir");
+        let (state, writer) = Inner::new(
+            now,
+            Rotation::SIZE,
+            directory.path(),
+            Some("test_max_file_size".to_string()),
+            None,
+            Some(5),
+            Some(MAX_FILE_SIZE),
+        )
+        .unwrap();
+
+        let clock = Arc::new(Mutex::new(now));
+        let now = {
+            let clock = clock.clone();
+            Box::new(move || *clock.lock().unwrap())
+        };
+        let appender = RollingFileAppender { state, writer, now };
+        let default = tracing_subscriber::fmt()
+            .without_time()
+            .with_level(false)
+            .with_target(false)
+            .with_max_level(tracing_subscriber::filter::LevelFilter::TRACE)
+            .with_writer(appender)
+            .finish()
+            .set_default();
+
+        for file_num in 0..5 {
+            for i in 0..58 {
+                tracing::info!("file {} content {}", file_num, i);
+                (*clock.lock().unwrap()) += Duration::milliseconds(1);
+            }
+        }
+
+        drop(default);
+
+        let dir_contents = fs::read_dir(directory.path()).expect("Failed to read directory");
+        println!("dir={:?}", dir_contents);
+
+        for entry in dir_contents {
+            println!("entry={:?}", entry);
+            let path = entry.expect("Expected dir entry").path();
+            let file_fd = fs::File::open(&path).expect("Failed to open file");
+            let file_metadata = file_fd.metadata().expect("Failed to get file metadata");
+            println!(
+                "path={}\nfile_len={:?}",
+                path.display(),
+                file_metadata.len()
+            );
+            let file = fs::read_to_string(&path).expect("Failed to read file");
+            println!("path={}\nfile={:?}", path.display(), file);
+
+            assert_eq!(
+                MAX_FILE_SIZE + 10,
+                file_metadata.len(),
+                "expected size = {:?}, file size = {:?}",
+                MAX_FILE_SIZE,
+                file_metadata.len(),
+            );
+        }
+    }
 }