chore(act): group log lines when running act tests inside gha (#488)

Author: xnyo

tests/act/internal/act/act.go

@@ -14,6 +14,7 @@ import (
 	"regexp"
 	"runtime"
 	"strings"
+	"sync"
 	"testing"
 
 	"github.com/google/uuid"
@@ -34,6 +35,7 @@ var (
 		"ubuntu-arm64-xlarge",
 		"ubuntu-arm64-2xlarge",
 	}
+	globalLogMutex sync.Mutex
 )
 
 const nektosActRunnerImage = "ghcr.io/catthehacker/ubuntu:act-latest"
@@ -43,6 +45,10 @@ type Runner struct {
 	// t is the testing.T instance for the current test.
 	t *testing.T
 
+	// name is the name of this Runner, used for logging.
+	// By default, this is t.Name(), but can be overridden with WithName().
+	name string
+
 	// uuid is a unique identifier for this Runner instance.
 	uuid uuid.UUID
 
@@ -77,6 +83,9 @@ type Runner struct {
 	// By default, act uses the architecture of the host machine.
 	// This can be useful to force a specific platform when running on ARM Macs.
 	ContainerArchitecture string
+
+	// inGitHubActions indicates whether the runner is executing in a GitHub Actions environment.
+	inGitHubActions bool
 }
 
 // actionsCachePathBase is the base path for the action cache.
@@ -116,6 +125,14 @@ func WithActionsCachePath(cachePath string) RunnerOption {
 	}
 }
 
+// WithName sets the name of the Runner, used for logging.
+// By default, the Runner uses t.Name() as its name.
+func WithName(name string) RunnerOption {
+	return func(r *Runner) {
+		r.name = name
+	}
+}
+
 // NewRunner creates a new Runner instance.
 func NewRunner(t *testing.T, opts ...RunnerOption) (*Runner, error) {
 	// Get GitHub token from environment (GHA) or gh CLI (local)
@@ -129,10 +146,12 @@ func NewRunner(t *testing.T, opts ...RunnerOption) (*Runner, error) {
 		ghToken = strings.TrimSpace(string(output))
 	}
 	r := &Runner{
-		t:           t,
-		uuid:        uuid.New(),
-		gitHubToken: ghToken,
-		GCOM: newGCOM(t),
+		t:               t,
+		name:            t.Name(),
+		uuid:            uuid.New(),
+		gitHubToken:     ghToken,
+		inGitHubActions: os.Getenv("GITHUB_ACTIONS") == "true",
+		GCOM:            newGCOM(t),
 		Argo: NewHTTPSpy(t, map[string]string{
 			"uri": "https://mock-argo-workflows.example.com/workflows/grafana-plugins-cd/mock-workflow-id",
 		}),
@@ -316,28 +335,47 @@ func (r *Runner) Run(workflow workflow.Workflow, event Event) (runResult *RunRes
 	cmd := exec.Command("sh", "-c", actCmd)
 	cmd.Env = os.Environ()
 
-	// Get stdout pipe to parse act output
+	// Get stdout and stderr pipes to parse act output
 	stdout, err := cmd.StdoutPipe()
 	if err != nil {
 		return nil, fmt.Errorf("get act stdout pipe: %w", err)
 	}
+	stderr, err := cmd.StderrPipe()
+	if err != nil {
+		return nil, fmt.Errorf("get act stderr pipe: %w", err)
+	}
 
-	// Just pipe stderr as nothing to parse there
-	cmd.Stderr = os.Stderr
+	// Merge stdout and stderr into a single reader so both are grouped in GHA logs
+	mergedR, mergedW := io.Pipe()
+	go func() {
+		var wg sync.WaitGroup
+		wg.Add(2)
+		go func() {
+			defer wg.Done()
+			_, _ = io.Copy(mergedW, stdout)
+		}()
+		go func() {
+			defer wg.Done()
+			_, _ = io.Copy(mergedW, stderr)
+		}()
+		wg.Wait()
+		_ = mergedW.Close()
+	}()
 
 	// Run act in the background
 	if err := cmd.Start(); err != nil {
 		return nil, fmt.Errorf("start act: %w", err)
 	}
 
-	// Process json logs in stdout stream.
+	// Process json logs in merged stdout/stderr stream
 	// This must complete BEFORE cmd.Wait() is called, because cmd.Wait()
 	// closes the stdout pipe. If the goroutine is still reading when the
 	// pipe is closed, it will get a "file already closed" error.
 	errs := make(chan error, 1)
 	go func() {
-		if err := r.processStream(stdout, runResult); err != nil {
-			errs <- fmt.Errorf("process act stdout: %w", err)
+		if err := r.processStream(mergedR, runResult); err != nil {
+			errs <- fmt.Errorf("process act output: %w", err)
+			return
 		}
 		errs <- nil
 	}()
@@ -359,46 +397,73 @@ func (r *Runner) Run(workflow workflow.Workflow, event Event) (runResult *RunRes
 		return nil, fmt.Errorf("act exit: %w", err)
 	}
 	runResult.Success = true
-
 	return runResult, nil
 }
 
+// logOrBuffer writes a message to the buffer if running in GitHub Actions,
+// or prints it immediately to stdout otherwise.
+func (r *Runner) logOrBuffer(msg string, logBuffer *strings.Builder) {
+	if r.inGitHubActions {
+		logBuffer.WriteString(msg)
+		logBuffer.WriteString("\n")
+	} else {
+		fmt.Println(msg)
+	}
+}
+
 // processStream processes the given reader line by line as JSON log lines generated by act.
+// If running in GitHub Actions, it buffers all log lines and prints them in a log group when the process finishes.
+// Otherwise, it prints each line immediately to stdout.
 func (r *Runner) processStream(reader io.Reader, runResult *RunResult) error {
 	scanner := bufio.NewScanner(reader)
+	var logBuffer strings.Builder
+
 	for scanner.Scan() {
 		var data logLine
 		line := scanner.Bytes()
 		err := json.Unmarshal(line, &data)
-		if r.Verbose {
-			fmt.Println(string(line))
-		}
 		if err != nil {
+			// Preserve plain-text lines (commonly emitted on stderr) in non-verbose mode.
+			r.logOrBuffer(string(line), &logBuffer)
 			continue
 		}
+		if r.Verbose {
+			r.logOrBuffer(string(line), &logBuffer)
+		}
 
-		// Print back to stdout in a human-readable format for now
 		// Clean up uuids from data.Job for cleaner output
 		data.Job = logUUIDRegex.ReplaceAllString(data.Job, "")
-		fmt.Printf("%s: [%s] %s\n", r.t.Name(), data.Job, strings.TrimSpace(data.Message))
+		formattedLog := fmt.Sprintf("%s: [%s] %s", r.name, data.Job, strings.TrimSpace(data.Message))
+		r.logOrBuffer(formattedLog, &logBuffer)
 
 		// Parse GHA commands (outputs, annotations, etc.)
 		r.parseGHACommand(data, runResult)
 	}
 	if err := scanner.Err(); err != nil {
 		return fmt.Errorf("scanner error: %w", err)
 	}
+
+	// Print all buffered logs in a GitHub Actions log group
+	if r.inGitHubActions {
+		globalLogMutex.Lock()
+		fmt.Printf("::group::%s\n", r.name)
+		fmt.Print(logBuffer.String())
+		fmt.Println("::endgroup::")
+		globalLogMutex.Unlock()
+	}
+
 	return nil
 }
 
 // parseGHACommand parses intercepted GHA commands from act log lines and
 // updates the RunResult accordingly. If the log line does not contain a
 // recognized command, it is ignored.
+// Warning and verbose messages are always printed immediately to stdout.
 func (r *Runner) parseGHACommand(data logLine, runResult *RunResult) {
 	switch data.Command {
 	case "set-output":
 		if data.Name == "" {
-			fmt.Printf("%s: [%s]: WARNING: received GHA set-output command without name, ignoring output", r.t.Name(), data.Job)
+			fmt.Printf("%s: [%s]: WARNING: received GHA set-output command without name, ignoring output\n", r.name, data.Job)
 			break
 		}
 		// Store the output value. StepID can be an array in case of composite actions,
@@ -417,7 +482,7 @@ func (r *Runner) parseGHACommand(data logLine, runResult *RunResult) {
 	default:
 		// Nothing special to do
 		if r.Verbose && data.Command != "" {
-			fmt.Printf("%s: [%s]: unhandled GHA command %q, ignoring", r.t.Name(), data.Job, data.Command)
+			fmt.Printf("%s: [%s]: unhandled GHA command %q, ignoring\n", r.name, data.Job, data.Command)
 		}
 	}
 }

tests/act/main_package_test.go

@@ -177,8 +177,6 @@ func TestPackage(t *testing.T) {
 				expBasePluginZipFiles = append(expBasePluginZipFiles, filepath.Join(tc.expPluginID, "go_plugin_build_manifest"))
 
 				for _, osArch := range osArchCombos {
-					t.Logf("checking plugin ZIP for %s", osArch)
-
 					// Create a copy of the expected base files for each zip file we check
 					expPluginZipFiles := make([]string, len(expBasePluginZipFiles))
 					copy(expPluginZipFiles, expBasePluginZipFiles[:])

tests/act/main_smoke_test.go

@@ -85,7 +85,6 @@ func TestSmoke(t *testing.T) {
 			var pluginOutput testAndBuildOutput
 			rawOutput, ok := r.Outputs.Get("test-and-build", "outputs", "plugin")
 			require.True(t, ok, "plugin output should be present")
-			t.Log(rawOutput)
 			err = json.Unmarshal([]byte(rawOutput), &pluginOutput)
 			require.NoError(t, err, "unmarshal plugin output JSON")
 			require.Equal(t, tc.exp, pluginOutput)

tests/act/main_test.go

@@ -146,6 +146,7 @@ func warmUpCaches(ciWf workflow.BaseWorkflow) error {
 	warmupRunner, err := act.NewRunner(
 		&testing.T{},
 		act.WithActionsCachePath(act.TemplateActionsCachePath),
+		act.WithName("toolcache-warmup"),
 	)
 	if err != nil {
 		return fmt.Errorf("create warmup runner: %w", err)