• programmer from Rayark, a game company in Taiwan
• backend (and temporary frontend) engineer, focus on common service
• usually develop something related to my work in Python, Ruby, ECMAScript, Golang, C#
• ECMAScript hater since Netscape is dead
• built CDN-aware game asset update system
• built almost entire VOEZ game server by myself only
• supported Sdorica backend development

4. TL;DR
5. Theory
6. Troll
7. Conclusion
8. Q&A

• Go 1.13 error system
• golang/xerrors
  • https://github.com/golang/xerrors
  • https://godoc.org/golang.org/x/xerrors

• pkg/errors
  • https://github.com/pkg/errors
  • https://godoc.org/github.com/pkg/errors

• for http server
  • use the gin, luke
    • https://github.com/gin-gonic/gin#model-binding-and-validation

or follow the below

package main
 
import (
	"encoding/json"
	"errors"
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
	"reflect"
	"strings"
 
	"github.com/julienschmidt/httprouter"
)
 
// utility function
 
func _wrapError(msg string, err error) error {
	return fmt.Errorf("%s: %w", msg, err)
}
 
func GetErrorMessageTitle(err error) string {
	return strings.SplitN(err.Error(), ":", 2)[0]
}
 
// ApiError
 
type ApiError struct {
	statusCode int
	msg        string
	err        error
}
 
func NewApiError(statusCode int, msg string, err error) error {
	if err != nil {
		msg = fmt.Sprintf("%s: %s", msg, err.Error())
	}
	return &ApiError{statusCode: statusCode, msg: msg, err: err}
}
 
func (e *ApiError) Error() string {
	return e.msg
}
 
func (e *ApiError) Unwrap() error {
	return e.err
}
 
func (e *ApiError) StatusCode() int {
	return e.statusCode
}
 
func ExtractErrorMessageChain(err error) string {
	e := err
	var b strings.Builder
	for {
		b.WriteString(e.Error() + "\n")
		e = errors.Unwrap(e)
		if e == nil {
			break
		}
	}
	return b.String()
}
 
func IsErrorEqual(e1 error, e2 error) bool {
	if e1 == nil || e2 == nil {
		return e1 == e2
	} else {
		return reflect.TypeOf(e1) == reflect.TypeOf(e2) && GetErrorMessageTitle(e1) == GetErrorMessageTitle(e2)
	}
}
 
func WrapError(template error, err error) error {
	apiErrorTemplate, ok := template.(*ApiError)
	if ok {
		err = NewApiError(apiErrorTemplate.StatusCode(), apiErrorTemplate.Error(), err)
	} else {
		err = _wrapError(template.Error(), err)
	}
	return err
}
 
// handler
 
type HandleE func(http.ResponseWriter, *http.Request, httprouter.Params) error
 
func ErrAwareHandle(h HandleE) httprouter.Handle {
	return func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
		err := h(w, r, ps)
		if err != nil {
			switch e := err.(type) {
			case *ApiError:
				/*var respBody string
				cause := errors.Unwrap(e)
				if cause != nil {
					respBody = e.Error() + ": " + cause.Error()
				} else {
					respBody = e.Error()
				}
				http.Error(w, respBody, e.StatusCode())*/
				http.Error(w, e.Error(), e.StatusCode())
			default:
				http.Error(w, e.Error(), 500)
			}
 
			messageChain := ExtractErrorMessageChain(err)
			fmt.Fprintf(os.Stderr, "error:\n%s\n", messageChain)
		}
	}
}
 
// usage
 
type Input struct {
	Msg string `json:msg`
}
 
func example(w http.ResponseWriter, r *http.Request, ps httprouter.Params) error {
	name := ps.ByName("name")
	if name != "say" {
		return NewApiError(404, "not found", errors.New("must be /error_test/say"))
	}
 
	body, err := ioutil.ReadAll(r.Body)
	if err != nil {
		return fmt.Errorf("body read failed: %v", err)
	}
 
	if len(body) < 2 {
		return errors.New("body is not enough")
	}
 
	var input Input
	if err = json.Unmarshal(body, &input); err != nil {
		return NewApiError(400, "bad request", err)
	}
 
	if input.Msg == "" {
		return NewApiError(400, "msg lost", nil)
	}
 
	if input.Msg == "FQ" {
		return NewApiError(403, "you dirty", fmt.Errorf("変態 %w", errors.New("助兵衛")))
	}
 
	w.WriteHeader(200)
	w.Write([]byte("OK\n"))
	return nil
}
 
func main() {
	router := httprouter.New()
	router.POST("/error_test/:name", ErrAwareHandle(example))
 
	err := http.ListenAndServe(":8000", router)
	if err != nil {
		panic(err)
	}
}
 
// client example
// curl -v -X POST --data '{"msg": "FQ2"}' http://localhost:8000/error_test/say

Go

• error title
• error type
• line number
• calling stack

Wrap

err = fmt.Errorf("... %w ...", ..., err, ...)
err.Unwrap()

Inspect Error Chain

errors.Is(err, ErrorInstance) // must be same address
 
var perr *ErrorType
errors.As(err, &perr)

package main
 
import (
	"errors"
	"fmt"
)
 
type MyError struct {
	msg string
	err error
}
 
func NewMyError(msg string, err error) *MyError {
	if err != nil {
		msg = fmt.Sprintf("%s: %s", msg, err.Error())
	}
	return &MyError{
		msg: msg,
		err: err,
	}
}
 
func (e *MyError) Error() string {
	return e.msg
}
 
func (e *MyError) Unwrap() error {
	return e.err
}
 
func main() {
	var err error
	err = errors.New("err1")
	err = fmt.Errorf("err2: %w", err)
 
	myErr := NewMyError("my err3", err)
	myErr2 := NewMyError("my err3", err)
	err = myErr
 
	err = fmt.Errorf("err4: %w", err)
	err = fmt.Errorf("err5: %w", err)
 
	if err != nil {
		fmt.Println("error is:", err)
 
		if errors.Is(err, myErr) {
			fmt.Println("It is myErr!")
		}
		if !errors.Is(err, myErr2) {
			fmt.Println("It is NOT myErr2!")
		}
 
		fmt.Println("")
 
		var myError *MyError
		if errors.As(err, &myError) {
			fmt.Println("failed:", err.Error())
			fmt.Println("MyError:", myError.Error())
		}
	}
}

Go error system SUCKS

again, Go error system SUCKS

Rust

panic!()
 
Result<T, E>
Option<T>
 
myobj.myfn()? // ? operator

https://doc.rust-lang.org/book/ch09-00-error-handling.html

e.source()
e.backtrace()

https://doc.rust-lang.org/std/error/trait.Error.html

• pkg/errors
  • https://github.com/pkg/errors
  • https://godoc.org/github.com/pkg/errors