refactor(rds-refresh): clarify terminology - RDS clone, RDS snapshot

- Use 'RDS clone' instead of 'clone' to avoid confusion with DBLab clones
- Use 'RDS snapshot' instead of 'snapshot' to avoid confusion with DBLab snapshots
- Update description: 'Perform full refresh from RDS/Aurora snapshots (logical mode)'

Author: claude

rds-refresh/README.md

@@ -1,6 +1,6 @@
 # RDS/Aurora Refresh for DBLab
 
-Refresh DBLab from RDS/Aurora snapshots without touching production.
+Perform full refresh from RDS/Aurora snapshots (logical mode).
 
 ## Why?
 
@@ -9,11 +9,11 @@ DBLab logical mode runs `pg_dump` against your database. On large databases, thi
 - **Creates load on production**
 - **Requires direct network access** to production
 
-This tool dumps from a **temporary snapshot clone** instead. Production is never touched.
+This tool dumps from a **temporary RDS clone** instead. Production is never touched.
 
 ```
-Production RDS ──snapshot──► Snapshot ──restore──► Temp Clone ──pg_dump──► DBLab
-                (automated)                         (deleted)
+Production ──RDS snapshot──► RDS Snapshot ──restore──► RDS Clone ──pg_dump──► DBLab
+              (automated)                              (temporary)
 ```
 
 ## Quick Start
@@ -62,7 +62,7 @@ docker run --rm \
 | `source.dbName` | ✓ | Database name |
 | `source.username` | ✓ | Database user |
 | `source.password` | ✓ | Password (use `${ENV_VAR}`) |
-| `clone.instanceClass` | ✓ | Clone instance type |
+| `clone.instanceClass` | ✓ | RDS clone instance type |
 | `clone.securityGroups` | | SGs allowing DBLab access |
 | `clone.subnetGroup` | | DB subnet group |
 | `dblab.apiEndpoint` | ✓ | DBLab API URL |
@@ -160,7 +160,7 @@ aws events put-targets --rule dblab-refresh --targets '[{
 
 ## Network
 
-Clone must be reachable from DBLab on port 5432. Same VPC or peered.
+RDS clone must be reachable from DBLab on port 5432. Same VPC or peered.
 
 ## DBLab Setup
 
@@ -184,24 +184,24 @@ retrieval:
 
 1. Check DBLab health
 2. Find latest RDS snapshot
-3. Create temp clone (`dblab-refresh-YYYYMMDD-HHMMSS`)
-4. Wait for clone (~15 min)
+3. Create RDS clone from RDS snapshot (`dblab-refresh-YYYYMMDD-HHMMSS`)
+4. Wait for RDS clone (~15 min)
 5. Update DBLab config via API
 6. Trigger refresh, wait for completion
-7. Delete clone (always, even on error)
+7. Delete RDS clone (always, even on error)
 
 ## Troubleshooting
 
 | Error | Fix |
 |-------|-----|
 | No snapshots | Enable automated backups on RDS |
-| Clone not accessible | Check security group allows 5432 from DBLab |
+| RDS clone not accessible | Check security group allows 5432 from DBLab |
 | Config update failed | Verify DBLab endpoint and token |
 | Timeout | Increase `dblab.timeout`, check DBLab logs |
 
 ## Cost
 
-Clone cost only while running (~2-5 hours):
+RDS clone cost only while running (~2-5 hours):
 - db.t3.medium: ~$0.35
 - db.r5.large: ~$1.20
 

rds-refresh/main.go

