Added flags to enable logging of gRPC calls

Author: cmaglie

cli/daemon/daemon.go

@@ -56,10 +56,12 @@ func NewCommand() *cobra.Command {
 	cmd.PersistentFlags().String("port", "", tr("The TCP port the daemon will listen to"))
 	configuration.Settings.BindPFlag("daemon.port", cmd.PersistentFlags().Lookup("port"))
 	cmd.Flags().BoolVar(&daemonize, "daemonize", false, tr("Do not terminate daemon process if the parent process dies"))
+	cmd.Flags().BoolVar(&debug, "debug", false, tr("Enable debug logging of gRPC calls"))
 	return cmd
 }
 
 var daemonize bool
+var debug bool
 
 func runDaemonCommand(cmd *cobra.Command, args []string) {
 
@@ -69,8 +71,15 @@ func runDaemonCommand(cmd *cobra.Command, args []string) {
 		defer stats.Flush()
 	}
 	port := configuration.Settings.GetString("daemon.port")
-	s := grpc.NewServer()
-
+	var s *grpc.Server
+	if debug {
+		s = grpc.NewServer(
+			grpc.UnaryInterceptor(unaryLoggerInterceptor),
+			grpc.StreamInterceptor(streamLoggerInterceptor),
+		)
+	} else {
+		s = grpc.NewServer()
+	}
 	// Set specific user-agent for the daemon
 	configuration.Settings.Set("network.user_agent_ext", "daemon")
 

cli/daemon/interceptors.go

@@ -0,0 +1,79 @@
+// This file is part of arduino-cli.
+//
+// Copyright 2020 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-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"
+
+	"google.golang.org/grpc"
+)
+
+func log(isRequest bool, msg interface{}) {
+	j, _ := json.MarshalIndent(msg, "|  ", "  ")
+	inOut := map[bool]string{true: "REQ:  ", false: "RESP: "}
+	fmt.Println("|  " + inOut[isRequest] + string(j))
+}
+
+func logError(err error) {
+	if err != nil {
+		fmt.Println("|  ERROR: ", err)
+	}
+}
+
+func unaryLoggerInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
+	fmt.Println("CALLED:", info.FullMethod)
+	log(true, req)
+	resp, err := handler(ctx, req)
+	logError(err)
+	log(false, resp)
+	fmt.Println()
+	return resp, err
+}
+
+func streamLoggerInterceptor(srv interface{}, stream grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
+	streamReq := ""
+	if info.IsClientStream {
+		streamReq = "STREAM_REQ "
+	}
+	if info.IsServerStream {
+		streamReq += "STREAM_RESP"
+	}
+	fmt.Println("CALLED:", info.FullMethod, streamReq)
+	err := handler(srv, &loggingServerStream{ServerStream: stream})
+	logError(err)
+	fmt.Println()
+	return err
+}
+
+type loggingServerStream struct {
+	grpc.ServerStream
+}
+
+func (l *loggingServerStream) RecvMsg(m interface{}) error {
+	err := l.ServerStream.RecvMsg(m)
+	logError(err)
+	log(true, m)
+	return err
+}
+
+func (l *loggingServerStream) SendMsg(m interface{}) error {
+	err := l.ServerStream.SendMsg(m)
+	logError(err)
+	log(false, m)
+	return err
+}