Log filename and line number #63

gust1n · 2014-09-22T21:40:49Z

Both stdlib package log and many other logging frameworks are supporting this (e.g. https://github.com/inconshreveable/log15). Am I missing how to enable it or is it not supported?

sirupsen · 2014-09-22T22:10:55Z

There's currently no way of doing it. Would definitely be interested in a contribution adding this.

gust1n · 2014-09-22T22:18:50Z

I was part of the discussion leading to this solution: inconshreveable/log15@dbf739e
Does it look good to you? Then I could start working on a PR in a couple of days. I guess the question os how to enable it, since we probably should let users decide whether to use it or not...

sirupsen · 2014-09-25T03:39:49Z

Hm.. it'd be nice if formatters and hooks could lazily load this if they need it, but I'm not sure if we can do that nicely. I don't want to call those functions and pass it down with the entry every time we log.

derekdowling · 2014-11-04T04:58:34Z

I'm interested in this as well. @sirupsen from your perspective how do you feel about adding some sort of a middleware layer that allows people to gather their own context and automatically append it to an entry's Fields?

That mechanism would allow us to add this sort of thing in quite easily. I am not sure about what other use cases this might also open up.

sirupsen · 2014-11-04T15:15:08Z

I wouldn't be opposed to adding it by default and then allowing the formatters/hooks to use it appropriately. This is also useful for exception tracking etc., however, it might have a performance impact. We'll need to measure that

c4milo · 2014-11-11T01:14:10Z

Yes please, this feature is very much needed.

aarongreenlee · 2014-11-17T20:32:32Z

I like the idea of a middleware layer but agree with @sirupsen that this is not something I would want to occur in a production environment. If we're logging errors the existing ability to log detailed and helpful values should be sufficient; however, in a development environment quick access to filepath and line number is very valuable.

Thanks everyone for this discussion.

sirupsen · 2014-11-17T21:14:50Z

Yes, unless someone can prove a negligible performance impact I think this should be a hook.

cep21 · 2015-03-13T17:58:42Z

I solve this in a performant manner by doing the following:

var log *logrus.Logger

func init() {
    log = mylog.NewLogger()
}


func NewLogger() *logrus.Logger {
    _, file, _, ok := runtime.Caller(1)
    if !ok {
        file = "unknown"
    }
    ret := logrus.New()
    inst := &logInstance{
        innerLogger: ret,
        file:        filepath.Base(file),
    }
    ret.Hooks.Add(inst)
    return ret
}

logInstance is a hook that adds "file" to the log entry. This saves me calling runtime.Caller each time I log a message while still having code that does

  log.WithField()....Info()

The disadvantage is that I only have one "log" per package that contains the filename of where it was created. This usually works enough for me since I use many packages. If not, I would give each file it's own log() variable.

chreble · 2015-06-04T15:40:08Z

+1 it's a MUST-HAVE, and saying "completely API compatible with the standard library logger" in the README is wrong as we have that feature in the standard Go logger (SetFlags) http://golang.org/pkg/log/#SetFlags

gonzaloserrano · 2015-06-11T15:39:57Z

+1

sirupsen · 2015-06-14T14:09:57Z

Perhaps someone take a closer look at SetFlags implementation and port it to logrus? Currently all the implementations I've seen rely on hardcoding number of stack frames which is not very portable and doesn't work in some cases.

chreble · 2015-06-15T06:16:08Z

@sirupsen, I can definitely have a look :)

sirupsen · 2015-06-15T11:56:12Z

@chreble awesome, let me know what you find!

dmlyons · 2015-06-23T15:57:25Z

@sirupsen unfortunately, the SetFlags implementation in the standard library uses a (sort of) hardcoded number of stack frames: http://golang.org/src/log/log.go#L130. Each exported output function, such as Println, passes callDepth like this: http://golang.org/src/log/log.go#L169.

Is this such a big deal to implement in logrus?

sirupsen · 2015-07-06T15:50:53Z

@dmlyons no it's not, I've just not needed this myself and haven't seen an implementation that hasn't failed on different platforms.

davisford · 2015-08-18T17:09:18Z

Has anyone resolved this in a reasonable way? I just want the filename and line number. I'd also prefer to be able to configure it to only print on specific levels (e.g. err, panic, warn)

gonzaloserrano · 2015-08-18T17:58:30Z

We have wrapped the stuff we most use from logrus with the file information, i don't know if you will find it useful or not but here you are https://gist.github.com/gonzaloserrano/d360c1b195f7313b6d19

ryanwalls · 2015-08-22T00:31:20Z

+1

ephemeralsnow · 2015-08-25T07:04:07Z

+1

santagada · 2015-09-01T14:22:46Z

I will try to take a swing at it, as @dmlyons said it is pretty straightforward to implement.

leonlee · 2015-09-17T05:41:49Z

+1

AkihiroSuda · 2015-10-07T08:04:12Z

+1

davisford · 2015-10-10T02:23:08Z

My solution was to use https://github.com/inconshreveable/log15

dgsb · 2018-11-03T07:04:58Z

This feature is contained in v1.2.0

Found at: sirupsen/logrus#63

wesgt · 2018-11-19T16:07:29Z

Here's how to have logrus log the filename and line number with the latest release. Basically just add log.SetReportCaller(true) when initializing.

Example:
package main

import (
	log "github.com/sirupsen/logrus"
)

func main() {
        // Add this line for logging filename and line number!
	log.SetReportCaller(true)

	log.Println("hello world")
}
Output:
INFO[0000]/Users/bob/go/src/github.com/bob/test/main.go:17 main.main() hello world

Hi all, is there a way to cut the longest file path? like just to display the

INFO[0000]/test/main.go:17 main.main() hello world

Thanks...QQ

Jing-Li · 2018-11-21T05:17:45Z

@andytsnowden ,

@Jing-Li I've been using the solution posted here: #63 (comment) in production for about 6 months now and haven't really had any issues at all. In my use-case we emit about 10m lines of logging daily and I really haven't seen logging be a "slow" point.

@andytsnowden , this helps a lot, thanks.

Wamani · 2019-03-23T02:29:39Z

Here's how to have logrus log the filename and line number with the latest release. Basically just add log.SetReportCaller(true) when initializing.
Example:
package main

import (
	log "github.com/sirupsen/logrus"
)

func main() {
        // Add this line for logging filename and line number!
	log.SetReportCaller(true)

	log.Println("hello world")
}
Output:
INFO[0000]/Users/bob/go/src/github.com/bob/test/main.go:17 main.main() hello world
Hi all, is there a way to cut the longest file path? like just to display the
INFO[0000]/test/main.go:17 main.main() hello world
Thanks...QQ

any idea on how to cut file name ?

dgsb · 2019-03-23T13:44:05Z

@Wamani please don't comment on closed issue, because it's kind of hard to find it back.
The basic filter on the github interface doesn't show closed issues whatever how recently they have been updated. The next time open a new one, it will be easier for maintainers to provide feedback and guidance.

That said if you want to customiza the output of the caller field you can give a specific formatting function in the CallerPrettyfier field of the JSONFormatter (https://godoc.org/github.com/sirupsen/logrus#JSONFormatter) or of the TextFormatter (https://godoc.org/github.com/sirupsen/logrus#TextFormatter).

You also have an example in the logrus repository on how to use that with the JSONFormatter here
https://github.com/sirupsen/logrus/blob/master/example_custom_caller_test.go

miguelmota · 2019-03-26T05:56:29Z

@wesgt @Wamani

Here's how to cut the longest file path:

package main

import (
	"fmt"
	"os"
	"runtime"
	"strings"

	"github.com/sirupsen/logrus"
)

func main() {
	log := logrus.New()
	log.SetReportCaller(true)
	log.Formatter = &logrus.TextFormatter{
		CallerPrettyfier: func(f *runtime.Frame) (string, string) {
			repopath := fmt.Sprintf("%s/src/github.com/bob", os.Getenv("GOPATH"))
			filename := strings.Replace(f.File, repopath, "", -1)
			return fmt.Sprintf("%s()", f.Function), fmt.Sprintf("%s:%d", filename, f.Line)
		},
	}

	log.Println("hello world")
}

Output:

INFO[0000]/test/main.go:23 main.main() hello world

Wamani · 2019-04-04T08:22:59Z

@wesgt @Wamani

Here's how to cut the longest file path:

package main

import (
	"fmt"
	"os"
	"runtime"
	"strings"

	"github.com/sirupsen/logrus"
)

func main() {
	log := logrus.New()
	log.SetReportCaller(true)
	log.Formatter = &logrus.TextFormatter{
		CallerPrettyfier: func(f *runtime.Frame) (string, string) {
			repopath := fmt.Sprintf("%s/src/github.com/bob", os.Getenv("GOPATH"))
			filename := strings.Replace(f.File, repopath, "", -1)
			return fmt.Sprintf("%s()", f.Function), fmt.Sprintf("%s:%d", filename, f.Line)
		},
	}

	log.Println("hello world")
}

Output:

INFO[0000]/test/main.go:23 main.main() hello world

thanks it works

art-frela · 2019-08-22T15:51:42Z

package main

import (
	"fmt"
	"os"
	"runtime"
	"strings"

	"github.com/sirupsen/logrus"
)

func main() {
	log := logrus.New()
	log.SetReportCaller(true)
	log.Formatter = &logrus.TextFormatter{
		CallerPrettyfier: func(f *runtime.Frame) (string, string) {
			repopath := fmt.Sprintf("%s/src/github.com/bob", os.Getenv("GOPATH"))
			filename := strings.Replace(f.File, repopath, "", -1)
			return fmt.Sprintf("%s()", f.Function), fmt.Sprintf("%s:%d", filename, f.Line)
		},
	}

	log.Println("hello world")
}

Thank a lot of!
I am using path.Base, this is more universal, I think ;-)

