feat: unit resolver performance improvements

cli/commands/commands.go

@@ -212,7 +212,7 @@ func setupAutoProviderCacheDir(ctx context.Context, l log.Logger, opts *options.
 
 	// Check if OpenTofu is being used
 	if tfImplementation != options.OpenTofuImpl {
-		return fmt.Errorf("auto provider cache dir requires OpenTofu, but detected %s", tfImplementation)
+		return errors.Errorf("auto provider cache dir requires OpenTofu, but detected %s", tfImplementation)
 	}
 
 	// Check OpenTofu version > 1.10
@@ -222,19 +222,19 @@ func setupAutoProviderCacheDir(ctx context.Context, l log.Logger, opts *options.
 
 	requiredVersion, err := version.NewVersion(minTofuVersionForAutoProviderCacheDir)
 	if err != nil {
-		return fmt.Errorf("failed to parse required version: %w", err)
+		return errors.Errorf("failed to parse required version: %w", err)
 	}
 
 	if terraformVersion.LessThan(requiredVersion) {
-		return fmt.Errorf("auto provider cache dir requires OpenTofu version >= 1.10, but found %s", terraformVersion)
+		return errors.Errorf("auto provider cache dir requires OpenTofu version >= 1.10, but found %s", terraformVersion)
 	}
 
 	// Set up the provider cache directory
 	providerCacheDir := opts.ProviderCacheDir
 	if providerCacheDir == "" {
 		cacheDir, err := util.GetCacheDir()
 		if err != nil {
-			return fmt.Errorf("failed to get cache directory: %w", err)
+			return errors.Errorf("failed to get cache directory: %w", err)
 		}
 
 		providerCacheDir = filepath.Join(cacheDir, "providers")
@@ -244,7 +244,7 @@ func setupAutoProviderCacheDir(ctx context.Context, l log.Logger, opts *options.
 	if !filepath.IsAbs(providerCacheDir) {
 		absPath, err := filepath.Abs(providerCacheDir)
 		if err != nil {
-			return fmt.Errorf("failed to get absolute path for provider cache directory: %w", err)
+			return errors.Errorf("failed to get absolute path for provider cache directory: %w", err)
 		}
 
 		providerCacheDir = absPath
@@ -254,7 +254,7 @@ func setupAutoProviderCacheDir(ctx context.Context, l log.Logger, opts *options.
 
 	// Create the cache directory if it doesn't exist
 	if err := os.MkdirAll(providerCacheDir, cacheDirMode); err != nil {
-		return fmt.Errorf("failed to create provider cache directory: %w", err)
+		return errors.Errorf("failed to create provider cache directory: %w", err)
 	}
 
 	// Initialize environment variables map if it's nil
@@ -389,7 +389,7 @@ func initialSetup(cliCtx *cli.Context, l log.Logger, opts *options.TerragruntOpt
 	if !doubleStarEnabled {
 		opts.IncludeDirs, err = util.GlobCanonicalPath(l, opts.WorkingDir, opts.IncludeDirs...)
 		if err != nil {
-			return fmt.Errorf("invalid include dirs: %w", err)
+			return errors.Errorf("invalid include dirs: %w", err)
 		}
 	}
 
@@ -406,7 +406,7 @@ func initialSetup(cliCtx *cli.Context, l log.Logger, opts *options.TerragruntOpt
 	if !doubleStarEnabled {
 		opts.ExcludeDirs, err = util.GlobCanonicalPath(l, opts.WorkingDir, opts.ExcludeDirs...)
 		if err != nil {
-			return fmt.Errorf("invalid exclude dirs: %w", err)
+			return errors.Errorf("invalid exclude dirs: %w", err)
 		}
 	}
 

cli/commands/common/runall/runall.go

@@ -120,7 +120,9 @@ func RunAllOnStack(ctx context.Context, l log.Logger, opts *options.TerragruntOp
 		}
 	}
 
-	return telemetry.TelemeterFromContext(ctx).Collect(ctx, "run_all_on_stack", map[string]any{
+	var runErr error
+
+	telemetryErr := telemetry.TelemeterFromContext(ctx).Collect(ctx, "run_all_on_stack", map[string]any{
 		"terraform_command": opts.TerraformCommand,
 		"working_dir":       opts.WorkingDir,
 	}, func(ctx context.Context) error {
@@ -141,11 +143,22 @@ func RunAllOnStack(ctx context.Context, l log.Logger, opts *options.TerragruntOp
 
 			exitCode.Set(int(cli.ExitCodeGeneralError))
 
+			// Save error to potentially return after telemetry completes
+			runErr = err
+
+			// Return nil to allow telemetry and reporting to complete
 			return nil
 		}
 
 		return nil
 	})
+
+	// log telemetry error and continue execution
+	if telemetryErr != nil {
+		l.Warnf("Telemetry collection failed: %v", telemetryErr)
+	}
+
+	return runErr
 }
 
 // shouldSkipSummary determines if summary output should be skipped for programmatic interactions.

config/config.go

@@ -1991,19 +1991,19 @@ func (cfg *TerragruntConfig) ErrorsConfig() (*options.ErrorsConfig, error) {
 
 		// Validate retry settings
 		if retryBlock.MaxAttempts < 1 {
-			return nil, fmt.Errorf("cannot have less than 1 max retry in errors.retry %q, but you specified %d", retryBlock.Label, retryBlock.MaxAttempts)
+			return nil, errors.Errorf("cannot have less than 1 max retry in errors.retry %q, but you specified %d", retryBlock.Label, retryBlock.MaxAttempts)
 		}
 
 		if retryBlock.SleepIntervalSec < 0 {
-			return nil, fmt.Errorf("cannot sleep for less than 0 seconds in errors.retry %q, but you specified %d", retryBlock.Label, retryBlock.SleepIntervalSec)
+			return nil, errors.Errorf("cannot sleep for less than 0 seconds in errors.retry %q, but you specified %d", retryBlock.Label, retryBlock.SleepIntervalSec)
 		}
 
 		compiledPatterns := make([]*options.ErrorsPattern, 0, len(retryBlock.RetryableErrors))
 
 		for _, pattern := range retryBlock.RetryableErrors {
 			value, err := errorsPattern(pattern)
 			if err != nil {
-				return nil, fmt.Errorf("invalid retry pattern %q in block %q: %w",
+				return nil, errors.Errorf("invalid retry pattern %q in block %q: %w",
 					pattern, retryBlock.Label, err)
 			}
 
@@ -2042,7 +2042,7 @@ func (cfg *TerragruntConfig) ErrorsConfig() (*options.ErrorsConfig, error) {
 		for _, pattern := range ignoreBlock.IgnorableErrors {
 			value, err := errorsPattern(pattern)
 			if err != nil {
-				return nil, fmt.Errorf("invalid ignore pattern %q in block %q: %w",
+				return nil, errors.Errorf("invalid ignore pattern %q in block %q: %w",
 					pattern, ignoreBlock.Label, err)
 			}
 

internal/discovery/discovery.go

@@ -429,34 +429,48 @@ func Parse(
 	parserOptions []hclparse.Option,
 ) error {
 	parseOpts := opts.Clone()
-	parseOpts.WorkingDir = c.Path()
+
+	// Determine working directory and config filename, supporting file paths and stack kind
+	componentPath := c.Path()
+
+	var workingDir, configFilename string
+
+	// Defaults assume a directory path
+	workingDir = componentPath
+	configFilename = config.DefaultTerragruntConfigPath
+
+	// If the path points directly to a file, split dir and filename
+	if util.FileExists(componentPath) && !util.IsDir(componentPath) {
+		workingDir = filepath.Dir(componentPath)
+		configFilename = filepath.Base(componentPath)
+	} else {
+		// Allow user-specified config filename when provided as a file path
+		if p := opts.TerragruntConfigPath; p != "" && !util.IsDir(p) {
+			configFilename = filepath.Base(p)
+		}
+		// Stacks always use the default stack filename
+		if c.Kind() == component.StackKind {
+			configFilename = config.DefaultStackFile
+		}
+	}
+
+	parseOpts.WorkingDir = workingDir
 
 	// Suppress logging to avoid cluttering the output.
 	parseOpts.Writer = io.Discard
 	parseOpts.ErrWriter = io.Discard
 	parseOpts.SkipOutput = true
 
-	// If the user provided a specific terragrunt config path and it is not a directory,
-	// use its base name as the file to parse. This allows users to run terragrunt with
-	// a specific config file instead of the default terragrunt.hcl.
-	// Otherwise, use the default terragrunt.hcl filename.
-	filename := config.DefaultTerragruntConfigPath
-	if opts.TerragruntConfigPath != "" && !util.IsDir(opts.TerragruntConfigPath) {
-		filename = filepath.Base(opts.TerragruntConfigPath)
-	}
-
-	// For stack configurations, always use the default stack config filename
-	if _, ok := c.(*component.Stack); ok {
-		filename = config.DefaultStackFile
-	}
-
-	parseOpts.TerragruntConfigPath = filepath.Join(parseOpts.WorkingDir, filename)
+	parseOpts.TerragruntConfigPath = filepath.Join(parseOpts.WorkingDir, configFilename)
 
 	parsingCtx := config.NewParsingContext(ctx, l, parseOpts).WithDecodeList(
+		config.TerraformSource,
 		config.DependenciesBlock,
 		config.DependencyBlock,
+		config.TerragruntFlags,
 		config.FeatureFlagsBlock,
 		config.ExcludeBlock,
+		config.ErrorsBlock,
 	).WithSkipOutputsResolution()
 
 	// Apply custom parser options if provided via discovery
@@ -505,10 +519,13 @@ func Parse(
 
 	// Set a list with partial blocks used to do discovery
 	parsingCtx = parsingCtx.WithDecodeList(
+		config.TerraformSource,
 		config.DependenciesBlock,
 		config.DependencyBlock,
+		config.TerragruntFlags,
 		config.FeatureFlagsBlock,
 		config.ExcludeBlock,
+		config.ErrorsBlock,
 	)
 
 	//nolint: contextcheck

internal/runner/common/unit.go

@@ -76,12 +76,7 @@ func (unit *Unit) FlushOutput() error {
 	}
 
 	if writer, ok := unit.TerragruntOptions.Writer.(*UnitWriter); ok {
-		key := unit.Path
-		if !filepath.IsAbs(key) {
-			if abs, err := filepath.Abs(key); err == nil {
-				key = abs
-			}
-		}
+		key := unit.AbsolutePath(unit.Logger)
 
 		mu := getUnitOutputLock(key)
 
@@ -166,6 +161,25 @@ func (unit *Unit) FindUnitInPath(targetDirs []string) bool {
 	return slices.Contains(targetDirs, unit.Path)
 }
 
+// AbsolutePath returns the absolute path of the unit.
+// If path conversion fails, returns the original path and logs a warning.
+func (unit *Unit) AbsolutePath(l log.Logger) string {
+	if filepath.IsAbs(unit.Path) {
+		return unit.Path
+	}
+
+	absPath, err := filepath.Abs(unit.Path)
+	if err != nil {
+		if l != nil {
+			l.Warnf("Failed to get absolute path for %s: %v", unit.Path, err)
+		}
+
+		return unit.Path
+	}
+
+	return absPath
+}
+
 // getDependenciesForUnit Get the list of units this unit depends on
 func (unit *Unit) getDependenciesForUnit(unitsMap UnitsMap, terragruntConfigPaths []string) (Units, error) {
 	dependencies := Units{}