Improvement/add more logs to management api (#316)

* Remove useless ping handler

* Add logs to handlers

* Add logger field to services

* Run lint

Author: guilhermocc

cmd/managementapi/wire.go

@@ -58,7 +58,6 @@ func initializeManagementMux(ctx context.Context, conf config.Config) (*runtime.
 		// api handlers
 		handlers.ProvideSchedulersHandler,
 		handlers.ProvideOperationsHandler,
-		handlers.ProvidePingHandler,
 		provideManagementMux,
 
 		// config
@@ -68,9 +67,8 @@ func initializeManagementMux(ctx context.Context, conf config.Config) (*runtime.
 	return &runtime.ServeMux{}, nil
 }
 
-func provideManagementMux(ctx context.Context, pingHandler *handlers.PingHandler, schedulersHandler *handlers.SchedulersHandler, operationsHandler *handlers.OperationsHandler) *runtime.ServeMux {
+func provideManagementMux(ctx context.Context, schedulersHandler *handlers.SchedulersHandler, operationsHandler *handlers.OperationsHandler) *runtime.ServeMux {
 	mux := runtime.NewServeMux()
-	_ = api.RegisterPingServiceHandlerServer(ctx, mux, pingHandler)
 	_ = api.RegisterSchedulersServiceHandlerServer(ctx, mux, schedulersHandler)
 	_ = api.RegisterOperationsServiceHandlerServer(ctx, mux, operationsHandler)
 

cmd/managementapi/wire_gen.go

@@ -29,6 +29,8 @@ import (
 	"strings"
 	"time"
 
+	"go.uber.org/zap"
+
 	"github.com/topfreegames/maestro/internal/core/ports"
 
 	"github.com/topfreegames/maestro/internal/core/entities/operation"
@@ -40,51 +42,61 @@ import (
 
 type OperationsHandler struct {
 	operationManager ports.OperationManager
+	logger           *zap.Logger
 	api.UnimplementedOperationsServiceServer
 }
 
 func ProvideOperationsHandler(operationManager ports.OperationManager) *OperationsHandler {
 	return &OperationsHandler{
 		operationManager: operationManager,
+		logger: zap.L().
+			With(zap.String("component", "handler"), zap.String("handler", "operations_handler")),
 	}
 }
 
 func (h *OperationsHandler) ListOperations(ctx context.Context, request *api.ListOperationsRequest) (*api.ListOperationsResponse, error) {
 	sortingOrder, err := extractSortingParameters(request.OrderBy)
 	if err != nil {
+		h.logger.Error("error parsing sorting parameters", zap.String("schedulerName", request.GetSchedulerName()), zap.String("orderBy", request.OrderBy), zap.Error(err))
 		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 
 	pendingOperationEntities, err := h.operationManager.ListSchedulerPendingOperations(ctx, request.GetSchedulerName())
 	if err != nil {
+		h.logger.Error("error listing pending operations", zap.String("schedulerName", request.GetSchedulerName()), zap.Error(err))
 		return nil, status.Error(codes.Unknown, err.Error())
 	}
 	sortOperationsByCreatedAt(pendingOperationEntities, sortingOrder)
 
 	pendingOperationResponse, err := h.fromOperationsToResponses(pendingOperationEntities)
 	if err != nil {
+		h.logger.Error("error converting pending operations", zap.String("schedulerName", request.GetSchedulerName()), zap.Error(err))
 		return nil, status.Error(codes.Unknown, err.Error())
 	}
 
 	activeOperationEntities, err := h.operationManager.ListSchedulerActiveOperations(ctx, request.GetSchedulerName())
 	if err != nil {
+		h.logger.Error("error listing pending operations", zap.String("schedulerName", request.GetSchedulerName()), zap.Error(err))
 		return nil, status.Error(codes.Unknown, err.Error())
 	}
 	sortOperationsByCreatedAt(activeOperationEntities, sortingOrder)
 
 	activeOperationResponses, err := h.fromOperationsToResponses(activeOperationEntities)
 	if err != nil {
+		h.logger.Error("error converting active operations", zap.String("schedulerName", request.GetSchedulerName()), zap.Error(err))
 		return nil, status.Error(codes.Unknown, err.Error())
 	}
 
 	finishedOperationEntities, err := h.operationManager.ListSchedulerFinishedOperations(ctx, request.GetSchedulerName())
 	if err != nil {
+		h.logger.Error("error listing finished operations", zap.String("schedulerName", request.GetSchedulerName()), zap.Error(err))
 		return nil, status.Error(codes.Unknown, err.Error())
 	}
 	sortOperationsByCreatedAt(finishedOperationEntities, sortingOrder)
 
 	finishedOperationResponse, err := h.fromOperationsToResponses(finishedOperationEntities)
 	if err != nil {
+		h.logger.Error("error converting finished operations", zap.String("schedulerName", request.GetSchedulerName()), zap.Error(err))
 		return nil, status.Error(codes.Unknown, err.Error())
 	}
 
@@ -98,6 +110,7 @@ func (h *OperationsHandler) ListOperations(ctx context.Context, request *api.Lis
 func (h *OperationsHandler) CancelOperation(ctx context.Context, request *api.CancelOperationRequest) (*api.CancelOperationResponse, error) {
 	err := h.operationManager.EnqueueOperationCancellationRequest(ctx, request.SchedulerName, request.OperationId)
 	if err != nil {
+		h.logger.Error("error cancelling operation", zap.String("schedulerName", request.GetSchedulerName()), zap.String("operationId", request.GetOperationId()), zap.Error(err))
 		return nil, status.Error(codes.Unknown, err.Error())
 	}
 

internal/api/handlers/operations_handler.go

@@ -27,6 +27,8 @@ import (
 	"errors"
 	"time"
 
+	"go.uber.org/zap"
+
 	"github.com/topfreegames/maestro/internal/core/ports"
 
 	"github.com/topfreegames/maestro/internal/core/entities/events"
@@ -44,13 +46,16 @@ import (
 type RoomsHandler struct {
 	roomManager   ports.RoomManager
 	eventsService ports.EventsService
+	logger        *zap.Logger
 	api.UnimplementedRoomsServiceServer
 }
 
 func ProvideRoomsHandler(roomManager ports.RoomManager, eventsService ports.EventsService) *RoomsHandler {
 	return &RoomsHandler{
 		roomManager:   roomManager,
 		eventsService: eventsService,
+		logger: zap.L().
+			With(zap.String("component", "handler"), zap.String("handler", "rooms_handler")),
 	}
 }
 
@@ -61,6 +66,7 @@ func (h *RoomsHandler) ForwardRoomEvent(ctx context.Context, message *api.Forwar
 
 	err := h.eventsService.ProduceEvent(ctx, events.NewRoomEvent(message.SchedulerName, message.RoomName, eventMetadata))
 	if err != nil {
+		h.logger.Error("error forwarding room event", zap.String("schedulerName", message.SchedulerName), zap.String("roomName", message.RoomName), zap.Any("eventMessage", message), zap.Error(err))
 		return &api.ForwardRoomEventResponse{Success: false, Message: err.Error()}, nil
 	}
 	return &api.ForwardRoomEventResponse{Success: true, Message: ""}, nil
@@ -72,6 +78,7 @@ func (h *RoomsHandler) ForwardPlayerEvent(ctx context.Context, message *api.Forw
 
 	err := h.eventsService.ProduceEvent(ctx, events.NewPlayerEvent(message.SchedulerName, message.RoomName, eventMetadata))
 	if err != nil {
+		h.logger.Error("error forwarding player event", zap.String("schedulerName", message.SchedulerName), zap.String("roomName", message.RoomName), zap.Any("eventMessage", message), zap.Error(err))
 		return &api.ForwardPlayerEventResponse{Success: false, Message: err.Error()}, nil
 	}
 	return &api.ForwardPlayerEventResponse{Success: true, Message: ""}, nil
@@ -80,10 +87,12 @@ func (h *RoomsHandler) ForwardPlayerEvent(ctx context.Context, message *api.Forw
 func (h *RoomsHandler) UpdateRoomWithPing(ctx context.Context, message *api.UpdateRoomWithPingRequest) (*api.UpdateRoomWithPingResponse, error) {
 	gameRoom, err := h.fromApiUpdateRoomRequestToEntity(message)
 	if err != nil {
+		h.logger.Error("error parsing ping request", zap.String("schedulerName", message.SchedulerName), zap.String("roomName", message.RoomName), zap.Any("ping", message), zap.Error(err))
 		return nil, status.Error(codes.InvalidArgument, err.Error())
 	}
 	err = h.roomManager.UpdateRoom(ctx, gameRoom)
 	if err != nil {
+		h.logger.Error("error updating room with ping", zap.String("schedulerName", message.SchedulerName), zap.String("roomName", message.RoomName), zap.Any("ping", message), zap.Error(err))
 		if errors.Is(err, portsErrors.ErrNotFound) {
 			return nil, status.Error(codes.NotFound, err.Error())
 		}