log15库将纪元时间从纳秒舍入到秒以进行记录

Question

I'd like to have millisecond precision for my logging in my golang project, currently using log15 library

Problem is when I append it to Context, it rounds back up to seconds

newTimeWithMilliseconds := time.Unix(0, time.Now().UnixNano())

return log.FuncHandler(func(r *log.Record) {
     r.Ctx = append(r.Ctx, "time", newTimeWithMilliseconds)
     nextHandler.Log(r)
})

When I convert it to string newTimeWithMilliseconds.String() it works and I get "2018-09-25 15:07:45.25801232 -0500 PDT", but when I don't, the decimals go away and I get 2018-09-25 15:07:45 -0700 PDT.

I want to keep in Time format though and not use string, anybody have any ideas on why this is happening and how to solve this?

Answer 1

You need to use time.Format to display your time.Time's value with the precision you want. It doesn't loose its precision unless you modify its value, the reason why you see a difference is only due to the layout used by the call for time.Format of whatever is printing your time.

When you use mytime.String(), the layout used is different that the one used by whatever prints your time otherwise.

That's why you need to either use the time.Time value but manipulate the way it is printed, or store it as a formatted string instead.

See Go by example

// Go supports time formatting and parsing via
// pattern-based layouts.

package main

import "fmt"
import "time"

func main() {
    p := fmt.Println

    // Here's a basic example of formatting a time
    // according to RFC3339, using the corresponding layout
    // constant.
    t := time.Now()
    p(t.Format(time.RFC3339))

    // Time parsing uses the same layout values as `Format`.
    t1, e := time.Parse(
        time.RFC3339,
        "2012-11-01T22:08:41+00:00")
    p(t1)

    // `Format` and `Parse` use example-based layouts. Usually
    // you'll use a constant from `time` for these layouts, but
    // you can also supply custom layouts. Layouts must use the
    // reference time `Mon Jan 2 15:04:05 MST 2006` to show the
    // pattern with which to format/parse a given time/string.
    // The example time must be exactly as shown: the year 2006,
    // 15 for the hour, Monday for the day of the week, etc.
    p(t.Format("3:04PM"))
    p(t.Format("Mon Jan _2 15:04:05 2006"))
    p(t.Format("2006-01-02T15:04:05.999999-07:00"))
    form := "3 04 PM"
    t2, e := time.Parse(form, "8 41 PM")
    p(t2)

    // For purely numeric representations you can also
    // use standard string formatting with the extracted
    // components of the time value.
    fmt.Printf("%d-%02d-%02dT%02d:%02d:%02d-00:00
",
        t.Year(), t.Month(), t.Day(),
        t.Hour(), t.Minute(), t.Second())

    // `Parse` will return an error on malformed input
    // explaining the parsing problem.
    ansic := "Mon Jan _2 15:04:05 2006"
    _, e = time.Parse(ansic, "8:41PM")
    p(e)
}

Outputs

2009-11-10T23:00:00Z
2012-11-01 22:08:41 +0000 UTC
11:00PM
Tue Nov 10 23:00:00 2009
2009-11-10T23:00:00+00:00
0000-01-01 20:41:00 +0000 UTC
2009-11-10T23:00:00-00:00
parsing time "8:41PM" as "Mon Jan _2 15:04:05 2006": cannot parse "8:41PM" as "Mon"

Try it out yourself here