fix(logger/parser): de-interleave parallel logs emitted through t.Log

Routing logs through t.Log (previous commit) indents each line and prepends the
testing framework's "file.go:NN: " decoration, so terratest_log_parser's
un-indented "Test"-prefix heuristic no longer matched and every parallel line
fell through to the previousTestName rollup. Both parallel tests resume up front
via === CONT and never pause again, so that rollup attributed all output to the
last test resumed.

The indented lines still embed their owning test name, so detect that format and
extract the name directly, restoring correct de-interleaving. The existing
un-indented case still handles the stdout fallback path. Adds unit tests for the
new matcher and an end-to-end SpawnParsers test over interleaved t.Log output.

Author: james00012

modules/core/logger/parser/parser.go

@@ -56,6 +56,11 @@ var (
 	regexStatus  = regexp.MustCompile(`=== (RUN|PAUSE|CONT)\s+(.+)`)
 	regexSummary = regexp.MustCompile(`(^FAIL$)|(^(ok|FAIL)\s+([^ ]+)\s+(?:(\d+\.\d+)s|\(cached\)|(\[\w+ failed]))(?:\s+coverage:\s+(\d+\.\d+)%\sof\sstatements(?:\sin\s.+)?)?$)`)
 	regexPanic   = regexp.MustCompile(`^panic:`)
+	// regexIndentedTerratestLog matches a terratest log line emitted through t.Log: the testing framework indents it
+	// and prepends its own "file.go:NN: " decoration, e.g. "    apply_test.go:42: TestFoo 2006-01-02T15:04:05Z07:00
+	// caller.go:7: message". It captures the embedded test name so parallel output can still be de-interleaved. The
+	// "TestName <RFC3339 timestamp>" signature is what distinguishes a terratest line from an ordinary t.Log line.
+	regexIndentedTerratestLog = regexp.MustCompile(`^\s+\S+:\d+:\s+(Test\S*)\s+\d{4}-\d{2}-\d{2}T`)
 )
 
 // GetIndent takes a line and returns the indent string
@@ -109,6 +114,19 @@ func IsPanicLine(text string) bool {
 	return regexPanic.MatchString(text)
 }
 
+// IsIndentedTerratestLogLine checks whether a line is a terratest log line that was emitted through t.Log, i.e. indented
+// by the testing framework and prefixed with its "file.go:NN: " decoration. See regexIndentedTerratestLog.
+func IsIndentedTerratestLogLine(text string) bool {
+	return regexIndentedTerratestLog.MatchString(text)
+}
+
+// GetTestNameFromIndentedTerratestLogLine extracts the test name embedded in a terratest log line emitted through
+// t.Log. See regexIndentedTerratestLog.
+func GetTestNameFromIndentedTerratestLogLine(text string) string {
+	m := regexIndentedTerratestLog.FindStringSubmatch(text)
+	return m[1]
+}
+
 // parseAndStoreTestOutput will take test log entries from terratest and aggregate the output by test. Takes advantage
 // of the fact that terratest logs are prefixed by the test name. This will store the broken out logs into files under
 // the outputDir, named by test name.
