chore: PR comments

Author: denis256

cli/commands/backend/migrate/migrate.go

@@ -55,15 +55,23 @@ func Run(ctx context.Context, l log.Logger, srcPath, dstPath string, opts *optio
 	}
 
 	srcRemoteState, err := config.ParseRemoteState(ctx, l, srcModule.Execution.TerragruntOptions)
-	if err != nil || srcRemoteState == nil {
+	if err != nil {
 		return err
 	}
 
+	if srcRemoteState == nil {
+		return errors.Errorf("missing remote state configuration for source module: %s", srcPath)
+	}
+
 	dstRemoteState, err := config.ParseRemoteState(ctx, l, dstModule.Execution.TerragruntOptions)
-	if err != nil || dstRemoteState == nil {
+	if err != nil {
 		return err
 	}
 
+	if dstRemoteState == nil {
+		return errors.Errorf("missing remote state configuration for destination module: %s", dstPath)
+	}
+
 	if !opts.ForceBackendMigrate {
 		enabled, err := srcRemoteState.IsVersionControlEnabled(ctx, l, srcModule.Execution.TerragruntOptions)
 		if err != nil && !errors.As(err, new(backend.BucketDoesNotExistError)) {

internal/component/unit.go

@@ -11,6 +11,7 @@ import (
 	"github.com/gruntwork-io/terragrunt/options"
 	"github.com/gruntwork-io/terragrunt/pkg/log"
 	"github.com/gruntwork-io/terragrunt/tf"
+	"github.com/gruntwork-io/terragrunt/util"
 )
 
 const (
@@ -218,7 +219,11 @@ func (u *Unit) Dependents() Components {
 
 // String renders this unit as a human-readable string for debugging.
 func (u *Unit) String() string {
+	// Snapshot values under read lock to avoid data races
+	u.rLock()
+	path := u.path
 	deps := make([]string, 0, len(u.dependencies))
+
 	for _, dep := range u.dependencies {
 		deps = append(deps, dep.Path())
 	}
@@ -231,30 +236,46 @@ func (u *Unit) String() string {
 		assumeApplied = u.Execution.AssumeAlreadyApplied
 	}
 
+	u.rUnlock()
+
 	return fmt.Sprintf(
 		"Unit %s (excluded: %v, assume applied: %v, dependencies: [%s])",
-		u.path, excluded, assumeApplied, strings.Join(deps, ", "),
+		path, excluded, assumeApplied, strings.Join(deps, ", "),
 	)
 }
 
 // AbsolutePath returns the absolute path of the unit.
-// If path conversion fails, returns the original path and logs a warning.
+// If path conversion fails, returns the original path and logs a warning if a logger is available.
 func (u *Unit) AbsolutePath() string {
 	if filepath.IsAbs(u.path) {
 		return u.path
 	}
 
 	absPath, err := filepath.Abs(u.path)
 	if err != nil {
+		if u.Execution != nil && u.Execution.Logger != nil {
+			u.Execution.Logger.Warnf("Failed to convert unit path %q to absolute path: %v", u.path, err)
+		}
+
 		return u.path
 	}
 
 	return absPath
 }
 
 // FindInPaths returns true if the unit is located in one of the target directories.
+// Paths are normalized before comparison to handle absolute/relative path mismatches.
 func (u *Unit) FindInPaths(targetDirs []string) bool {
-	return slices.Contains(targetDirs, u.path)
+	cleanUnitPath := util.CleanPath(u.path)
+
+	for _, dir := range targetDirs {
+		cleanDir := util.CleanPath(dir)
+		if util.HasPathPrefix(cleanUnitPath, cleanDir) {
+			return true
+		}
+	}
+
+	return false
 }
 
 // PlanFile returns plan file location if output folder is set.

internal/discovery/discovery.go

@@ -724,8 +724,7 @@ func (d *Discovery) skipDirIfIgnorable(_ log.Logger, path string) error {
 		}
 	}
 
-	// When the filter flag is enabled, let the filters control discovery instead of exclude patterns
-	// When the filter flag is enabled, let the filters control discovery instead of exclude patterns
+	// When the filter flag is enabled, let the filters control discovery instead of exclude patterns.
 	// We also avoid early skipping for CLI exclude patterns so reporting can capture excluded units.
 	if d.filterFlagEnabled {
 		return nil
@@ -1288,7 +1287,12 @@ func (d *Discovery) Discover(
 	}
 
 	if d.graphTarget != "" {
-		components = d.filterGraphTarget(l, components)
+		var err error
+
+		components, err = d.filterGraphTarget(components)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	components = d.applyQueueFilters(opts, components)
@@ -1297,35 +1301,46 @@ func (d *Discovery) Discover(
 }
 
 // filterGraphTarget prunes components to the target path and its dependents.
-func (d *Discovery) filterGraphTarget(l log.Logger, components component.Components) component.Components {
+func (d *Discovery) filterGraphTarget(components component.Components) (component.Components, error) {
 	if d.graphTarget == "" {
-		return components
+		return components, nil
 	}
 
-	targetPath := canonicalizeGraphTarget(l, d.workingDir, d.graphTarget)
+	targetPath, err := canonicalizeGraphTarget(d.workingDir, d.graphTarget)
+	if err != nil {
+		return nil, err
+	}
 
 	dependentUnits := buildDependentsIndex(components)
 	propagateTransitiveDependents(dependentUnits)
 
 	allowed := buildAllowSet(targetPath, dependentUnits)
 
-	return filterByAllowSet(components, allowed)
+	return filterByAllowSet(components, allowed), nil
 }
 
 // canonicalizeGraphTarget resolves the graph target to an absolute, cleaned path.
-// Falls back to a cleaned relative path on canonicalization failure, logging at debug level.
-func canonicalizeGraphTarget(l log.Logger, baseDir, target string) string {
-	targetPath := target
-	if !filepath.IsAbs(targetPath) {
-		if abs, err := util.CanonicalPath(targetPath, baseDir); err == nil {
-			targetPath = abs
-		} else {
-			l.Debugf("Could not canonicalize graph target %s: %v", targetPath, err)
-			targetPath = filepath.Clean(targetPath)
-		}
+// Returns an error if the path cannot be made absolute.
+func canonicalizeGraphTarget(baseDir, target string) (string, error) {
+	// If already absolute, just clean it
+	if filepath.IsAbs(target) {
+		return filepath.Clean(target), nil
+	}
+
+	// Try canonical path first
+	if abs, err := util.CanonicalPath(target, baseDir); err == nil {
+		return abs, nil
+	}
+
+	// Fallback: join with baseDir and make absolute
+	joined := filepath.Join(baseDir, filepath.Clean(target))
+
+	abs, err := filepath.Abs(joined)
+	if err != nil {
+		return "", errors.Errorf("failed to resolve graph target %q relative to %q: %w", target, baseDir, err)
 	}
 
-	return targetPath
+	return abs, nil
 }
 
 // buildDependentsIndex builds an index mapping each unit path to the list of units