Trick to quickly find file & line number throwing an error in Go?

In my journey with go discovered that there are no stacktraces. so whenever something breaks, all we get an simple string error message without any information where is this is coming from. This is in stark contrast with other languages where I am used to seing detailed stacktraces

For example, below is the error message from apex

$ cat event.json | apex invoke --logs webhook                                  
   ⨯ error parsing response: json: cannot unmarshal array into Go value of type map[string]interface {}

here its telling me that unmarshal to a map ins't working because event.json is an array. We have unmarshal to interface{} to support both arrays & maps.However, it doesn't tell me which file/line is causing this error.

Questions:

1. What is way to quickly find which file/line this error coming from?
2. In General, Are there tips/tricks which gophers use to get to the source of problem quickly from this string error message?
3. is this how stack traces are for most go projects or there are any best practices that should be followed?

> What is way to quickly find which file/line this error coming from?

There are no default stacks printed unless it's an unrecovered panic.

> In General, Are there tips/tricks which gophers use to get to the source of problem quickly from this string error message? is this how stack traces are for most go projects or there are any best practices that should be followed?

In General, you need to check error returns from most of the function calls. There are more than one way to do that.
I usually use standard library package log to print out error logs with file and line numbers for easy debugging in simple programs. For example:

package main

import "log"
import "errors"

func init() { log.SetFlags(log.Lshortfile | log.LstdFlags) }

func callFunc() error {
	return errors.New("error")
}

func main() {
	if err := callFunc(); err != nil {
		log.Println(err)
	}
}

http://play.golang.org/p/0iytNw7eZ7

output:

2009/11/10 23:00:00 main.go:14: error

Also, there are functions for you to print or retrieve current stacks in standard library runtime/debug, e.g. https://golang.org/pkg/runtime/debug/#PrintStack

There are many community efforts on bringing error handling easier, you can search error in GoDoc: https://godoc.org/?q=error

Your attempted solution: Finding the piece of code that produces the error to fix the code.

Your actual problem: The content of event.json.

_{This is called the X-Y-Problem}

Invoke expects a json object, you are passing a json array. Fix that and your problem is gone!

$ echo -n '{ "value": "Tobi the ferret" }' | apex invoke uppercase

Relevant part of the documentation: Invoking Functions

And that's the piece of code that produces the error: Github

And yes, Go does have stack traces! Read Dave Cheneys blog post on errors and exceptions.

Go does produce stack traces when a panic happens, crashing the program. This will happen if the code calls panic() directly, typically in cases like:

if err != nil {
    panic("it broke")
}

or, when a runtime error happens:

a := []int{1, 2, 3}
b := a[12] // index out of range

Here's a minimal example:

package main

func main() {
	panic("wtf?!")
}

Output:

panic: wtf?!

goroutine 1 [running]:
panic(0x94e60, 0x1030a040)
    /usr/local/go/src/runtime/panic.go:464 +0x700
main.main()
    /tmp/sandbox366642315/main.go:4 +0x80

Note the main.go:4 indicating the filename and line number.

In your example, the program did not panic, instead opting to call (I'm guessing) os.Exit(1) or log.Fatal("error message") (which calls os.Exit(1)). Or, the panic was simply recovered from in the calling function. Unfortunately, there's nothing you can do about this if you aren't the author of the code.

I would recommend reading Defer, Panic, and Recover on the Golang blog for more about this.

Setting log.SetFlags(log.LstdFlags | log.Lshortfile) in main() should do it.

For example, log.Printf("Deadline!") would print:

> 03/11/2020 23:59:59 liberty_test.go:42: Deadline!