package main

import (
	"fmt"
	"path"
	"runtime"

	"github.com/sirupsen/logrus"
)

func main() {
	log := logrus.New()
	log.SetReportCaller(true)
	log.Formatter = &logrus.TextFormatter{
		CallerPrettyfier: func(f *runtime.Frame) (string, string) {
			filename := path.Base(f.File)
			return fmt.Sprintf("%s()", f.Function), fmt.Sprintf("%s:%d", filename, f.Line)
		},
	}

	log.Println("hello world")
}
`

miguelmota · 2019-08-23T11:15:55Z

@art-frela great suggestion on using path.Base!

saurabh-hirani · 2019-11-01T13:45:41Z

Worth mentioning that if you are using logrus JSONFormatter and you need filename and line support, there is a handy example in the codebase which adds funcname and filename. - https://github.com/sirupsen/logrus/blob/master/example_custom_caller_test.go

l.Formatter = &logrus.JSONFormatter{
		DisableTimestamp: true,
		CallerPrettyfier: func(f *runtime.Frame) (string, string) {
			s := strings.Split(f.Function, ".")
			funcname := s[len(s)-1]
			_, filename := path.Split(f.File)
			return funcname, filename
		},
	}

A slight modification to it can return line number also

return funcname, filename + ":" + strconv.Itoa(f.Line)

bruceadowns · 2020-01-11T01:09:38Z

Worth mentioning that if you are using logrus JSONFormatter and you need filename and line support, there is a handy example in the codebase which adds funcname and filename. - https://github.com/sirupsen/logrus/blob/master/example_custom_caller_test.go

My code ended up looking a little like this:

logrus.SetReportCaller(true)
formatter = &logrus.JSONFormatter{
    CallerPrettyfier: func(f *runtime.Frame) (string, string) {
        s := strings.Split(f.Function, ".")
        funcName := s[len(s)-1]
        return funcName, fmt.Sprintf("%s:%d", path.Base(f.File), f.Line)
    },
}

Which logs source file name, function name, and line number.

chibby0ne · 2020-02-28T16:02:16Z

I can't reproduce this in logrus 1.4.2 using Go 1.14, I tried @art-frela snippet, and I can't reproduce it. This is my output:

INFO[0000]entry.go:359 github.com/sirupsen/logrus.(*Entry).Logln() hello world

I would have expected to see something like

INFO[0000]/test/main.go:23 main.main() hello world

Any ideas?

dgsb · 2020-02-28T16:09:42Z

related to #1096

chibby0ne · 2020-02-28T16:41:13Z

Yep it's Go 1.14 thanks @dgsb I thought I was going crazy for the last hour 👍

huongtx498 · 2020-10-23T19:00:35Z

formatter := runtime.Formatter{ChildFormatter: &log.TextFormatter{
	FullTimestamp: true,
}}
formatter.Line = true
log.SetFormatter(&formatter)
log.SetOutput(os.Stdout)
log.SetLevel(log.InfoLevel)
log.WithFields(log.Fields{
	"file": "main.go",
}).Info("Server is running...")

Note: import ( runtime "github.com/banzaicloud/logrus-runtime-formatter"
log "github.com/sirupsen/logrus")

kuchaguangjie · 2021-04-13T07:02:55Z

package main

import (
	"fmt"
	"os"
	"runtime"
	"strings"

	"github.com/sirupsen/logrus"
)

func main() {
	log := logrus.New()
	log.SetReportCaller(true)
	log.Formatter = &logrus.TextFormatter{
		CallerPrettyfier: func(f *runtime.Frame) (string, string) {
			repopath := fmt.Sprintf("%s/src/github.com/bob", os.Getenv("GOPATH"))
			filename := strings.Replace(f.File, repopath, "", -1)
			return fmt.Sprintf("%s()", f.Function), fmt.Sprintf("%s:%d", filename, f.Line)
		},
	}

	log.Println("hello world")
}

Thank a lot of!
I am using path.Base, this is more universal, I think ;-)

package main

import (
	"fmt"
	"path"
	"runtime"

	"github.com/sirupsen/logrus"
)

func main() {
	log := logrus.New()
	log.SetReportCaller(true)
	log.Formatter = &logrus.TextFormatter{
		CallerPrettyfier: func(f *runtime.Frame) (string, string) {
			filename := path.Base(f.File)
			return fmt.Sprintf("%s()", f.Function), fmt.Sprintf("%s:%d", filename, f.Line)
		},
	}

	log.Println("hello world")
}
`

