chore: remove redundant inline comments

alexluong · claude · alexluong · commit da1ca941f362 · 2026-01-27T04:08:05.000+07:00
Remove comments that simply restate what the next line of code does,
such as "// Create client" before NewClient() or "// Check if exists"
before .Exists(). Preserves all meaningful comments including godoc,
section headers, WHY explanations, and unit clarifications.

Co-Authored-By: Claude Opus 4.5 &lt;noreply@anthropic.com&gt;
diff --git a/cmd/publish/publish_http.go b/cmd/publish/publish_http.go
@@ -16,14 +16,11 @@ const (
 func publishHTTP(body map[string]interface{}) error {
 	log.Printf("[x] Publishing HTTP")
 
-	// make HTTP POST request to the URL specified in the body
-
 	jsonData, err := json.Marshal(body)
 	if err != nil {
 		return fmt.Errorf("failed to marshal body to JSON: %w", err)
 	}
 
-	// Make HTTP POST request
 	req, err := http.NewRequest("POST", ServerURL, bytes.NewBuffer(jsonData))
 	if err != nil {
 		return fmt.Errorf("failed to create HTTP request: %w", err)
@@ -37,7 +34,6 @@ func publishHTTP(body map[string]interface{}) error {
 	}
 	defer resp.Body.Close()
 
-	// Check for non-200 status code
 	if resp.StatusCode != http.StatusOK {
 		return fmt.Errorf("received non-200 response: %d", resp.StatusCode)
 	}
diff --git a/internal/alert/evaluator.go b/internal/alert/evaluator.go
@@ -39,7 +39,6 @@ func NewAlertEvaluator(thresholds []int, autoDisableFailureCount int) AlertEvalu
 		})
 	}
 
-	// Sort by failure count
 	sort.Slice(finalThresholds, func(i, j int) bool { return finalThresholds[i].failures < finalThresholds[j].failures })
 
 	// Check if we need to add 100
diff --git a/internal/alert/monitor.go b/internal/alert/monitor.go
@@ -148,7 +148,6 @@ func (m *alertMonitor) HandleAttempt(ctx context.Context, attempt DeliveryAttemp
 		return fmt.Errorf("failed to get alert state: %w", err)
 	}
 