@@ -170,8 +188,8 @@ func parseAndStoreTestOutput(
 			case strings.HasPrefix(data, "Test"):
 				// Heuristic: `go test` will only execute test functions named `Test.*`, so we assume any line prefixed
 				// with `Test` is a test output for a named test. Also assume that test output will be space delimited and
-				// test names can't contain spaces (because they are function names).
-				// This must be modified when `logger.DoLog` changes.
+				// test names can't contain spaces (because they are function names). This handles un-indented terratest
+				// output, i.e. the stdout fallback path in logger.DoLog (used when no *testing.T is available).
 				vals := strings.Split(data, " ")
 				testName := vals[0]
 				previousTestName = testName
@@ -180,6 +198,19 @@ func parseAndStoreTestOutput(
 					logger.Errorf("Error writing log for test %s: %s", testName, writeErr)
 				}
 
+			case IsIndentedTerratestLogLine(data):
+				// When a *testing.T is available, logger.DoLog emits through t.Log, so terratest lines are indented and
+				// carry the framework's "file.go:NN: " decoration before the terratest prefix. The line still embeds its
+				// owning test name, so we extract and attribute it directly. This is what preserves de-interleaving of
+				// parallel tests: the `=== CONT` status lines alone cannot, since both tests resume up front and never
+				// pause again, so previousTestName would otherwise misattribute every line to the last test resumed.
+				testName := GetTestNameFromIndentedTerratestLogLine(data)
+				previousTestName = testName
+
+				if writeErr := logWriter.WriteLog(logger, testName, data); writeErr != nil {
+					logger.Errorf("Error writing log for test %s: %s", testName, writeErr)
+				}
+
 			case isIndented && IsResultLine(data):
 				// In a nested test result block, so collect the line into all the test results we have seen so far.
 				for _, marker := range testResultMarkers {

modules/core/logger/parser/terratest_log_line_test.go

@@ -0,0 +1,112 @@
+package parser_test
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/gruntwork-io/terratest/modules/core/v2/logger/parser"
+	"github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestIsIndentedTerratestLogLine(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name string
+		in   string
+		out  bool
+	}{
+		{
+			name: "IndentedTerratestLine",
+			in:   "    apply_test.go:42: TestFoo 2026-07-18T13:36:46-04:00 logger.go:81: applying",
+			out:  true,
+		},
+		{
+			name: "IndentedSubtestLine",
+			in:   "        apply_test.go:42: TestFoo/Sub1 2026-07-18T13:36:46-04:00 logger.go:81: applying",
+			out:  true,
+		},
+		{
+			name: "UnindentedTerratestLine",
+			in:   "TestFoo 2026-07-18T13:36:46-04:00 logger.go:81: applying",
+			out:  false,
+		},
+		{
+			name: "PlainTLogLine",
+			in:   "    apply_test.go:42: some plain message",
+			out:  false,
+		},
+		{
+			name: "IndentedResultLine",
+			in:   "    --- PASS: TestFoo (0.02s)",
+			out:  false,
+		},
+	}
+
+	for _, testCase := range testCases {
+		testCase := testCase
+		t.Run(testCase.name, func(t *testing.T) {
+			t.Parallel()
+			assert.Equal(t, testCase.out, parser.IsIndentedTerratestLogLine(testCase.in))
+		})
+	}
+}
+
+func TestGetTestNameFromIndentedTerratestLogLine(t *testing.T) {
+	t.Parallel()
+
+	assert.Equal(t, "TestFoo", parser.GetTestNameFromIndentedTerratestLogLine(
+		"    apply_test.go:42: TestFoo 2026-07-18T13:36:46-04:00 logger.go:81: applying"))
+	assert.Equal(t, "TestFoo/Sub1", parser.GetTestNameFromIndentedTerratestLogLine(
+		"        apply_test.go:42: TestFoo/Sub1 2026-07-18T13:36:46-04:00 logger.go:81: applying"))
+}
+
+// TestSpawnParsersDeinterleavesTLogOutput verifies that the parser de-interleaves parallel-test output that terratest
+// now emits through t.Log (indented and decorated by the testing framework). Both tests resume up front, so the
+// `=== CONT` status lines cannot distinguish them; correct attribution relies on the test name embedded in each line.
+func TestSpawnParsersDeinterleavesTLogOutput(t *testing.T) {
+	t.Parallel()
+
+	// Interleaved `go test -v` output (non-JSON) as produced after logging is routed through t.Log.
+	sample := strings.Join([]string{
+		"=== RUN   TestParA",
+		"=== PAUSE TestParA",
+		"=== RUN   TestParB",
+		"=== PAUSE TestParB",
+		"=== CONT  TestParA",
+		"=== CONT  TestParB",
+		"    a_test.go:10: TestParA 2026-07-18T13:36:46-04:00 logger.go:81: MARKA payload 0",
+		"    b_test.go:20: TestParB 2026-07-18T13:36:46-04:00 logger.go:81: MARKB payload 0",
+		"    b_test.go:20: TestParB 2026-07-18T13:36:46-04:00 logger.go:81: MARKB payload 1",
+		"    a_test.go:10: TestParA 2026-07-18T13:36:46-04:00 logger.go:81: MARKA payload 1",
+		"    a_test.go:10: TestParA 2026-07-18T13:36:46-04:00 logger.go:81: MARKA payload 2",
+		"    b_test.go:20: TestParB 2026-07-18T13:36:46-04:00 logger.go:81: MARKB payload 2",
+		"--- PASS: TestParA (0.02s)",
+		"--- PASS: TestParB (0.02s)",
+		"PASS",
+		"ok  \tpkg\t0.10s",
+		"",
+	}, "\n")
+
+	out := t.TempDir()
+	parser.SpawnParsers(logrus.New(), strings.NewReader(sample), out)
+
+	readLog := func(test string) string {
+		b, err := os.ReadFile(filepath.Join(out, test+".log"))
+		require.NoError(t, err, "expected a log file for %s", test)
+
+		return string(b)
+	}
+
+	a := readLog("TestParA")
+	assert.Equal(t, 3, strings.Count(a, "MARKA"), "TestParA.log should contain all of its own lines")
+	assert.NotContains(t, a, "MARKB", "TestParA.log should not contain TestParB output")
+
+	b := readLog("TestParB")
+	assert.Equal(t, 3, strings.Count(b, "MARKB"), "TestParB.log should contain all of its own lines")
+	assert.NotContains(t, b, "MARKA", "TestParB.log should not contain TestParA output")
+}