@@ -101,10 +101,10 @@ func run(configPath string, dryRun bool) error {
 }
 
 func printUsage() {
-	fmt.Fprintf(os.Stderr, `rds-refresh - Refresh DBLab from RDS/Aurora snapshots
+	fmt.Fprintf(os.Stderr, `rds-refresh - Perform full refresh from RDS/Aurora snapshots (logical mode)
 
 Avoids pg_dump on production (which holds xmin → bloat). Instead, creates a
-temporary clone from snapshot, refreshes DBLab from clone, then deletes clone.
+temporary RDS clone from RDS snapshot, refreshes DBLab from it, then deletes it.
 
 USAGE
     rds-refresh -config <path> [-dry-run]

rds-refresh/refresher.go

@@ -35,7 +35,7 @@ func (l *DefaultLogger) Debug(msg string, args ...interface{}) {
 	fmt.Printf("[DEBUG] "+msg+"\n", args...)
 }
 
-// Refresher orchestrates the RDS/Aurora clone and DBLab refresh workflow.
+// Refresher orchestrates the RDS/Aurora refresh workflow.
 type Refresher struct {
 	cfg    *Config
 	rds    *RDSClient
@@ -79,13 +79,13 @@ func NewRefresher(ctx context.Context, cfg *Config, logger Logger) (*Refresher,
 // Run executes the full refresh workflow:
 // 1. Verifies DBLab is healthy and not already refreshing
 // 2. Gets source database info
-// 3. Finds the latest snapshot
-// 4. Creates a temporary clone from the snapshot
-// 5. Waits for the clone to be available
-// 6. Updates DBLab config with the clone endpoint
+// 3. Finds the latest RDS snapshot
+// 4. Creates a temporary RDS clone from the RDS snapshot
+// 5. Waits for the RDS clone to be available
+// 6. Updates DBLab config with the RDS clone endpoint
 // 7. Triggers DBLab full refresh
 // 8. Waits for refresh to complete
-// 9. Deletes the temporary clone
+// 9. Deletes the temporary RDS clone
 func (r *Refresher) Run(ctx context.Context) *RefreshResult {
 	result := &RefreshResult{
 		StartTime: time.Now(),
@@ -126,54 +126,54 @@ func (r *Refresher) Run(ctx context.Context) *RefreshResult {
 
 	r.logger.Info("Source: %s", sourceInfo)
 
-	// Step 3: Find latest snapshot
-	r.logger.Info("Finding latest snapshot...")
+	// Step 3: Find latest RDS snapshot
+	r.logger.Info("Finding latest RDS snapshot...")
 
 	snapshotID, err := r.rds.FindLatestSnapshot(ctx)
 	if err != nil {
-		result.Error = fmt.Errorf("failed to find snapshot: %w", err)
+		result.Error = fmt.Errorf("failed to find RDS snapshot: %w", err)
 		return result
 	}
 
 	result.SnapshotID = snapshotID
-	r.logger.Info("Using snapshot: %s", snapshotID)
+	r.logger.Info("Using RDS snapshot: %s", snapshotID)
 
-	// Step 4: Create temporary clone
-	r.logger.Info("Creating temporary RDS clone from snapshot...")
+	// Step 4: Create temporary RDS clone
+	r.logger.Info("Creating RDS clone from RDS snapshot...")
 
 	clone, err := r.rds.CreateClone(ctx, snapshotID)
 	if err != nil {
-		result.Error = fmt.Errorf("failed to create clone: %w", err)
+		result.Error = fmt.Errorf("failed to create RDS clone: %w", err)
 		return result
 	}
 
 	result.CloneID = clone.Identifier
-	r.logger.Info("Created clone: %s", clone.Identifier)
+	r.logger.Info("Created RDS clone: %s", clone.Identifier)
 
 	// Ensure cleanup on any exit
 	defer func() {
-		r.logger.Info("Cleaning up temporary clone %s...", clone.Identifier)
+		r.logger.Info("Deleting temporary RDS clone %s...", clone.Identifier)
 
 		if deleteErr := r.rds.DeleteClone(context.Background(), clone); deleteErr != nil {
-			r.logger.Error("Failed to delete clone %s: %v (manual cleanup may be required)", clone.Identifier, deleteErr)
+			r.logger.Error("Failed to delete RDS clone %s: %v (manual cleanup required)", clone.Identifier, deleteErr)
 		} else {
-			r.logger.Info("Successfully deleted temporary clone %s", clone.Identifier)
+			r.logger.Info("Deleted RDS clone %s", clone.Identifier)
 		}
 	}()
 
-	// Step 5: Wait for clone to be available
-	r.logger.Info("Waiting for clone to become available (this may take 10-30 minutes)...")
+	// Step 5: Wait for RDS clone to be available
+	r.logger.Info("Waiting for RDS clone (10-30 min)...")
 
 	if err := r.rds.WaitForCloneAvailable(ctx, clone); err != nil {
-		result.Error = fmt.Errorf("clone did not become available: %w", err)
+		result.Error = fmt.Errorf("RDS clone did not become available: %w", err)
 		return result
 	}
 
 	result.CloneEndpoint = clone.Endpoint
-	r.logger.Info("Clone available at: %s:%d", clone.Endpoint, clone.Port)
+	r.logger.Info("RDS clone ready: %s:%d", clone.Endpoint, clone.Port)
 
-	// Step 6: Update DBLab config with clone endpoint
-	r.logger.Info("Updating DBLab source config with clone endpoint...")
+	// Step 6: Update DBLab config with RDS clone endpoint
+	r.logger.Info("Updating DBLab config...")
 
 	if err := r.dblab.UpdateSourceConfig(
 		ctx,
@@ -245,16 +245,16 @@ func (r *Refresher) DryRun(ctx context.Context) error {
 
 	r.logger.Info("Source: %s", sourceInfo)
 
-	// Check snapshot
-	r.logger.Info("Finding latest snapshot...")
+	// Check RDS snapshot
+	r.logger.Info("Finding latest RDS snapshot...")
 
 	snapshotID, err := r.rds.FindLatestSnapshot(ctx)
 	if err != nil {
-		return fmt.Errorf("failed to find snapshot: %w", err)
+		return fmt.Errorf("failed to find RDS snapshot: %w", err)
 	}
 
-	r.logger.Info("Would use snapshot: %s", snapshotID)
-	r.logger.Info("Would create clone with instance class: %s", r.cfg.Clone.InstanceClass)
+	r.logger.Info("Would use RDS snapshot: %s", snapshotID)
+	r.logger.Info("Would create RDS clone with instance class: %s", r.cfg.Clone.InstanceClass)
 
 	r.logger.Info("=== DRY RUN COMPLETE - All checks passed ===")