chore(broadcast): better logging

aleksander-vedvik · aleksander-vedvik · commit eb870240c1fd · 2024-05-29T14:49:48.000+02:00
diff --git a/broadcast/processor.go b/broadcast/processor.go
@@ -62,14 +62,14 @@ func (p *BroadcastProcessor) handle(msg Content) {
 			msg.ReceiveChan <- shardResponse{
 				err: OutOfOrderErr{},
 			}
-			p.log("msg: out of order", "err", OutOfOrderErr{}, "method", msg.CurrentMethod, "from", msg.SenderAddr)
+			p.log("msg: out of order", OutOfOrderErr{}, "method", msg.CurrentMethod, "from", msg.SenderAddr)
 		} else {
 			msg.ReceiveChan <- shardResponse{
 				err:              nil,
 				reqCtx:           p.cancellationCtx,
 				enqueueBroadcast: p.enqueueBroadcast,
 			}
-			p.log("msg: processed", "err", nil, "method", msg.CurrentMethod, "from", msg.SenderAddr)
+			p.log("msg: processed", nil, "method", msg.CurrentMethod, "from", msg.SenderAddr)
 		}
 	}
 	defer func() {
@@ -83,15 +83,15 @@ func (p *BroadcastProcessor) handle(msg Content) {
 		//close(p.broadcastChan)
 		//close(p.sendChan)
 		p.emptyChannels(metadata)
-		p.log("processor stopped", "err", nil, "started", p.started, "ended", p.ended)
+		p.log("processor stopped", nil, "started", p.started, "ended", p.ended)
 	}()
 	for {
 		select {
 		case <-p.ctx.Done():
 			return
 		case bMsg := <-p.broadcastChan:
 			if p.broadcastID != bMsg.BroadcastID {
-				p.log("broadcast: wrong BroadcastID", "err", BroadcastIDErr{}, "type", bMsg.MsgType.String(), "stopping", false)
+				p.log("broadcast: wrong BroadcastID", BroadcastIDErr{}, "type", bMsg.MsgType.String(), "stopping", false)
 				continue
 			}
 			switch bMsg.MsgType {
@@ -116,7 +116,7 @@ func (p *BroadcastProcessor) handle(msg Content) {
 				new.ReceiveChan <- shardResponse{
 					err: BroadcastIDErr{},
 				}
-				p.log("msg: wrong BroadcastID", "err", BroadcastIDErr{}, "method", new.CurrentMethod, "from", new.SenderAddr)
+				p.log("msg: wrong BroadcastID", BroadcastIDErr{}, "method", new.CurrentMethod, "from", new.SenderAddr)
 				continue
 			}
 			if new.IsCancellation {
@@ -126,7 +126,7 @@ func (p *BroadcastProcessor) handle(msg Content) {
 				new.ReceiveChan <- shardResponse{
 					err: nil,
 				}
-				p.log("msg: received cancellation", "err", nil, "method", new.CurrentMethod, "from", new.SenderAddr)
+				p.log("msg: received cancellation", nil, "method", new.CurrentMethod, "from", new.SenderAddr)
 				continue
 			}
 
@@ -137,7 +137,7 @@ func (p *BroadcastProcessor) handle(msg Content) {
 					new.ReceiveChan <- shardResponse{
 						err: ClientReqAlreadyReceivedErr{},
 					}
-					p.log("msg: duplicate client req", "err", ClientReqAlreadyReceivedErr{}, "method", new.CurrentMethod, "from", new.SenderAddr)
+					p.log("msg: duplicate client req", ClientReqAlreadyReceivedErr{}, "method", new.CurrentMethod, "from", new.SenderAddr)
 					continue
 				}
 				// important to set this option to prevent duplicate client reqs.
@@ -155,7 +155,7 @@ func (p *BroadcastProcessor) handle(msg Content) {
 					}
 					p.cancellationCtxCancel()
 				}()
-				p.log("msg: received client req", "err", nil, "method", new.CurrentMethod, "from", new.SenderAddr)
+				p.log("msg: received client req", nil, "method", new.CurrentMethod, "from", new.SenderAddr)
 			}
 
 			metadata.update(new)
@@ -174,7 +174,7 @@ func (p *BroadcastProcessor) handle(msg Content) {
 					err: err,
 				}
 				//	slog.Info("receive: late", "err", err, "id", p.broadcastID)
-				p.log("msg: late msg", "err", err, "method", new.CurrentMethod, "from", new.SenderAddr)
+				p.log("msg: late msg", err, "method", new.CurrentMethod, "from", new.SenderAddr)
 				return
 			}
 			if !p.isInOrder(new.CurrentMethod) {
@@ -183,26 +183,26 @@ func (p *BroadcastProcessor) handle(msg Content) {
 				new.ReceiveChan <- shardResponse{
 					err: OutOfOrderErr{},
 				}
-				p.log("msg: out of order", "err", OutOfOrderErr{}, "method", new.CurrentMethod, "from", new.SenderAddr)
+				p.log("msg: out of order", OutOfOrderErr{}, "method", new.CurrentMethod, "from", new.SenderAddr)
 				continue
 			}
 			new.ReceiveChan <- shardResponse{
 				err:              nil,
 				reqCtx:           p.cancellationCtx,
 				enqueueBroadcast: p.enqueueBroadcast,
 			}
-			p.log("msg: processed", "err", nil, "method", new.CurrentMethod, "from", new.SenderAddr)
+			p.log("msg: processed", nil, "method", new.CurrentMethod, "from", new.SenderAddr)
 		}
 	}
 }
 
 func (p *BroadcastProcessor) handleCancellation(bMsg Msg, metadata *metadata) bool {
 	if bMsg.Cancellation.end {
-		p.log("broadcast: broadcast.Done() called", "err", nil, "type", bMsg.MsgType.String(), "stopping", true)
+		p.log("broadcast: broadcast.Done() called", nil, "type", bMsg.MsgType.String(), "stopping", true)
 		return true
 	}
 	if !metadata.SentCancellation {
-		p.log("broadcast: sent cancellation", "err", nil, "type", bMsg.MsgType.String(), "stopping", false)
+		p.log("broadcast: sent cancellation", nil, "type", bMsg.MsgType.String(), "stopping", false)
 		metadata.SentCancellation = true
 		go p.router.Send(p.broadcastID, "", "", bMsg.Cancellation)
 	}
@@ -216,16 +216,22 @@ func (p *BroadcastProcessor) handleBroadcast(bMsg Msg, methods []string, metadat
 		return false
 	}
 	p.router.Send(p.broadcastID, metadata.OriginAddr, metadata.OriginMethod, bMsg.Msg)
-	p.log("broadcast: sending broadcast", "err", nil, "type", bMsg.MsgType.String(), "stopping", false, "isBroadcastCall", metadata.isBroadcastCall())
+	p.log("broadcast: sending broadcast", nil, "type", bMsg.MsgType.String(), "method", bMsg.Method, "stopping", false, "isBroadcastCall", metadata.isBroadcastCall())
 
 	p.updateOrder(bMsg.Method)
 	p.dispatchOutOfOrderMsgs()
 	return true
 }
 