This lose coloring on console.

shinebayar-g · 2022-11-27T11:19:40Z

Just for reference I came up with this to show filename:line. It's little bit cleaner than f.Function IMO.

log.SetReportCaller(true)
log.SetFormatter(&log.TextFormatter{
    FullTimestamp: true,
    CallerPrettyfier: func(f *runtime.Frame) (second string, first string) {
        _, b, _, _ := runtime.Caller(0)
        basepath := filepath.Dir(b)
        rel, err := filepath.Rel(basepath, f.File)
        if err != nil {
            log.Error("Couldn't determine file path\n", err)
        }
        return "", fmt.Sprintf("%s:%d", rel, f.Line)
    },
})

INFO[2022-11-27T03:16:16-08:00]main.go:34 Hello from main.go
INFO[2022-11-27T03:16:16-08:00]database/setup.go:31 Connected to database.
INFO[2022-11-27T03:16:16-08:00]database/setup.go:32 Running migrations.
INFO[2022-11-27T03:16:16-08:00]scheduler/task.go:17 Doing something.

flyzhang007 · 2022-11-27T11:20:08Z

您的邮件已收到，我会尽快查看&回复:)

shinebayar-g · 2022-11-27T22:18:21Z

package main

import (
	"fmt"
	"os"
	"runtime"
	"strings"

	"github.com/sirupsen/logrus"
)

func main() {
	log := logrus.New()
	log.SetReportCaller(true)
	log.Formatter = &logrus.TextFormatter{
		CallerPrettyfier: func(f *runtime.Frame) (string, string) {
			repopath := fmt.Sprintf("%s/src/github.com/bob", os.Getenv("GOPATH"))
			filename := strings.Replace(f.File, repopath, "", -1)
			return fmt.Sprintf("%s()", f.Function), fmt.Sprintf("%s:%d", filename, f.Line)
		},
	}

	log.Println("hello world")
}

Thank a lot of!
I am using path.Base, this is more universal, I think ;-)

package main

import (
	"fmt"
	"path"
	"runtime"

	"github.com/sirupsen/logrus"
)

