Como você faz com que um programa Golang imprima o número da linha do erro que acabou de chamar?

Estava tentando lançar erros no meu programa Golang com log.Fatalmas, log.Fataltambém não imprime a linha onde o log.Fatalfoi executado. Não há como obter acesso ao número da linha que chamou log.Fatal? ou seja, existe uma maneira de obter o número da linha ao lançar um erro?

Eu estava tentando pesquisar no Google, mas não sabia como. A melhor coisa que consegui foi imprimir o rastreamento da pilha , o que acho bom, mas pode ser um pouco demais. Eu também não quero escrever debug.PrintStack()sempre que preciso do número da linha, estou apenas surpreso que não haja nenhuma função embutida para este tipo log.FatalStackTrace()ou algo que não seja fantasia.

Além disso, o motivo pelo qual não quero fazer minhas próprias coisas de depuração / tratamento de erros é porque não quero que as pessoas tenham que aprender como usar meu código especial de tratamento de fantasias. Eu só quero algo padrão onde as pessoas possam ler meu código mais tarde e ser como

"ah ok, então é lançar um erro e fazer X ..."

Quanto menos pessoas aprenderem sobre meu código, melhor :)

Você pode definir os sinalizadores em um registrador personalizado ou o padrão para incluir LlongfileouLshortfile

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

Versão curta, não há nada embutido diretamente, no entanto, você pode implementá-lo com uma curva de aprendizado mínima usando 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

Se você precisa exatamente de um rastreamento de pilha, dê uma olhada em https://github.com/ztrue/tracerr

Eu criei este pacote para ter rastreamento de pilha e fragmentos de origem para poder depurar mais rápido e registrar erros com muito mais detalhes.

Aqui está um exemplo 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)
}

E aqui está a saída: