Timestamp support local timezone

[zonyitoo]

Printing timestamp in local timezone is more useful than UTC.

[KodrAus]

For output that's expected to be consumed by a person immediately it is definitely nicer to use the local timezone. For output that's picked up by a sidecar it's not necessarily better.

We could add a human_format() method to the Builder that's designed for consumption using a friendlier timestamp format and suitable for, say, diagnostic output from command-line tools. What do you think?

[zonyitoo]

Yes, that's great.

[julianandrews]

I'd love to have this feature - my default use case for env_logger is lightweight CLI tools, and local time would be a big improvement.

I looked through the code, and it doesn't seem too hard to do - the main stumbling block I'm guessing is that humantime doesn't support timezone output.

@KodrAus - are you open to switching to chrono from humantime?

I threw together a really quick proof of concept, and it looks to me as if it would work well. chrono comes with functions for the same RFC3339 output at all the expected precisions. It's definitely a little heavier weight than humantime (minimal dependencies will be chrono, num-integer, and num-traits), but it's the de-facto standard Rust datetime library.

If this sounds good to you, I'd be happy to clean up my proof of concept and make it a PR.

[AshfordN]

Any update on this feature? This is seems like a rather useful feature.

[philolo1]

If anybody else looks for this feature, its written here: https://rust-lang-nursery.github.io/rust-cookbook/development_tools/debugging/config_log.html#include-timestamp-in-log-messages:

use std::io::Write;
use chrono::Local;
use env_logger::Builder;
use log::LevelFilter;

fn main() {
    Builder::new()
        .format(|buf, record| {
            writeln!(buf,
                "{} [{}] - {}",
                Local::now().format("%Y-%m-%dT%H:%M:%S"),
                record.level(),
                record.args()
            )
        })
        .filter(None, LevelFilter::Info)
        .init();

    log::warn!("warn");
    log::info!("info");
    log::debug!("debug");
}

[DanceMore]

hm. as an operations / SRE type, I kinda wish this was an ENV setting to toggle UTC vs local.

I'm currently deploying some software where I'm using a Scheduler and I intended to use ENV TZ=$deploymentTimezone as a bit of a hack because the User Experience is expected to be local time, but all my container workers run UTC (even when they're physically in my local timezone ☁️ )

I currently have it deployed via docker compose with the TZ set but it's challenging to see if that config setting has "taken" because the debug/info logs are still coming out UTC.

as much as I am a fan of "all systems should use UTC", that's often an up-stack choice and sometimes the app depends on local time. also timezones can get weirder if you support Windows too. iirc, Windows will often write the hardware clock to local timezone and disregard UTC whereas UNIX-based systems tend to write the system clock to UTC and use ENV or locale in the display / presentation of the time.

[wez]

I would love for this to be integrated! FWIW, I think it would be reasonable to make this a crate feature that only pulls in chrono for the local time formatting, which would allow folks to opt-in or opt-out of the additional weight of chrono.

Meanwhile, for those that want to match the default colorized style, but with local time:

.format(|buf, record| {
    use env_logger::fmt::Color;
    use std::io::Write;

    let subtle = buf
        .style()
        .set_color(Color::Black)
        .set_intense(true)
        .clone();
    write!(buf, "{}", subtle.value("["))?;
    write!(buf, "{} ", chrono::Local::now().format("%Y-%m-%dT%H:%M:%S"))?;
    write!(buf, "{:<5}", buf.default_styled_level(record.level()))?;
    if let Some(path) = record.module_path() {
        write!(buf, " {}", path)?;
    }
    write!(buf, "{}", subtle.value("]"))?;
    writeln!(buf, " {}", record.args())
})

[kelvie]

For those of us in the future where the previous comment doesn't work, here's a version that uses the new included anstyle package (didn't include the module path)

        .format(|buf, record| {
            use std::io::Write;
            use chrono::Local;
            use env_logger::fmt::style::{Style, AnsiColor};

            let subtle = Style::new()
                .fg_color(Some(AnsiColor::BrightBlack.into()));
            let level_style = buf.default_level_style(record.level());

            writeln!(buf,
                     "{subtle}[{subtle:#}{} {level_style}{:<5}{level_style:#}{subtle}]{subtle:#} {}",
                     Local::now().format("%Y-%m-%d %H:%M:%S%Z"),
                     record.level(),
                     record.args()
            )
        })