fix: add new package truncbuffer

Author: claudiogodoy99

go/internal/truncbuffer/truncbuffer.go

@@ -0,0 +1,69 @@
+package truncbuffer
+
+import "sync"
+
+// TruncBuffer is a ring buffer that retains only the last max bytes,
+// discarding older data. This is useful for capturing stderr output in a
+// memory-bounded way when the full output may be arbitrarily large.
+// All methods are safe for concurrent use.
+type TruncBuffer struct {
+	mu   sync.RWMutex
+	buf  []byte
+	head int
+	size int
+	full bool
+}
+
+// NewTruncBuffer creates a TruncBuffer that keeps at most n bytes.
+func NewTruncBuffer(n int) *TruncBuffer {
+	return &TruncBuffer{
+		buf:  make([]byte, n),
+		size: n,
+	}
+}
+
+// Write appends p to the buffer, keeping only the last size bytes.
+// The return value n is the length of p;
+func (t *TruncBuffer) Write(p []byte) (int, error) {
+	t.mu.Lock()
+	defer t.mu.Unlock()
+
+	// If input is larger than the buffer, only keep the tail.
+	if len(p) >= t.size {
+		copy(t.buf, p[len(p)-t.size:])
+		t.head = 0
+		t.full = true
+		return len(p), nil
+	}
+
+	for _, b := range p {
+		t.buf[t.head] = b
+		t.head++
+		if t.head == t.size {
+			t.head = 0
+			t.full = true
+		}
+	}
+
+	return len(p), nil
+}
+
+// Bytes returns a copy of the current buffer contents in order.
+func (t *TruncBuffer) Bytes() []byte {
+	t.mu.RLock()
+	defer t.mu.RUnlock()
+
+	if !t.full {
+		return append([]byte(nil), t.buf[:t.head]...)
+	}
+
+	out := make([]byte, t.size)
+	n := copy(out, t.buf[t.head:])
+	copy(out[n:], t.buf[:t.head])
+	return out
+}
+
+// String returns the buffer contents as a string.
+func (t *TruncBuffer) String() string {
+	return string(t.Bytes())
+}

go/internal/truncbuffer/truncbuffer_test.go

@@ -0,0 +1,68 @@
+package truncbuffer
+
+import (
+	"io"
+	"sync"
+	"testing"
+)
+
+var _ io.Writer = (*TruncBuffer)(nil)
+
+func TestTruncBuffer_SmallWrites(t *testing.T) {
+	tb := NewTruncBuffer(10)
+	tb.Write([]byte("hello"))
+	if got := string(tb.Bytes()); got != "hello" {
+		t.Fatalf("got %q, want %q", got, "hello")
+	}
+}
+
+func TestTruncBuffer_ExactMax(t *testing.T) {
+	tb := NewTruncBuffer(5)
+	tb.Write([]byte("abcde"))
+	if got := string(tb.Bytes()); got != "abcde" {
+		t.Fatalf("got %q, want %q", got, "abcde")
+	}
+}
+
+func TestTruncBuffer_OverflowSingleWrite(t *testing.T) {
+	tb := NewTruncBuffer(5)
+	tb.Write([]byte("abcdefgh"))
+	if got := string(tb.Bytes()); got != "defgh" {
+		t.Fatalf("got %q, want %q", got, "defgh")
+	}
+}
+
+func TestTruncBuffer_OverflowMultipleWrites(t *testing.T) {
+	tb := NewTruncBuffer(6)
+	tb.Write([]byte("abc"))
+	tb.Write([]byte("defgh"))
+	if got := string(tb.Bytes()); got != "cdefgh" {
+		t.Fatalf("got %q, want %q", got, "cdefgh")
+	}
+}
+
+func TestTruncBuffer_ManySmallWrites(t *testing.T) {
+	tb := NewTruncBuffer(4)
+	for _, b := range []byte("abcdefg") {
+		tb.Write([]byte{b})
+	}
+	if got := string(tb.Bytes()); got != "defg" {
+		t.Fatalf("got %q, want %q", got, "defg")
+	}
+}
+
+func TestTruncBuffer_ConcurrentWrites(t *testing.T) {
+	tb := NewTruncBuffer(64)
+	var wg sync.WaitGroup
+	for i := 0; i < 100; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			tb.Write([]byte("abcdefgh"))
+		}()
+	}
+	wg.Wait()
+	if got := len(tb.Bytes()); got > 64 {
+		t.Fatalf("buffer exceeded max: got %d bytes", got)
+	}
+}