fix(printer): properly close output files to prevent data loss

The Close() methods for jsonEventPrinter, templateEventPrinter, and
tableEventPrinter were empty stubs that never closed the underlying
io.WriteCloser. This caused intermittent test failures when OS write
buffers weren't flushed before process termination, resulting in lost
events in the output files.

Now all printer types properly close their output files, ensuring
buffers are flushed and all events are written to disk.

Author: yanivagman

pkg/cmd/printer/printer.go

@@ -349,6 +349,11 @@ func (p tableEventPrinter) Epilogue(stats metrics.Stats) {
 }
 
 func (p tableEventPrinter) Close() {
+	if p.out != nil {
+		if err := p.out.Close(); err != nil {
+			logger.Errorw("Error closing table output file", "error", err)
+		}
+	}
 }
 
 type templateEventPrinter struct {
@@ -389,6 +394,11 @@ func (p templateEventPrinter) Print(event trace.Event) {
 func (p templateEventPrinter) Epilogue(stats metrics.Stats) {}
 
 func (p templateEventPrinter) Close() {
+	if p.out != nil {
+		if err := p.out.Close(); err != nil {
+			logger.Errorw("Error closing template output file", "error", err)
+		}
+	}
 }
 
 type jsonEventPrinter struct {
@@ -410,6 +420,11 @@ func (p jsonEventPrinter) Print(event trace.Event) {
 func (p jsonEventPrinter) Epilogue(stats metrics.Stats) {}
 
 func (p jsonEventPrinter) Close() {
+	if p.out != nil {
+		if err := p.out.Close(); err != nil {
+			logger.Errorw("Error closing JSON output file", "error", err)
+		}
+	}
 }
 
 // ignoreEventPrinter ignores events

pkg/cmd/printer/printer_test.go

@@ -135,3 +135,128 @@ func TestTemplateEventPrinterSprigFunctions(t *testing.T) {
 	// Should contain timestamp
 	assert.Contains(t, output, `1234567890`, "timestamp should be included")
 }
+
+// TestPrinterCloseFlusheData tests that Close() properly flushes and closes output files
+func TestPrinterCloseFlushesData(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name        string
+		printerKind string
+	}{
+		{
+			name:        "json printer",
+			printerKind: "json",
+		},
+		{
+			name:        "table printer",
+			printerKind: "table",
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			// Create a temporary file
+			tempDir := t.TempDir()
+			outputPath := filepath.Join(tempDir, "test_output.txt")
+
+			// Create the output file
+			file, err := flags.CreateOutputFile(outputPath)
+			require.NoError(t, err)
+
+			// Create printer config
+			cfg := config.PrinterConfig{
+				Kind:    tc.printerKind,
+				OutFile: file,
+			}
+
+			// Create and initialize the printer
+			p, err := printer.New(cfg)
+			require.NoError(t, err)
+
+			// Create a sample event
+			sampleEvent := trace.Event{
+				ProcessName: "test_process",
+				EventID:     1,
+				EventName:   "test_event",
+				Timestamp:   1234567890,
+				Args: []trace.Argument{
+					{ArgMeta: trace.ArgMeta{Name: "arg1", Type: "string"}, Value: "value1"},
+				},
+			}
+
+			// Print an event
+			p.Preamble()
+			p.Print(sampleEvent)
+			p.Close()
+
+			// Read the file content
+			content, err := os.ReadFile(outputPath)
+			require.NoError(t, err, "Should be able to read file after Close()")
+
+			// Verify data was written and flushed
+			assert.NotEmpty(t, content, "File should contain data after Close()")
+			assert.Contains(t, string(content), "test_process", "File should contain event data")
+
+			// Verify file is actually closed by trying to write to it
+			// This should fail because Close() should have closed the file
+			_, err = file.Write([]byte("test"))
+			assert.Error(t, err, "Writing to file after Close() should fail")
+		})
+	}
+}
+
+// TestTemplateEventPrinterCloseFlushesData tests template printer Close() behavior
+func TestTemplateEventPrinterCloseFlushesData(t *testing.T) {
+	t.Parallel()
+
+	// Create a temporary template file
+	templateContent := `{"event": "{{ .EventName }}", "process": "{{ .ProcessName }}"}`
+	tempDir := t.TempDir()
+	templatePath := filepath.Join(tempDir, "test.tmpl")
+	outputPath := filepath.Join(tempDir, "test_output.txt")
+
+	err := os.WriteFile(templatePath, []byte(templateContent), 0644)
+	require.NoError(t, err)
+
+	// Create the output file
+	file, err := flags.CreateOutputFile(outputPath)
+	require.NoError(t, err)
+
+	// Create printer config
+	cfg := config.PrinterConfig{
+		Kind:    "gotemplate=" + templatePath,
+		OutFile: file,
+	}
+
+	// Create and initialize the printer
+	p, err := printer.New(cfg)
+	require.NoError(t, err)
+
+	// Create a sample event
+	sampleEvent := trace.Event{
+		ProcessName: "test_process",
+		EventName:   "test_event",
+	}
+
+	// Print an event
+	p.Preamble()
+	p.Print(sampleEvent)
+	p.Close()
+
+	// Read the file content
+	content, err := os.ReadFile(outputPath)
+	require.NoError(t, err, "Should be able to read file after Close()")
+
+	// Verify data was written and flushed
+	assert.NotEmpty(t, content, "File should contain data after Close()")
+	assert.Contains(t, string(content), "test_process", "File should contain event data")
+	assert.Contains(t, string(content), "test_event", "File should contain event name")
+
+	// Verify file is actually closed
+	_, err = file.Write([]byte("test"))
+	assert.Error(t, err, "Writing to file after Close() should fail")
+}