[cjslep]

I find that I wind up "bubbling up" errors of my own to build a stack trace yet still retain control of my program, like:

  func LowLevelCode() (int, error) {
    // rest of body...
    if /* error condition */ {
      return 0, errors.New("LowLevelCode error: " + /* error description */)
    }
  }

  func MiddleWare() (interface{}, error) {
    // body of code...
    nCount, err := LowLevelCode()
    if err != nil {
      return nil, errors.New("MiddleWare error: " + err.Error())
    }
  }

  func ApplicationCode() {
    // Do cool stuff...
    obj, err := MiddleWare()
    if err != nil {
      log.Println(err) // Prints "MiddleWare error: LowLevelCode error: " + ...
      // Handle on a high level, retry connections, etc.
    }
  }

I'm hoping someone comes in and corrects me with a more elegant way of "building up your own stack trace" without having to do this manually and without panic.

[NateDad]

There are a lot of error handling libraries out there. On Juju, we're working on one right now. This is the preliminary version: https://github.com/juju/errgo

Basically you just call a function every time you would return an error, and it automatically records the file and line number and lets you add on some context to the message, plus it gives you the option to mask the type of the error (to hide implementation details from your callers).

I wouldn't use errgo right now, it's still under heavy development, but it's similar to a lot of other error handling libraries out there.

[vardump]

This is what I used.

http://golang.org/pkg/runtime/#Stack