-func (p *BroadcastProcessor) log(msg string, args ...any) {
+func (p *BroadcastProcessor) log(msg string, err error, args ...any) {
 	if p.logger != nil {
-		p.logger.Debug(msg, args...)
+		if err != nil {
+			args = append(args, "err", err.Error())
+			p.logger.Error(msg, args...)
+		} else {
+			args = append(args, "err", nil)
+			p.logger.Info(msg, args...)
+		}
 	}
 }
 
@@ -234,7 +240,7 @@ func (p *BroadcastProcessor) handleReply(bMsg Msg, metadata *metadata) bool {
 	if metadata.isBroadcastCall() {
 		go p.router.Send(p.broadcastID, metadata.OriginAddr, metadata.OriginMethod, bMsg.Reply)
 		// the request is done becuase we have sent a reply to the client
-		p.log("broadcast: sending reply to client", "err", nil, "type", bMsg.MsgType.String(), "stopping", true, "isBroadcastCall", metadata.isBroadcastCall())
+		p.log("broadcast: sending reply to client", nil, "type", bMsg.MsgType.String(), "stopping", true, "isBroadcastCall", metadata.isBroadcastCall())
 		return true
 	}
 	// QuorumCall if origin addr is empty.
@@ -254,11 +260,11 @@ func (p *BroadcastProcessor) handleReply(bMsg Msg, metadata *metadata) bool {
 		// the request is not done yet because we have not replied to
 		// the client.
 		//slog.Info("reply: late", "err", err, "id", p.broadcastID)
-		p.log("broadcast: failed to send reply to client", "err", err, "type", bMsg.MsgType.String(), "stopping", false, "isBroadcastCall", metadata.isBroadcastCall())
+		p.log("broadcast: failed to send reply to client", err, "type", bMsg.MsgType.String(), "stopping", false, "isBroadcastCall", metadata.isBroadcastCall())
 		return false
 	}
 	// the request is done becuase we have sent a reply to the client
-	p.log("broadcast: sending reply to client", "err", err, "type", bMsg.MsgType.String(), "stopping", true, "isBroadcastCall", metadata.isBroadcastCall())
+	p.log("broadcast: sending reply to client", err, "type", bMsg.MsgType.String(), "stopping", true, "isBroadcastCall", metadata.isBroadcastCall())
 	return true
 }
 
@@ -419,7 +425,7 @@ func (r *BroadcastProcessor) dispatchOutOfOrderMsgs() {
 		if order <= r.orderIndex {
 			for _, msg := range msgs {
 				msg.Run(r.cancellationCtx, r.enqueueBroadcast)
-				r.log("msg: dispatching out of order msg", "err", nil, "method", msg.CurrentMethod, "from", msg.SenderAddr)
+				r.log("msg: dispatching out of order msg", nil, "method", msg.CurrentMethod, "from", msg.SenderAddr)
 			}
 			handledMethods = append(handledMethods, method)
 		}
diff --git a/broadcast/router.go b/broadcast/router.go
@@ -71,7 +71,7 @@ func (r *BroadcastRouter) Send(broadcastID uint64, addr, method string, req any)
 		return nil
 	}
 	err := errors.New("wrong req type")
-	r.log("router: malformed msg", "err", err, "BroadcastID", broadcastID)
+	r.log("router: malformed msg", err, "BroadcastID", broadcastID)
 	return err
 }
 
