flexi_logger 0.31.9

An easy-to-configure and flexible logger that writes logs to stderr or stdout and/or to files. It allows custom logline formats, and it allows changing the log specification at runtime. It also allows defining additional log streams, e.g. for alert or security messages.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

//! The infix for rotated files contains an index number.
use super::{InfixFilter, 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, &InfixFilter::Numbrs)
    {
        let name = file.file_stem().unwrap(/*ok*/).to_string_lossy();
        let infix = if file_spec.has_basename()
            || file_spec.has_discriminant()
            || file_spec.uses_timestamp()
        {
            // infix is the last, but not the first part of the name, starts with _r
            match name.rsplit("_r").next() {
                Some(infix) => infix,
                None => continue, // ignore unexpected files
            }
        } else {
            // infix is the only part of the name, just skip over the r
            &name[1..]
        };

        let idx: u32 = infix.parse().unwrap_or(0);
        o_highest_idx = match o_highest_idx {
            None => Some(idx),
            Some(prev) => Some(max(prev, idx)),
        };
    }
    o_highest_idx
}