refactor: call flush_atexit at exit

[tisonkun]

Avoid global static IS_TEARING_DOWN trick.

[tisonkun]

This may be even pub if users set their own global static LOGGER. But given that is not quite possible it's OK to leave pub(crate) until real use cases occur.

[SpriteOvO]

I like this idea! In fact, previously we still couldn't guarantee that users wouldn't use thread-local (or anything else that might conflict with atexit()) in their own sinks, because the global atomic bool variable IS_TEARING_DOWN is not public. This PR enables users to be aware that the program is in an atexit() callback and customize the flush implementation for this case.

Perhaps one minor nitpick is that I'm not sure if there might be a better choice for the naming. flush_atexit implies that it will be called in the atexit() callback, which is good, on the other hand the naming style is not so Rusty... I'll think about it some more, anyway it's not a big issue.

[SpriteOvO]

We should also flush the underlying sub-sinks with flush_atexit method too.

[tisonkun]

IIUC self.backend.flush() already does it?

This is an identical refactor from the previous code snippet.

[SpriteOvO]

The point here is that sub-sinks are agnostic to AsyncPoolSink. If a sub-sink is user-defined, it may still use thread-local in its flush(), and it won't know if the program is tearing down.

In other words, as a combined sink, I think AsyncPoolSink should forward flush_atexit to its sub-sinks, so that it can propagate the information that "this flush is the last flush, you are currently in the atexit callback".

[SpriteOvO]

Currently, self.backend.flush() is still calling .flush() for sub-sinks.

[tisonkun]

Ah. I got it.

[tisonkun]

Suggested change

	self.backend.flush()
	self.backend.flush_atexit()

[SpriteOvO]

And please also apply a flush_atexit override for DedupSink, as it's also a conbined-sink.

[tisonkun]

Resolved at 3e52f81. Although the name looks more terrible.

[tisonkun]

on the other hand the naming style is not so Rusty

Yeah. I'm struggling with naming this method also. Let's give it some days for potential new ideas :D

[SpriteOvO]

Nitpick, for better maintainability

fn flush_sinks_with<'a>(&'a self, with: impl Fn(&'a dyn Sink) -> Result<()>) {
    self.sinks.iter().for_each(|sink| {
        if let Err(err) = with(&**sink) {
            self.handle_error(err);
        }
    });
}

fn flush_sinks_atexit(&self) {
    self.flush_with(Sink::flush_atexit);
}

fn flush_sinks(&self) {
    self.flush_with(Sink::flush);
}

Same thing for AsyncPoolSink and DedupSink.