fix(op-acceptor): add build dependencies and increase logs

op-acceptor/Dockerfile

@@ -9,7 +9,9 @@ COPY op-acceptor/ .
 
 RUN just build
 
-FROM alpine:3.21
+FROM golang:1.23.5-alpine3.21
+
+RUN apk add --no-cache ca-certificates build-base git
 
 # Install Go binary
 # (we copy Go directly from the builder stage for simplicity and consistency)
@@ -19,6 +21,7 @@ ENV GOPATH="/go"
 ENV PATH="${GOPATH}/bin:${PATH}"
 
 WORKDIR /app
+
 RUN addgroup -S app && adduser -S app -G app && \
     mkdir -p /devnets && \
     chown -R app:app /devnets
@@ -30,7 +33,12 @@ chown -R app:app /go
 
 COPY --from=builder /app/bin/op-acceptor /app/
 COPY op-acceptor/example-validators.yaml /app/
+
+# Set ownership of the /app directory to allow the application to write logs and other files at runtime
+RUN chown -R app:app /app/
+
 USER app
 
 VOLUME /devnets
+
 ENTRYPOINT ["/app/op-acceptor"]

op-acceptor/config.go

@@ -22,8 +22,9 @@ type Config struct {
 	AllowSkips      bool          // Allow tests to be skipped instead of failing when preconditions are not met
 	DefaultTimeout  time.Duration // Default timeout for individual tests, can be overridden by test config
 	LogDir          string        // Directory to store test logs
-
-	Log log.Logger
+	OutputTestLogs  bool          // Whether to output test logs to the console
+	TestLogLevel    string        // Log level to be used for the tests
+	Log             log.Logger
 }
 
 // NewConfig creates a new Config instance
@@ -72,6 +73,8 @@ func NewConfig(ctx *cli.Context, log log.Logger, testDir string, validatorConfig
 		RunOnce:         runOnce,
 		AllowSkips:      ctx.Bool(flags.AllowSkips.Name),
 		DefaultTimeout:  ctx.Duration(flags.DefaultTimeout.Name),
+		OutputTestLogs:  ctx.Bool(flags.OutputTestLogs.Name),
+		TestLogLevel:    ctx.String(flags.TestLogLevel.Name),
 		LogDir:          logDir,
 		Log:             log,
 	}, nil

op-acceptor/flags/flags.go

@@ -66,6 +66,18 @@ var (
 		EnvVars: opservice.PrefixEnvVar(EnvVarPrefix, "LOGDIR"),
 		Usage:   "Directory to store test logs. Defaults to 'logs' if not specified.",
 	}
