Merge remote-tracking branch 'origin/main' into filter-otel

Author: denis256

cli/flags/shared/shared.go

@@ -251,15 +251,7 @@ func NewFilterFlags(l log.Logger, opts *options.TerragruntOptions) cli.Flags {
 						l.Warnf("Warning: You have uncommitted changes. The --filter-affected flag may not include all your local modifications.")
 					}
 
-					defaultBranch := "main"
-
-					if b, err := gitRunner.Config(ctx.Context, "init.defaultBranch"); err == nil && b != "" {
-						l.Debugf("Using default branch discovered from git config: %s", b)
-
-						defaultBranch = b
-					} else {
-						l.Warnf("Failed to get default branch from `git config init.defaultBranch`, using main.")
-					}
+					defaultBranch := gitRunner.GetDefaultBranch(ctx.Context, l)
 
 					opts.FilterQueries = append(opts.FilterQueries, fmt.Sprintf("[%s...HEAD]", defaultBranch))
 

docs-starlight/src/content/docs/04-reference/04-experiments.md

@@ -169,9 +169,9 @@ To transition the `filter-flag` feature to a stable release, the following must
 - [x] Add support for git-based filtering ([ref...ref] syntax)
 - [x] Add support for dependency/dependent traversal (... syntax)
 - [x] Add support for `--filters-file` flag
-- [ ] Add support for `--filter-allow-destroy` flag
+- [x] Add support for `--filter-allow-destroy` flag
 - [x] Add support for `--filter-affected` shorthand
-- [ ] Comprehensive integration testing across all commands
+- [x] Comprehensive integration testing across all commands
 - [ ] Backport legacy queue control flags (queue-exclude-dir, queue-include-dir, etc.) into equivalent filter patterns as aliases.
 
 **Future Deprecations:**

docs-starlight/src/content/docs/06-troubleshooting/03-performance.mdx

@@ -38,9 +38,9 @@ terragrunt run --all plan --provider-cache
 
 #### Provider Cache - Gotchas
 
-The provider cache server is a single server that is used by all Terragrunt runs being performed in a given Terragrunt invocation. You will see the most benefit if you are using it in a command that will perform multiple OpenTofu/Terraform operations, like with the `--all` flag and the `--graph` flag.
+The provider cache server is a single server that is used by all Terragrunt runs being performed in a given Terragrunt invocation. You will see the most benefit if you are using it in a command that will perform many OpenTofu/Terraform operations, like with the `--all` flag and the `--graph` flag.
 
