Remove fmt.Prinln and add Zerolog logging system

grpcapi/events.go

@@ -2,9 +2,9 @@ package grpcapi
 
 import (
 	"encoding/json"
-	"fmt"
 
 	"git.coopgo.io/coopgo-platform/agenda/storage"
+	"github.com/rs/zerolog/log"
 	"google.golang.org/protobuf/encoding/protojson"
 	"google.golang.org/protobuf/types/known/structpb"
 	"google.golang.org/protobuf/types/known/timestamppb"
@@ -12,23 +12,23 @@ import (
 
 func (e Event) ToStorageType() storage.Event {
 	event := storage.Event{
-		ID:             e.Id,
-		Namespace:      e.Namespace,
-		Owners:         e.Owners,
-		RestrictedTo:   e.RestrictedTo,
-		Type:           e.Type,
-		Name:           e.Name,
-		Description:    e.Description,
-		Startdate:      e.Startdate.AsTime(),
-		Enddate:        e.Enddate.AsTime(),
-		Starttime:      e.Starttime,
-		Endtime:        e.Endtime,
-		Allday:         e.Allday,
-		MaxSubscribers: e.MaxSubscribers,
-		Subscriptions:  []storage.Subscription{},
+		ID:                  e.Id,
+		Namespace:           e.Namespace,
+		Owners:              e.Owners,
+		RestrictedTo:        e.RestrictedTo,
+		Type:                e.Type,
+		Name:                e.Name,
+		Description:         e.Description,
+		Startdate:           e.Startdate.AsTime(),
+		Enddate:             e.Enddate.AsTime(),
+		Starttime:           e.Starttime,
+		Endtime:             e.Endtime,
+		Allday:              e.Allday,
+		MaxSubscribers:      e.MaxSubscribers,
+		Subscriptions:       []storage.Subscription{},
 		DeletedSubscription: []storage.Subscription{},
-		Data:           map[string]any{},
-		Deleted:        e.Deleted,
+		Data:                map[string]any{},
+		Deleted:             e.Deleted,
 	}
 
 	for _, v := range e.Subscriptions {
@@ -42,7 +42,7 @@ func (e Event) ToStorageType() storage.Event {
 	for k, d := range e.Data.GetFields() {
 		jsondata, err := protojson.Marshal(d)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			break
 		}
 		var data any
@@ -73,7 +73,7 @@ func EventFromStorageType(event *storage.Event) (*Event, error) {
 
 	data, err := structpb.NewStruct(d)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return nil, err
 	}
 
@@ -91,23 +91,23 @@ func EventFromStorageType(event *storage.Event) (*Event, error) {
 	}
 
 	return &Event{
-		Id:             event.ID,
-		Namespace:      event.Namespace,
-		Type:           event.Type,
-		Owners:         event.Owners,
-		RestrictedTo:   event.RestrictedTo,
-		Name:           event.Name,
-		Description:    event.Description,
-		Startdate:      timestamppb.New(event.Startdate),
-		Enddate:        timestamppb.New(event.Enddate),
-		Starttime:      event.Starttime,
-		Endtime:        event.Endtime,
-		Allday:         event.Allday,
-		MaxSubscribers: event.MaxSubscribers,
-		Subscriptions:  subscriptions,
+		Id:                  event.ID,
+		Namespace:           event.Namespace,
+		Type:                event.Type,
+		Owners:              event.Owners,
+		RestrictedTo:        event.RestrictedTo,
+		Name:                event.Name,
+		Description:         event.Description,
+		Startdate:           timestamppb.New(event.Startdate),
+		Enddate:             timestamppb.New(event.Enddate),
+		Starttime:           event.Starttime,
+		Endtime:             event.Endtime,
+		Allday:              event.Allday,
+		MaxSubscribers:      event.MaxSubscribers,
+		Subscriptions:       subscriptions,
 		DeletedSubscription: deletedsubscription,
-		Data:           data,
-		Deleted:        event.Deleted,
+		Data:                data,
+		Deleted:             event.Deleted,
 	}, nil
 }
 
@@ -121,7 +121,7 @@ func SubscriptionFromStorageType(s storage.Subscription) (*Subscription, error)
 	data, err := structpb.NewStruct(d)
 
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return nil, err
 	}
 	subscription := Subscription{

grpcapi/grpcapi.go

@@ -2,14 +2,13 @@ package grpcapi
 
 import (
 	context "context"
-	"fmt"
-	"log"
 	"net"
 	"time"
 
 	"git.coopgo.io/coopgo-platform/agenda/handlers"
 	"git.coopgo.io/coopgo-platform/agenda/storage"
 	timestamp "github.com/golang/protobuf/ptypes/timestamp"
+	"github.com/rs/zerolog/log"
 	"github.com/spf13/viper"
 	"google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
@@ -32,12 +31,12 @@ func (s AgendaServerImpl) CreateEvent(ctx context.Context, req *CreateEventReque
 	e := req.Event.ToStorageType()
 	event, err := s.handler.CreateEvent(e)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return nil, status.Errorf(codes.AlreadyExists, "event creation failed : %v", err)
 	}
 	response, err := EventFromStorageType(event)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return nil, status.Errorf(codes.Internal, "issue while retrieving event : %v", err)
 	}
 	return &CreateEventResponse{Event: response}, nil
@@ -45,12 +44,12 @@ func (s AgendaServerImpl) CreateEvent(ctx context.Context, req *CreateEventReque
 func (s AgendaServerImpl) GetEvent(ctx context.Context, req *GetEventRequest) (*GetEventResponse, error) {
 	event, err := s.handler.GetEvent(req.Id)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return nil, status.Errorf(codes.AlreadyExists, "issue while retrieving event : %v", err)
 	}
 	response, err := EventFromStorageType(event)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return nil, status.Errorf(codes.Internal, "issue while retrieving event : %v", err)
 	}
 	return &GetEventResponse{Event: response}, nil
@@ -70,7 +69,7 @@ func (s AgendaServerImpl) GetEvents(ctx context.Context, req *GetEventsRequest)
 
 	responses, err := s.handler.GetEvents(req.Namespaces, mindate, maxdate)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return nil, status.Errorf(codes.NotFound, "could not get events : %v", err)
 	}
 	var events []*Event
@@ -78,7 +77,7 @@ func (s AgendaServerImpl) GetEvents(ctx context.Context, req *GetEventsRequest)
 	for _, e := range responses {
 		event, err := EventFromStorageType(&e)
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			return nil, status.Errorf(codes.Internal, "could not get events : %v", err)
 		}
 		events = append(events, event)
@@ -141,13 +140,13 @@ func ConvertMapToStruct(dataMap map[string]interface{}) (*structpb.Struct, error
 func (s AgendaServerImpl) GetSubscriptionByUser(ctx context.Context, req *GetSubscriptionByUserRequest) (*GetSubscriptionByUserResponse, error) {
 	results, err := s.handler.GetSubscriptionByUser(req.Subscriber)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return nil, status.Errorf(codes.NotFound, "could not get subscriptions : %v", err)
 	}
 	var subscriptions []*storage.Subscription
 	for _, result := range results {
 		if err != nil {
-			fmt.Println(err)
+			log.Error().Err(err).Msg("")
 			return nil, status.Errorf(codes.Internal, "could not get subscriptions : %v", err)
 		}
 		subscription := &storage.Subscription{
@@ -162,13 +161,13 @@ func (s AgendaServerImpl) GetSubscriptionByUser(ctx context.Context, req *GetSub
 	}
 	sub, err := ConvertStorageToProtoSubscription(subscriptions)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return nil, status.Errorf(codes.Internal, "could not get subscriptions : %v", err)
 	}
 	return &GetSubscriptionByUserResponse{Subscription: sub}, nil
 }
 
-////////////////////////////////////////////////////////////
+// //////////////////////////////////////////////////////////
 func (s AgendaServerImpl) DeleteSubscription(ctx context.Context, req *DeleteSubscriptionRequest) (*DeleteSubscriptionResponse, error) {
 	err := s.handler.DeleteSubscription(req.Eventid, req.Subscriber, req.Data.AsMap())
 	return &DeleteSubscriptionResponse{
@@ -178,23 +177,23 @@ func (s AgendaServerImpl) DeleteSubscription(ctx context.Context, req *DeleteSub
 
 ////////////////////////////////////////////////////////////////////
 
-/////////////////////////////////////////////////////////////////////////////////////////
+// ///////////////////////////////////////////////////////////////////////////////////////
 func (s AgendaServerImpl) UpdateEvent(ctx context.Context, req *UpdateEventRequest) (*UpdateEventResponse, error) {
 	b := req.Event.ToStorageType()
 	event, err := s.handler.UpdateEvent(b)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return nil, status.Errorf(codes.AlreadyExists, "event update failed : %v", err)
 	}
 	response, err := EventFromStorageType(event)
 	if err != nil {
-		fmt.Println(err)
+		log.Error().Err(err).Msg("")
 		return nil, status.Errorf(codes.Internal, "issue while retrieving event : %v", err)
 	}
 	return &UpdateEventResponse{Event: response}, nil
 }
 
-//////////////////////////////////////////////////////////////////////////////////////////////
+// ////////////////////////////////////////////////////////////////////////////////////////////
 func (s AgendaServerImpl) mustEmbedUnimplementedAgendaServer() {}
 
 func Run(done chan error, cfg *viper.Viper, handler handlers.AgendaHandler) {
@@ -202,13 +201,13 @@ func Run(done chan error, cfg *viper.Viper, handler handlers.AgendaHandler) {
 		dev_env = cfg.GetBool("dev_env")
 		address = ":" + cfg.GetString("services.grpc.port")
 	)
-	fmt.Println("-> GRPC server on", address)
+	log.Info().Str("address", address).Msg("Running gRPC server")
 
 	server := grpc.NewServer()
 	RegisterAgendaServer(server, NewAgendaServer(handler))
 	l, err := net.Listen("tcp", address)
 	if err != nil {
-		log.Fatal(err)
+		log.Fatal().Str("address", address).Err(err).Msg("Cannot listen to address")
 	}
 
 	if dev_env {
@@ -216,7 +215,7 @@ func Run(done chan error, cfg *viper.Viper, handler handlers.AgendaHandler) {
 	}
 
 	if err := server.Serve(l); err != nil {
-		fmt.Println("gRPC service ended")
+		log.Error().Err(err).Msg("gRPC service ended")
 		done <- err
 	}
 }