+	TestLogLevel = &cli.StringFlag{
+		Name:    "test-log-level",
+		Value:   "info",
+		EnvVars: opservice.PrefixEnvVar(EnvVarPrefix, "TEST_LOG_LEVEL"),
+		Usage:   "Log level to be used for the tests. Defaults to 'info'.",
+	}
+	OutputTestLogs = &cli.BoolFlag{
+		Name:    "output-test-logs",
+		Value:   false,
+		EnvVars: opservice.PrefixEnvVar(EnvVarPrefix, "OUTPUT_TEST_LOGS"),
+		Usage:   "Output test logs to the console. Defaults to false.",
+	}
 )
 
 var requiredFlags = []cli.Flag{
@@ -80,6 +92,8 @@ var optionalFlags = []cli.Flag{
 	AllowSkips,
 	DefaultTimeout,
 	LogDir,
+	TestLogLevel,
+	OutputTestLogs,
 }
 var Flags []cli.Flag
 

op-acceptor/nat.go

@@ -76,14 +76,16 @@ func New(ctx context.Context, config *Config, version string, shutdownCallback f
 
 	// Create runner with registry
 	testRunner, err := runner.NewTestRunner(runner.Config{
-		Registry:    reg,
-		WorkDir:     config.TestDir,
-		Log:         config.Log,
-		TargetGate:  config.TargetGate,
-		GoBinary:    config.GoBinary,
-		AllowSkips:  config.AllowSkips,
-		NetworkName: networkName,
-		DevnetEnv:   env,
+		Registry:       reg,
+		WorkDir:        config.TestDir,
+		Log:            config.Log,
+		TargetGate:     config.TargetGate,
+		GoBinary:       config.GoBinary,
+		AllowSkips:     config.AllowSkips,
+		OutputTestLogs: config.OutputTestLogs,
+		TestLogLevel:   config.TestLogLevel,
+		NetworkName:    networkName,
+		DevnetEnv:      env,
 	})
 	if err != nil {
 		return nil, fmt.Errorf("failed to create test runner: %w", err)

op-acceptor/runner/logging_test.go

@@ -2,6 +2,8 @@ package runner
 
 import (
 	"context"
+	"os"
+	"path/filepath"
 	"testing"
 
 	"github.com/ethereum-optimism/infra/op-acceptor/types"
@@ -68,3 +70,133 @@ gates:
 	assert.Contains(t, failingTest.Stdout, "This is some stdout output that should be captured")
 	assert.Contains(t, failingTest.Stdout, "This is a second line of output")
 }
+
+// TestLogLevelEnvironment verifies that the TEST_LOG_LEVEL environment variable is correctly set and used
+func TestLogLevelEnvironment(t *testing.T) {
+	ctx := context.Background()
+
+	// Create a simple test file in the work directory
+	testContent := []byte(`
+package main
+
+import (
+	"os"
+	"testing"
+)
+
+func TestLogLevelEnvironment(t *testing.T) {
+    // Get log level from environment
+    logLevel := os.Getenv("TEST_LOG_LEVEL")
+    if logLevel == "" {
+		t.Log("TEST_LOG_LEVEL not set")
+    } else {
+		t.Log("TEST_LOG_LEVEL set to", logLevel)
+	}
+}
+`)
+	configContent := []byte(`
+gates:
+  - id: logging-gate
+    description: "Gate with a test that outputs logs"
+    suites:
+      logging-suite:
+        description: "Suite with a test that outputs logs"
+        tests:
+          - name: TestLogLevelEnvironment
+            package: "./main"
+`)
+
+	r := setupTestRunner(t, testContent, configContent)
+	r.testLogLevel = "debug"
+	err := os.WriteFile(filepath.Join(r.workDir, "main_test.go"), testContent, 0644)
+	require.NoError(t, err)
+
+	result, err := r.RunTest(ctx, types.ValidatorMetadata{
+		ID:       "test1",
+		Gate:     "logging-gate",
+		FuncName: "TestLogLevelEnvironment",
+		Package:  ".",
+	})
+
+	require.NoError(t, err)
+	assert.Equal(t, types.TestStatusPass, result.Status)
+	assert.Equal(t, "test1", result.Metadata.ID)
+	assert.Equal(t, "logging-gate", result.Metadata.Gate)
+	assert.Equal(t, ".", result.Metadata.Package)
+	assert.False(t, result.Metadata.RunAll)
+	assert.Contains(t, result.Stdout, "TEST_LOG_LEVEL set to debug")
+}
+
+// TestOutputTestLogs verifies that test logs are properly captured and output when enabled
+func TestOutputTestLogs(t *testing.T) {
+	// Create a test file that outputs logs at different levels
+	testContent := []byte(`
+package feature_test
+
+import (
+	"testing"
+)
+
+func TestWithLogs(t *testing.T) {
+	t.Log("This is a test output")
+}
+`)
+
+	configContent := []byte(`
+gates:
+  - id: logging-gate
+    description: "Gate with a test that outputs logs"
+    suites:
+      logging-suite:
+        description: "Suite with a test that outputs logs"
+        tests:
+          - name: TestWithLogs
+            package: "./feature"
+`)
+
+	// Setup the test runner with OutputTestLogs enabled
+	r := setupTestRunner(t, testContent, configContent)
+	r.outputTestLogs = true
+
+	// Run the test
+	result, err := r.RunAllTests(context.Background())
+	require.NoError(t, err)
+	assert.Equal(t, types.TestStatusPass, result.Status)
+
+	// Verify the structure
+	require.Contains(t, result.Gates, "logging-gate")
+	gate := result.Gates["logging-gate"]
+	require.Contains(t, gate.Suites, "logging-suite")
+	suite := gate.Suites["logging-suite"]
+
+	// Get the test result
+	var testResult *types.TestResult
+	for _, test := range suite.Tests {
+		testResult = test
+		break
+	}
+	require.NotNil(t, testResult)
+
+	// Verify the test passed and has logs captured
+	assert.Equal(t, types.TestStatusPass, testResult.Status)
+	assert.NotEmpty(t, testResult.Stdout)
+	assert.Contains(t, testResult.Stdout, "This is a test output")
+
+	// Now run with OutputTestLogs disabled
+	r.outputTestLogs = false
+	result, err = r.RunAllTests(context.Background())
+	require.NoError(t, err)
+	assert.Equal(t, types.TestStatusPass, result.Status)
+
+	// Get the test result again
+	var testResult2 *types.TestResult
+	for _, test := range result.Gates["logging-gate"].Suites["logging-suite"].Tests {
+		testResult2 = test
+		break
+	}
+	require.NotNil(t, testResult)
+
+	// Verify that logs are not captured when OutputTestLogs is disabled
+	assert.Equal(t, types.TestStatusPass, testResult2.Status)
+	assert.Contains(t, testResult2.Stdout, "This is a test output")
+}