func main() {
	log := logrus.New()
	log.SetReportCaller(true)
	log.Formatter = &logrus.TextFormatter{
		CallerPrettyfier: func(f *runtime.Frame) (string, string) {
			filename := path.Base(f.File)
			return fmt.Sprintf("%s()", f.Function), fmt.Sprintf("%s:%d", filename, f.Line)
		},
	}

	log.Println("hello world")
}
`

This lose coloring on console.

You're right.. Using &log.TextFormatter loses all the colors..

log.SetFormatter(&log.TextFormatter{
    FullTimestamp: true,
})

nimrodshn · 2023-04-18T12:48:23Z

Is there a way to do this with the file and line number added as separate fields?

flyzhang007 · 2023-04-18T12:48:48Z

您的邮件已收到，我会尽快查看&回复:)

SharkFourSix · 2023-07-01T19:10:30Z

Is there a way to do this with the file and line number added as separate fields?

I think the best way would be to create an instance per package and pass a custom string (package name or tag) to the formatter. At least that way you know which package the error took place in. It just adds some context instead of a spontaneous error message.

kuchaguangjie · 2024-02-06T05:15:43Z

After set log.SetReportCaller(true)

The log looks like this:

time="2024-02-06T13:12:16+08:00" level=info msg="Server exit, bye." func=github.com/xxx/xxx/util/main_util.gracefulShutdown file="/home/eric/go/src/gitlab.com/xxx/xxx/util/main_util/main_util.go:108"

2 problems:

It contains func and file part, we only want file part usually.
and call log.SetFormatter(..) as suggested above, doesn't make the file part shorter.

flyzhang007 · 2024-02-06T05:16:13Z

您的邮件已收到，我会尽快查看&回复:)

derekdowling mentioned this issue Nov 4, 2014

Adding File, Line, Stacktrace #75

Closed

rht mentioned this issue Jun 14, 2015

Cleanup logging 1 ipfs/kubo#1359

Merged

rht mentioned this issue Sep 4, 2015

logs no longer show filename/number ipfs/kubo#1652

Closed

sirupsen mentioned this issue Oct 6, 2015

How display the package import path, file name and line number? #197

Closed

rht mentioned this issue Oct 7, 2015

Sprint Sep 28 ipfs/team-mgmt#35

Closed

88 tasks

j16sdiz mentioned this issue Oct 9, 2015

spec: add __FILE__ and __LINE__ macro golang/go#12876

Closed

jaytaylor added a commit to jaytaylor/andromeda that referenced this issue Nov 18, 2018

Include filenames in logrus output.

a3c924b

Found at: sirupsen/logrus#63

zhujl1991 mentioned this issue May 14, 2019

Add filename and line number to logs argoproj/argo-workflows#1367

Closed

dilallkx mentioned this issue Feb 3, 2020

logs optimizations InterDigitalInc/AdvantEDGE#60

Merged

davidnewhall mentioned this issue Aug 31, 2020

Add function name, file and line number to debug output. aws/amazon-kinesis-firehose-for-fluent-bit#59

Merged

aucampia mentioned this issue Jan 7, 2022

go-logger: log information about where a log statement is coming from coopnorge/go-logger#8

Closed

detailyang mentioned this issue Jun 6, 2023

bugfix:typha:avoid concurrent map iteration and map write projectcalico/calico#7743

Closed

Log filename and line number #63

Log filename and line number #63

Comments

gust1n commented Sep 22, 2014

sirupsen commented Sep 22, 2014

gust1n commented Sep 22, 2014

sirupsen commented Sep 25, 2014

derekdowling commented Nov 4, 2014

sirupsen commented Nov 4, 2014

c4milo commented Nov 11, 2014

aarongreenlee commented Nov 17, 2014

sirupsen commented Nov 17, 2014

cep21 commented Mar 13, 2015

chreble commented Jun 4, 2015

gonzaloserrano commented Jun 11, 2015

sirupsen commented Jun 14, 2015

chreble commented Jun 15, 2015

sirupsen commented Jun 15, 2015

dmlyons commented Jun 23, 2015

sirupsen commented Jul 6, 2015

davisford commented Aug 18, 2015

gonzaloserrano commented Aug 18, 2015

ryanwalls commented Aug 22, 2015

ephemeralsnow commented Aug 25, 2015

santagada commented Sep 1, 2015

leonlee commented Sep 17, 2015

AkihiroSuda commented Oct 7, 2015

davisford commented Oct 10, 2015

dgsb commented Nov 3, 2018

wesgt commented Nov 19, 2018 • edited Loading

Jing-Li commented Nov 21, 2018 • edited Loading

Wamani commented Mar 23, 2019

dgsb commented Mar 23, 2019 • edited Loading

miguelmota commented Mar 26, 2019

Wamani commented Apr 4, 2019

art-frela commented Aug 22, 2019

miguelmota commented Aug 23, 2019

saurabh-hirani commented Nov 1, 2019

bruceadowns commented Jan 11, 2020

chibby0ne commented Feb 28, 2020 • edited Loading

dgsb commented Feb 28, 2020

chibby0ne commented Feb 28, 2020

huongtx498 commented Oct 23, 2020

kuchaguangjie commented Apr 13, 2021

shinebayar-g commented Nov 27, 2022 • edited Loading

flyzhang007 commented Nov 27, 2022 via email

shinebayar-g commented Nov 27, 2022

nimrodshn commented Apr 18, 2023

flyzhang007 commented Apr 18, 2023 via email

SharkFourSix commented Jul 1, 2023 • edited Loading

kuchaguangjie commented Feb 6, 2024

flyzhang007 commented Feb 6, 2024 via email

wesgt commented Nov 19, 2018 •

edited

Loading

Jing-Li commented Nov 21, 2018 •

edited

Loading

dgsb commented Mar 23, 2019 •

edited

Loading

chibby0ne commented Feb 28, 2020 •

edited

Loading

shinebayar-g commented Nov 27, 2022 •

edited

Loading

SharkFourSix commented Jul 1, 2023 •

edited

Loading