"Could not determine the UTC offset on this system" and defaulting to UTC timestamps

[borntyping]

The current defaults are to format timestamps using the local timezone. Since switching to the time crate to avoid unsafe code in chrono (CVE-2020-26235), a lot of users use simple_logger in scenarios where time refuses to fetch the local timezone to avoid running unsafe code (time-rs/time#293). This usually affects users running a multithreaded application, as time assumes it's safe to get the local timezone when running in a single-threaded environment where there's no risk of an environment variable being set by a different thread.

Support for UTC timestamps has been added to simple_logger, but I'm currently trying to work out the best way to safely change the default away from local timestamps in a way that doesn't risk silently changing user's logs from one timezone to another with no way to tell the difference.

If this issue is affecting you, there are a few approaches you can take:

1. Upgrade to simple_logger 2.0.0
   This breaking change switches to UTC timestamps in RFC 3339 format.
2. Switch the timestamp display
   Use UTC via .with_utc_timestamps() like in examples/timestamps_utc.rs.
   Use a static UTC offset via .with_utc_offset(...) like in examples/timestamps_utc_offset.rs.
   Don't display timestamps at all via .without_timestamps() like in examples/timestamps_none.rs.
3. Use the time crate's unsafe features
   Export RUSTFLAGS="--cfg unsound_local_offset" when compiling (docs).

Issues related to this are all tagged CVE-2020-26235. Tagging #51, #48, #47, #44, #43, #35.

[ClementNerma]

A potential solution to this could be to save the offset while starting the program, which works fine, and save it globally. I personally use once_cell::Lazy<UtcOffset> for that matter:

static OFFSET: Lazy<UtcOffset> = Lazy::new(|| {
    UtcOffset::local_offset_at(OffsetDateTime::now_utc()).unwrap_or_else(|_| {
        warn!("Failed to determine local offset, UTC will be used instead");
        UtcOffset::UTC
    })
});

pub fn get_now() -> OffsetDateTime {
    OffsetDateTime::now_utc().to_offset(*OFFSET)
}

[borntyping]

It's rare, but UTC offsets can change while a program is running (e.g. when daylight savings time starts and ends).

There is a with_utc_offset method that configures the logger to use a specific offset you can combine the above example with. :)

[ClementNerma]

Oh nice, I didn't now about that! Maybe it could be a good idea to make this method more visible in the docs :)

[borntyping]

The examples in the module documentation could definitely do with some improvement, they don't cover many of the builder methods SimpleLogger supports when configuring it.

[ctaoist]

Since time>=0.3.18, this example can get right local time:

unsafe {
    time::util::local_offset::set_soundness(time::util::local_offset::Soundness::Unsound);
}

[ClementNerma]

Unfortunately it's unsound for a good reason, so you shouldn't do this unless you really know what you're doing.

From the docs:

Obtaining the local UTC offset is allowed to invoke undefined behavior.
Setting this value is strongly discouraged.
To do so, you must comply with the safety requirements of `time::local_offset::set_soundness`

And:

If the operating system is not Unix-like, the call is sound.
* If the process is single-threaded, the call is sound.
* If the process is multi-threaded, no other thread may mutate the environment in any way at the same time a call to a method that obtains the local UTC offset. This includes adding, removing, or modifying an environment variable.

Note that you must not only verify this safety condition for your code, but for all code that will be included in the final binary.
Notably, it applies to both direct and transitive dependencies and to both Rust and non-Rust code.
For this reason it is not possible to soundly pass `Soundness::Unsound` to this method if you are writing a library that may used by others.