Use structured logging instead of fmt.Fprintf for gRPC retry

Author: jribbink

cmd/emulator/start/start.go

@@ -196,17 +196,17 @@ func Cmd(config StartConfig) *cobra.Command {
 				storageMBPerFLOW = parseCadenceUFix64(conf.StorageMBPerFLOW, "storage-per-flow")
 			}
 
-			// Recompute chain ID and service address accurately for fork mode by querying the node.
-			forkHost := conf.ForkHost
-			resolvedChainID := flowChainID
-
-			if forkHost != "" {
-				parsed, err := server.DetectRemoteChainID(forkHost)
-				if err != nil {
-					Exit(1, fmt.Sprintf("failed to detect remote chain id from %s: %v", forkHost, err))
-				}
-				resolvedChainID = parsed
+		// Recompute chain ID and service address accurately for fork mode by querying the node.
+		forkHost := conf.ForkHost
+		resolvedChainID := flowChainID
+		
+		if forkHost != "" {
+			parsed, err := server.DetectRemoteChainID(logger, forkHost)
+			if err != nil {
+				Exit(1, fmt.Sprintf("failed to detect remote chain id from %s: %v", forkHost, err))
 			}
+			resolvedChainID = parsed
+		}
 
 			serverConf := &server.Config{
 				GRPCPort:     conf.Port,

server/server.go

@@ -183,7 +183,7 @@ func NewEmulatorServer(logger *zerolog.Logger, conf *Config) (*EmulatorServer, e
 	// Derive chain ID for the emulator setup.
 	resolvedChainID := conf.ChainID
 	if conf.ForkHost != "" && conf.ChainID == "" {
-		parsed, err := DetectRemoteChainID(conf.ForkHost)
+		parsed, err := DetectRemoteChainID(logger, conf.ForkHost)
 		if err != nil {
 			logger.Error().Err(err).Str("forkHost", conf.ForkHost).Msg("❗  Failed to detect remote chain ID")
 			return nil, fmt.Errorf("failed to detect remote chain ID from %s: %w", conf.ForkHost, err)
@@ -279,35 +279,35 @@ func NewEmulatorServer(logger *zerolog.Logger, conf *Config) (*EmulatorServer, e
 }
 
 // detectRemoteChainID connects to the remote access node and fetches network parameters to obtain the chain ID.
-func DetectRemoteChainID(url string) (flowgo.ChainID, error) {
-	_, _ = fmt.Fprintf(os.Stdout, "Detecting chain ID for: %s\n", url)
+func DetectRemoteChainID(logger *zerolog.Logger, url string) (flowgo.ChainID, error) {
+	logger.Info().Str("url", url).Msg("Detecting chain ID")
 
 	// Expect raw host:port
 	conn, err := grpc.NewClient(
 		url,
 		grpc.WithTransportCredentials(insecure.NewCredentials()),
-		utils.DefaultGRPCRetryInterceptor(),
+		utils.DefaultGRPCRetryInterceptorWithLogger(logger),
 	)
 	if err != nil {
-		_, _ = fmt.Fprintf(os.Stderr, "❌ Failed to connect to %s: %v\n", url, err)
+		logger.Error().Err(err).Str("url", url).Msg("Failed to create gRPC client")
 		return "", err
 	}
 	defer func() { _ = conn.Close() }()
 
 	client := flowaccess.NewAccessAPIClient(conn)
 	resp, err := client.GetNetworkParameters(context.Background(), &flowaccess.GetNetworkParametersRequest{})
 	if err != nil {
-		_, _ = fmt.Fprintf(os.Stderr, "❌ GetNetworkParameters failed for %s: %v\n", url, err)
+		logger.Error().Err(err).Str("url", url).Msg("GetNetworkParameters failed")
 		return "", err
 	}
 
 	if resp == nil {
-		_, _ = fmt.Fprintf(os.Stderr, "❌ GetNetworkParameters returned nil response for: %s\n", url)
+		logger.Error().Str("url", url).Msg("GetNetworkParameters returned nil response")
 		return "", fmt.Errorf("GetNetworkParameters returned nil response")
 	}
 
 	chainID := flowgo.ChainID(resp.ChainId)
-	_, _ = fmt.Fprintf(os.Stdout, "✅ Detected chain ID: %s from %s\n", string(chainID), url)
+	logger.Info().Str("url", url).Str("chainId", string(chainID)).Msg("Successfully detected chain ID")
 
 	return chainID, nil
 }

utils/grpc.go

@@ -20,8 +20,6 @@ package utils
 
 import (
 	"context"
-	"fmt"
-	"os"
 	"time"
 
 	"github.com/rs/zerolog"
@@ -86,8 +84,6 @@ func retryInterceptorWithLogger(
 
 	for attempt := 0; attempt < defaultMaxAttempts; attempt++ {
 		if attempt > 0 {
-			_, _ = fmt.Fprintf(os.Stdout, "🔄 Retry attempt %d/%d for %s after %v (last error: %v)\n", 
-				attempt+1, defaultMaxAttempts, method, backoff, lastErr)
 			log.Warn().
 				Str("method", method).
 				Int("attempt", attempt+1).
@@ -110,17 +106,12 @@ func retryInterceptorWithLogger(
 
 		lastErr = invoker(ctx, method, req, reply, cc, opts...)
 		if lastErr == nil {
-			if attempt > 0 {
-				_, _ = fmt.Fprintf(os.Stdout, "✅ Call succeeded for %s on attempt %d\n", method, attempt+1)
-			}
 			return nil
 		}
 
 		// Check if error is retryable
 		code := status.Code(lastErr)
 		isRetryable := isRetryableCode(code)
-		_, _ = fmt.Fprintf(os.Stderr, "❌ Call failed for %s (attempt %d): %v (code: %s, retryable: %v)\n", 
-			method, attempt+1, lastErr, code.String(), isRetryable)
 		log.Error().
 			Str("method", method).
 			Int("attempt", attempt+1).
@@ -134,7 +125,6 @@ func retryInterceptorWithLogger(
 		}
 	}
 
-	_, _ = fmt.Fprintf(os.Stderr, "❌ Max retry attempts (%d) exhausted for %s: %v\n", defaultMaxAttempts, method, lastErr)
 	log.Error().
 		Str("method", method).
 		Int("maxAttempts", defaultMaxAttempts).