chore: delete unnecessary logs

Author: zecit

redis_transport.go

@@ -95,20 +95,16 @@ func NewRedisTransport(u *url.URL, l Logger) (Transport, error) { //nolint:iretu
 }
 
 func subscribeToUpdate(t *RedisTransport) {
-	t.logger.Info("subscribeToUpdate:Subscribe")
 	pubsub := t.client.Subscribe(t.ctx, t.bucketName)
-	t.logger.Info("subscribeToUpdate:pubsub.Channel")
 	ch := pubsub.Channel()
 	for msg := range ch {
 		var update *Update
-		t.logger.Info("subscribeToUpdate:Unmarshal")
 		errUnmarshal := json.Unmarshal([]byte(msg.Payload), &update)
 		if errUnmarshal != nil {
 			t.logger.Error("error when unmarshaling message", zap.Any("message", msg), zap.Error(errUnmarshal))
 
 			continue
 		}
-		t.logger.Info("subscribeToUpdate:dispatch")
 		t.dispatch(update)
 	}
 }
@@ -130,32 +126,26 @@ func getRedisLastEventID(ctx context.Context, client *redis.Client, bucketName s
 
 // Dispatch dispatches an update to all subscribers and persists it in Bolt DB.
 func (t *RedisTransport) Dispatch(update *Update) error {
-	t.logger.Info("Dispatch:select")
 	select {
 	case <-t.closed:
 		return ErrClosedTransport
 	default:
 	}
 
-	t.logger.Info("Dispatch:AssignUUID")
 	AssignUUID(update)
 
-	t.logger.Info("Dispatch:Lock")
 	t.Lock()
 	defer t.Unlock()
 
-	t.logger.Info("Dispatch:Marshal")
 	updateJSON, err := json.Marshal(*update)
 	if err != nil {
 		return fmt.Errorf("error when marshaling update: %w", err)
 	}
 
-	t.logger.Info("Dispatch:persist")
 	if err := t.persist(update.ID, updateJSON); err != nil {
 		return err
 	}
 
-	t.logger.Info("Dispatch:Publish")
 	// publish in pubsub for others mercure instances to consume the update and dispatch it to its subscribers
 	if err := t.client.Publish(t.ctx, t.bucketName, updateJSON).Err(); err != nil {
 		return fmt.Errorf("error when publishing update: %w", err)
@@ -166,22 +156,17 @@ func (t *RedisTransport) Dispatch(update *Update) error {
 
 // Called when a pubsub message is received.
 func (t *RedisTransport) dispatch(update *Update) error {
-	t.logger.Info("dispatch:select")
 	select {
 	case <-t.closed:
 		return ErrClosedTransport
 	default:
 	}
 
-	t.logger.Info("dispatch:Lock")
 	t.Lock()
 	defer t.Unlock()
 
-	t.logger.Info("dispatch:update")
 	for _, s := range t.subscribers.MatchAny(update) {
-		t.logger.Info("dispatch:Dispatch")
 		if !s.Dispatch(update, false) {
-			t.logger.Info("dispatch:Remove")
 			t.subscribers.Remove(s)
 		}
 	}
@@ -191,58 +176,46 @@ func (t *RedisTransport) dispatch(update *Update) error {
 
 // persist stores update in the database.
 func (t *RedisTransport) persist(updateID string, updateJSON []byte) error {
-	t.logger.Info("persist")
 	t.lastEventID = updateID
-	t.logger.Info("persist:LPush")
 	err := t.client.LPush(t.ctx, t.bucketName, updateJSON).Err()
 	if err != nil {
 		return fmt.Errorf("error while persisting to redis: %w", err)
 	}
-	t.logger.Info("persist:cleanup")
 
 	return t.cleanup()
 }
 
 // AddSubscriber adds a new subscriber to the transport.
 func (t *RedisTransport) AddSubscriber(s *Subscriber) error {
-	t.logger.Info("AddSubscriber:select")
 	select {
 	case <-t.closed:
 		return ErrClosedTransport
 	default:
 	}
 
-	t.logger.Info("AddSubscriber:Lock")
 	t.Lock()
-	t.logger.Info("AddSubscriber:Add")
 	t.subscribers.Add(s)
-	t.logger.Info("AddSubscriber:Unlock")
 	t.Unlock()
 
 	if s.RequestLastEventID != "" {
-		t.logger.Info("AddSubscriber:dispatchHistory")
 		t.dispatchHistory(s)
 	}
 
-	t.logger.Info("AddSubscriber:Ready")
 	s.Ready()
 
 	return nil
 }
 
 // RemoveSubscriber removes a new subscriber from the transport.
 func (t *RedisTransport) RemoveSubscriber(s *Subscriber) error {
-	t.logger.Info("RemoveSubscriber:select")
 	select {
 	case <-t.closed:
 		return ErrClosedTransport
 	default:
 	}
 
-	t.logger.Info("RemoveSubscriber:Lock")
 	t.Lock()
 	defer t.Unlock()
-	t.logger.Info("RemoveSubscriber:Remove")
 	t.subscribers.Remove(s)
 
 	return nil
@@ -257,10 +230,8 @@ func (t *RedisTransport) GetSubscribers() (string, []*Subscriber, error) {
 }
 
 func (t *RedisTransport) dispatchHistory(s *Subscriber) {
-	t.logger.Info("dispatchHistory:LRange")
 	updates, err := t.client.LRange(t.ctx, t.bucketName, 0, int64(t.size)).Result()
 	if err != nil {
-		t.logger.Info("dispatchHistory:HistoryDispatched")
 		s.HistoryDispatched(EarliestLastEventID)
 
 		return
@@ -270,7 +241,6 @@ func (t *RedisTransport) dispatchHistory(s *Subscriber) {
 	afterFromID := s.RequestLastEventID == EarliestLastEventID
 	for _, update := range updates {
 		var lastUpdate *Update
-		t.logger.Info("dispatchHistory:Unmarshal")
 		errUnmarshal := json.Unmarshal([]byte(update), &lastUpdate)
 		if errUnmarshal != nil {
 			s.HistoryDispatched(responseLastEventID)
@@ -288,7 +258,6 @@ func (t *RedisTransport) dispatchHistory(s *Subscriber) {
 			continue
 		}
 
-		t.logger.Info("dispatchHistory:Dispatch")
 		if !s.Dispatch(lastUpdate, true) {
 			s.HistoryDispatched(responseLastEventID)
 
@@ -303,7 +272,6 @@ func (t *RedisTransport) dispatchHistory(s *Subscriber) {
 
 // Close closes the Transport.
 func (t *RedisTransport) Close() (err error) {
-	t.logger.Info("Close")
 	t.closedOnce.Do(func() {
 		close(t.closed)
 
@@ -328,7 +296,6 @@ func (t *RedisTransport) Close() (err error) {
 
 // cleanup removes entries in the history above the size limit, triggered probabilistically.
 func (t *RedisTransport) cleanup() error {
-	t.logger.Info("cleanup:LLen")
 	sizeUpdates, errLen := t.client.LLen(t.ctx, t.bucketName).Result()
 	if errLen != nil {
 		return fmt.Errorf("error when getting updates length: %w", errLen)
@@ -341,7 +308,6 @@ func (t *RedisTransport) cleanup() error {
 		return nil
 	}
 
-	t.logger.Info("cleanup:LTrim")
 	errTrim := t.client.LTrim(t.ctx, t.bucketName, 0, int64(t.size)).Err()
 	if errTrim != nil {
 		return fmt.Errorf("error when trimming update length: %w", errLen)