-When performing individual runs, like `terragrunt plan`, the provider cache server can be a net negative to performance, because starting and stopping the server might add more overhead than just downloading the providers. Whether this is the case depends on many factors, including network speed, the number of providers being downloaded, and whether or not the providers are already cached in the Terragrunt provider cache.
+When performing individual runs, like `terragrunt plan`, the provider cache server can be a net negative to performance, because starting and stopping the server might add more overhead than just downloading the providers (or using the [Automatic Provider Cache Dir](/docs/features/auto-provider-cache-dir) feature). Whether this is the case depends on many factors, including network speed, the number of providers being downloaded, and whether or not the providers are already cached in the Terragrunt provider cache.
 
 When in doubt, [measure the performance](#measuring-performance) before and after enabling the provider cache server to see if it's a net win for your use case.
 
@@ -50,17 +50,17 @@ Under the hood, Terragrunt dependency blocks leverage the OpenTofu/Terraform `ou
 
 The OpenTofu/Terraform `output -json` command does a bit more work than simply fetching output values from state, and a significant portion of that slowdown is loading providers, which it doesn't really need in most cases.
 
-You can significantly improve the performance of dependency blocks by using the `--dependency-fetch-output-from-state` flag. When the flag is set, Terragrunt will directly fetch the backend state file from S3 and parse it directly, avoiding any overhead incurred by calling the `output -json` command.
+You can significantly improve the performance of dependency blocks by using the [`dependency-fetch-output-from-state`](https://terragrunt.gruntwork.io/docs/reference/experiments/#dependency-fetch-output-from-state) experiment. When the experiment is active, Terragrunt will resolve outputs by directly fetching the backend state file from S3 and parse it directly, avoiding any overhead incurred by calling the `output -json` command of OpenTofu/Terraform.
 
 For example:
 
-```shell
-terragrunt run --all plan --dependency-fetch-output-from-state
+```bash
+terragrunt run --all plan --experiment=dependency-fetch-output-from-state
 ```
 
 #### Fetching Output From State - Gotchas
 
-The first thing you need to be aware of when considering usage of the `--dependency-fetch-output-from-state` flag is that it only works for S3 backends. If you are using a different backend, this flag won't do anything.
+The first thing you need to be aware of when considering usage of the `dependency-fetch-output-from-state` experiment is that it only works for S3 backends. If you are using a different backend, this experiment won't do anything.
 
 Next, you should be aware that there is no guarantee that OpenTofu/Terraform will maintain the existing schema of their state files, so there is also no guarantee that the flag will work as expected in future versions of OpenTofu/Terraform.
 
@@ -93,7 +93,7 @@ You can use configurations like the `--warmup` flag to do some warmup runs befor
 Here's an example of how to use Hyperfine to benchmark the performance of Terragrunt with two different configurations:
 
 ```shell
-hyperfine -w 3 -r 5 'terragrunt run --all plan' 'terragrunt run --all plan --dependency-fetch-output-from-state'
+hyperfine -w 3 -r 5 'terragrunt run --all plan' 'terragrunt run --all plan --experiment=dependency-fetch-output-from-state'
 ```
 
 ### Terragrunt Developer

internal/git/git.go

@@ -28,6 +28,7 @@ import (
 
 	"github.com/go-git/go-git/v6"
 	"github.com/go-git/go-git/v6/storage/filesystem"
+	"github.com/gruntwork-io/terragrunt/pkg/log"
 )
 
 const (
@@ -495,6 +496,154 @@ func (g *GitRunner) GetHeadCommit(ctx context.Context) string {
 	return strings.TrimSpace(stdout.String())
 }
 
+// GetDefaultBranch implements the hybrid approach to detect the default branch:
+// 1. Tries to determine the default branch of the remote repository using the fast local method first
+// 2. Falls back to the network method if the local method fails
+// 3. Attempts to update local cache for future use
+// Returns the branch name (e.g., "main") or an error if both methods fail.
+func (g *GitRunner) GetDefaultBranch(ctx context.Context, l log.Logger) string {
+	branch, err := g.GetDefaultBranchLocal(ctx)
+	if err == nil && branch != "" {
+		return branch
+	}
+
+	branch, err = g.GetDefaultBranchRemote(ctx)
+	if err == nil && branch != "" {
+		err = g.SetRemoteHeadAuto(ctx)
+		if err != nil {
+			l.Warnf("Failed to update local cache for default branch: %v", err)
+		}
+
+		return branch
+	}
+
+	l.Debugf("Failed to determine default branch of remote repository, attempting to get default branch of local repository")
+
+	if b, err := g.Config(ctx, "init.defaultBranch"); err == nil && b != "" {
+		return b
+	}
+
+	l.Debugf("Failed to determine default branch of local repository, using 'main' as fallback")
+
+	return "main"
+}
+
+// GetDefaultBranchLocal attempts to get the default branch using the local cached remote HEAD.
+// Returns the branch name (e.g., "main") if successful, or an error if the local ref is not set.
+// This is fast and works offline, but requires that `git remote set-head origin --auto` has been run.
+func (g *GitRunner) GetDefaultBranchLocal(ctx context.Context) (string, error) {
+	if err := g.RequiresWorkDir(); err != nil {
+		return "", err
+	}
+
+	cmd := g.prepareCommand(ctx, "rev-parse", "--abbrev-ref", "origin/HEAD")
+
+	var stdout, stderr bytes.Buffer
+
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	if err := cmd.Run(); err != nil {
+		return "", &WrappedError{
+			Op:      "git_rev_parse_origin_head",
+			Context: stderr.String(),
+			Err:     ErrCommandSpawn,
+		}
+	}
+
+	result := strings.TrimSpace(stdout.String())
+
+	// If the result is just "origin/HEAD", the local ref is not properly set
+	if result == "origin/HEAD" {
+		return "", &WrappedError{
+			Op:      "git_rev_parse_origin_head",
+			Context: "local origin/HEAD ref not set",
+			Err:     ErrNoMatchingReference,
+		}
+	}
+
+	if after, ok := strings.CutPrefix(result, "origin/"); ok {
+		return after, nil
+	}
+
+	return result, nil
+}
+
+// GetDefaultBranchRemote queries the remote repository to determine the default branch.
+// This is the most accurate method but requires network access.
+// Returns the branch name (e.g., "main") if successful.
+func (g *GitRunner) GetDefaultBranchRemote(ctx context.Context) (string, error) {
+	if err := g.RequiresWorkDir(); err != nil {
+		return "", err
+	}
+
+	cmd := g.prepareCommand(ctx, "ls-remote", "--symref", "origin", "HEAD")
+
+	var stdout, stderr bytes.Buffer
+
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	if err := cmd.Run(); err != nil {
+		return "", &WrappedError{
+			Op:      "git_ls_remote_symref",
+			Context: stderr.String(),
+			Err:     ErrCommandSpawn,
+		}
+	}
+
+	// Parse output: "ref: refs/heads/main    HEAD"
+	output := stdout.String()
+	lines := strings.SplitSeq(strings.TrimSpace(output), "\n")
+
+	for line := range lines {
+		if line == "" {
+			continue
+		}
+
+		if strings.HasPrefix(line, "ref:") {
+			parts := strings.Fields(line)
+			if len(parts) >= 2 { //nolint:mnd
+				ref := parts[1]
+
+				if after, ok := strings.CutPrefix(ref, "refs/heads/"); ok {
+					return after, nil
+				}
+			}
+		}
+	}
+
+	return "", &WrappedError{
+		Op:      "git_ls_remote_symref",
+		Context: "could not parse default branch from ls-remote output",
+		Err:     ErrNoMatchingReference,
+	}
+}
+
+// SetRemoteHeadAuto runs `git remote set-head origin --auto` to update the local cached remote HEAD.
+// This makes future calls to GetDefaultBranchLocal faster.
+func (g *GitRunner) SetRemoteHeadAuto(ctx context.Context) error {
+	if err := g.RequiresWorkDir(); err != nil {
+		return err
+	}
+
+	cmd := g.prepareCommand(ctx, "remote", "set-head", "origin", "--auto")
+
+	var stderr bytes.Buffer
+
+	cmd.Stderr = &stderr
+
+	if err := cmd.Run(); err != nil {
+		return &WrappedError{
+			Op:      "git_remote_set_head",
+			Context: stderr.String(),
+			Err:     ErrCommandSpawn,
+		}
+	}
+
+	return nil
+}
+
 func (g *GitRunner) prepareCommand(ctx context.Context, name string, args ...string) *exec.Cmd {
 	cmd := exec.CommandContext(ctx, g.GitPath, append([]string{name}, args...)...)