diff --git a/.github/workflows/ci_test.yml b/.github/workflows/ci_test.yml
index 14f2bcf..6e3474d 100644
--- a/.github/workflows/ci_test.yml
+++ b/.github/workflows/ci_test.yml
@@ -57,7 +57,7 @@ jobs:
     strategy:
       matrix:
         os: [ ubuntu-latest, windows-latest, macos-latest ]
-        rust: [ stable, 1.64.0 ]
+        rust: [ stable, 1.66.1 ]
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v2
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 89a01f3..5d5cc6f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,15 @@ 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.26.1] - 2023-09-19
+
+Introduce new naming variants that work without `_rCURRENT` files: `Naming::TimestampsDirect`
+and `Naming::NumbersDirect` (fixes #127).
+
+Improve documentation of filename handling.
+
+Introduce `LoggerHandle.trigger_rotation()` (fixes #147).
+
 ## [0.26.0] - 2023-08-30
 
 Re-open output also for other writers (fixes #143).
diff --git a/Cargo.toml b/Cargo.toml
index 3cab97d..452ffd9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "flexi_logger"
-version = "0.26.0"
+version = "0.26.1"
 authors = ["emabee <meinolf.block@sap.com>"]
 categories = ["development-tools::debugging"]
 description = """
@@ -15,7 +15,7 @@ keywords = ["file", "logger"]
 license = "MIT OR Apache-2.0"
 readme = "README.md"
 repository = "https://github.com/emabee/flexi_logger"
-rust-version = "1.64.0"
+rust-version = "1.66.0"
 
 [lib]
 doctest = false
@@ -55,7 +55,7 @@ regex = { version = "1.1", optional = true }
 serde = { version = "1.0", optional = true }
 serde_derive = { version = "1.0", optional = true }
 thiserror = "1.0"
-toml = { version = "0.7", optional = true }
+toml = { version = "0.8", optional = true }
 tracing = { version = "0.1.36", optional = true }
 tracing-subscriber = { version = "0.3", optional = true, features = [
     "env-filter",
diff --git a/README.md b/README.md
index f6360e1..4a3f4f5 100644
--- a/README.md
+++ b/README.md
@@ -60,7 +60,7 @@ See
 
 ## Minimal rust version
 
-The minimal supported rust version is currently "1.64.0",
+The minimal supported rust version is currently "1.66.0",
 due to a change in a patch version of a dependency.
 
 ## Crate Features
diff --git a/scripts/cleanup.rs b/scripts/cleanup.rs
index ad8a7b5..4f65a22 100755
--- a/scripts/cleanup.rs
+++ b/scripts/cleanup.rs
@@ -22,7 +22,6 @@ fn main() {
         "./log_files/**/*.log",
         "./log_files/**/*.seclog",
         "./log_files/**/*.toml",
-        "./log_files/**/*.zip",
         "./server/**/*.toml",
     ] {
         for globresult in glob::glob(pattern).unwrap() {
diff --git a/scripts/qualify.rs b/scripts/qualify.rs
index c7b93e2..1870837 100755
--- a/scripts/qualify.rs
+++ b/scripts/qualify.rs
@@ -48,8 +48,8 @@ fn main() {
 
     // Build in important variants
     std::fs::remove_file("Cargo.lock").ok();
-    run_command!("cargo", "+1.64.0", "build", "--no-default-features");
-    run_command!("cargo", "+1.64.0", "build", "--all-features");
+    run_command!("cargo", "+1.66.1", "build", "--no-default-features");
+    run_command!("cargo", "+1.66.1", "build", "--all-features");
 
     std::fs::remove_file("Cargo.lock").ok();
     run_command!("cargo", "build");
@@ -67,7 +67,7 @@ fn main() {
     run_command!("cargo", "+nightly", "clippy", "--all-targets", "--all-features", "--", "-D", "warnings");
 
     // Run tests in important variants
-    run_command!("cargo", "+1.64.0", "test", "--all-features");
+    run_command!("cargo", "+1.66.1", "test", "--all-features");
     run_command!("cargo", "test", "--release", "--all-features");
     run_command!("cargo", "test", "--no-default-features");
     run_command!("cargo", "test", "--release");
diff --git a/src/file_spec.rs b/src/file_spec.rs
index 9de3dae..2e7e19f 100644
--- a/src/file_spec.rs
+++ b/src/file_spec.rs
@@ -4,17 +4,29 @@ use std::path::{Path, PathBuf};
 
 /// Builder object for specifying the name and path of the log output file.
 ///
-/// ```rust
-/// # use flexi_logger::FileSpec;
-/// assert_eq!(
-///     FileSpec::default()
-///         .directory("/a/b/c")
-///         .basename("foo")
-///         .suppress_timestamp()
-///         .suffix("bar"),
-///     FileSpec::try_from("/a/b/c/foo.bar").unwrap()
-/// );
-/// ```
+/// The filename is built from several partially optional components, using this pattern:
+///
+/// ```<basename>[_<discriminant>][_<date>_<time>][_infix][.<suffix>]```
+///
+/// The default filename pattern without rotation uses the program name as basename,
+/// no discriminant, the timestamp of the program start, and the suffix `.log`,
+/// e.g.
+///
+/// ```myprog_2015-07-08_10-44-11.log```.
+///
+/// This ensures that with every program start a new trace file is written that can easily
+/// be associated with a concrete program run.
+///
+/// When the timestamp is suppressed with [`FileSpec::suppress_timestamp`],
+/// you get a fixed output file.
+/// It is then worth considering whether a new program start should discard
+/// the content of an already existing outputfile or if it should append its new content to it
+/// (see [`Logger::append`](crate::Logger::append)).
+///
+/// With rotation the timestamp is by default suppressed and instead the infix is used.
+/// The infix always starts with "_r". For more details how its precise content can be influenced,
+/// see [`Naming`](crate::Naming).
+///
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct FileSpec {
     pub(crate) directory: PathBuf,
@@ -50,6 +62,17 @@ impl FileSpec {
     /// If it exists, it must be a file, not a folder.
     /// If necessary, parent folders will be created.
     ///
+    /// ```rust
+    /// # use flexi_logger::FileSpec;
+    /// assert_eq!(
+    ///     FileSpec::default()
+    ///         .directory("/a/b/c")
+    ///         .basename("foo")
+    ///         .suppress_timestamp()
+    ///         .suffix("bar"),
+    ///     FileSpec::try_from("/a/b/c/foo.bar").unwrap()
+    /// );
+    /// ```
     /// # Errors
     ///
     /// [`FlexiLoggerError::OutputBadFile`] if the given path exists and is a folder.
@@ -177,7 +200,7 @@ impl FileSpec {
         self.directory.clone()
     }
 
-    /// Creates a `PathBuf` to the described log file.
+    /// Derives a `PathBuf` from the spec and the given infix.
     ///
     /// It is composed like this:
     ///  `<directory>/<basename>_<discr>_<timestamp><infix>.<suffix>`
@@ -206,8 +229,8 @@ impl FileSpec {
         p_path
     }
 
-    // <directory>/<basename>_<discr>_<timestamp><infix>.<suffix>
-    pub(crate) fn as_glob_pattern(&self, o_infix: Option<&str>, o_suffix: Option<&str>) -> String {
+    // <directory>/<basename>_<discr>_<timestamp><infix_pattern>.<suffix>
+    pub(crate) fn as_glob_pattern(&self, infix_pattern: &str, o_suffix: Option<&str>) -> String {
         let mut filename = self.basename.clone();
         filename.reserve(50);
 
@@ -218,9 +241,8 @@ impl FileSpec {
         if let Some(timestamp) = &self.timestamp_cfg.get_timestamp() {
             filename.push_str(timestamp);
         }
-        if let Some(infix) = o_infix {
-            filename.push_str(infix);
-        };
+        filename.push_str(infix_pattern);
+
         match o_suffix {
             Some(s) => {
                 filename.push('.');
diff --git a/src/logger.rs b/src/logger.rs
index be4dbfa..8eecdbe 100644
--- a/src/logger.rs
+++ b/src/logger.rs
@@ -187,9 +187,7 @@ impl Logger {
 
     /// Log is written to a file.
     ///
-    ///
-    /// The default filename pattern is `<program_name>_<date>_<time>.<suffix>`,
-    ///  e.g. `myprog_2015-07-08_10-44-11.log`.
+    /// See [`FileSpec`] for details about the filename pattern.
     ///
     /// You can duplicate to stdout and stderr, and you can add additional writers.
     #[must_use]
@@ -858,7 +856,7 @@ pub(crate) fn create_specfile_watcher<S: LogSpecSubscriber>(
 
     let mut debouncer = new_debouncer(
         std::time::Duration::from_millis(1000),
-        None,
+        None, // <--- goes away with notify-debouncer-mini version 0.4
         move |res: DebounceEventResult| match res {
             Ok(events) => events.iter().for_each(|e| {
                 if e.path
@@ -888,6 +886,11 @@ pub(crate) fn create_specfile_watcher<S: LogSpecSubscriber>(
                     &e,
                 );
             }),
+            // Err(e) => eprint_err(
+            //     ErrorCode::LogSpecFile,
+            //     "error while watching the specfile",
+            //     &e,
+            // ),
         },
     )
     .unwrap();
diff --git a/src/logger_handle.rs b/src/logger_handle.rs
index 2af9db1..1ad9edb 100644
--- a/src/logger_handle.rs
+++ b/src/logger_handle.rs
@@ -271,6 +271,23 @@ impl LoggerHandle {
         result
     }
 
+    /// Trigger an extra log file rotation.
+    ///
+    /// Does nothing if rotation is not configured.
+    ///
+    /// # Errors
+    ///
+    /// `FlexiLoggerError::Poison` if some mutex is poisoned.
+    pub fn trigger_rotation(&self) -> Result<(), FlexiLoggerError> {
+        if let PrimaryWriter::Multi(ref mw) = &*self.writers_handle.primary_writer {
+            mw.trigger_rotation()?;
+        }
+        // for blw in self.writers_handle.other_writers.values() {
+        //     let result2 = blw.trigger_rotation(); // todo is not (yet?) part of trait LogWriter
+        // }
+        Ok(())
+    }
+
     /// Shutdown all participating writers.
     ///
     /// This method is supposed to be called at the very end of your program, if
diff --git a/src/parameters.rs b/src/parameters.rs
index 33b88c5..651c112 100644
--- a/src/parameters.rs
+++ b/src/parameters.rs
@@ -71,17 +71,47 @@ pub enum Age {
 
 /// The naming convention for rotated log files.
 ///
-/// With file rotation, the logs are written to a file with infix `_rCURRENT`.
-/// When rotation happens, the CURRENT log file will be renamed to a file with
-/// another infix of the form `"_r..."`. `Naming` defines which other infix will be used.
+/// Common rule for all variants is that the names of the current output file
+/// and the rotated log files only differ in the infix.
+///
+/// See [`Logger::log_to_file`](crate::Logger::log_to_file)
+/// for a description of how the filename is built, including the infix.
+///
+/// See the variants for how the infix is used by them.
 ///
 /// Used in [`Logger::rotate`](crate::Logger::rotate).
 #[derive(Copy, Clone, Debug)]
 pub enum Naming {
-    /// File rotation rotates to files with a timestamp-infix, like `"r2020-01-27_14-41-08"`.
+    /// Logs are written to a file with infix `_rCURRENT`.
+    ///
+    /// File rotation renames this file to a name with a timestamp-infix
+    /// like `"_r2023-01-27_14-41-08"`, logging continues with a fresh file with infix `_rCURRENT`.
+    ///
+    /// If multiple rotations happen within the same second, extended infixes are used like
+    /// `"_r2023-01-27_14-41-08.restart-0001"`.
     Timestamps,
-    /// File rotation rotates to files with a number-infix.
+
+    /// Logs are written to a file with a timestamp-infix,
+    /// like `"_r2023-01-27_14-41-08"`.
+    ///
+    /// File rotation switches over to the next file.
+    ///
+    /// If multiple rotations happen within the same second, extended infixes are used like
+    /// `"_r2023-01-27_14-41-08.restart-0001"`.
+    TimestampsDirect,
+
+    /// Logs are written to a file with infix `_rCURRENT`.
+    ///
+    /// File rotation renames this file to a name with a number-infix
+    /// like `"_r00000"`, `"_r00001"`, etc.,
+    /// logging continues with a fresh file with infix `_rCURRENT`.
     Numbers,
+
+    /// Logs are written to a file with a number-infix,
+    /// like `"_r00000"`, `"_r00001"`, etc.
+    ///
+    /// File rotation switches over to the next file.
+    NumbersDirect,
 }
 /// Defines the strategy for handling older log files.
 ///
diff --git a/src/primary_writer/multi_writer.rs b/src/primary_writer/multi_writer.rs
index 5d6af89..8211c72 100644
--- a/src/primary_writer/multi_writer.rs
+++ b/src/primary_writer/multi_writer.rs
@@ -93,6 +93,16 @@ impl MultiWriter {
     fn duplication_to_stdout(&self) -> Duplicate {
         Duplicate::from(self.duplicate_stdout.load(Ordering::Relaxed))
     }
+
+    pub(crate) fn trigger_rotation(&self) -> Result<(), FlexiLoggerError> {
+        if let Some(ref w) = &self.o_file_writer {
+            w.trigger_rotation()?;
+        }
+        // if let Some(w) = &self.o_other_writer {
+        //     w.trigger_rotation(); // todo is not (yet?) part of trait LogWriter
+        // }
+        Ok(())
+    }
 }
 
 impl LogWriter for MultiWriter {
diff --git a/src/writers/file_log_writer.rs b/src/writers/file_log_writer.rs
index b998f43..1792cec 100644
--- a/src/writers/file_log_writer.rs
+++ b/src/writers/file_log_writer.rs
@@ -7,7 +7,6 @@ mod threads;
 
 pub use self::builder::{ArcFileLogWriter, FileLogWriterBuilder, FileLogWriterHandle};
 pub use self::config::FileLogWriterConfig;
-pub(crate) use self::state::remove_or_compress_too_old_logfiles_impl;
 
 use self::{config::RotationConfig, state::State, state_handle::StateHandle};
 use crate::{
@@ -70,12 +69,6 @@ impl FileLogWriter {
         self.state_handle.format_function()
     }
 
-    #[must_use]
-    #[doc(hidden)]
-    pub fn current_filename(&self) -> PathBuf {
-        self.state_handle.current_filename()
-    }
-
     pub(crate) fn plain_write(&self, buffer: &[u8]) -> std::result::Result<usize, std::io::Error> {
         self.state_handle.plain_write(buffer)
     }
@@ -132,10 +125,20 @@ impl FileLogWriter {
         self.state_handle.reopen_outputfile()
     }
 
+    /// Trigger an extra log file rotation.
+    ///
+    /// Does nothing if rotation is not configured.
+    ///
+    /// # Errors
+    ///
+    /// `FlexiLoggerError::Poison` if some mutex is poisoned.
+    pub fn trigger_rotation(&self) -> Result<(), FlexiLoggerError> {
+        self.state_handle.force_rotation()
+    }
+
     /// Returns the list of existing log files according to the current `FileSpec`.
     ///
     /// The list includes the current log file and the compressed files, if they exist.
-    /// The list is empty if the logger is not configured for writing to files.
     ///
     /// # Errors
     ///
diff --git a/src/writers/file_log_writer/state.rs b/src/writers/file_log_writer/state.rs
index 057b06f..0627331 100644
--- a/src/writers/file_log_writer/state.rs
+++ b/src/writers/file_log_writer/state.rs
@@ -1,152 +1,214 @@
-use super::{
-    config::{FileLogWriterConfig, RotationConfig},
-    threads::{start_cleanup_thread, MessageToCleanupThread},
-};
+mod list_and_cleanup;
+mod numbers;
+mod timestamps;
+
+use super::config::{FileLogWriterConfig, RotationConfig};
 use crate::{
     util::{eprint_err, ErrorCode},
-    Age, Cleanup, Criterion, FileSpec, FlexiLoggerError, Naming,
+    Age, Cleanup, Criterion, FlexiLoggerError, Naming,
 };
 use chrono::{DateTime, Datelike, Local, Timelike};
-use std::cmp::max;
-use std::fs::{remove_file, File, OpenOptions};
-use std::io::{BufRead, BufReader, BufWriter, Write};
-use std::iter::Chain;
-use std::ops::Add;
-use std::path::{Path, PathBuf};
-use std::vec::IntoIter;
-const CURRENT_INFIX: &str = "_rCURRENT";
-fn number_infix(idx: u32) -> String {
-    format!("_r{idx:0>5}")
-}
+use std::{
+    fs::{remove_file, File, OpenOptions},
+    io::{BufRead, BufReader, BufWriter, Write},
+    path::{Path, PathBuf},
+    sync::{Arc, Mutex},
+    thread::JoinHandle,
+};
 
-//  Describes the latest existing numbered log file.
-#[derive(Clone, Copy, Debug)]
-enum IdxState {
-    // We rotate to numbered files, and no rotated numbered file exists yet
-    Start,
-    // highest index of rotated numbered files
-    Idx(u32),
-}
+#[cfg(feature = "async")]
+const ASYNC_FLUSHER: &str = "flexi_logger-fs-async_flusher";
+
+#[cfg(feature = "async")]
+use {
+    crate::util::{ASYNC_FLUSH, ASYNC_SHUTDOWN},
+    crossbeam_channel::{self, Sender as CrossbeamSender},
+    crossbeam_queue::ArrayQueue,
+};
+
+#[cfg(feature = "async")]
+const ASYNC_WRITER: &str = "flexi_logger-fs-async_writer";
+
+const CURRENT_INFIX: &str = "_rCURRENT";
 
-// Created_at is needed both for
-//      is_rotation_necessary() -> if Criterion::Age -> NamingState::CreatedAt
-//      and rotate_to_date()    -> if Naming::Timestamps -> RollState::Age
 #[derive(Debug)]
 enum NamingState {
-    CreatedAt,
-    IdxState(IdxState),
+    // contains the timestamp to which we will rotate
+    TimestampsRCurrent(DateTime<Local>),
+
+    // contains the timestamp of the current output file (read from its name)
+    TimestampsDirect(DateTime<Local>),
+
+    // contains the index to which we will rotate
+    NumbersRCurrent(u32),
+
+    // contains the index of the current output file
+    NumbersDirect(u32),
 }
 
 #[derive(Debug)]
 enum RollState {
-    Size(u64, u64), // max_size, current_size
-    Age(Age),
-    AgeOrSize(Age, u64, u64), // age, max_size, current_size
+    Size {
+        max_size: u64,
+        current_size: u64,
+    },
+    Age {
+        age: Age,
+        created_at: DateTime<Local>,
+    },
+    AgeOrSize {
+        age: Age,
+        created_at: DateTime<Local>,
+        max_size: u64,
+        current_size: u64,
+    },
 }
+impl RollState {
+    fn new(criterion: Criterion, append: bool, path: &Path) -> Result<RollState, std::io::Error> {
+        let current_size = if append {
+            std::fs::metadata(path)?.len()
+        } else {
+            0
+        };
+        let created_at = get_creation_date(path);
+
+        Ok(match criterion {
+            Criterion::Age(age) => RollState::Age { age, created_at },
+            Criterion::Size(max_size) => RollState::Size {
+                max_size,
+                current_size,
+            },
+            Criterion::AgeOrSize(age, max_size) => RollState::AgeOrSize {
+                age,
+                created_at,
+                max_size,
+                current_size,
+            },
+        })
+    }
 
-#[derive(Debug)]
-struct CleanupThreadHandle {
-    sender: std::sync::mpsc::Sender<MessageToCleanupThread>,
-    join_handle: std::thread::JoinHandle<()>,
-}
+    fn rotation_necessary(&self) -> bool {
+        match &self {
+            RollState::Size {
+                max_size,
+                current_size,
+            } => Self::size_rotation_necessary(*max_size, *current_size),
+            RollState::Age { age, created_at } => Self::age_rotation_necessary(*age, created_at),
+            RollState::AgeOrSize {
+                age,
+                created_at,
+                max_size,
+                current_size,
+            } => {
+                Self::size_rotation_necessary(*max_size, *current_size)
+                    || Self::age_rotation_necessary(*age, created_at)
+            }
+        }
+    }
 
-#[derive(Debug)]
-struct RotationState {
-    naming_state: NamingState,
-    roll_state: RollState,
-    created_at: DateTime<Local>,
-    cleanup: Cleanup,
-    o_cleanup_thread_handle: Option<CleanupThreadHandle>,
-}
-impl RotationState {
     fn size_rotation_necessary(max_size: u64, current_size: u64) -> bool {
         current_size > max_size
     }
 
-    fn age_rotation_necessary(&self, age: Age) -> bool {
+    fn age_rotation_necessary(age: Age, created_at: &DateTime<Local>) -> bool {
         let now = Local::now();
         match age {
             Age::Day => {
-                self.created_at.year() != now.year()
-                    || self.created_at.month() != now.month()
-                    || self.created_at.day() != now.day()
+                created_at.year() != now.year()
+                    || created_at.month() != now.month()
+                    || created_at.day() != now.day()
             }
             Age::Hour => {
-                self.created_at.year() != now.year()
-                    || self.created_at.month() != now.month()
-                    || self.created_at.day() != now.day()
-                    || self.created_at.hour() != now.hour()
+                created_at.year() != now.year()
+                    || created_at.month() != now.month()
+                    || created_at.day() != now.day()
+                    || created_at.hour() != now.hour()
             }
             Age::Minute => {
-                self.created_at.year() != now.year()
-                    || self.created_at.month() != now.month()
-                    || self.created_at.day() != now.day()
-                    || self.created_at.hour() != now.hour()
-                    || self.created_at.minute() != now.minute()
+                created_at.year() != now.year()
+                    || created_at.month() != now.month()
+                    || created_at.day() != now.day()
+                    || created_at.hour() != now.hour()
+                    || created_at.minute() != now.minute()
             }
             Age::Second => {
-                self.created_at.year() != now.year()
-                    || self.created_at.month() != now.month()
-                    || self.created_at.day() != now.day()
-                    || self.created_at.hour() != now.hour()
-                    || self.created_at.minute() != now.minute()
-                    || self.created_at.second() != now.second()
+                created_at.year() != now.year()
+                    || created_at.month() != now.month()
+                    || created_at.day() != now.day()
+                    || created_at.hour() != now.hour()
+                    || created_at.minute() != now.minute()
+                    || created_at.second() != now.second()
             }
         }
     }
 
-    fn rotation_necessary(&self) -> bool {
-        match &self.roll_state {
-            RollState::Size(max_size, current_size) => {
-                Self::size_rotation_necessary(*max_size, *current_size)
+    fn reset_size_and_date(&mut self, path: &Path) {
+        match self {
+            RollState::Size {
+                max_size: _,
+                current_size,
+            } => {
+                *current_size = 0;
             }
-            RollState::Age(age) => self.age_rotation_necessary(*age),
-            RollState::AgeOrSize(age, max_size, current_size) => {
-                Self::size_rotation_necessary(*max_size, *current_size)
-                    || self.age_rotation_necessary(*age)
+            RollState::Age { age: _, created_at } => {
+                *created_at = get_creation_date(path);
             }
+            RollState::AgeOrSize {
+                age: _,
+                created_at,
+                max_size: _,
+                current_size,
+            } => {
+                *created_at = get_creation_date(path);
+                *current_size = 0;
+            }
+        }
+    }
+
+    fn increase_size(&mut self, add: u64) {
+        if let RollState::Size {
+            max_size: _,
+            ref mut current_size,
+        }
+        | RollState::AgeOrSize {
+            age: _,
+            created_at: _,
+            max_size: _,
+            ref mut current_size,
+        } = *self
+        {
+            *current_size += add;
         }
     }
+}
+
+#[derive(Debug)]
+struct CleanupThreadHandle {
+    sender: std::sync::mpsc::Sender<list_and_cleanup::MessageToCleanupThread>,
+    join_handle: JoinHandle<()>,
+}
 
+#[derive(Debug)]
+struct RotationState {
+    naming_state: NamingState,
+    roll_state: RollState,
+    cleanup: Cleanup,
+    o_cleanup_thread_handle: Option<CleanupThreadHandle>,
+}
+impl RotationState {
     fn shutdown(&mut self) {
         // this sets o_cleanup_thread_handle in self.state.o_rotation_state to None:
         let o_cleanup_thread_handle = self.o_cleanup_thread_handle.take();
         if let Some(cleanup_thread_handle) = o_cleanup_thread_handle {
             cleanup_thread_handle
                 .sender
-                .send(MessageToCleanupThread::Die)
+                .send(list_and_cleanup::MessageToCleanupThread::Die)
                 .ok();
             cleanup_thread_handle.join_handle.join().ok();
         }
     }
 }
 
-fn try_roll_state_from_criterion(
-    criterion: Criterion,
-    config: &FileLogWriterConfig,
-    p_path: &Path,
-) -> Result<RollState, std::io::Error> {
-    Ok(match criterion {
-        Criterion::Age(age) => RollState::Age(age),
-        Criterion::Size(size) => {
-            let written_bytes = if config.append {
-                std::fs::metadata(p_path)?.len()
-            } else {
-                0
-            };
-            RollState::Size(size, written_bytes)
-        } // max_size, current_size
-        Criterion::AgeOrSize(age, size) => {
-            let written_bytes = if config.append {
-                std::fs::metadata(p_path)?.len()
-            } else {
-                0
-            };
-            RollState::AgeOrSize(age, size, written_bytes)
-        } // age, max_size, current_size
-    })
-}
-
 enum Inner {
     Initial(Option<RotationConfig>, bool),
     Active(Option<RotationState>, Box<dyn Write + Send>, PathBuf),
@@ -184,68 +246,90 @@ impl State {
         if let Inner::Initial(o_rotation_config, cleanup_in_background_thread) = &self.inner {
             match o_rotation_config {
                 None => {
-                    let (log_file, _created_at, p_path) = open_log_file(&self.config, false)?;
-                    self.inner = Inner::Active(None, log_file, p_path);
+                    // no rotation
+                    let (write, path) = open_log_file(&self.config, None)?;
+                    self.inner = Inner::Active(None, write, path);
                 }
                 Some(rotate_config) => {
-                    // first rotate, then open the log file
-                    let naming_state = match rotate_config.naming {
-                        Naming::Timestamps => {
-                            if !self.config.append {
-                                rotate_output_file_to_date(
-                                    &get_creation_date(
-                                        &self.config.file_spec.as_pathbuf(Some(CURRENT_INFIX)),
-                                    ),
-                                    &self.config,
-                                )?;
-                            }
-                            NamingState::CreatedAt
+                    // get NamingState and the infix for the current output file
+                    let (naming_state, infix) = match rotate_config.naming {
+                        Naming::Timestamps => (
+                            NamingState::TimestampsRCurrent(timestamps::rcurrents_creation_date(
+                                &self.config,
+                                None,
+                                !self.config.append,
+                            )?),
+                            CURRENT_INFIX.to_string(),
+                        ),
+                        Naming::TimestampsDirect => {
+                            let ts = timestamps::latest_timestamp_file(
+                                &self.config,
+                                !self.config.append,
+                            );
+                            (
+                                NamingState::TimestampsDirect(ts),
+                                timestamps::ts_infix_from_timestamp(&ts, self.config.use_utc),
+                            )
                         }
-                        Naming::Numbers => {
-                            let mut rotation_state = get_highest_rotate_idx(&self.config.file_spec);
-                            if !self.config.append {
-                                rotation_state =
-                                    rotate_output_file_to_idx(rotation_state, &self.config)?;
-                            }
-                            NamingState::IdxState(rotation_state)
+
+                        Naming::Numbers => (
+                            NamingState::NumbersRCurrent(numbers::index_for_rcurrent(
+                                &self.config,
+                                None,
+                                !self.config.append,
+                            )?),
+                            CURRENT_INFIX.to_string(),
+                        ),
+                        Naming::NumbersDirect => {
+                            let idx = match numbers::get_highest_index(&self.config.file_spec) {
+                                None => 0,
+                                Some(idx) => {
+                                    if self.config.append {
+                                        idx
+                                    } else {
+                                        idx + 1
+                                    }
+                                }
+                            };
+                            (NamingState::NumbersDirect(idx), numbers::number_infix(idx))
                         }
                     };
-                    let (log_file, created_at, p_path) = open_log_file(&self.config, true)?;
-
-                    let roll_state = try_roll_state_from_criterion(
-                        rotate_config.criterion,
-                        &self.config,
-                        &p_path,
-                    )?;
-                    let mut o_cleanup_thread_handle = None;
-                    if rotate_config.cleanup.do_cleanup() {
-                        remove_or_compress_too_old_logfiles(
+                    let (write, path) = open_log_file(&self.config, Some(&infix))?;
+
+                    let roll_state =
+                        RollState::new(rotate_config.criterion, self.config.append, &path)?;
+
+                    let o_cleanup_thread_handle = if rotate_config.cleanup.do_cleanup() {
+                        list_and_cleanup::remove_or_compress_too_old_logfiles(
                             &None,
                             &rotate_config.cleanup,
                             &self.config.file_spec,
                         )?;
                         if *cleanup_in_background_thread {
-                            let (sender, join_handle) = start_cleanup_thread(
+                            let (sender, join_handle) = list_and_cleanup::start_cleanup_thread(
                                 rotate_config.cleanup,
                                 self.config.file_spec.clone(),
                             )?;
 
-                            o_cleanup_thread_handle = Some(CleanupThreadHandle {
+                            Some(CleanupThreadHandle {
                                 sender,
                                 join_handle,
-                            });
+                            })
+                        } else {
+                            None
                         }
-                    }
+                    } else {
+                        None
+                    };
                     self.inner = Inner::Active(
                         Some(RotationState {
                             naming_state,
                             roll_state,
-                            created_at,
                             cleanup: rotate_config.cleanup,
                             o_cleanup_thread_handle,
                         }),
-                        log_file,
-                        p_path,
+                        write,
+                        path,
                     );
                 }
             }
@@ -269,30 +353,52 @@ impl State {
     // On overflow, an existing `_rCURRENT` file is renamed to the next numbered file,
     // before writing into `_rCURRENT` goes on.
     #[inline]
-    fn mount_next_linewriter_if_necessary(&mut self) -> Result<(), FlexiLoggerError> {
-        if let Inner::Active(Some(ref mut rotation_state), ref mut file, ref mut path) = self.inner
+    pub(super) fn mount_next_linewriter_if_necessary(
+        &mut self,
+        force: bool,
+    ) -> Result<(), FlexiLoggerError> {
+        if let Inner::Active(
+            Some(ref mut rotation_state),
+            ref mut current_write,
+            ref mut current_path,
+        ) = self.inner
         {
-            if rotation_state.rotation_necessary() {
-                match rotation_state.naming_state {
-                    NamingState::CreatedAt => {
-                        rotate_output_file_to_date(&rotation_state.created_at, &self.config)?;
+            if force || rotation_state.roll_state.rotation_necessary() {
+                let infix = match rotation_state.naming_state {
+                    NamingState::TimestampsRCurrent(ref mut created_at) => {
+                        *created_at = timestamps::rcurrents_creation_date(
+                            &self.config,
+                            Some(created_at),
+                            true,
+                        )?;
+                        CURRENT_INFIX.to_string()
                     }
-                    NamingState::IdxState(ref mut idx_state) => {
-                        *idx_state = rotate_output_file_to_idx(*idx_state, &self.config)?;
+                    NamingState::TimestampsDirect(ref mut ts) => {
+                        *ts = Local::now();
+                        timestamps::collision_free_infix_for_rotated_file(
+                            &self.config.file_spec,
+                            self.config.use_utc,
+                            ts,
+                        )
                     }
-                }
+                    NamingState::NumbersRCurrent(ref mut idx_state) => {
+                        *idx_state =
+                            numbers::index_for_rcurrent(&self.config, Some(*idx_state), true)?;
+                        CURRENT_INFIX.to_string()
+                    }
+                    NamingState::NumbersDirect(ref mut idx_state) => {
+                        *idx_state += 1;
+                        numbers::number_infix(*idx_state)
+                    }
+                };
+                let (new_write, new_path) = open_log_file(&self.config, Some(&infix))?;
 
-                let (line_writer, created_at, p_path) = open_log_file(&self.config, true)?;
-                *file = line_writer;
-                *path = p_path;
-                rotation_state.created_at = created_at;
-                if let RollState::Size(_, ref mut current_size)
-                | RollState::AgeOrSize(_, _, ref mut current_size) = rotation_state.roll_state
-                {
-                    *current_size = 0;
-                }
+                *current_write = new_write;
+                *current_path = new_path;
 
-                remove_or_compress_too_old_logfiles(
+                rotation_state.roll_state.reset_size_and_date(current_path);
+
+                list_and_cleanup::remove_or_compress_too_old_logfiles(
                     &rotation_state.o_cleanup_thread_handle,
                     &rotation_state.cleanup,
                     &self.config.file_spec,
@@ -309,44 +415,21 @@ impl State {
         }
 
         // rotate if necessary
-        self.mount_next_linewriter_if_necessary()
+        self.mount_next_linewriter_if_necessary(false)
             .unwrap_or_else(|e| {
                 eprint_err(ErrorCode::LogFile, "can't open file", &e);
             });
 
         if let Inner::Active(ref mut o_rotation_state, ref mut log_file, ref _path) = self.inner {
             log_file.write_all(buf)?;
+
             if let Some(ref mut rotation_state) = o_rotation_state {
-                if let RollState::Size(_, ref mut current_size)
-                | RollState::AgeOrSize(_, _, ref mut current_size) = rotation_state.roll_state
-                {
-                    *current_size += buf.len() as u64;
-                }
+                rotation_state.roll_state.increase_size(buf.len() as u64);
             };
         }
         Ok(())
     }
 
-    pub fn current_filename(&self) -> PathBuf {
-        let o_infix = match &self.inner {
-            Inner::Initial(o_rotation_config, _) => {
-                if o_rotation_config.is_some() {
-                    Some(CURRENT_INFIX)
-                } else {
-                    None
-                }
-            }
-            Inner::Active(o_rotation_state, _, _) => {
-                if o_rotation_state.is_some() {
-                    Some(CURRENT_INFIX)
-                } else {
-                    None
-                }
-            }
-        };
-        self.config.file_spec.as_pathbuf(o_infix)
-    }
-
     pub fn reopen_outputfile(&mut self) -> Result<(), std::io::Error> {
         if let Inner::Active(_, ref mut file, ref p_path) = self.inner {
             match OpenOptions::new().create(true).append(true).open(p_path) {
@@ -371,7 +454,8 @@ impl State {
 
     pub fn existing_log_files(&self) -> Vec<PathBuf> {
         let mut list: Vec<PathBuf> =
-            list_of_log_and_compressed_files(&self.config.file_spec).collect();
+            list_and_cleanup::list_of_log_and_compressed_files(&self.config.file_spec).collect();
+        // todo this should only be returned if the file exists:
         list.push(self.config.file_spec.as_pathbuf(Some(CURRENT_INFIX)));
         list
     }
@@ -384,9 +468,8 @@ impl State {
             let rotation_possible = o_rotation_state.is_some();
             let f = File::open(path.clone()).unwrap_or_else(|e| {
                 panic!(
-                    "validate_logs: can't open file {} due to {:?}",
+                    "validate_logs: can't open file {} due to {e:?}",
                     path.display(),
-                    e
                 )
             });
             let mut reader = BufReader::new(f);
@@ -456,11 +539,9 @@ fn validate_logs_in_file(
 #[allow(clippy::type_complexity)]
 fn open_log_file(
     config: &FileLogWriterConfig,
-    with_rotation: bool,
-) -> Result<(Box<dyn Write + Send>, DateTime<Local>, PathBuf), std::io::Error> {
-    let path = config
-        .file_spec
-        .as_pathbuf(with_rotation.then_some(CURRENT_INFIX));
+    o_infix: Option<&str>,
+) -> Result<(Box<dyn Write + Send>, PathBuf), std::io::Error> {
+    let path = config.file_spec.as_pathbuf(o_infix);
 
     if config.print_message {
         println!("Log is written to {}", &path.display());
@@ -481,225 +562,7 @@ fn open_log_file(
     } else {
         Box::new(logfile)
     };
-    Ok((w, get_creation_date(&path), path))
-}
-
-fn get_highest_rotate_idx(file_spec: &FileSpec) -> IdxState {
-    let mut highest_idx = IdxState::Start;
-    for file in list_of_log_and_compressed_files(file_spec) {
-        let filename = file.file_stem().unwrap(/*ok*/).to_string_lossy();
-        let mut it = filename.rsplit("_r");
-        match it.next() {
-            Some(next) => {
-                let idx: u32 = next.parse().unwrap_or(0);
-                highest_idx = match highest_idx {
-                    IdxState::Start => IdxState::Idx(idx),
-                    IdxState::Idx(prev) => IdxState::Idx(max(prev, idx)),
-                };
-            }
-            None => continue, // ignore unexpected files
-        }
-    }
-    highest_idx
-}
-
-#[allow(clippy::type_complexity)]
-fn list_of_log_and_compressed_files(
-    file_spec: &FileSpec,
-) -> Chain<Chain<IntoIter<PathBuf>, IntoIter<PathBuf>>, IntoIter<PathBuf>> {
-    let o_infix = Some("_r[0-9]*");
-
-    let log_pattern = file_spec.as_glob_pattern(o_infix, None);
-    let zip_pattern = file_spec.as_glob_pattern(o_infix, Some("zip"));
-    let gz_pattern = file_spec.as_glob_pattern(o_infix, Some("gz"));
-
-    list_of_files(&log_pattern)
-        .chain(list_of_files(&gz_pattern))
-        .chain(list_of_files(&zip_pattern))
-}
-
-fn list_of_files(pattern: &str) -> std::vec::IntoIter<PathBuf> {
-    let mut log_files: Vec<PathBuf> = glob::glob(pattern)
-        .unwrap(/* failure should be impossible */)
-        .filter_map(Result::ok)
-        .collect();
-    log_files.reverse();
-    log_files.into_iter()
-}
-
-fn remove_or_compress_too_old_logfiles(
-    o_cleanup_thread_handle: &Option<CleanupThreadHandle>,
-    cleanup_config: &Cleanup,
-    file_spec: &FileSpec,
-) -> Result<(), std::io::Error> {
-    o_cleanup_thread_handle.as_ref().map_or_else(
-        || remove_or_compress_too_old_logfiles_impl(cleanup_config, file_spec),
-        |cleanup_thread_handle| {
-            cleanup_thread_handle
-                .sender
-                .send(MessageToCleanupThread::Act)
-                .ok();
-            Ok(())
-        },
-    )
-}
-
-pub(crate) fn remove_or_compress_too_old_logfiles_impl(
-    cleanup_config: &Cleanup,
-    file_spec: &FileSpec,
-) -> Result<(), std::io::Error> {
-    let (log_limit, compress_limit) = match *cleanup_config {
-        Cleanup::Never => {
-            return Ok(());
-        }
-        Cleanup::KeepLogFiles(log_limit) => (log_limit, 0),
-
-        #[cfg(feature = "compress")]
-        Cleanup::KeepCompressedFiles(compress_limit) => (0, compress_limit),
-
-        #[cfg(feature = "compress")]
-        Cleanup::KeepLogAndCompressedFiles(log_limit, compress_limit) => {
-            (log_limit, compress_limit)
-        }
-    };
-
-    for (index, file) in list_of_log_and_compressed_files(file_spec).enumerate() {
-        if index >= log_limit + compress_limit {
-            // delete (log or log.gz)
-            std::fs::remove_file(file)?;
-        } else if index >= log_limit {
-            #[cfg(feature = "compress")]
-            {
-                // compress, if not yet compressed
-                if let Some(extension) = file.extension() {
-                    if extension != "gz" {
-                        let mut old_file = File::open(file.clone())?;
-                        let mut compressed_file = file.clone();
-                        compressed_file.set_extension("log.gz");
-                        let mut gz_encoder = flate2::write::GzEncoder::new(
-                            File::create(compressed_file)?,
-                            flate2::Compression::fast(),
-                        );
-                        std::io::copy(&mut old_file, &mut gz_encoder)?;
-                        gz_encoder.finish()?;
-                        std::fs::remove_file(&file)?;
-                    }
-                }
-            }
-        }
-    }
-
-    Ok(())
-}
-
-// Moves the current file to the timestamp of the CURRENT file's creation date.
-// If the rotation comes very fast, the new timestamp can be equal to the old one.
-// To avoid file collisions, we insert an additional string to the filename (".restart-<number>").
-// The number is incremented in case of repeated collisions.
-// Cleaning up can leave some restart-files with higher numbers; if we still are in the same
-// second, we need to continue with the restart-incrementing.
-fn rotate_output_file_to_date(
-    creation_date: &DateTime<Local>,
-    config: &FileLogWriterConfig,
-) -> Result<(), std::io::Error> {
-    let current_path = config.file_spec.as_pathbuf(Some(CURRENT_INFIX));
-    let rotated_path = determine_new_name_for_rotate_output_file_to_date(
-        &config.file_spec,
-        config.use_utc,
-        creation_date,
-    );
-
-    match std::fs::rename(current_path, rotated_path) {
-        Ok(()) => Ok(()),
-        Err(e) => {
-            if e.kind() == std::io::ErrorKind::NotFound {
-                // current did not exist, so we had nothing to do
-                Ok(())
-            } else {
-                Err(e)
-            }
-        }
-    }
-}
-
-fn determine_new_name_for_rotate_output_file_to_date(
-    file_spec: &FileSpec,
-    use_utc: bool,
-    creation_date: &DateTime<Local>,
-) -> PathBuf {
-    const INFIX_DATE: &str = "_r%Y-%m-%d_%H-%M-%S";
-    let infix_date_string = if use_utc {
-        (*creation_date).naive_utc().format(INFIX_DATE)
-    } else {
-        (*creation_date).format(INFIX_DATE)
-    }
-    .to_string();
-
-    let mut rotated_path = file_spec.as_pathbuf(Some(&infix_date_string));
-    // Search for rotated_path as is and for restart-siblings;
-    // if any exists, find highest restart and add 1, else continue without restart
-    let mut pattern = rotated_path.clone();
-    if file_spec.o_suffix.is_some() {
-        pattern.set_extension("");
-    }
-    let mut pattern = pattern.to_string_lossy().to_string();
-    pattern.push_str(".restart-*");
-    let mut restart_siblings: Vec<PathBuf> =
-        glob::glob(&pattern).unwrap(/*ok*/).map(Result::unwrap).collect();
-    restart_siblings.sort_unstable();
-    if (*rotated_path).exists() || !restart_siblings.is_empty() {
-        let mut number = if restart_siblings.is_empty() {
-            0
-        } else {
-            rotated_path = restart_siblings.pop().unwrap(/*ok*/);
-            let file_stem_string = if file_spec.o_suffix.is_some() {
-                rotated_path
-                    .file_stem().unwrap(/*ok*/)
-                    .to_string_lossy().to_string()
-            } else {
-                rotated_path.to_string_lossy().to_string()
-            };
-            let index = file_stem_string.find(".restart-").unwrap(/*ok*/);
-            file_stem_string[(index + 9)..].parse::<usize>().unwrap(/*ok*/)
-        };
-
-        while (*rotated_path).exists() {
-            rotated_path = file_spec.as_pathbuf(Some(
-                &infix_date_string
-                    .clone()
-                    .add(&format!(".restart-{number:04}")),
-            ));
-            number += 1;
-        }
-    }
-    rotated_path
-}
-
-// Moves the current file to the name with the next rotate_idx and returns the next rotate_idx.
-// The current file must be closed already.
-fn rotate_output_file_to_idx(
-    idx_state: IdxState,
-    config: &FileLogWriterConfig,
-) -> Result<IdxState, std::io::Error> {
-    let new_idx = match idx_state {
-        IdxState::Start => 0,
-        IdxState::Idx(idx) => idx + 1,
-    };
-
-    match std::fs::rename(
-        config.file_spec.as_pathbuf(Some(CURRENT_INFIX)),
-        config.file_spec.as_pathbuf(Some(&number_infix(new_idx))),
-    ) {
-        Ok(()) => Ok(IdxState::Idx(new_idx)),
-        Err(e) => {
-            if e.kind() == std::io::ErrorKind::NotFound {
-                // current did not exist, so we had nothing to do
-                Ok(idx_state)
-            } else {
-                Err(e)
-            }
-        }
-    }
+    Ok((w, path))
 }
 
 // See documentation of Criterion::Age.
@@ -715,7 +578,6 @@ fn get_creation_date(path: &Path) -> DateTime<Local> {
             .unwrap_or_else(|_| get_current_date())
     }
 }
-
 fn try_get_creation_date(path: &Path) -> Result<DateTime<Local>, FlexiLoggerError> {
     Ok(std::fs::metadata(path)?.created()?.into())
 }
@@ -728,6 +590,96 @@ fn get_current_date() -> DateTime<Local> {
     Local::now()
 }
 
+#[cfg(feature = "async")]
+pub(super) fn start_async_fs_writer(
+    am_state: Arc<Mutex<State>>,
+    message_capa: usize,
+    a_pool: Arc<ArrayQueue<Vec<u8>>>,
+) -> (CrossbeamSender<Vec<u8>>, Mutex<Option<JoinHandle<()>>>) {
+    let (sender, receiver) = crossbeam_channel::unbounded::<Vec<u8>>();
+    (
+        sender,
+        Mutex::new(Some(
+            std::thread::Builder::new()
+                .name(ASYNC_WRITER.to_string())
+                .spawn(move || loop {
+                    match receiver.recv() {
+                        Err(_) => break,
+                        Ok(mut message) => {
+                            let mut state = am_state.lock().unwrap(/* ok */);
+                            match message.as_ref() {
+                                ASYNC_FLUSH => {
+                                    state.flush().unwrap_or_else(|e| {
+                                        eprint_err(ErrorCode::Flush, "flushing failed", &e);
+                                    });
+                                }
+                                ASYNC_SHUTDOWN => {
+                                    state.shutdown();
+                                    break;
+                                }
+                                _ => {
+                                    state.write_buffer(&message).unwrap_or_else(|e| {
+                                        eprint_err(ErrorCode::Write, "writing failed", &e);
+                                    });
+                                }
+                            }
+                            if message.capacity() <= message_capa {
+                                message.clear();
+                                a_pool.push(message).ok();
+                            }
+                        }
+                    }
+                })
+                .expect("Couldn't spawn flexi_logger-async_file_log_writer"),
+        )),
+    )
+}
+
+pub(super) fn start_sync_flusher(am_state: Arc<Mutex<State>>, flush_interval: std::time::Duration) {
+    let builder = std::thread::Builder::new().name("flexi_logger-flusher".to_string());
+    #[cfg(not(feature = "dont_minimize_extra_stacks"))]
+    let builder = builder.stack_size(128);
+    builder.spawn(move || {
+        let (_tx, rx) = std::sync::mpsc::channel::<()>();
+            loop {
+                rx.recv_timeout(flush_interval).ok();
+                (*am_state).lock().map_or_else(
+                    |_e| (),
+                    |mut state| {
+                        state.flush().ok();
+                    },
+                );
+            }
+        })
+        .unwrap(/* yes, let's panic if the thread can't be spawned */);
+}
+
+#[cfg(feature = "async")]
+pub(crate) fn start_async_fs_flusher(
+    async_writer: CrossbeamSender<Vec<u8>>,
+    flush_interval: std::time::Duration,
+) {
+    use crate::util::eprint_msg;
+
+    let builder = std::thread::Builder::new().name(ASYNC_FLUSHER.to_string());
+    #[cfg(not(feature = "dont_minimize_extra_stacks"))]
+    let builder = builder.stack_size(128);
+    builder.spawn(move || {
+            let (_tx, rx) = std::sync::mpsc::channel::<()>();
+            loop {
+                if let Err(std::sync::mpsc::RecvTimeoutError::Disconnected) =
+                    rx.recv_timeout(flush_interval)
+                {
+                    eprint_msg(ErrorCode::Flush, "Flushing unexpectedly stopped working");
+                    break;
+                }
+
+                async_writer.send(ASYNC_FLUSH.to_vec()).ok();
+            }
+        })
+        .unwrap(/* yes, let's panic if the thread can't be spawned */);
+}
+
 mod platform {
     #[cfg(target_family = "unix")]
     use crate::util::{eprint_err, ErrorCode};
@@ -755,3 +707,127 @@ mod platform {
     #[cfg(not(target_family = "unix"))]
     fn unix_create_symlink(_: &Path, _: &Path) {}
 }
+
+#[cfg(test)]
+mod test {
+    use chrono::Local;
+
+    use super::list_and_cleanup::list_of_files;
+
+    use crate::{
+        writers::{file_log_writer::config::RotationConfig, FileLogWriterConfig},
+        Cleanup, Criterion, FileSpec, Naming, WriteMode,
+    };
+
+    use super::State;
+
+    fn write_log_entries(file_spec: &FileSpec, timestamps: bool, rcurrent: bool) {
+        {
+            let mut state1 = State::new(
+                get_flw_config(file_spec.clone(), true),
+                Some(get_rotation_config(timestamps, rcurrent)),
+                false,
+            );
+            // write to it to provoke some rotations
+            for _ in 0..17 {
+                std::thread::sleep(std::time::Duration::from_millis(60));
+                state1
+                    .write_buffer(b"hello world hello world hello world hello world\n")
+                    .unwrap();
+            }
+        }
+
+        // restart with a new instance of State with append
+        {
+            let mut state2 = State::new(
+                get_flw_config(file_spec.clone(), true),
+                Some(get_rotation_config(timestamps, rcurrent)),
+                false,
+            );
+            // write to it to provoke some rotations
+            for _ in 0..23 {
+                std::thread::sleep(std::time::Duration::from_millis(60));
+                state2
+                    .write_buffer(b"hello world hello world hello world hello world\n")
+                    .unwrap();
+            }
+        }
+
+        // restart with a new instance of State without append
+        {
+            let mut state3 = State::new(
+                get_flw_config(file_spec.clone(), false),
+                Some(get_rotation_config(timestamps, rcurrent)),
+                false,
+            );
+            // write to it to provoke some rotations
+            for _ in 0..15 {
+                std::thread::sleep(std::time::Duration::from_millis(60));
+                state3
+                    .write_buffer(b"hello world hello world hello world hello world\n")
+                    .unwrap();
+            }
+        }
+    }
+
+    #[test]
+    fn test_timestamps_rcurrent() {
+        let dir = format!("log_files/state_unit_tests1-{}", Local::now());
+        std::fs::create_dir_all(dir.clone()).unwrap();
+        let file_spec = FileSpec::default()
+            .directory(dir)
+            .discriminant("ts")
+            .suppress_timestamp();
+
+        write_log_entries(&file_spec, true, true);
+
+        // verify that rCURRENT and the intended number of rotated files exist
+        let pattern = file_spec.as_glob_pattern("_r[0-9]*", Some("log"));
+        assert_eq!(list_of_files(&pattern).count(), 8);
+        let pattern = file_spec.as_glob_pattern("_rCURRENT", Some("log"));
+        assert_eq!(list_of_files(&pattern).count(), 1);
+    }
+
+    #[test]
+    fn test_numbers_rcurrent() {
+        let dir = format!("log_files/state_unit_tests2-{}", Local::now());
+        std::fs::create_dir_all(dir.clone()).unwrap();
+        let file_spec = FileSpec::default()
+            .discriminant("nr")
+            .directory(dir)
+            .suppress_timestamp();
+
+        write_log_entries(&file_spec, false, true);
+
+        // verify that rCURRENT and the intended number of rotated files exist
+        let pattern = file_spec.as_glob_pattern("_r[0-9]*", Some("log"));
+        assert_eq!(list_of_files(&pattern).count(), 8);
+        let pattern = file_spec.as_glob_pattern("_rCURRENT", Some("log"));
+        assert_eq!(list_of_files(&pattern).count(), 1);
+    }
+
+    fn get_flw_config(file_spec: FileSpec, append: bool) -> FileLogWriterConfig {
+        // create an instance of State with Naming::Timestamps and Criterion::Size(200)
+        FileLogWriterConfig {
+            print_message: false,
+            append,
+            write_mode: WriteMode::Direct,
+            file_spec,
+            o_create_symlink: None,
+            line_ending: &[b'\n'],
+            use_utc: true,
+        }
+    }
+
+    fn get_rotation_config(timestamps: bool, _rcurrent: bool) -> RotationConfig {
+        RotationConfig {
+            criterion: Criterion::Size(290),
+            naming: if timestamps {
+                Naming::Timestamps
+            } else {
+                Naming::Numbers
+            },
+            cleanup: Cleanup::Never,
+        }
+    }
+}
diff --git a/src/writers/file_log_writer/state/list_and_cleanup.rs b/src/writers/file_log_writer/state/list_and_cleanup.rs
new file mode 100644
index 0000000..5418667
--- /dev/null
+++ b/src/writers/file_log_writer/state/list_and_cleanup.rs
@@ -0,0 +1,120 @@
+use super::CleanupThreadHandle;
+use crate::{Cleanup, FileSpec};
+#[cfg(feature = "compress")]
+use std::fs::File;
+use std::{
+    iter::Chain,
+    path::PathBuf,
+    sync::mpsc::Sender,
+    thread::{Builder as ThreadBuilder, JoinHandle},
+    vec::IntoIter,
+};
+
+pub(super) const INFIX_PATTERN: &str = "_r[0-9]*";
+
+pub(super) fn list_of_log_and_compressed_files(
+    file_spec: &FileSpec,
+) -> Chain<IntoIter<PathBuf>, IntoIter<PathBuf>> {
+    let log_pattern = file_spec.as_glob_pattern(INFIX_PATTERN, None);
+    let gz_pattern = file_spec.as_glob_pattern(INFIX_PATTERN, Some("gz"));
+
+    list_of_files(&log_pattern).chain(list_of_files(&gz_pattern))
+}
+
+pub(super) fn list_of_files(pattern: &str) -> std::vec::IntoIter<PathBuf> {
+    let mut log_files: Vec<PathBuf> = glob::glob(pattern)
+        .unwrap(/* failure should be impossible */)
+        .filter_map(Result::ok)
+        .collect();
+    log_files.reverse();
+    log_files.into_iter()
+}
+
+pub(super) fn remove_or_compress_too_old_logfiles(
+    o_cleanup_thread_handle: &Option<CleanupThreadHandle>,
+    cleanup_config: &Cleanup,
+    file_spec: &FileSpec,
+) -> Result<(), std::io::Error> {
+    o_cleanup_thread_handle.as_ref().map_or_else(
+        || remove_or_compress_too_old_logfiles_impl(cleanup_config, file_spec),
+        |cleanup_thread_handle| {
+            cleanup_thread_handle
+                .sender
+                .send(MessageToCleanupThread::Act)
+                .ok();
+            Ok(())
+        },
+    )
+}
+
+pub(crate) fn remove_or_compress_too_old_logfiles_impl(
+    cleanup_config: &Cleanup,
+    file_spec: &FileSpec,
+) -> Result<(), std::io::Error> {
+    let (log_limit, compress_limit) = match *cleanup_config {
+        Cleanup::Never => {
+            return Ok(());
+        }
+        Cleanup::KeepLogFiles(log_limit) => (log_limit, 0),
+
+        #[cfg(feature = "compress")]
+        Cleanup::KeepCompressedFiles(compress_limit) => (0, compress_limit),
+
+        #[cfg(feature = "compress")]
+        Cleanup::KeepLogAndCompressedFiles(log_limit, compress_limit) => {
+            (log_limit, compress_limit)
+        }
+    };
+
+    for (index, file) in list_of_log_and_compressed_files(file_spec).enumerate() {
+        if index >= log_limit + compress_limit {
+            // delete (log or log.gz)
+            std::fs::remove_file(file)?;
+        } else if index >= log_limit {
+            #[cfg(feature = "compress")]
+            {
+                // compress, if not yet compressed
+                if let Some(extension) = file.extension() {
+                    if extension != "gz" {
+                        let mut old_file = File::open(file.clone())?;
+                        let mut compressed_file = file.clone();
+                        compressed_file.set_extension("log.gz");
+                        let mut gz_encoder = flate2::write::GzEncoder::new(
+                            File::create(compressed_file)?,
+                            flate2::Compression::fast(),
+                        );
+                        std::io::copy(&mut old_file, &mut gz_encoder)?;
+                        gz_encoder.finish()?;
+                        std::fs::remove_file(&file)?;
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
+const CLEANER: &str = "flexi_logger-fs-cleanup";
+
+pub(crate) enum MessageToCleanupThread {
+    Act,
+    Die,
+}
+pub(crate) fn start_cleanup_thread(
+    cleanup: Cleanup,
+    file_spec: FileSpec,
+) -> Result<(Sender<MessageToCleanupThread>, JoinHandle<()>), std::io::Error> {
+    let (sender, receiver) = std::sync::mpsc::channel();
+    let builder = ThreadBuilder::new().name(CLEANER.to_string());
+    #[cfg(not(feature = "dont_minimize_extra_stacks"))]
+    let builder = builder.stack_size(512 * 1024);
+    Ok((
+        sender,
+        builder.spawn(move || {
+            while let Ok(MessageToCleanupThread::Act) = receiver.recv() {
+                remove_or_compress_too_old_logfiles_impl(&cleanup, &file_spec).ok();
+            }
+        })?,
+    ))
+}
diff --git a/src/writers/file_log_writer/state/numbers.rs b/src/writers/file_log_writer/state/numbers.rs
new file mode 100644
index 0000000..0a58f51
--- /dev/null
+++ b/src/writers/file_log_writer/state/numbers.rs
@@ -0,0 +1,58 @@
+//! The infix for rotated files contains an index number.
+use super::CURRENT_INFIX;
+use crate::{writers::FileLogWriterConfig, FileSpec};
+use std::cmp::max;
+
+pub(super) fn number_infix(idx: u32) -> String {
+    format!("_r{idx:0>5}")
+}
+
+pub(super) fn index_for_rcurrent(
+    config: &FileLogWriterConfig,
+    o_index_for_rcurrent: Option<u32>,
+    rotate_rcurrent: bool,
+) -> Result<u32, std::io::Error> {
+    // we believe what we get - but if we get nothing, we determine what's next
+    // according to the filesystem
+    let mut index_for_rcurrent = o_index_for_rcurrent
+        .or_else(|| get_highest_index(&config.file_spec).map(|idx| idx + 1))
+        .unwrap_or(0);
+
+    if rotate_rcurrent {
+        match std::fs::rename(
+            config.file_spec.as_pathbuf(Some(CURRENT_INFIX)),
+            config
+                .file_spec
+                .as_pathbuf(Some(&number_infix(index_for_rcurrent))),
+        ) {
+            Ok(()) => {
+                index_for_rcurrent += 1;
+            }
+            Err(e) => {
+                if e.kind() != std::io::ErrorKind::NotFound {
+                    return Err(e);
+                }
+            }
+        }
+    }
+    Ok(index_for_rcurrent)
+}
+
+pub(super) fn get_highest_index(file_spec: &FileSpec) -> Option<u32> {
+    let mut o_highest_idx = None;
+    for file in super::list_and_cleanup::list_of_log_and_compressed_files(file_spec) {
+        let filename = file.file_stem().unwrap(/*ok*/).to_string_lossy();
+        let mut it = filename.rsplit("_r");
+        match it.next() {
+            Some(next) => {
+                let idx: u32 = next.parse().unwrap_or(0);
+                o_highest_idx = match o_highest_idx {
+                    None => Some(idx),
+                    Some(prev) => Some(max(prev, idx)),
+                };
+            }
+            None => continue, // ignore unexpected files
+        }
+    }
+    o_highest_idx
+}
diff --git a/src/writers/file_log_writer/state/timestamps.rs b/src/writers/file_log_writer/state/timestamps.rs
new file mode 100644
index 0000000..977f074
--- /dev/null
+++ b/src/writers/file_log_writer/state/timestamps.rs
@@ -0,0 +1,178 @@
+use super::list_and_cleanup::{list_of_files, INFIX_PATTERN};
+use super::{get_creation_date, CURRENT_INFIX};
+use crate::{writers::FileLogWriterConfig, FileSpec};
+use chrono::{DateTime, Local, NaiveDateTime, TimeZone};
+use std::path::Path;
+use std::{ops::Add, path::PathBuf};
+
+const TS_INFIX_FORMAT: &str = "_r%Y-%m-%d_%H-%M-%S";
+pub(super) fn ts_infix_from_timestamp(ts: &DateTime<Local>, use_utc: bool) -> String {
+    if use_utc {
+        ts.naive_utc().format(TS_INFIX_FORMAT)
+    } else {
+        ts.format(TS_INFIX_FORMAT)
+    }
+    .to_string()
+}
+fn ts_infix_from_path(path: &Path, file_spec: &FileSpec) -> String {
+    let idx = file_spec
+        .as_pathbuf(Some("_rXXXXX"))
+        .to_string_lossy()
+        .find("_rXXXXX")
+        .unwrap();
+    String::from_utf8_lossy(&path.to_string_lossy().as_bytes()[idx..idx + 21]).to_string()
+}
+fn timestamp_from_ts_infix(infix: &str) -> Option<DateTime<Local>> {
+    NaiveDateTime::parse_from_str(infix, TS_INFIX_FORMAT)
+        .ok()
+        .and_then(|ts| Local.from_local_datetime(&ts).single())
+}
+
+pub(super) fn rcurrents_creation_date(
+    config: &FileLogWriterConfig,
+    o_date_for_rotated_file: Option<&DateTime<Local>>,
+    rotate_rcurrent: bool,
+) -> Result<DateTime<Local>, std::io::Error> {
+    let current_path = config.file_spec.as_pathbuf(Some(CURRENT_INFIX));
+
+    Ok(if rotate_rcurrent {
+        let date_for_rotated_file = o_date_for_rotated_file
+            .copied()
+            .unwrap_or_else(|| get_creation_date(&current_path));
+        let rotated_path =
+            path_for_rotated_file(&config.file_spec, config.use_utc, &date_for_rotated_file);
+
+        match std::fs::rename(current_path, rotated_path.clone()) {
+            Ok(()) => {}
+            Err(e) => {
+                if e.kind() != std::io::ErrorKind::NotFound {
+                    return Err(e);
+                }
+            }
+        }
+        get_creation_date(&rotated_path)
+    } else {
+        get_creation_date(&current_path)
+    })
+}
+
+// determine the timestamp to which we want to write (file needn't exist)
+pub(super) fn latest_timestamp_file(config: &FileLogWriterConfig, rotate: bool) -> DateTime<Local> {
+    if rotate {
+        Local::now()
+    } else {
+        // find all file paths that fit the pattern
+        list_of_files(INFIX_PATTERN)
+            // retrieve the infix
+            .map(|path| ts_infix_from_path(&path, &config.file_spec))
+            // parse infix as date, ignore all files where this fails,
+            .filter_map(|infix| timestamp_from_ts_infix(&infix))
+            // take the newest of these dates
+            .reduce(|acc, e| if acc > e { acc } else { e })
+            // if nothing is found, take Local::now()
+            .unwrap_or_else(Local::now)
+    }
+}
+
+fn path_for_rotated_file(
+    file_spec: &FileSpec,
+    use_utc: bool,
+    date_for_rotated_file: &DateTime<Local>,
+) -> PathBuf {
+    let infix = collision_free_infix_for_rotated_file(file_spec, use_utc, date_for_rotated_file);
+    file_spec.as_pathbuf(Some(&infix))
+}
+
+// handles collisions by appending ".restart-<number>" to the infix, if necessary
+pub(super) fn collision_free_infix_for_rotated_file(
+    file_spec: &FileSpec,
+    use_utc: bool,
+    date_for_rotated_file: &DateTime<Local>,
+) -> String {
+    let infix_date_string = ts_infix_from_timestamp(date_for_rotated_file, use_utc);
+
+    let mut new_path = file_spec.as_pathbuf(Some(&infix_date_string));
+    // Search for rotated_path as is and for restart-siblings;
+    // if any exists, find highest restart and add 1, else continue without restart
+    let mut pattern = new_path.clone();
+    if file_spec.o_suffix.is_some() {
+        pattern.set_extension("");
+    }
+    let mut pattern = pattern.to_string_lossy().to_string();
+    pattern.push_str(".restart-*");
+    let mut restart_siblings =
+        glob::glob(&pattern).unwrap(/*ok*/).map(Result::unwrap).collect::<Vec<PathBuf>>();
+
+    if (*new_path).exists() || !restart_siblings.is_empty() {
+        let next_number = if restart_siblings.is_empty() {
+            0
+        } else {
+            restart_siblings.sort_unstable();
+            new_path = restart_siblings.pop().unwrap(/*ok*/);
+            let file_stem_string = if file_spec.o_suffix.is_some() {
+                new_path
+                    .file_stem().unwrap(/*ok*/)
+                    .to_string_lossy().to_string()
+            } else {
+                new_path.to_string_lossy().to_string()
+            };
+            let index = file_stem_string.find(".restart-").unwrap(/*ok*/);
+            file_stem_string[(index + 9)..].parse::<usize>().unwrap(/*ok*/) + 1
+        };
+
+        infix_date_string
+            .clone()
+            .add(&format!(".restart-{next_number:04}"))
+    } else {
+        infix_date_string
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::path::PathBuf;
+
+    use chrono::{Duration, Local};
+
+    use crate::FileSpec;
+
+    #[test]
+    fn test_latest_timestamp_file() {
+        let file_spec = FileSpec::default()
+            .basename("basename")
+            .directory("direc/tory")
+            .discriminant("disc")
+            .suppress_timestamp();
+
+        let now = Local::now();
+        let now = now
+            .checked_sub_signed(
+                Duration::from_std(std::time::Duration::from_nanos(u64::from(
+                    now.timestamp_subsec_nanos(),
+                )))
+                .unwrap(),
+            )
+            .unwrap();
+        let paths: Vec<PathBuf> = (0..10)
+            .map(|i| now - Duration::seconds(i))
+            .map(|ts| file_spec.as_pathbuf(Some(&super::ts_infix_from_timestamp(&ts, false))))
+            .collect();
+
+        assert_eq!(
+            dbg!(now),
+            // TODO: use mocking to avoid code duplication:
+            // this test is only useful if the path evaluation sis the same as in
+            // super::latest_timestamp_file()
+            paths
+                .iter()
+                // retrieve the infix
+                .map(|path| super::ts_infix_from_path(path, &file_spec))
+                // parse infix as date, ignore all files where this fails,
+                .filter_map(|infix| super::timestamp_from_ts_infix(&infix))
+                // take the newest of these dates
+                .reduce(|acc, e| if acc > e { acc } else { e })
+                // if nothing is found, take Local::now()
+                .unwrap_or_else(Local::now)
+        );
+    }
+}
diff --git a/src/writers/file_log_writer/state_handle.rs b/src/writers/file_log_writer/state_handle.rs
index 8fb8f11..b845150 100644
--- a/src/writers/file_log_writer/state_handle.rs
+++ b/src/writers/file_log_writer/state_handle.rs
@@ -33,7 +33,7 @@ impl SyncHandle {
         let am_state = Arc::new(Mutex::new(state));
 
         if flush_interval.as_secs() != 0 || flush_interval.subsec_nanos() != 0 {
-            super::threads::start_sync_flusher(Arc::clone(&am_state), flush_interval);
+            super::state::start_sync_flusher(Arc::clone(&am_state), flush_interval);
         }
 
         Self {
@@ -76,14 +76,14 @@ impl AsyncHandle {
         let am_state = Arc::new(Mutex::new(state));
         let a_pool = Arc::new(ArrayQueue::new(pool_capa));
 
-        let (sender, mo_thread_handle) = super::threads::start_async_fs_writer(
+        let (sender, mo_thread_handle) = super::state::start_async_fs_writer(
             Arc::clone(&am_state),
             message_capa,
             Arc::clone(&a_pool),
         );
 
         if flush_interval != std::time::Duration::from_secs(0) {
-            super::threads::start_async_fs_flusher(sender.clone(), flush_interval);
+            super::state::start_async_fs_flusher(sender.clone(), flush_interval);
         }
 
         Self {
@@ -154,16 +154,6 @@ impl StateHandle {
         ))
     }
 
-    pub(super) fn current_filename(&self) -> std::path::PathBuf {
-        match self {
-            StateHandle::Sync(handle) => handle.am_state.lock(),
-            #[cfg(feature = "async")]
-            StateHandle::Async(handle) => handle.am_state.lock(),
-        }
-        .expect("state_handle.am_state is poisoned")
-        .current_filename()
-    }
-
     pub(super) fn format_function(&self) -> FormatFunction {
         match self {
             StateHandle::Sync(handle) => handle.format_function,
@@ -281,6 +271,16 @@ impl StateHandle {
         Ok(state.reopen_outputfile()?)
     }
 
+    pub(super) fn force_rotation(&self) -> Result<(), FlexiLoggerError> {
+        let mut state = match self {
+            StateHandle::Sync(handle) => handle.am_state.lock(),
+            #[cfg(feature = "async")]
+            StateHandle::Async(handle) => handle.am_state.lock(),
+        }
+        .map_err(|_| FlexiLoggerError::Poison)?;
+        state.mount_next_linewriter_if_necessary(true)
+    }
+
     pub(crate) fn config(&self) -> Result<FileLogWriterConfig, FlexiLoggerError> {
         let state = match self {
             StateHandle::Sync(handle) => handle.am_state.lock(),
diff --git a/src/writers/file_log_writer/threads.rs b/src/writers/file_log_writer/threads.rs
index abb82a0..8b13789 100644
--- a/src/writers/file_log_writer/threads.rs
+++ b/src/writers/file_log_writer/threads.rs
@@ -1,136 +1 @@
-use {
-    super::State,
-    crate::{
-        writers::file_log_writer::remove_or_compress_too_old_logfiles_impl, Cleanup, FileSpec,
-    },
-    std::{
-        sync::{
-            mpsc::Sender,
-            {Arc, Mutex},
-        },
-        thread::{Builder as ThreadBuilder, JoinHandle},
-    },
-};
 
-#[cfg(feature = "async")]
-use {
-    crate::util::{eprint_err, eprint_msg, ErrorCode, ASYNC_FLUSH, ASYNC_SHUTDOWN},
-    crossbeam_channel::{self, Sender as CrossbeamSender},
-    crossbeam_queue::ArrayQueue,
-};
-
-const CLEANER: &str = "flexi_logger-fs-cleanup";
-#[cfg(feature = "async")]
-const ASYNC_WRITER: &str = "flexi_logger-fs-async_writer";
-#[cfg(feature = "async")]
-const ASYNC_FLUSHER: &str = "flexi_logger-fs-async_flusher";
-
-pub(crate) enum MessageToCleanupThread {
-    Act,
-    Die,
-}
-pub(crate) fn start_cleanup_thread(
-    cleanup: Cleanup,
-    file_spec: FileSpec,
-) -> Result<(Sender<MessageToCleanupThread>, JoinHandle<()>), std::io::Error> {
-    let (sender, receiver) = std::sync::mpsc::channel();
-    let builder = ThreadBuilder::new().name(CLEANER.to_string());
-    #[cfg(not(feature = "dont_minimize_extra_stacks"))]
-    let builder = builder.stack_size(512 * 1024);
-    Ok((
-        sender,
-        builder.spawn(move || {
-            while let Ok(MessageToCleanupThread::Act) = receiver.recv() {
-                remove_or_compress_too_old_logfiles_impl(&cleanup, &file_spec).ok();
-            }
-        })?,
-    ))
-}
-
-pub(super) fn start_sync_flusher(am_state: Arc<Mutex<State>>, flush_interval: std::time::Duration) {
-    let builder = std::thread::Builder::new().name("flexi_logger-flusher".to_string());
-    #[cfg(not(feature = "dont_minimize_extra_stacks"))]
-    let builder = builder.stack_size(128);
-    builder.spawn(move || {
-        let (_tx, rx) = std::sync::mpsc::channel::<()>();
-            loop {
-                rx.recv_timeout(flush_interval).ok();
-                (*am_state).lock().map_or_else(
-                    |_e| (),
-                    |mut state| {
-                        state.flush().ok();
-                    },
-                );
-            }
-        })
-        .unwrap(/* yes, let's panic if the thread can't be spawned */);
-}
-
-#[cfg(feature = "async")]
-pub(super) fn start_async_fs_writer(
-    am_state: Arc<Mutex<State>>,
-    message_capa: usize,
-    a_pool: Arc<ArrayQueue<Vec<u8>>>,
-) -> (CrossbeamSender<Vec<u8>>, Mutex<Option<JoinHandle<()>>>) {
-    let (sender, receiver) = crossbeam_channel::unbounded::<Vec<u8>>();
-    (
-        sender,
-        Mutex::new(Some(
-            std::thread::Builder::new()
-                .name(ASYNC_WRITER.to_string())
-                .spawn(move || loop {
-                    match receiver.recv() {
-                        Err(_) => break,
-                        Ok(mut message) => {
-                            let mut state = am_state.lock().unwrap(/* ok */);
-                            match message.as_ref() {
-                                ASYNC_FLUSH => {
-                                    state.flush().unwrap_or_else(|e| {
-                                        eprint_err(ErrorCode::Flush, "flushing failed", &e);
-                                    });
-                                }
-                                ASYNC_SHUTDOWN => {
-                                    state.shutdown();
-                                    break;
-                                }
-                                _ => {
-                                    state.write_buffer(&message).unwrap_or_else(|e| {
-                                        eprint_err(ErrorCode::Write, "writing failed", &e);
-                                    });
-                                }
-                            }
-                            if message.capacity() <= message_capa {
-                                message.clear();
-                                a_pool.push(message).ok();
-                            }
-                        }
-                    }
-                })
-                .expect("Couldn't spawn flexi_logger-async_file_log_writer"),
-        )),
-    )
-}
-
-#[cfg(feature = "async")]
-pub(super) fn start_async_fs_flusher(
-    async_writer: CrossbeamSender<Vec<u8>>,
-    flush_interval: std::time::Duration,
-) {
-    let builder = std::thread::Builder::new().name(ASYNC_FLUSHER.to_string());
-    #[cfg(not(feature = "dont_minimize_extra_stacks"))]
-    let builder = builder.stack_size(128);
-    builder.spawn(move || {
-            let (_tx, rx) = std::sync::mpsc::channel::<()>();
-            loop {
-                if let Err(std::sync::mpsc::RecvTimeoutError::Disconnected) =
-                    rx.recv_timeout(flush_interval)
-                {
-                    eprint_msg(ErrorCode::Flush, "Flushing unexpectedly stopped working");
-                    break;
-                }
-
-                async_writer.send(ASYNC_FLUSH.to_vec()).ok();
-            }
-        })
-        .unwrap(/* yes, let's panic if the thread can't be spawned */);
-}
diff --git a/tests/test_rotate_naming_variants.rs b/tests/test_rotate_naming_variants.rs
new file mode 100644
index 0000000..d1add6b
--- /dev/null
+++ b/tests/test_rotate_naming_variants.rs
@@ -0,0 +1,105 @@
+mod test_utils;
+
+use std::{
+    fs::File,
+    io::{BufRead, BufReader},
+    ops::Add,
+    path::Path,
+};
+
+use chrono::Local;
+use flexi_logger::{Age, Cleanup, Criterion, Duplicate, FileSpec, Logger, Naming};
+use glob::glob;
+use log::*;
+
+const COUNT: u8 = 8;
+
+#[test]
+fn test_rotate_naming_variants() {
+    if let Some(value) = test_utils::dispatch(COUNT) {
+        work(value)
+    }
+}
+
+fn work(value: u8) {
+    match value {
+        0 => test_variant(Naming::Timestamps, Criterion::AgeOrSize(Age::Second, 200)),
+        1 => test_variant(
+            Naming::TimestampsDirect,
+            Criterion::AgeOrSize(Age::Second, 200),
+        ),
+        2 => test_variant(Naming::Numbers, Criterion::AgeOrSize(Age::Second, 200)),
+        3 => test_variant(
+            Naming::NumbersDirect,
+            Criterion::AgeOrSize(Age::Second, 200),
+        ),
+
+        4 => test_variant(Naming::Timestamps, Criterion::Age(Age::Second)),
+        5 => test_variant(Naming::TimestampsDirect, Criterion::Age(Age::Second)),
+        6 => test_variant(Naming::Numbers, Criterion::Age(Age::Second)),
+        7 => test_variant(Naming::NumbersDirect, Criterion::Age(Age::Second)),
+        COUNT..=u8::MAX => unreachable!("asAS"),
+    }
+}
+
+fn test_variant(naming: Naming, criterion: Criterion) {
+    let directory = test_utils::dir();
+
+    test_utils::wait_for_start_of_second();
+
+    let _logger = Logger::try_with_str("trace")
+        .unwrap()
+        .log_to_file(FileSpec::default().directory(&directory))
+        .format_for_files(flexi_logger::detailed_format)
+        .format_for_stderr(flexi_logger::detailed_format)
+        .duplicate_to_stderr(Duplicate::Info)
+        .rotate(criterion, naming, Cleanup::Never)
+        .start()
+        .unwrap_or_else(|e| panic!("Logger initialization failed with {e}"));
+
+    info!(
+        "test correct rotation by {}",
+        match criterion {
+            Criterion::Age(_) => "age",
+            Criterion::AgeOrSize(_, _) => "age or size",
+            Criterion::Size(_) => "size",
+        }
+    );
+    let mut line_count = 1;
+    let start = Local::now();
+    let duration = chrono::Duration::from_std(std::time::Duration::from_secs(10)).unwrap();
+    while Local::now() - start < duration {
+        trace!("{}", 'a');
+        line_count += 1;
+        std::thread::sleep(std::time::Duration::from_millis(100));
+    }
+
+    verify_logs(&directory, line_count);
+}
+
+fn verify_logs(directory: &Path, count: usize) {
+    // read all files
+    let pattern = directory.display().to_string().add("/*");
+    let globresults = match glob(&pattern) {
+        Err(e) => panic!("Is this ({pattern}) really a directory? Listing failed with {e}",),
+        Ok(globresults) => globresults,
+    };
+    let mut total_line_count = 0_usize;
+    for globresult in globresults.into_iter() {
+        let mut line_count = 0_usize;
+        let pathbuf = globresult.unwrap_or_else(|e| panic!("Ups - error occured: {e}"));
+        let f = File::open(&pathbuf)
+            .unwrap_or_else(|e| panic!("Cannot open file {pathbuf:?} due to {e}"));
+        let mut reader = BufReader::new(f);
+        let mut buffer = String::new();
+        while reader.read_line(&mut buffer).unwrap() > 0 {
+            line_count += 1;
+        }
+        total_line_count += line_count;
+    }
+
+    assert_eq!(
+        total_line_count, count,
+        "wrong line count: {total_line_count} instead of {count}"
+    );
+}
diff --git a/tests/test_trigger_rotation.rs b/tests/test_trigger_rotation.rs
new file mode 100644
index 0000000..5b70ba2
--- /dev/null
+++ b/tests/test_trigger_rotation.rs
@@ -0,0 +1,95 @@
+mod test_utils;
+
+use std::{
+    fs::File,
+    io::{BufRead, BufReader},
+    ops::Add,
+    path::Path,
+};
+
+use flexi_logger::{Cleanup, Criterion, Duplicate, FileSpec, Logger, Naming};
+use glob::glob;
+use log::*;
+
+const COUNT: u8 = 4;
+
+#[test]
+fn test_rotate_naming_variants() {
+    if let Some(value) = test_utils::dispatch(COUNT) {
+        work(value)
+    }
+}
+
+fn work(value: u8) {
+    match value {
+        0 => test_variant(Naming::Timestamps, Criterion::Size(800)),
+        1 => test_variant(Naming::TimestampsDirect, Criterion::Size(800)),
+        2 => test_variant(Naming::Numbers, Criterion::Size(800)),
+        3 => test_variant(Naming::NumbersDirect, Criterion::Size(800)),
+        COUNT..=u8::MAX => unreachable!("asAS"),
+    }
+}
+
+fn test_variant(naming: Naming, criterion: Criterion) {
+    let directory = test_utils::dir();
+
+    std::thread::sleep(std::time::Duration::from_millis(500));
+
+    test_utils::wait_for_start_of_second();
+
+    let logger = Logger::try_with_str("trace")
+        .unwrap()
+        .log_to_file(FileSpec::default().directory(&directory))
+        .format_for_files(flexi_logger::detailed_format)
+        .format_for_stderr(flexi_logger::detailed_format)
+        .duplicate_to_stderr(Duplicate::Info)
+        .rotate(criterion, naming, Cleanup::Never)
+        .start()
+        .unwrap_or_else(|e| panic!("Logger initialization failed with {e}"));
+
+    info!("test trigger rotation",);
+    let mut line_count = 1;
+
+    for i in 0..45 {
+        if i == 12 {
+            logger.trigger_rotation().unwrap();
+        }
+        trace!("{}", 'a');
+        line_count += 1;
+    }
+
+    verify_logs(&directory, line_count, 7);
+}
+
+fn verify_logs(directory: &Path, line_count: usize, file_count: usize) {
+    // read all files
+    let pattern = directory.display().to_string().add("/*");
+    let globresults = match glob(&pattern) {
+        Err(e) => panic!("Is this ({pattern}) really a directory? Listing failed with {e}",),
+        Ok(globresults) => globresults,
+    };
+    let mut total_line_count = 0_usize;
+    let mut total_file_count = 0_usize;
+    for globresult in globresults.into_iter() {
+        total_file_count += 1;
+        let mut current_line_count = 0_usize;
+        let pathbuf = globresult.unwrap_or_else(|e| panic!("Ups - error occured: {e}"));
+        let f = File::open(&pathbuf)
+            .unwrap_or_else(|e| panic!("Cannot open file {pathbuf:?} due to {e}"));
+        let mut reader = BufReader::new(f);
+        let mut buffer = String::new();
+        while reader.read_line(&mut buffer).unwrap() > 0 {
+            current_line_count += 1;
+        }
+        total_line_count += current_line_count;
+    }
+
+    assert_eq!(
+        total_line_count, line_count,
+        "wrong line count: {total_line_count} instead of {line_count}"
+    );
+    assert_eq!(
+        total_file_count, file_count,
+        "wrong file count: {total_file_count} instead of {file_count}"
+    );
+}