@@ -87,7 +87,7 @@ func (r *BroadcastRouter) routeBroadcast(broadcastID uint64, addr, method string
 		return nil
 	}
 	err := errors.New("handler not found")
-	r.log("router (broadcast): could not find handler", "err", err, "BroadcastID", broadcastID, "addr", addr, "method", method)
+	r.log("router (broadcast): could not find handler", err, "BroadcastID", broadcastID, "addr", addr, "method", method)
 	return err
 }
 
@@ -96,17 +96,17 @@ func (r *BroadcastRouter) routeClientReply(broadcastID uint64, addr, method stri
 	if _, ok := r.clientHandlers[method]; ok && addr != "" {
 		client, err := r.getClient(addr)
 		if err != nil {
-			r.log("router (reply): could not get client", "err", err, "BroadcastID", broadcastID, "addr", addr, "method", method)
+			r.log("router (reply): could not get client", err, "BroadcastID", broadcastID, "addr", addr, "method", method)
 			return err
 		}
 		err = client.SendMsg(broadcastID, method, resp.getResponse(), r.dialTimeout)
-		r.log("router (reply): could not send reply", "err", err, "BroadcastID", broadcastID, "addr", addr, "method", method)
+		r.log("router (reply): sending reply to client", err, "BroadcastID", broadcastID, "addr", addr, "method", method)
 		return err
 	}
 	// the server can receive a broadcast from another server before a client sends a direct message.
 	// it should thus wait for a potential message from the client. otherwise, it should be removed.
 	err := errors.New("not routed")
-	r.log("router (reply): could not find handler", "err", err, "BroadcastID", broadcastID, "addr", addr, "method", method)
+	r.log("router (reply): could not find handler", err, "BroadcastID", broadcastID, "addr", addr, "method", method)
 	return err
 }
 
@@ -141,9 +141,15 @@ func (r *BroadcastRouter) getClient(addr string) (*Client, error) {
 	return client, nil
 }
 
