chore: import upstream snapshot with attribution

pkg/log/io.go

@@ -0,0 +1,61 @@
+package log
+
+import (
+	"io"
+
+	"log/slog"
+)
+
+// IOLogger is a wrapper around io.Reader and io.Writer that can be used
+// to log the data being read and written from the underlying streams
+type IOLogger struct {
+	io.ReadWriteCloser
+
+	reader io.Reader
+	writer io.Writer
+	logger *slog.Logger
+}
+
+// NewIOLogger creates a new IOLogger instance
+func NewIOLogger(r io.Reader, w io.Writer, logger *slog.Logger) *IOLogger {
+	return &IOLogger{
+		reader: r,
+		writer: w,
+		logger: logger,
+	}
+}
+
+// Read reads data from the underlying io.Reader and logs it.
+func (l *IOLogger) Read(p []byte) (n int, err error) {
+	if l.reader == nil {
+		return 0, io.EOF
+	}
+	n, err = l.reader.Read(p)
+	if n > 0 {
+		l.logger.Info("[stdin]: received bytes", "count", n, "data", string(p[:n]))
+	}
+	return n, err
+}
+
+// Write writes data to the underlying io.Writer and logs it.
+func (l *IOLogger) Write(p []byte) (n int, err error) {
+	if l.writer == nil {
+		return 0, io.ErrClosedPipe
+	}
+	l.logger.Info("[stdout]: sending bytes", "count", len(p), "data", string(p))
+	return l.writer.Write(p)
+}
+
+func (l *IOLogger) Close() error {
+	var errReader, errWriter error
+	if closer, ok := l.reader.(io.Closer); ok {
+		errReader = closer.Close()
+	}
+	if closer, ok := l.writer.(io.Closer); ok {
+		errWriter = closer.Close()
+	}
+	if errReader != nil {
+		return errReader
+	}
+	return errWriter
+}

pkg/log/io_test.go

@@ -0,0 +1,65 @@
+package log
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"log/slog"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestLoggedReadWriter(t *testing.T) {
+	t.Run("Read method logs and passes data", func(t *testing.T) {
+		// Setup
+		inputData := "test input data"
+		reader := strings.NewReader(inputData)
+
+		// Create logger with buffer to capture output
+		var logBuffer bytes.Buffer
+		logger := slog.New(slog.NewTextHandler(&logBuffer, &slog.HandlerOptions{ReplaceAttr: removeTimeAttr}))
+
+		lrw := NewIOLogger(reader, nil, logger)
+
+		// Test Read
+		buf := make([]byte, 100)
+		n, err := lrw.Read(buf)
+
+		// Assertions
+		assert.NoError(t, err)
+		assert.Equal(t, len(inputData), n)
+		assert.Equal(t, inputData, string(buf[:n]))
+		assert.Contains(t, logBuffer.String(), "[stdin]")
+		assert.Contains(t, logBuffer.String(), inputData)
+	})
+
+	t.Run("Write method logs and passes data", func(t *testing.T) {
+		// Setup
+		outputData := "test output data"
+		var writeBuffer bytes.Buffer
+
+		// Create logger with buffer to capture output
+		var logBuffer bytes.Buffer
+		logger := slog.New(slog.NewTextHandler(&logBuffer, &slog.HandlerOptions{ReplaceAttr: removeTimeAttr}))
+
+		lrw := NewIOLogger(nil, &writeBuffer, logger)
+
+		// Test Write
+		n, err := lrw.Write([]byte(outputData))
+
+		// Assertions
+		assert.NoError(t, err)
+		assert.Equal(t, len(outputData), n)
+		assert.Equal(t, outputData, writeBuffer.String())
+		assert.Contains(t, logBuffer.String(), "[stdout]")
+		assert.Contains(t, logBuffer.String(), outputData)
+	})
+}
+
+func removeTimeAttr(groups []string, a slog.Attr) slog.Attr {
+	if a.Key == slog.TimeKey && len(groups) == 0 {
+		return slog.Attr{}
+	}
+	return a
+}