feat: improve aggsender logs (0xPolygon#186)

agglayer/types.go

@@ -556,7 +556,7 @@ func (c CertificateHeader) String() string {
 		errors = c.Error.String()
 	}
 
-	return fmt.Sprintf("Height: %d, CertificateID: %s, NewLocalExitRoot: %s. Status: %s. Errors: %s",
+	return fmt.Sprintf("Height: %d, CertificateID: %s, NewLocalExitRoot: %s. Status: %s. Errors: [%s]",
 		c.Height, c.CertificateID.String(), c.NewLocalExitRoot.String(), c.Status.String(), errors)
 }
 

aggsender/aggsender.go

@@ -55,7 +55,7 @@ func New(
 	cfg Config,
 	aggLayerClient agglayer.AgglayerClientInterface,
 	l1InfoTreeSyncer *l1infotreesync.L1InfoTreeSync,
-	l2Syncer *bridgesync.BridgeSync,
+	l2Syncer types.L2BridgeSyncer,
 	epochNotifier types.EpochNotifier) (*AggSender, error) {
 	storage, err := db.NewAggSenderSQLStorage(logger, cfg.StoragePath)
 	if err != nil {
@@ -93,14 +93,14 @@ func (a *AggSender) sendCertificates(ctx context.Context) {
 		select {
 		case epoch := <-chEpoch:
 			a.log.Infof("Epoch received: %s", epoch.String())
-			thereArePendingCerts, err := a.checkPendingCertificatesStatus(ctx)
-			if err == nil && !thereArePendingCerts {
+			thereArePendingCerts := a.checkPendingCertificatesStatus(ctx)
+			if !thereArePendingCerts {
 				if _, err := a.sendCertificate(ctx); err != nil {
 					log.Error(err)
 				}
 			} else {
-				log.Warnf("Skipping epoch %s because there are pending certificates %v or error: %w",
-					epoch.String(), thereArePendingCerts, err)
+				log.Infof("Skipping epoch %s because there are pending certificates",
+					epoch.String())
 			}
 		case <-ctx.Done():
 			a.log.Info("AggSender stopped")
@@ -177,7 +177,7 @@ func (a *AggSender) sendCertificate(ctx context.Context) (*agglayer.SignedCertif
 	}
 
 	a.saveCertificateToFile(signedCertificate)
-	a.log.Debugf("certificate ready to be send to AggLayer: %s", signedCertificate.String())
+	a.log.Infof("certificate ready to be send to AggLayer: %s", signedCertificate.String())
 
 	certificateHash, err := a.aggLayerClient.SendCertificate(signedCertificate)
 	if err != nil {
@@ -488,46 +488,49 @@ func (a *AggSender) signCertificate(certificate *agglayer.Certificate) (*agglaye
 // and updates in the storage if it changed on agglayer
 // It returns:
 // bool -> if there are pending certificates
-// error -> if there was an error
-func (a *AggSender) checkPendingCertificatesStatus(ctx context.Context) (bool, error) {
+func (a *AggSender) checkPendingCertificatesStatus(ctx context.Context) bool {
 	pendingCertificates, err := a.storage.GetCertificatesByStatus(nonSettledStatuses)
 	if err != nil {
 		err = fmt.Errorf("error getting pending certificates: %w", err)
 		a.log.Error(err)
-		return true, err
+		return true
 	}
-	thereArePendingCertificates := false
+	thereArePendingCerts := false
 	a.log.Debugf("checkPendingCertificatesStatus num of pendingCertificates: %d", len(pendingCertificates))
 	for _, certificate := range pendingCertificates {
 		certificateHeader, err := a.aggLayerClient.GetCertificateHeader(certificate.CertificateID)
 		if err != nil {
 			err = fmt.Errorf("error getting certificate header of %d/%s from agglayer: %w",
 				certificate.Height, certificate.String(), err)
 			a.log.Error(err)
-			return true, err
+			return true
 		}
-		if slices.Contains(nonSettledStatuses, certificateHeader.Status) {
-			thereArePendingCertificates = true
-		}
-		a.log.Debugf("aggLayerClient.GetCertificateHeader status [%s] of certificate %s ",
+		elapsedTime := time.Now().UTC().Sub(time.UnixMilli(certificate.CreatedAt))
+		a.log.Debugf("aggLayerClient.GetCertificateHeader status [%s] of certificate %s  elapsed time:%s",
 			certificateHeader.Status,
-			certificateHeader.String())
+			certificateHeader.String(),
+			elapsedTime)
 
 		if certificateHeader.Status != certificate.Status {
-			a.log.Infof("certificate %s changed status from [%s] to [%s]",
-				certificateHeader.String(), certificate.Status, certificateHeader.Status)
+			a.log.Infof("certificate %s changed status from [%s] to [%s] elapsed time: %s",
+				certificateHeader.String(), certificate.Status, certificateHeader.Status, elapsedTime)
 
 			certificate.Status = certificateHeader.Status
 			certificate.UpdatedAt = time.Now().UTC().UnixMilli()
 
 			if err := a.storage.UpdateCertificateStatus(ctx, *certificate); err != nil {
 				err = fmt.Errorf("error updating certificate %s status in storage: %w", certificateHeader.String(), err)
 				a.log.Error(err)
-				return true, err
+				return true
 			}
 		}
+		if slices.Contains(nonSettledStatuses, certificateHeader.Status) {
+			a.log.Infof("certificate %s is still pending, elapsed time:%s ",
+				certificateHeader.String(), elapsedTime)
+			thereArePendingCerts = true
+		}
 	}
-	return thereArePendingCertificates, nil
+	return thereArePendingCerts
 }
 
 // shouldSendCertificate checks if a certificate should be sent at given time