Update protobuf validation interceptors to log invalid requests and responses

Author: jeffyanta

pkg/grpc/protobuf/validation/client_interceptor.go

@@ -16,26 +16,26 @@ import (
 func UnaryClientInterceptor() grpc.UnaryClientInterceptor {
 	log := logrus.StandardLogger().WithField("type", "protobuf/validation/interceptor")
 
-	return func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
+	return func(ctx context.Context, method string, req, resp interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
 		// Validate request
 		if v, ok := req.(Validator); ok {
 			if err := v.Validate(); err != nil {
 				// Log warn since the caller is at fault.
-				log.WithError(err).Warn("dropping invalid request")
+				log.WithError(err).WithField("req", req).Warn("dropping invalid request")
 				return status.Errorf(codes.InvalidArgument, err.Error())
 			}
 		}
 
 		// Do service call
-		if err := invoker(ctx, method, req, reply, cc, opts...); err != nil {
+		if err := invoker(ctx, method, req, resp, cc, opts...); err != nil {
 			return err
 		}
 
 		// Validate service response
-		if v, ok := reply.(Validator); ok {
+		if v, ok := resp.(Validator); ok {
 			if err := v.Validate(); err != nil {
-				// Just log debug here since the outbound service is mis-behaving.
-				log.WithError(err).Debug("dropping invalid response")
+				// Just log info here since the outbound service is mis-behaving.
+				log.WithError(err).WithField("resp", resp).Info("dropping invalid response")
 				return status.Errorf(codes.Internal, err.Error())
 			}
 		}
@@ -73,24 +73,24 @@ func (c *clientStreamWrapper) SendMsg(req interface{}) error {
 	if v, ok := req.(Validator); ok {
 		if err := v.Validate(); err != nil {
 			// Log warn since the caller is at fault.
-			c.log.WithError(err).Warn("dropping invalid request")
+			c.log.WithError(err).WithField("req", req).Warn("dropping invalid request")
 			return status.Errorf(codes.InvalidArgument, err.Error())
 		}
 	}
 
 	return c.ClientStream.SendMsg(req)
 }
 
-func (c *clientStreamWrapper) RecvMsg(res interface{}) error {
-	if err := c.ClientStream.RecvMsg(res); err != nil {
+func (c *clientStreamWrapper) RecvMsg(resp interface{}) error {
+	if err := c.ClientStream.RecvMsg(resp); err != nil {
 		return err
 	}
 
 	// Validate service response
-	if v, ok := res.(Validator); ok {
+	if v, ok := resp.(Validator); ok {
 		if err := v.Validate(); err != nil {
-			// Just log debug here since the outbound service is mis-behaving.
-			c.log.WithError(err).Debug("dropping invalid response")
+			// Just log info here since the outbound service is mis-behaving.
+			c.log.WithError(err).WithField("resp", resp).Info("dropping invalid response")
 			return status.Errorf(codes.Internal, err.Error())
 		}
 	}

pkg/grpc/protobuf/validation/server_interceptor.go

@@ -23,8 +23,8 @@ func UnaryServerInterceptor() grpc.UnaryServerInterceptor {
 	return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
 		if v, ok := req.(Validator); ok {
 			if err := v.Validate(); err != nil {
-				// We use a debug level here because it is outside of 'our' control.
-				log.WithError(err).Debug("dropping invalid request")
+				// We use an info level here because it is outside of 'our' control.
+				log.WithError(err).WithField("req", req).Info("dropping invalid request")
 				return nil, status.Errorf(codes.InvalidArgument, err.Error())
 			}
 		}
@@ -37,7 +37,7 @@ func UnaryServerInterceptor() grpc.UnaryServerInterceptor {
 		if v, ok := resp.(Validator); ok {
 			if err := v.Validate(); err != nil {
 				// We warn here because this indicates a problem with 'our' service.
-				log.WithError(err).Warn("dropping invalid response")
+				log.WithError(err).WithField("resp", req).Warn("dropping invalid response")
 				return nil, status.Errorf(codes.Internal, err.Error())
 			}
 		}
@@ -69,21 +69,21 @@ func (s *serverStreamWrapper) RecvMsg(req interface{}) error {
 
 	if v, ok := req.(Validator); ok {
 		if err := v.Validate(); err != nil {
-			s.log.WithError(err).Debug("dropping invalid request")
+			s.log.WithError(err).WithField("req", req).Info("dropping invalid request")
 			return status.Errorf(codes.InvalidArgument, err.Error())
 		}
 	}
 
 	return nil
 }
 
-func (s *serverStreamWrapper) SendMsg(res interface{}) error {
-	if v, ok := res.(Validator); ok {
+func (s *serverStreamWrapper) SendMsg(resp interface{}) error {
+	if v, ok := resp.(Validator); ok {
 		if err := v.Validate(); err != nil {
-			s.log.WithError(err).Warn("dropping invalid response")
+			s.log.WithError(err).WithField("resp", resp).Warn("dropping invalid response")
 			return status.Errorf(codes.Internal, err.Error())
 		}
 	}
 
-	return s.ServerStream.SendMsg(res)
+	return s.ServerStream.SendMsg(resp)
 }