-func (r *BroadcastRouter) log(msg string, args ...any) {
+func (r *BroadcastRouter) log(msg string, err error, args ...any) {
 	if r.logger != nil {
-		r.logger.Debug(msg, args...)
+		if err != nil {
+			args = append(args, "err", err.Error())
+			r.logger.Error(msg, args...)
+		} else {
+			args = append(args, "err", nil)
+			r.logger.Info(msg, args...)
+		}
 	}
 }
 

Original file line number	Diff line number	Diff line change
`@@ -62,14 +62,14 @@ func (p *BroadcastProcessor) handle(msg Content) {`
`62`	`62`	`msg.ReceiveChan <- shardResponse{`
`63`	`63`	`err: OutOfOrderErr{},`
`64`	`64`	`}`
`65`		`- p.log("msg: out of order", "err", OutOfOrderErr{}, "method", msg.CurrentMethod, "from", msg.SenderAddr)`
	`65`	`+ p.log("msg: out of order", OutOfOrderErr{}, "method", msg.CurrentMethod, "from", msg.SenderAddr)`
`66`	`66`	`} else {`
`67`	`67`	`msg.ReceiveChan <- shardResponse{`
`68`	`68`	`err: nil,`
`69`	`69`	`reqCtx: p.cancellationCtx,`
`70`	`70`	`enqueueBroadcast: p.enqueueBroadcast,`
`71`	`71`	`}`
`72`		`- p.log("msg: processed", "err", nil, "method", msg.CurrentMethod, "from", msg.SenderAddr)`
	`72`	`+ p.log("msg: processed", nil, "method", msg.CurrentMethod, "from", msg.SenderAddr)`
`73`	`73`	`}`
`74`	`74`	`}`
`75`	`75`	`defer func() {`
`@@ -83,15 +83,15 @@ func (p *BroadcastProcessor) handle(msg Content) {`
`83`	`83`	`//close(p.broadcastChan)`
`84`	`84`	`//close(p.sendChan)`
`85`	`85`	`p.emptyChannels(metadata)`
`86`		`- p.log("processor stopped", "err", nil, "started", p.started, "ended", p.ended)`
	`86`	`+ p.log("processor stopped", nil, "started", p.started, "ended", p.ended)`
`87`	`87`	`}()`
`88`	`88`	`for {`
`89`	`89`	`select {`
`90`	`90`	`case <-p.ctx.Done():`
`91`	`91`	`return`
`92`	`92`	`case bMsg := <-p.broadcastChan:`
`93`	`93`	`if p.broadcastID != bMsg.BroadcastID {`
`94`		`- p.log("broadcast: wrong BroadcastID", "err", BroadcastIDErr{}, "type", bMsg.MsgType.String(), "stopping", false)`
	`94`	`+ p.log("broadcast: wrong BroadcastID", BroadcastIDErr{}, "type", bMsg.MsgType.String(), "stopping", false)`
`95`	`95`	`continue`
`96`	`96`	`}`
`97`	`97`	`switch bMsg.MsgType {`
`@@ -116,7 +116,7 @@ func (p *BroadcastProcessor) handle(msg Content) {`
`116`	`116`	`new.ReceiveChan <- shardResponse{`
`117`	`117`	`err: BroadcastIDErr{},`
`118`	`118`	`}`
`119`		`- p.log("msg: wrong BroadcastID", "err", BroadcastIDErr{}, "method", new.CurrentMethod, "from", new.SenderAddr)`
	`119`	`+ p.log("msg: wrong BroadcastID", BroadcastIDErr{}, "method", new.CurrentMethod, "from", new.SenderAddr)`
`120`	`120`	`continue`
`121`	`121`	`}`
`122`	`122`	`if new.IsCancellation {`
`@@ -126,7 +126,7 @@ func (p *BroadcastProcessor) handle(msg Content) {`
`126`	`126`	`new.ReceiveChan <- shardResponse{`
`127`	`127`	`err: nil,`
`128`	`128`	`}`
`129`		`- p.log("msg: received cancellation", "err", nil, "method", new.CurrentMethod, "from", new.SenderAddr)`
	`129`	`+ p.log("msg: received cancellation", nil, "method", new.CurrentMethod, "from", new.SenderAddr)`
`130`	`130`	`continue`
`131`	`131`	`}`
`132`	`132`
`@@ -137,7 +137,7 @@ func (p *BroadcastProcessor) handle(msg Content) {`
`137`	`137`	`new.ReceiveChan <- shardResponse{`
`138`	`138`	`err: ClientReqAlreadyReceivedErr{},`
`139`	`139`	`}`
`140`		`- p.log("msg: duplicate client req", "err", ClientReqAlreadyReceivedErr{}, "method", new.CurrentMethod, "from", new.SenderAddr)`
	`140`	`+ p.log("msg: duplicate client req", ClientReqAlreadyReceivedErr{}, "method", new.CurrentMethod, "from", new.SenderAddr)`
`141`	`141`	`continue`
`142`	`142`	`}`
`143`	`143`	`// important to set this option to prevent duplicate client reqs.`
`@@ -155,7 +155,7 @@ func (p *BroadcastProcessor) handle(msg Content) {`
`155`	`155`	`}`
`156`	`156`	`p.cancellationCtxCancel()`
`157`	`157`	`}()`
`158`		`- p.log("msg: received client req", "err", nil, "method", new.CurrentMethod, "from", new.SenderAddr)`
	`158`	`+ p.log("msg: received client req", nil, "method", new.CurrentMethod, "from", new.SenderAddr)`
`159`	`159`	`}`
`160`	`160`
`161`	`161`	`metadata.update(new)`
`@@ -174,7 +174,7 @@ func (p *BroadcastProcessor) handle(msg Content) {`
`174`	`174`	`err: err,`
`175`	`175`	`}`
`176`	`176`	`// slog.Info("receive: late", "err", err, "id", p.broadcastID)`
`177`		`- p.log("msg: late msg", "err", err, "method", new.CurrentMethod, "from", new.SenderAddr)`
	`177`	`+ p.log("msg: late msg", err, "method", new.CurrentMethod, "from", new.SenderAddr)`
`178`	`178`	`return`
`179`	`179`	`}`
`180`	`180`	`if !p.isInOrder(new.CurrentMethod) {`
`@@ -183,26 +183,26 @@ func (p *BroadcastProcessor) handle(msg Content) {`
`183`	`183`	`new.ReceiveChan <- shardResponse{`
`184`	`184`	`err: OutOfOrderErr{},`
`185`	`185`	`}`
`186`		`- p.log("msg: out of order", "err", OutOfOrderErr{}, "method", new.CurrentMethod, "from", new.SenderAddr)`
	`186`	`+ p.log("msg: out of order", OutOfOrderErr{}, "method", new.CurrentMethod, "from", new.SenderAddr)`
`187`	`187`	`continue`
`188`	`188`	`}`
`189`	`189`	`new.ReceiveChan <- shardResponse{`
`190`	`190`	`err: nil,`
`191`	`191`	`reqCtx: p.cancellationCtx,`
`192`	`192`	`enqueueBroadcast: p.enqueueBroadcast,`
`193`	`193`	`}`
`194`		`- p.log("msg: processed", "err", nil, "method", new.CurrentMethod, "from", new.SenderAddr)`
	`194`	`+ p.log("msg: processed", nil, "method", new.CurrentMethod, "from", new.SenderAddr)`
`195`	`195`	`}`
`196`	`196`	`}`
`197`	`197`	`}`
`198`	`198`
`199`	`199`	`func (p BroadcastProcessor) handleCancellation(bMsg Msg, metadata metadata) bool {`
`200`	`200`	`if bMsg.Cancellation.end {`
`201`		`- p.log("broadcast: broadcast.Done() called", "err", nil, "type", bMsg.MsgType.String(), "stopping", true)`
	`201`	`+ p.log("broadcast: broadcast.Done() called", nil, "type", bMsg.MsgType.String(), "stopping", true)`
`202`	`202`	`return true`
`203`	`203`	`}`
`204`	`204`	`if !metadata.SentCancellation {`
`205`		`- p.log("broadcast: sent cancellation", "err", nil, "type", bMsg.MsgType.String(), "stopping", false)`
	`205`	`+ p.log("broadcast: sent cancellation", nil, "type", bMsg.MsgType.String(), "stopping", false)`
`206`	`206`	`metadata.SentCancellation = true`
`207`	`207`	`go p.router.Send(p.broadcastID, "", "", bMsg.Cancellation)`
`208`	`208`	`}`
`@@ -216,16 +216,22 @@ func (p *BroadcastProcessor) handleBroadcast(bMsg Msg, methods []string, metadat`
`216`	`216`	`return false`
`217`	`217`	`}`
`218`	`218`	`p.router.Send(p.broadcastID, metadata.OriginAddr, metadata.OriginMethod, bMsg.Msg)`
`219`		`- p.log("broadcast: sending broadcast", "err", nil, "type", bMsg.MsgType.String(), "stopping", false, "isBroadcastCall", metadata.isBroadcastCall())`
	`219`	`+ p.log("broadcast: sending broadcast", nil, "type", bMsg.MsgType.String(), "method", bMsg.Method, "stopping", false, "isBroadcastCall", metadata.isBroadcastCall())`
`220`	`220`
`221`	`221`	`p.updateOrder(bMsg.Method)`
`222`	`222`	`p.dispatchOutOfOrderMsgs()`
`223`	`223`	`return true`
`224`	`224`	`}`
`225`	`225`
`226`		`-func (p *BroadcastProcessor) log(msg string, args ...any) {`
	`226`	`+func (p *BroadcastProcessor) log(msg string, err error, args ...any) {`
`227`	`227`	`if p.logger != nil {`
`228`		`- p.logger.Debug(msg, args...)`
	`228`	`+ if err != nil {`
	`229`	`+ args = append(args, "err", err.Error())`
	`230`	`+ p.logger.Error(msg, args...)`
	`231`	`+ } else {`
	`232`	`+ args = append(args, "err", nil)`
	`233`	`+ p.logger.Info(msg, args...)`
	`234`	`+ }`
`229`	`235`	`}`
`230`	`236`	`}`
`231`	`237`
`@@ -234,7 +240,7 @@ func (p BroadcastProcessor) handleReply(bMsg Msg, metadata metadata) bool {`
`234`	`240`	`if metadata.isBroadcastCall() {`
`235`	`241`	`go p.router.Send(p.broadcastID, metadata.OriginAddr, metadata.OriginMethod, bMsg.Reply)`
`236`	`242`	`// the request is done becuase we have sent a reply to the client`
`237`		`- p.log("broadcast: sending reply to client", "err", nil, "type", bMsg.MsgType.String(), "stopping", true, "isBroadcastCall", metadata.isBroadcastCall())`
	`243`	`+ p.log("broadcast: sending reply to client", nil, "type", bMsg.MsgType.String(), "stopping", true, "isBroadcastCall", metadata.isBroadcastCall())`
`238`	`244`	`return true`
`239`	`245`	`}`
`240`	`246`	`// QuorumCall if origin addr is empty.`
`@@ -254,11 +260,11 @@ func (p BroadcastProcessor) handleReply(bMsg Msg, metadata metadata) bool {`
`254`	`260`	`// the request is not done yet because we have not replied to`
`255`	`261`	`// the client.`
`256`	`262`	`//slog.Info("reply: late", "err", err, "id", p.broadcastID)`
`257`		`- p.log("broadcast: failed to send reply to client", "err", err, "type", bMsg.MsgType.String(), "stopping", false, "isBroadcastCall", metadata.isBroadcastCall())`
	`263`	`+ p.log("broadcast: failed to send reply to client", err, "type", bMsg.MsgType.String(), "stopping", false, "isBroadcastCall", metadata.isBroadcastCall())`
`258`	`264`	`return false`
`259`	`265`	`}`
`260`	`266`	`// the request is done becuase we have sent a reply to the client`
`261`		`- p.log("broadcast: sending reply to client", "err", err, "type", bMsg.MsgType.String(), "stopping", true, "isBroadcastCall", metadata.isBroadcastCall())`
	`267`	`+ p.log("broadcast: sending reply to client", err, "type", bMsg.MsgType.String(), "stopping", true, "isBroadcastCall", metadata.isBroadcastCall())`
`262`	`268`	`return true`
`263`	`269`	`}`
`264`	`270`
`@@ -419,7 +425,7 @@ func (r *BroadcastProcessor) dispatchOutOfOrderMsgs() {`
`419`	`425`	`if order <= r.orderIndex {`
`420`	`426`	`for _, msg := range msgs {`
`421`	`427`	`msg.Run(r.cancellationCtx, r.enqueueBroadcast)`
`422`		`- r.log("msg: dispatching out of order msg", "err", nil, "method", msg.CurrentMethod, "from", msg.SenderAddr)`
	`428`	`+ r.log("msg: dispatching out of order msg", nil, "method", msg.CurrentMethod, "from", msg.SenderAddr)`
`423`	`429`	`}`
`424`	`430`	`handledMethods = append(handledMethods, method)`
`425`	`431`	`}`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ func (r *BroadcastRouter) Send(broadcastID uint64, addr, method string, req any)`
`71`	`71`	`return nil`
`72`	`72`	`}`
`73`	`73`	`err := errors.New("wrong req type")`
`74`		`- r.log("router: malformed msg", "err", err, "BroadcastID", broadcastID)`
	`74`	`+ r.log("router: malformed msg", err, "BroadcastID", broadcastID)`
`75`	`75`	`return err`
`76`	`76`	`}`
`77`	`77`
`@@ -87,7 +87,7 @@ func (r *BroadcastRouter) routeBroadcast(broadcastID uint64, addr, method string`
`87`	`87`	`return nil`
`88`	`88`	`}`
`89`	`89`	`err := errors.New("handler not found")`
`90`		`- r.log("router (broadcast): could not find handler", "err", err, "BroadcastID", broadcastID, "addr", addr, "method", method)`
	`90`	`+ r.log("router (broadcast): could not find handler", err, "BroadcastID", broadcastID, "addr", addr, "method", method)`
`91`	`91`	`return err`
`92`	`92`	`}`
`93`	`93`
`@@ -96,17 +96,17 @@ func (r *BroadcastRouter) routeClientReply(broadcastID uint64, addr, method stri`
`96`	`96`	`if _, ok := r.clientHandlers[method]; ok && addr != "" {`
`97`	`97`	`client, err := r.getClient(addr)`
`98`	`98`	`if err != nil {`
`99`		`- r.log("router (reply): could not get client", "err", err, "BroadcastID", broadcastID, "addr", addr, "method", method)`
	`99`	`+ r.log("router (reply): could not get client", err, "BroadcastID", broadcastID, "addr", addr, "method", method)`
`100`	`100`	`return err`
`101`	`101`	`}`
`102`	`102`	`err = client.SendMsg(broadcastID, method, resp.getResponse(), r.dialTimeout)`
`103`		`- r.log("router (reply): could not send reply", "err", err, "BroadcastID", broadcastID, "addr", addr, "method", method)`
	`103`	`+ r.log("router (reply): sending reply to client", err, "BroadcastID", broadcastID, "addr", addr, "method", method)`
`104`	`104`	`return err`
`105`	`105`	`}`
`106`	`106`	`// the server can receive a broadcast from another server before a client sends a direct message.`
`107`	`107`	`// it should thus wait for a potential message from the client. otherwise, it should be removed.`
`108`	`108`	`err := errors.New("not routed")`
`109`		`- r.log("router (reply): could not find handler", "err", err, "BroadcastID", broadcastID, "addr", addr, "method", method)`
	`109`	`+ r.log("router (reply): could not find handler", err, "BroadcastID", broadcastID, "addr", addr, "method", method)`
`110`	`110`	`return err`
`111`	`111`	`}`
`112`	`112`
`@@ -141,9 +141,15 @@ func (r BroadcastRouter) getClient(addr string) (Client, error) {`
`141`	`141`	`return client, nil`
`142`	`142`	`}`
`143`	`143`
`144`		`-func (r *BroadcastRouter) log(msg string, args ...any) {`
	`144`	`+func (r *BroadcastRouter) log(msg string, err error, args ...any) {`
`145`	`145`	`if r.logger != nil {`
`146`		`- r.logger.Debug(msg, args...)`
	`146`	`+ if err != nil {`
	`147`	`+ args = append(args, "err", err.Error())`
	`148`	`+ r.logger.Error(msg, args...)`
	`149`	`+ } else {`
	`150`	`+ args = append(args, "err", nil)`
	`151`	`+ r.logger.Info(msg, args...)`
	`152`	`+ }`
`147`	`153`	`}`
`148`	`154`	`}`
`149`	`155`