¿Cómo se consigue que un programa Golang imprima el número de línea del error que acaba de llamar?

Estaba tratando de arrojar errores en mi programa Golang con log.Fatal, pero log.Fataltampoco imprime la línea donde log.Fatalse ejecutó. ¿No hay forma de acceder al número de línea que llamó log.Fatal? es decir, ¿hay alguna forma de obtener el número de línea cuando se produce un error?

Estaba tratando de buscar en Google esto, pero no estaba seguro de cómo. Lo mejor que pude conseguir fue imprimir el seguimiento de la pila , que supongo que es bueno, pero puede que sea demasiado. Tampoco quiero escribir debug.PrintStack()cada vez que necesito el número de línea, solo me sorprende que no haya ninguna función incorporada para esto log.FatalStackTrace()o algo que no sea un disfraz.

Además, la razón por la que no quiero hacer mi propia depuración / manejo de errores es porque no quiero que la gente tenga que aprender a usar mi código especial de manejo de vestuario. Solo quiero algo estándar donde la gente pueda leer mi código más tarde y ser como

"Ah, está bien, entonces está arrojando un error y haciendo X ..."

Cuanta menos gente tenga que aprender sobre mi código, mejor :)

Puede configurar los indicadores en un registrador personalizado o en el predeterminado para incluir LlongfileoLshortfile

// to change the flags on the default logger
log.SetFlags(log.LstdFlags | log.Lshortfile)

Version corta, no hay nada directamente incorporado, sin embargo, puede implementarlo con una curva de aprendizaje mínima utilizando runtime.Caller

func HandleError(err error) (b bool) {
    if err != nil {
        // notice that we're using 1, so it will actually log where
        // the error happened, 0 = this function, we don't want that.
        _, fn, line, _ := runtime.Caller(1)
        log.Printf("[error] %s:%d %v", fn, line, err)
        b = true
    }
    return
}

//this logs the function name as well.
func FancyHandleError(err error) (b bool) {
    if err != nil {
        // notice that we're using 1, so it will actually log the where
        // the error happened, 0 = this function, we don't want that.
        pc, fn, line, _ := runtime.Caller(1)

        log.Printf("[error] in %s[%s:%d] %v", runtime.FuncForPC(pc).Name(), fn, line, err)
        b = true
    }
    return
}

func main() {
    if FancyHandleError(fmt.Errorf("it's the end of the world")) {
        log.Print("stuff")
    }
}

playground

Si necesita exactamente un seguimiento de pila, eche un vistazo a https://github.com/ztrue/tracerr

Creé este paquete para tener tanto el seguimiento de la pila como los fragmentos de origen para poder depurar más rápido y registrar errores con muchos más detalles.

Aquí hay un ejemplo de código:

package main

import (
    "io/ioutil"
    "github.com/ztrue/tracerr"
)

func main() {
    if err := read(); err != nil {
        tracerr.PrintSourceColor(err)
    }
}

func read() error {
    return readNonExistent()
}

func readNonExistent() error {
    _, err := ioutil.ReadFile("/tmp/non_existent_file")
    // Add stack trace to existing error, no matter if it's nil.
    return tracerr.Wrap(err)
}

Y aquí está la salida: