better error handling

Author: ehsannm

bridge_north.go

@@ -1,5 +1,9 @@
 package ronykit
 
+import (
+	"github.com/clubpay/ronykit/internal/errors"
+)
+
 // Gateway is main component of the EdgeServer. Without Gateway, the EdgeServer is not functional. You can use
 // some standard bundles in std/bundle path. However, if you need special handling of communication
 // between your server and the clients you are free to implement your own Gateway.
@@ -52,10 +56,18 @@ func (n *northBridge) OnMessage(conn Conn, msg []byte) {
 
 	arg, err := n.gw.Dispatch(ctx, msg)
 	if err != nil {
-		n.eh(ctx, err)
+		n.eh(ctx, errors.Wrap(ErrDispatchFailed, err))
 	} else {
 		ctx.execute(arg, n.cr(arg.ContractID))
 	}
 
 	n.releaseCtx(ctx)
 }
+
+var (
+	ErrNoHandler                   = errors.New("handler is not set for request")
+	ErrWriteToClosedConn           = errors.New("write to closed connection")
+	ErrDecodeIncomingMessageFailed = errors.New("decoding the incoming message failed")
+	ErrEncodeOutgoingMessageFailed = errors.New("encoding the outgoing message failed")
+	ErrDispatchFailed              = errors.New("dispatch failed")
+)

edge.go

@@ -17,10 +17,6 @@ import (
 	"github.com/jedib0t/go-pretty/v6/text"
 )
 
-var errServiceAlreadyRegistered errors.ErrFunc = func(v ...interface{}) error {
-	return fmt.Errorf("service %s already registered", v...)
-}
-
 type contractResolver func(contractID string) Contract
 
 // EdgeServer is the main component of the ronykit. It glues all other components of the
@@ -89,7 +85,7 @@ func (s *EdgeServer) RegisterBundle(b Bundle) *EdgeServer {
 // RouteSelector in each desc.Contract.
 func (s *EdgeServer) RegisterService(svc Service) *EdgeServer {
 	if _, ok := s.contracts[svc.Name()]; ok {
-		panic(errServiceAlreadyRegistered(svc.Name()))
+		panic(errors.New("service already registered: %s", svc.Name()))
 	}
 
 	s.svc = append(s.svc, svc)

options.go edge_options.gooptions.go renamed to edge_options.go

@@ -27,6 +27,13 @@ func RegisterService(services ...Service) Option {
 	}
 }
 
+// WithErrorHandler registers a global error handler to catch any error that
+// happens before EdgeServer can deliver incoming message to the handler, or delivering
+// the outgoing message to the client.
+// Internal errors are usually wrapped and could be checked for better error handling.
+// You can check with errors.Is function to see if the error is one of the following:
+// ErrDispatchFailed, ErrWriteToClosedConn, ErrNoHandler
+// ErrDecodeIncomingMessageFailed,, ErrEncodeOutgoingMessageFailed
 func WithErrorHandler(h ErrHandler) Option {
 	return func(s *EdgeServer) {
 		s.eh = h

exmples/simple-rest-server/stub/sampleservice.go

@@ -1,3 +1,42 @@
 package errors
 
-type ErrFunc func(v ...interface{}) error
+import (
+	"errors"
+	"fmt"
+)
+
+type qError struct {
+	top  error
+	down error
+}
+
+func (e qError) Error() string {
+	if e.down == nil {
+		return e.top.Error()
+	}
+
+	return fmt.Sprintf("%s: %s", e.top, e.down)
+}
+
+func (e qError) Is(err error) bool {
+	return errors.Is(e.top, err)
+}
+
+func (e qError) Unwrap() error {
+	return e.down
+}
+
+func New(format string, v ...interface{}) error {
+	return fmt.Errorf(format, v...)
+}
+
+func Wrap(top, down error) error {
+	if top == nil {
+		return down
+	}
+
+	return qError{
+		top:  top,
+		down: down,
+	}
+}

internal/errors/error.go

@@ -0,0 +1,51 @@
+package errors_test
+
+import (
+	builtinErr "errors"
+	"fmt"
+	"testing"
+
+	"github.com/clubpay/ronykit/internal/errors"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var (
+	errInternal  = builtinErr.New("internal error")
+	errRuntime   = builtinErr.New("runtime error")
+	errEndOfFile = builtinErr.New("end of file")
+
+	errWrappedInternal = fmt.Errorf("wrapped error: %w", errInternal)
+)
+
+func TestError(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Ronykit Suite")
+}
+
+var _ = Describe("WrapError", func() {
+	we := errors.Wrap(errRuntime, errEndOfFile)
+
+	It("Wrap 1", func() {
+		Expect(builtinErr.Is(we, errRuntime)).To(BeTrue())
+		Expect(builtinErr.Is(we, errEndOfFile)).To(BeTrue())
+		Expect(we.Error()).To(BeEquivalentTo("runtime error: end of file"))
+	})
+
+	It("Wrap 2", func() {
+		wwe := errors.Wrap(errInternal, we)
+		Expect(builtinErr.Is(wwe, errInternal)).To(BeTrue())
+		Expect(builtinErr.Is(wwe, errRuntime)).To(BeTrue())
+		Expect(builtinErr.Is(wwe, errEndOfFile)).To(BeTrue())
+		Expect(wwe.Error()).To(BeEquivalentTo("internal error: runtime error: end of file"))
+	})
+
+	It("Wrap 3", func() {
+		wwi := errors.Wrap(errWrappedInternal, we)
+		Expect(builtinErr.Is(wwi, errWrappedInternal)).To(BeTrue())
+		Expect(builtinErr.Is(wwi, errInternal)).To(BeTrue())
+		Expect(builtinErr.Is(wwi, errRuntime)).To(BeTrue())
+		Expect(builtinErr.Is(wwi, errEndOfFile)).To(BeTrue())
+		Expect(wwi.Error()).To(BeEquivalentTo("wrapped error: internal error: runtime error: end of file"))
+	})
+})

internal/errors/error_test.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/clubpay/ronykit"
 	"github.com/clubpay/ronykit/internal/common"
+	"github.com/clubpay/ronykit/internal/errors"
 	"github.com/clubpay/ronykit/internal/httpmux"
 	"github.com/clubpay/ronykit/utils"
 	"github.com/clubpay/ronykit/utils/buf"
@@ -213,13 +214,13 @@ func (b *bundle) wsDispatch(ctx *ronykit.Context, in []byte) (ronykit.ExecuteArg
 
 	routeData := b.wsRoutes[inputMsgContainer.GetHdr(b.predicateKey)]
 	if routeData == nil {
-		return ronykit.NoExecuteArg, errNoHandler
+		return ronykit.NoExecuteArg, ronykit.ErrNoHandler
 	}
 
 	msg := routeData.Factory()
 	err = inputMsgContainer.Fill(msg)
 	if err != nil {
-		return ronykit.NoExecuteArg, err
+		return ronykit.NoExecuteArg, errors.Wrap(ronykit.ErrDecodeIncomingMessageFailed, err)
 	}
 
 	ctx.In().
@@ -278,7 +279,7 @@ func (b *bundle) httpDispatch(ctx *ronykit.Context, in []byte) (ronykit.ExecuteA
 	b.cors.handle(conn, routeData != nil)
 
 	if routeData == nil {
-		return ronykit.NoExecuteArg, errRouteNotFound
+		return ronykit.NoExecuteArg, ronykit.ErrNoHandler
 	}
 
 	// Walk over all the query params
@@ -307,7 +308,7 @@ func (b *bundle) httpDispatch(ctx *ronykit.Context, in []byte) (ronykit.ExecuteA
 
 	m, err := routeData.Decoder(params, in)
 	if err != nil {
-		return ronykit.NoExecuteArg, err
+		return ronykit.NoExecuteArg, errors.Wrap(ronykit.ErrDecodeIncomingMessageFailed, err)
 	}
 
 	ctx.In().
@@ -375,9 +376,3 @@ func (b *bundle) Shutdown(_ context.Context) error {
 func (b *bundle) Subscribe(d ronykit.GatewayDelegate) {
 	b.d = d
 }
-
-var (
-	errRouteNotFound    = fmt.Errorf("route not found")
-	errNoHandler        = fmt.Errorf("no handler for request")
-	errConnectionClosed = fmt.Errorf("connection closed")
-)

std/gateway/fasthttp/bundle.go

@@ -37,7 +37,7 @@ func (w *wsConn) Write(data []byte) (int, error) {
 	if w.c != nil {
 		err = w.c.WriteMessage(websocket.TextMessage, data)
 	} else {
-		err = errConnectionClosed
+		err = ronykit.ErrWriteToClosedConn
 	}
 	w.Unlock()
 	if err != nil {

std/gateway/fasthttp/conn_ws.go

@@ -2,11 +2,11 @@ package fastws
 
 import (
 	"context"
-	"fmt"
 	"time"
 
 	"github.com/clubpay/ronykit"
 	"github.com/clubpay/ronykit/internal/common"
+	"github.com/clubpay/ronykit/internal/errors"
 	"github.com/panjf2000/gnet/v2"
 )
 
@@ -79,18 +79,18 @@ func (b *bundle) Dispatch(ctx *ronykit.Context, in []byte) (ronykit.ExecuteArg,
 	inputMsgContainer := b.rpcInFactory()
 	err := inputMsgContainer.Unmarshal(in)
 	if err != nil {
-		return ronykit.NoExecuteArg, err
+		return ronykit.NoExecuteArg, errors.Wrap(ronykit.ErrDecodeIncomingMessageFailed, err)
 	}
 
 	routeData := b.routes[inputMsgContainer.GetHdr(b.predicateKey)]
 	if routeData == nil {
-		return ronykit.NoExecuteArg, errNoHandler
+		return ronykit.NoExecuteArg, ronykit.ErrNoHandler
 	}
 
 	msg := routeData.Factory()
 	err = inputMsgContainer.Fill(msg)
 	if err != nil {
-		return ronykit.NoExecuteArg, err
+		return ronykit.NoExecuteArg, errors.Wrap(ronykit.ErrDecodeIncomingMessageFailed, err)
 	}
 
 	ctx.In().
@@ -116,7 +116,7 @@ func (b *bundle) writeFunc(conn ronykit.Conn, e ronykit.Envelope) error {
 
 	data, err := outputMsgContainer.Marshal()
 	if err != nil {
-		return err
+		return errors.Wrap(ronykit.ErrEncodeOutgoingMessageFailed, err)
 	}
 
 	_, err = conn.Write(data)
@@ -153,5 +153,3 @@ func (b *bundle) Shutdown(ctx context.Context) error {
 func (b *bundle) Subscribe(d ronykit.GatewayDelegate) {
 	b.d = d
 }
-
-var errNoHandler = fmt.Errorf("no handler for request")