-	// Check if we should send an alert
 	level, shouldAlert := m.evaluator.ShouldAlert(count)
 	if !shouldAlert {
 		return nil
diff --git a/internal/alert/notifier.go b/internal/alert/notifier.go
@@ -110,32 +110,27 @@ func NewHTTPAlertNotifier(callbackURL string, opts ...NotifierOption) AlertNotif
 }
 
 func (n *httpAlertNotifier) Notify(ctx context.Context, alert Alert) error {
-	// Marshal alert to JSON
 	body, err := alert.MarshalJSON()
 	if err != nil {
 		return fmt.Errorf("failed to marshal alert: %w", err)
 	}
 
-	// Create request
 	req, err := http.NewRequestWithContext(ctx, http.MethodPost, n.callbackURL, bytes.NewReader(body))
 	if err != nil {
 		return fmt.Errorf("failed to create request: %w", err)
 	}
 
-	// Set headers
 	req.Header.Set("Content-Type", "application/json")
 	if n.bearerToken != "" {
 		req.Header.Set("Authorization", "Bearer "+n.bearerToken)
 	}
 
-	// Send request
 	resp, err := n.client.Do(req)
 	if err != nil {
 		return fmt.Errorf("failed to send alert: %w", err)
 	}
 	defer resp.Body.Close()
 
-	// Check response status
 	if resp.StatusCode >= 400 {
 		return fmt.Errorf("alert callback failed with status %d", resp.StatusCode)
 	}
diff --git a/internal/alert/store.go b/internal/alert/store.go
@@ -42,7 +42,6 @@ func (s *redisAlertStore) IncrementConsecutiveFailureCount(ctx context.Context,
 	incrCmd := pipe.Incr(ctx, key)
 	pipe.Expire(ctx, key, 24*time.Hour)
 
-	// Execute the transaction
 	_, err := pipe.Exec(ctx)
 	if err != nil {
 		return 0, fmt.Errorf("failed to execute consecutive failure count transaction: %w", err)
diff --git a/internal/app/app.go b/internal/app/app.go
@@ -121,21 +121,17 @@ func (a *App) PostRun(ctx context.Context) {
 }
 
 func (a *App) run(ctx context.Context) error {
-	// Set up cancellation context
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 
-	// Handle sigterm and await termChan signal
 	termChan := make(chan os.Signal, 1)
 	signal.Notify(termChan, syscall.SIGINT, syscall.SIGTERM)
 
-	// Run workers in goroutine
 	errChan := make(chan error, 1)
 	go func() {
 		errChan <- a.supervisor.Run(ctx)
 	}()
 
-	// Wait for either termination signal or worker failure
 	var exitErr error
 	select {
 	case <-termChan:
@@ -202,7 +198,6 @@ func (a *App) initializeRedis(ctx context.Context) error {
 	}
 	a.redisClient = redisClient
 
-	// Run Redis schema migrations
 	if err := runRedisMigrations(ctx, redisClient, a.logger, a.config.DeploymentID); err != nil {
 		a.logger.Error("Redis migration failed", zap.Error(err))
 		return err
diff --git a/internal/app/installation.go b/internal/app/installation.go
@@ -21,12 +21,10 @@ func getInstallation(ctx context.Context, redisClient redis.Cmdable, telemetryCo
 	// First attempt: try to get existing installation ID
 	installationID, err := redisClient.HGet(ctx, outpostrcKey, installationKey).Result()
 	if err == nil {
-		// Installation ID already exists
 		return installationID, nil
 	}
 
 	if err != redis.Nil {
-		// Unexpected error
 		return "", err
 	}
 
@@ -41,7 +39,6 @@ func getInstallation(ctx context.Context, redisClient redis.Cmdable, telemetryCo
 	}
 
 	if wasSet {
-		// We successfully set the installation ID
 		return newInstallationID, nil
 	}
 
diff --git a/internal/app/migration.go b/internal/app/migration.go
@@ -51,7 +51,6 @@ func runMigration(ctx context.Context, cfg *config.Config, logger *logging.Logge
 		}
 
 		if err == nil {
-			// Migration succeeded
 			if versionJumped > 0 {
 				logger.Info("migrations applied",
 					zap.Int("version", version),
@@ -88,7 +87,6 @@ func runMigration(ctx context.Context, cfg *config.Config, logger *logging.Logge
 			case <-ctx.Done():
 				return ctx.Err()
 			case <-time.After(retryDelay):
-				// Continue to next attempt
 			}
 		} else {
 			// Exhausted all retries
diff --git a/internal/app/redis_migration.go b/internal/app/redis_migration.go
@@ -35,7 +35,6 @@ func runRedisMigrations(ctx context.Context, redisClient redis.Cmdable, logger *
 			return nil
 		}
 
-		// Check if this is a lock-related error
 		isLockError := isRedisLockError(err)
 		lastErr = err
 
@@ -56,7 +55,6 @@ func runRedisMigrations(ctx context.Context, redisClient redis.Cmdable, logger *
 			case <-ctx.Done():
 				return ctx.Err()
 			case <-time.After(retryDelay):
-				// Continue to next attempt
 			}
 		} else {
 			logger.Error("redis migration failed after retries",
@@ -70,7 +68,6 @@ func runRedisMigrations(ctx context.Context, redisClient redis.Cmdable, logger *
 
 // executeRedisMigrations creates the runner and executes migrations
 func executeRedisMigrations(ctx context.Context, redisClient redis.Cmdable, logger *logging.Logger, deploymentID string) error {
-	// Create runner
 	client, ok := redisClient.(redis.Client)
 	if !ok {
 		// Wrap Cmdable to implement Client interface
diff --git a/internal/deliverymq/messagehandler.go b/internal/deliverymq/messagehandler.go
@@ -131,7 +131,6 @@ func NewMessageHandler(
 func (h *messageHandler) Handle(ctx context.Context, msg *mqs.Message) error {
 	task := models.DeliveryTask{}
 
-	// Parse message
 	if err := task.FromMessage(msg); err != nil {
 		return h.handleError(msg, &PreDeliveryError{err: err})
 	}
@@ -142,13 +141,11 @@ func (h *messageHandler) Handle(ctx context.Context, msg *mqs.Message) error {
 		zap.String("destination_id", task.DestinationID),
 		zap.Int("attempt", task.Attempt))
 
-	// Get destination
 	destination, err := h.ensurePublishableDestination(ctx, task)
 	if err != nil {
 		return h.handleError(msg, &PreDeliveryError{err: err})
 	}
 
-	// Handle delivery
 	err = h.idempotence.Exec(ctx, idempotencyKeyFromDeliveryTask(task), func(ctx context.Context) error {
 		return h.doHandle(ctx, task, destination)
 	})
@@ -230,7 +227,6 @@ func (h *messageHandler) doHandle(ctx context.Context, task models.DeliveryTask,
 func (h *messageHandler) logDeliveryResult(ctx context.Context, task *models.DeliveryTask, destination *models.Destination, attempt *models.Attempt, err error) error {
 	logger := h.logger.Ctx(ctx)
 
-	// Set attempt fields from task
 	attempt.TenantID = task.Event.TenantID
 	attempt.AttemptNumber = task.Attempt
 	attempt.Manual = task.Manual
@@ -245,7 +241,6 @@ func (h *messageHandler) logDeliveryResult(ctx context.Context, task *models.Del
 		zap.Int("attempt", task.Attempt),
 		zap.Bool("manual", task.Manual))
 
-	// Publish attempt log
 	logEntry := models.LogEntry{
 		Event:   &task.Event,
 		Attempt: attempt,
@@ -264,7 +259,6 @@ func (h *messageHandler) logDeliveryResult(ctx context.Context, task *models.Del
 		return &PostDeliveryError{err: logErr}
 	}
 
-	// Call alert monitor in goroutine
 	go h.handleAlertAttempt(ctx, task, destination, attempt, err)
 
 	// If we have an AttemptError, return it as is
diff --git a/internal/deliverymq/retry.go b/internal/deliverymq/retry.go
@@ -38,19 +38,17 @@ func WithRetryVisibilityTimeout(vt uint) RetrySchedulerOption {
 }
 
 func NewRetryScheduler(deliverymq *DeliveryMQ, redisConfig *redis.RedisConfig, deploymentID string, pollBackoff time.Duration, logger *logging.Logger, eventGetter RetryEventGetter, opts ...RetrySchedulerOption) (scheduler.Scheduler, error) {
-	// Apply options
 	cfg := &retrySchedulerConfig{}
 	for _, opt := range opts {
 		opt(cfg)
 	}
-	// Create Redis client for RSMQ
+
 	ctx := context.Background()
 	redisClient, err := redis.New(ctx, redisConfig)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create Redis client for retry scheduler: %w", err)
 	}
 
-	// Create RSMQ adapter
 	adapter := rsmq.NewRedisAdapter(redisClient)
 
 	// Construct RSMQ namespace with deployment prefix if provided
@@ -61,15 +59,13 @@ func NewRetryScheduler(deliverymq *DeliveryMQ, redisConfig *redis.RedisConfig, d
 		namespace = fmt.Sprintf("%s:rsmq", deploymentID)
 	}
 
-	// Create RSMQ client with deployment-aware namespace
 	var rsmqClient *rsmq.RedisSMQ
 	if logger != nil {
 		rsmqClient = rsmq.NewRedisSMQ(adapter, namespace, logger)
 	} else {
 		rsmqClient = rsmq.NewRedisSMQ(adapter, namespace)
 	}
 
-	// Define execution function
 	exec := func(ctx context.Context, msg string) error {
 		retryTask := RetryTask{}
 		if err := retryTask.FromString(msg); err != nil {
@@ -111,7 +107,6 @@ func NewRetryScheduler(deliverymq *DeliveryMQ, redisConfig *redis.RedisConfig, d
 		return nil
 	}
 
-	// Build scheduler options - pass visibility timeout if configured
 	if cfg.visibilityTimeout > 0 {
 		return scheduler.New("deliverymq-retry", rsmqClient, exec,
 			scheduler.WithPollBackoff(pollBackoff),
diff --git a/internal/destinationmockserver/model.go b/internal/destinationmockserver/model.go
@@ -195,7 +195,6 @@ func verifySignature(secret string, payload []byte, signature string, algorithm
 		return false
 	}
 
-	// Create a new signature manager with the secret
 	secrets := []destwebhook.WebhookSecret{
 		{
 			Key:       secret,
@@ -209,7 +208,6 @@ func verifySignature(secret string, payload []byte, signature string, algorithm
 		destwebhook.WithAlgorithm(destwebhook.GetAlgorithm(algorithm)),
 	)
 
-	// Try each signature
 	for _, sig := range signatures {
 		if sm.VerifySignature(sig, secret, destwebhook.SignaturePayload{
 			Body:      string(payload),
diff --git a/internal/destinationmockserver/server.go b/internal/destinationmockserver/server.go
@@ -23,7 +23,6 @@ type DestinationMockServer struct {
 
 func (s *DestinationMockServer) Run(ctx context.Context) error {
 	go func() {
-		// service connections
 		if err := s.server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
 			s.logger.Fatal("listen: %s\n", zap.Error(err))
 		}
diff --git a/internal/idgen/idgen.go b/internal/idgen/idgen.go
@@ -62,7 +62,6 @@ func newIDGenerator(idType string) (idGenerator, error) {
 		idType = "uuidv4"
 	}
 
-	// Select the appropriate generator implementation
 	switch idType {
 	case "uuidv4":
 		return &uuidv4Generator{}, nil
diff --git a/internal/mqinfra/awssqs.go b/internal/mqinfra/awssqs.go
@@ -30,7 +30,6 @@ func (infra *infraAWSSQS) Exist(ctx context.Context) (bool, error) {
 		return false, err
 	}
 
-	// Check if main queue exists
 	_, err = awsutil.RetrieveQueueURL(ctx, sqsClient, infra.cfg.AWSSQS.Topic)
 	if err != nil {
 		var apiErr smithy.APIError
@@ -45,7 +44,6 @@ func (infra *infraAWSSQS) Exist(ctx context.Context) (bool, error) {
 		return false, err
 	}
 
-	// Check if DLQ exists
 	dlqName := infra.cfg.AWSSQS.Topic + "-dlq"
 	_, err = awsutil.RetrieveQueueURL(ctx, sqsClient, dlqName)
 	if err != nil {
diff --git a/internal/mqinfra/azureservicebus.go b/internal/mqinfra/azureservicebus.go
@@ -25,7 +25,6 @@ func (infra *infraAzureServiceBus) Exist(ctx context.Context) (bool, error) {
 		return true, nil
 	}
 
-	// Create credential for authentication
 	cred, err := azidentity.NewClientSecretCredential(
 		cfg.TenantID,
 		cfg.ClientID,
@@ -36,7 +35,6 @@ func (infra *infraAzureServiceBus) Exist(ctx context.Context) (bool, error) {
 		return false, fmt.Errorf("failed to create credential: %w", err)
 	}
 
-	// Create clients for topic and subscription management
 	topicClient, err := armservicebus.NewTopicsClient(cfg.SubscriptionID, cred, nil)
 	if err != nil {
 		return false, fmt.Errorf("failed to create topic client: %w", err)
@@ -47,7 +45,6 @@ func (infra *infraAzureServiceBus) Exist(ctx context.Context) (bool, error) {
 		return false, fmt.Errorf("failed to create subscription client: %w", err)
 	}
 
-	// Check if topic exists
 	_, err = topicClient.Get(ctx, cfg.ResourceGroup, cfg.Namespace, cfg.Topic, nil)
 	if err != nil {
 		if isNotFoundError(err) {
@@ -56,7 +53,6 @@ func (infra *infraAzureServiceBus) Exist(ctx context.Context) (bool, error) {
 		return false, fmt.Errorf("failed to check topic existence: %w", err)
 	}
 
-	// Check if subscription exists
 	_, err = subClient.Get(ctx, cfg.ResourceGroup, cfg.Namespace, cfg.Topic, cfg.Subscription, nil)
 	if err != nil {
 		if isNotFoundError(err) {
@@ -79,7 +75,6 @@ func (infra *infraAzureServiceBus) Declare(ctx context.Context) error {
 		return nil
 	}
 
-	// Create credential for authentication
 	cred, err := azidentity.NewClientSecretCredential(
 		cfg.TenantID,
 		cfg.ClientID,
@@ -90,7 +85,6 @@ func (infra *infraAzureServiceBus) Declare(ctx context.Context) error {
 		return fmt.Errorf("failed to create credential: %w", err)
 	}
 
-	// Create clients for topic and subscription management
 	topicClient, err := armservicebus.NewTopicsClient(cfg.SubscriptionID, cred, nil)
 	if err != nil {
 		return fmt.Errorf("failed to create topic client: %w", err)
@@ -101,7 +95,6 @@ func (infra *infraAzureServiceBus) Declare(ctx context.Context) error {
 		return fmt.Errorf("failed to create subscription client: %w", err)
 	}
 
-	// Declare main topic (upsert)
 	topicName := cfg.Topic
 	err = infra.declareTopic(ctx, topicClient, cfg.ResourceGroup, cfg.Namespace, topicName)
 	if err != nil {
@@ -158,7 +151,6 @@ func (infra *infraAzureServiceBus) TearDown(ctx context.Context) error {
 		return nil
 	}
 
-	// Create credential for authentication
 	cred, err := azidentity.NewClientSecretCredential(
 		cfg.TenantID,
 		cfg.ClientID,
@@ -169,7 +161,6 @@ func (infra *infraAzureServiceBus) TearDown(ctx context.Context) error {
 		return fmt.Errorf("failed to create credential: %w", err)
 	}
 
-	// Create clients for topic and subscription management
 	topicClient, err := armservicebus.NewTopicsClient(cfg.SubscriptionID, cred, nil)
 	if err != nil {
 		return fmt.Errorf("failed to create topic client: %w", err)
@@ -182,13 +173,11 @@ func (infra *infraAzureServiceBus) TearDown(ctx context.Context) error {
 
 	topicName := cfg.Topic
 
-	// Delete main subscription
 	err = infra.deleteSubscription(ctx, subClient, cfg.ResourceGroup, cfg.Namespace, topicName, cfg.Subscription)
 	if err != nil {
 		return fmt.Errorf("failed to delete subscription: %w", err)
 	}
 
-	// Delete main topic
 	err = infra.deleteTopic(ctx, topicClient, cfg.ResourceGroup, cfg.Namespace, topicName)
 	if err != nil {
 		return fmt.Errorf("failed to delete topic: %w", err)
diff --git a/internal/mqinfra/gcppubsub.go b/internal/mqinfra/gcppubsub.go
diff --git a/internal/mqinfra/rabbitmq.go b/internal/mqinfra/rabbitmq.go
diff --git a/internal/portal/src/scenes/Destination/Destination.tsx b/internal/portal/src/scenes/Destination/Destination.tsx
diff --git a/internal/redis/redis.go b/internal/redis/redis.go
diff --git a/internal/services/builder.go b/internal/services/builder.go
diff --git a/internal/telemetry/telemetry.go b/internal/telemetry/telemetry.go

Original file line number	Diff line number	Diff line change
`@@ -16,14 +16,11 @@ const (`
`16`	`16`	`func publishHTTP(body map[string]interface{}) error {`
`17`	`17`	`log.Printf("[x] Publishing HTTP")`
`18`	`18`
`19`		`- // make HTTP POST request to the URL specified in the body`
`20`		`-`
`21`	`19`	`jsonData, err := json.Marshal(body)`
`22`	`20`	`if err != nil {`
`23`	`21`	`return fmt.Errorf("failed to marshal body to JSON: %w", err)`
`24`	`22`	`}`
`25`	`23`
`26`		`- // Make HTTP POST request`
`27`	`24`	`req, err := http.NewRequest("POST", ServerURL, bytes.NewBuffer(jsonData))`
`28`	`25`	`if err != nil {`
`29`	`26`	`return fmt.Errorf("failed to create HTTP request: %w", err)`
`@@ -37,7 +34,6 @@ func publishHTTP(body map[string]interface{}) error {`
`37`	`34`	`}`
`38`	`35`	`defer resp.Body.Close()`
`39`	`36`
`40`		`- // Check for non-200 status code`
`41`	`37`	`if resp.StatusCode != http.StatusOK {`
`42`	`38`	`return fmt.Errorf("received non-200 response: %d", resp.StatusCode)`
`43`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,6 @@ func NewAlertEvaluator(thresholds []int, autoDisableFailureCount int) AlertEvalu`
`39`	`39`	`})`
`40`	`40`	`}`
`41`	`41`
`42`		`- // Sort by failure count`
`43`	`42`	`sort.Slice(finalThresholds, func(i, j int) bool { return finalThresholds[i].failures < finalThresholds[j].failures })`
`44`	`43`
`45`	`44`	`// Check if we need to add 100`
Original file line number	Diff line number	Diff line change
`@@ -148,7 +148,6 @@ func (m *alertMonitor) HandleAttempt(ctx context.Context, attempt DeliveryAttemp`
`148`	`148`	`return fmt.Errorf("failed to get alert state: %w", err)`
`149`	`149`	`}`
`150`	`150`
`151`		`- // Check if we should send an alert`
`152`	`151`	`level, shouldAlert := m.evaluator.ShouldAlert(count)`
`153`	`152`	`if !shouldAlert {`
`154`	`153`	`return nil`
Original file line number	Diff line number	Diff line change
`@@ -110,32 +110,27 @@ func NewHTTPAlertNotifier(callbackURL string, opts ...NotifierOption) AlertNotif`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`func (n *httpAlertNotifier) Notify(ctx context.Context, alert Alert) error {`
`113`		`- // Marshal alert to JSON`
`114`	`113`	`body, err := alert.MarshalJSON()`
`115`	`114`	`if err != nil {`
`116`	`115`	`return fmt.Errorf("failed to marshal alert: %w", err)`
`117`	`116`	`}`
`118`	`117`
`119`		`- // Create request`
`120`	`118`	`req, err := http.NewRequestWithContext(ctx, http.MethodPost, n.callbackURL, bytes.NewReader(body))`
`121`	`119`	`if err != nil {`
`122`	`120`	`return fmt.Errorf("failed to create request: %w", err)`
`123`	`121`	`}`
`124`	`122`
`125`		`- // Set headers`
`126`	`123`	`req.Header.Set("Content-Type", "application/json")`
`127`	`124`	`if n.bearerToken != "" {`
`128`	`125`	`req.Header.Set("Authorization", "Bearer "+n.bearerToken)`
`129`	`126`	`}`
`130`	`127`
`131`		`- // Send request`
`132`	`128`	`resp, err := n.client.Do(req)`
`133`	`129`	`if err != nil {`
`134`	`130`	`return fmt.Errorf("failed to send alert: %w", err)`
`135`	`131`	`}`
`136`	`132`	`defer resp.Body.Close()`
`137`	`133`
`138`		`- // Check response status`
`139`	`134`	`if resp.StatusCode >= 400 {`
`140`	`135`	`return fmt.Errorf("alert callback failed with status %d", resp.StatusCode)`
`141`	`136`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,12 +21,10 @@ func getInstallation(ctx context.Context, redisClient redis.Cmdable, telemetryCo`
`21`	`21`	`// First attempt: try to get existing installation ID`
`22`	`22`	`installationID, err := redisClient.HGet(ctx, outpostrcKey, installationKey).Result()`
`23`	`23`	`if err == nil {`
`24`		`- // Installation ID already exists`
`25`	`24`	`return installationID, nil`
`26`	`25`	`}`
`27`	`26`
`28`	`27`	`if err != redis.Nil {`
`29`		`- // Unexpected error`
`30`	`28`	`return "", err`
`31`	`29`	`}`
`32`	`30`
`@@ -41,7 +39,6 @@ func getInstallation(ctx context.Context, redisClient redis.Cmdable, telemetryCo`
`41`	`39`	`}`
`42`	`40`
`43`	`41`	`if wasSet {`
`44`		`- // We successfully set the installation ID`
`45`	`42`	`return newInstallationID, nil`
`46`	`43`	`}`
`47`	`44`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,6 @@ func runMigration(ctx context.Context, cfg config.Config, logger logging.Logge`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`if err == nil {`
`54`		`- // Migration succeeded`
`55`	`54`	`if versionJumped > 0 {`
`56`	`55`	`logger.Info("migrations applied",`
`57`	`56`	`zap.Int("version", version),`
`@@ -88,7 +87,6 @@ func runMigration(ctx context.Context, cfg config.Config, logger logging.Logge`
`88`	`87`	`case <-ctx.Done():`
`89`	`88`	`return ctx.Err()`
`90`	`89`	`case <-time.After(retryDelay):`
`91`		`- // Continue to next attempt`
`92`	`90`	`}`
`93`	`91`	`} else {`
`94`	`92`	`// Exhausted all retries`