feat: [CI-17888]: Command logging for Harness Docker Runner (#54)

* 466fdd Remove unnecessary imports from run.go

* f8d922 Added Unit tests and updated command logging implementation

* 0df289 Format runtime files for command logging implementation

Author: Gargi-thakur01

pipeline/runtime/common.go

@@ -213,6 +213,40 @@ func IsFeatureFlagEnabled(featureFlagName string, engine *engine.Engine, step *s
 	return ok && val == trueValue
 }
 
+// printCommand logs the command being executed to the output
+func printCommand(step *spec.Step, output io.Writer) {
+
+	if step == nil {
+		return
+	}
+
+	var actualCommand string
+
+	if len(step.Command) > 0 {
+		actualCommand = step.Command[0]
+	} else if len(step.Entrypoint) > 2 && step.Entrypoint[0] == "sh" && step.Entrypoint[1] == "-c" {
+		actualCommand = step.Entrypoint[2]
+	} else if len(step.Entrypoint) > 0 {
+		actualCommand = strings.Join(step.Entrypoint, " ")
+	}
+
+	if actualCommand != "" {
+
+		boldYellow := "\033[1;33m" // ANSI bold yellow
+		reset := "\033[0m"         // ANSI reset
+
+		header := fmt.Sprintf("%sExecuting the following command(s):%s\n", boldYellow, reset)
+		output.Write([]byte(header))
+
+		lines := strings.Split(actualCommand, "\n")
+		for _, line := range lines {
+			// Format each line with bold yellow and reset
+			formattedLine := fmt.Sprintf("%s%s%s\n", boldYellow, line, reset)
+			output.Write([]byte(formattedLine))
+		}
+	}
+}
+
 // checkStepSuccess checks if the step was successful based on the return values
 func checkStepSuccess(state *runtime.State, err error) bool {
 	if err == nil && state != nil && state.ExitCode == 0 && state.Exited {

pipeline/runtime/common_test.go

@@ -1,12 +1,161 @@
 package runtime
 
 import (
+	"bytes"
 	"os"
+	"regexp"
 	"testing"
 
+	"github.com/harness/harness-docker-runner/engine/spec"
+	"github.com/harness/harness-docker-runner/logstream"
 	"github.com/stretchr/testify/assert"
 )
 
+// Helper function to strip ANSI color codes
+func stripAnsiCodes(s string) string {
+	ansi := regexp.MustCompile("\033\\[[0-9;]*m")
+	return ansi.ReplaceAllString(s, "")
+}
+
+// testWriter implements the logstream.Writer interface for testing
+type testWriter struct {
+	buf *bytes.Buffer
+}
+
+func (w *testWriter) Write(p []byte) (n int, err error) {
+	return w.buf.Write(p)
+}
+
+func (w *testWriter) Open() error {
+	return nil
+}
+
+func (w *testWriter) Close() error {
+	return nil
+}
+
+func (w *testWriter) Start() {
+
+}
+
+func (w *testWriter) Error() error {
+	return nil
+}
+
+func TestPrintCommand(t *testing.T) {
+	tests := []struct {
+		name           string
+		step           *spec.Step
+		expectedOutput []string
+	}{
+		{
+			name: "command from Command field",
+			step: &spec.Step{
+				Name:    "test-step",
+				Command: []string{"echo 'hello world'"},
+			},
+			expectedOutput: []string{
+				"Executing the following command(s):",
+				"echo 'hello world'",
+			},
+		},
+		{
+			name: "command from sh -c entrypoint",
+			step: &spec.Step{
+				Name:       "test-step",
+				Entrypoint: []string{"sh", "-c", "echo 'hello'; echo 'world'"},
+			},
+			expectedOutput: []string{
+				"Executing the following command(s):",
+				"echo 'hello'; echo 'world'",
+			},
+		},
+		{
+			name: "command from regular entrypoint",
+			step: &spec.Step{
+				Name:       "test-step",
+				Entrypoint: []string{"node", "script.js", "--verbose"},
+			},
+			expectedOutput: []string{
+				"Executing the following command(s):",
+				"node script.js --verbose",
+			},
+		},
+		{
+			name: "multi-line command",
+			step: &spec.Step{
+				Name:    "test-step",
+				Command: []string{"echo 'Line 1'\necho 'Line 2'\necho 'Line 3'"},
+			},
+			expectedOutput: []string{
+				"Executing the following command(s):",
+				"echo 'Line 1'",
+				"echo 'Line 2'",
+				"echo 'Line 3'",
+			},
+		},
+		{
+			name:           "nil step",
+			step:           nil,
+			expectedOutput: []string{},
+		},
+		{
+			name: "empty command and entrypoint",
+			step: &spec.Step{
+				Name:       "test-step",
+				Command:    []string{},
+				Entrypoint: []string{},
+			},
+			expectedOutput: []string{},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			buf := new(bytes.Buffer)
+			printCommand(tc.step, buf)
+
+			output := buf.String()
+
+			// Strip ANSI color codes for easier comparison
+			output = stripAnsiCodes(output)
+
+			for _, expected := range tc.expectedOutput {
+				assert.Contains(t, output, expected, "Expected output to contain %q", expected)
+			}
+
+			if len(tc.expectedOutput) == 0 {
+				assert.Empty(t, output, "Expected no output for %s", tc.name)
+			}
+		})
+	}
+}
+
+func TestPrintCommandWithSecrets(t *testing.T) {
+	// Setup step with secret in command
+	step := &spec.Step{
+		Name:    "secret-step",
+		Command: []string{"curl -H 'Authorization: Bearer abcdeedcba' https://api.example.com"},
+	}
+
+	rawBuf := new(bytes.Buffer)
+	secrets := []string{"abcdeedcba"}
+	replacerWriter := logstream.NewReplacer(
+		&testWriter{buf: rawBuf},
+		secrets,
+	)
+
+	printCommand(step, replacerWriter)
+
+	output := stripAnsiCodes(rawBuf.String())
+
+	assert.Contains(t, output, "Executing the following command(s):")
+
+	assert.Contains(t, output, "curl -H 'Authorization: Bearer **************' https://api.example.com")
+
+	assert.NotContains(t, output, "abcdeedcba")
+}
+
 func TestFetchExportedVars(t *testing.T) {
 	tests := []struct {
 		Name       string

pipeline/runtime/run.go

@@ -63,7 +63,10 @@ func executeRunStep(ctx context.Context, engine *engine.Engine, r *api.StartStep
 	log := logrus.New()
 	log.Out = out
 
-	logrus.WithField("step_id", r.ID).WithField("stage_id", r.StageRuntimeID).Traceln("starting step run")
+	logrus.WithField("step_id", r.ID).WithField("stage_id", r.StageRuntimeID).Infoln("starting step run")
+
+	// Log the command being executed
+	printCommand(step, out)
 
 	artifactFile := fmt.Sprintf("%s/%s-artifact", pipeline.SharedVolPath, step.ID)
 	step.Envs["PLUGIN_ARTIFACT_FILE"] = artifactFile

pipeline/runtime/runtest.go

@@ -65,6 +65,9 @@ func executeRunTestStep(ctx context.Context, engine *engine.Engine, r *api.Start
 	artifactFile := fmt.Sprintf("%s/%s-artifact", pipeline.SharedVolPath, step.ID)
 	step.Envs["PLUGIN_ARTIFACT_FILE"] = artifactFile
 
+	// Log the command being executed
+	printCommand(step, out)
+
 	exited, err := engine.Run(ctx, step, out)
 	timeTakenMs := time.Since(start).Milliseconds()
 	if _, rerr := report.ParseAndUploadTests(ctx, r.TestReport, r.WorkingDir, step.Name, log, time.Now(), tiConfig, &telemetry.TestIntelligenceMetaData, r.Envs); rerr != nil {

pipeline/runtime/runtestsV2.go

@@ -80,6 +80,9 @@ func executeRunTestsV2Step(ctx context.Context, engine *engine.Engine, r *api.St
 	artifactFile := fmt.Sprintf("%s/%s-artifact", pipeline.SharedVolPath, step.ID)
 	step.Envs["PLUGIN_ARTIFACT_FILE"] = artifactFile
 
+	// Log the command being executed
+	printCommand(step, out)
+
 	exited, err := engine.Run(ctx, step, out)
 	timeTakenMs := time.Since(start).Milliseconds()
 	logrus.WithField("step_id", r.ID).WithField("stage_id", r.StageRuntimeID).Traceln("completed step runtestv2")