Rotation on demand

[lioriz1]

I have a rotating sink by size:

let by_size: Arc<RotatingFileSink> = Arc::new(match
            RotatingFileSink::builder()
                .base_path(path_by_size)
                .max_files(constants::LOG_FILE_MAX_FILES)
                .rotation_policy(RotationPolicy::FileSize(constants::LOG_FILE_MAX_SIZE))
                .rotate_on_open(true)
                .build(){
                Ok(v) => v,
                Err(e) => {
                    error!("Failed to create rotating file sink");
                    return Err(e.to_string());
                },
            },
        );

        let logger = Mutex::new(match Logger::builder().sink(by_size.clone()).build() {
            Ok(v) => v,
            Err(e) => {
                error!("Failed to create logger");
                return Err(e.to_string());
            },
        });

I flush the logger when needed using fn flush.
I need to rotate the log file, but I found the fn rotate to be private.

How can I rotate my log file when needed?

[SpriteOvO]

May I know the real use case for explicit rotating sinks? AFAIK, C++ spdlog doesn't support this either.

And considering that a RotatingFileSink is potentially a time-point rotator, explicit rotating is a bit hard to implement for it.

[lioriz1]

I didn't know that C++ spdlog doesn't support this.

In my program, I have some scenarios where I start a new operation, at that point I would like to start a new logs file, so I need to rotate the file.

[SpriteOvO]

This sounds like an XY problem, such a use case can be solved by creating multiple loggers. Here is a pseudo-code example:

fn create_logger(path: &Path) -> Arc<Logger> {
    // Returns a logger which owns a `FileSink` or `RotatingFileSink` here
}

fn sub_op_1(logger: Arc<Logger>) -> OpResult {
    info!(logger: logger, "something");
    info!(logger: logger, "done");
}

fn sub_op_2(logger: Arc<Logger>) -> OpResult {
    info!(logger: logger, "some other things");
    error!(logger: logger, "failed");
}

fn run_ops() {
    let logger = create_logger("./op.log");

    info!(logger: logger, "ready to run op_1");
    let op_1_result = sub_op_1(create_logger("./op_1.log"));

    info!(logger: logger, "ready to run op_2");
    let op_2_result = sub_op_2(create_logger("./op_2.log"));

    logger = create_logger("./op_results.log");
    info!(logger: logger, "result of op_1: {op_1_result}");
    info!(logger: logger, "result of op_2: {op_2_result}");
}

You will get files with contents:

$ cat ./op.log
ready to run op_1
ready to run op_2

$ cat ./op_results.log
result of op_1: true
result of op_1: true

$ cat ./op_1.log
something
done

$ cat ./op_2.log
some other things
failed