feat: add deamon debug mode

Author: MatteoPologruto

cmd/arduino-flasher-cli/daemon/daemon.go

@@ -29,18 +29,22 @@ import (
 	"github.com/arduino/arduino-flasher-cli/cmd/feedback"
 	"github.com/arduino/arduino-flasher-cli/cmd/i18n"
 	flasher "github.com/arduino/arduino-flasher-cli/rpc/cc/arduino/flasher/v1"
+	"github.com/arduino/go-paths-helper"
 )
 
 func NewDaemonCommand(srv flasher.FlasherServer) *cobra.Command {
 	var daemonPort string
 	var maxGRPCRecvMsgSize int
+	var debugFile string
+	var debug bool
+	var debugFiltersArg []string
 	daemonCommand := &cobra.Command{
 		Use:     "daemon",
 		Short:   i18n.Tr("Run the Arduino Flasher CLI as a gRPC daemon."),
 		Example: "  " + os.Args[0] + " daemon",
 		Args:    cobra.NoArgs,
 		Run: func(cmd *cobra.Command, args []string) {
-			runDaemonCommand(srv, daemonPort, maxGRPCRecvMsgSize)
+			runDaemonCommand(srv, daemonPort, maxGRPCRecvMsgSize, debugFile, debug, debugFiltersArg)
 		},
 	}
 
@@ -52,11 +56,49 @@ func NewDaemonCommand(srv flasher.FlasherServer) *cobra.Command {
 		"max-grpc-recv-message-size", 16*1024*1024,
 		i18n.Tr("Sets the maximum message size in bytes the daemon can receive"))
 
+	daemonCommand.Flags().BoolVar(&debug,
+		"debug", false,
+		i18n.Tr("Enable debug logging of gRPC calls"))
+	daemonCommand.Flags().StringVar(&debugFile,
+		"debug-file", "",
+		i18n.Tr("Append debug logging to the specified file"))
+
+	daemonCommand.Flags().StringSliceVar(&debugFiltersArg,
+		"debug-filter", []string{},
+		i18n.Tr("Display only the provided gRPC calls"))
+
 	return daemonCommand
 }
 
-func runDaemonCommand(srv flasher.FlasherServer, daemonPort string, maxGRPCRecvMsgSize int) {
+func runDaemonCommand(srv flasher.FlasherServer, daemonPort string, maxGRPCRecvMsgSize int, debugFile string, debug bool, debugFiltersArg []string) {
 	gRPCOptions := []grpc.ServerOption{}
+	if debugFile != "" {
+		if !debug {
+			feedback.Fatal(i18n.Tr("The flag --debug-file must be used with --debug."), feedback.ErrBadArgument)
+		}
+	}
+	if debug {
+		if debugFile != "" {
+			outFile := paths.New(debugFile)
+			f, err := outFile.Append()
+			if err != nil {
+				feedback.Fatal(i18n.Tr("Error opening debug logging file: %s", err), feedback.ErrGeneric)
+			}
+			defer f.Close()
+			debugStdOut = f
+		} else {
+			if out, _, err := feedback.DirectStreams(); err != nil {
+				feedback.Fatal(i18n.Tr("Can't write debug log: %s", err), feedback.ErrBadArgument)
+			} else {
+				debugStdOut = out
+			}
+		}
+		debugFilters = debugFiltersArg
+		gRPCOptions = append(gRPCOptions,
+			grpc.UnaryInterceptor(unaryLoggerInterceptor),
+			grpc.StreamInterceptor(streamLoggerInterceptor),
+		)
+	}
 	gRPCOptions = append(gRPCOptions, grpc.MaxRecvMsgSize(maxGRPCRecvMsgSize))
 	s := grpc.NewServer(gRPCOptions...)
 

cmd/arduino-flasher-cli/daemon/interceptors.go

@@ -0,0 +1,113 @@
+// This file is part of arduino-flasher-cli.
+//
+// Copyright 2025 ARDUINO SA (http://www.arduino.cc/)
+//
+// This software is released under the GNU General Public License version 3,
+// which covers the main part of arduino-flasher-cli.
+// The terms of this license can be found at:
+// https://www.gnu.org/licenses/gpl-3.0.en.html
+//
+// You can be released from the requirements of the above licenses by purchasing
+// a commercial license. Buying such a license is mandatory if you want to
+// modify or otherwise use the software for commercial activities involving the
+// Arduino software without disclosing the source code of your own applications.
+// To purchase a commercial license, send an email to license@arduino.cc.
+
+package daemon
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"strings"
+	"sync/atomic"
+
+	"google.golang.org/grpc"
+)
+
+var debugStdOut io.Writer
+var debugSeq uint32
+var debugFilters []string
+
+func log(isRequest bool, seq uint32, msg interface{}) {
+	prefix := fmt.Sprint(seq, " |  ")
+	j, _ := json.MarshalIndent(msg, prefix, "  ")
+	inOut := "RESP: "
+	if isRequest {
+		inOut = "REQ:  "
+	}
+	fmt.Fprintln(debugStdOut, prefix+inOut+string(j))
+}
+
+func logError(seq uint32, err error) {
+	if err != nil {
+		fmt.Fprintln(debugStdOut, seq, "|  ERROR: ", err)
+	}
+}
+
+func logSelector(method string) bool {
+	if len(debugFilters) == 0 {
+		return true
+	}
+	for _, filter := range debugFilters {
+		if strings.Contains(method, filter) {
+			return true
+		}
+	}
+	return false
+}
+
+func unaryLoggerInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
+	if !logSelector(info.FullMethod) {
+		return handler(ctx, req)
+	}
+	seq := atomic.AddUint32(&debugSeq, 1)
+	fmt.Fprintln(debugStdOut, seq, "CALLED:", info.FullMethod)
+	log(true, seq, req)
+	resp, err := handler(ctx, req)
+	logError(seq, err)
+	log(false, seq, resp)
+	fmt.Fprintln(debugStdOut, seq, "CALL END")
+	fmt.Fprintln(debugStdOut)
+	return resp, err
+}
+
+func streamLoggerInterceptor(srv interface{}, stream grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
+	if !logSelector(info.FullMethod) {
+		return handler(srv, stream)
+	}
+	seq := atomic.AddUint32(&debugSeq, 1)
+	streamReq := ""
+	if info.IsClientStream {
+		streamReq = "STREAM_REQ "
+	}
+	if info.IsServerStream {
+		streamReq += "STREAM_RESP"
+	}
+	fmt.Fprintln(debugStdOut, seq, "CALLED:", info.FullMethod, streamReq)
+	err := handler(srv, &loggingServerStream{ServerStream: stream, seq: seq})
+	logError(seq, err)
+	fmt.Fprintln(debugStdOut, seq, "STREAM CLOSED")
+	fmt.Fprintln(debugStdOut)
+	return err
+}
+
+type loggingServerStream struct {
+	grpc.ServerStream
+	seq uint32
+}
+
+func (l *loggingServerStream) RecvMsg(m interface{}) error {
+	err := l.ServerStream.RecvMsg(m)
+	logError(l.seq, err)
+	log(true, l.seq, m)
+	return err
+}
+
+func (l *loggingServerStream) SendMsg(m interface{}) error {
+	err := l.ServerStream.SendMsg(m)
+	logError(l.seq, err)
+	log(false, l.seq, m)
+	return err
+}