lib: Rethink common.GetErrorMsg approach

[oncilla]

The current common.GetErrorMsg approach is very brittle. If during a refactor the error is wrapped. or a non-constant string is modified, the check will fail.

We should consider an approach similar to xerrors.Is or just use xerrors.Is and let common.BasicError implement an Is method.

[oncilla]

E.g. the cause of #3037

[lukedirtwalker]

With Go 1.13 moving towards the current xerrors.Is etc. (See https://tip.golang.org/doc/go1.13#error_wrapping) we should definitely work towards this. Me and @oncilla quickly drafted a PoC how we can integrate this into our existing common errors library:

type SimpleError string

func (e SimpleError) Error() string {
	return string(e)
}

type BasicError struct {
	// Error message
	Msg SimpleError
	// Error context, for logging purposes only
	logCtx []interface{}
	// Nested error, if any.
	Err error
}

func (be BasicError) Is(err error) bool {
	switch other := err.(type) {
	case BasicError:
		return be.Msg == other.Msg
	case SimpleError:
		return be.Msg == other
	default:
		return false
	}
}

func (be BasicError) Unrwap() error {
	return be.GetErr()
}

Note that BasicError is the same existing error with Msg changed from string to SimpleError.

Note that using old string messages would still be allowed (except fmt.Sprintf break but those often contain stuff that should go into context anyway.) But the idea is that we move to typed errors:

const (
    ErrInvariantViolation common.SimpleError = "TRC invariant violation"
)

func foo() error {
     return common.NewBasicError(ErrInvariantViolation, nil, "ctx", 1)
}

func main() {
    err := foo()
    if xerrors.Is(err, ErrInvariantViolation) {
        fmt.Sprintf("Invariant violation\n")
    }
}

Note that with this we can define all errors as constants (no vars for simple text only errors as would be the case with errors.New or common.NewBasicError("text",nil)) so we get additional guarantees that no one can tamper with error message strings.

[oncilla]

serrors support is in (including a linter)
What remains to be done is translating the old common.BasicError to serrors.Error