chore: import upstream snapshot with attribution

internal/util/ring/buffer.go

@@ -0,0 +1,139 @@
+// Package ring provides a simple ring buffer for storing local data
+package ring
+
+import (
+	"sync"
+	"time"
+
+	"github.com/google/uuid"
+)
+
+// Buffer is ring buffer.
+type Buffer struct {
+	streams map[string]*Stream
+	vals    []*Entry
+	size    int
+
+	sync.RWMutex
+}
+
+// Entry is ring buffer data entry.
+type Entry struct {
+	Value     interface{}
+	Timestamp time.Time
+}
+
+// Stream is used to stream the buffer.
+type Stream struct {
+	// Buffered entries
+	Entries chan *Entry
+	// Stop channel
+	Stop chan bool
+	// Id of the stream
+	Id string
+}
+
+// Put adds a new value to ring buffer.
+func (b *Buffer) Put(v interface{}) {
+	b.Lock()
+	defer b.Unlock()
+
+	// append to values
+	entry := &Entry{
+		Value:     v,
+		Timestamp: time.Now(),
+	}
+	b.vals = append(b.vals, entry)
+
+	// trim if bigger than size required
+	if len(b.vals) > b.size {
+		b.vals = b.vals[1:]
+	}
+
+	// send to every stream
+	for _, stream := range b.streams {
+		select {
+		case <-stream.Stop:
+			delete(b.streams, stream.Id)
+			close(stream.Entries)
+		case stream.Entries <- entry:
+		}
+	}
+}
+
+// Get returns the last n entries.
+func (b *Buffer) Get(n int) []*Entry {
+	b.RLock()
+	defer b.RUnlock()
+
+	// reset any invalid values
+	if n > len(b.vals) || n < 0 {
+		n = len(b.vals)
+	}
+
+	// create a delta
+	delta := len(b.vals) - n
+
+	// return the delta set
+	return b.vals[delta:]
+}
+
+// Return the entries since a specific time.
+func (b *Buffer) Since(t time.Time) []*Entry {
+	b.RLock()
+	defer b.RUnlock()
+
+	// return all the values
+	if t.IsZero() {
+		return b.vals
+	}
+
+	// if its in the future return nothing
+	if time.Since(t).Seconds() < 0.0 {
+		return nil
+	}
+
+	for i, v := range b.vals {
+		// find the starting point
+		d := v.Timestamp.Sub(t)
+
+		// return the values
+		if d.Seconds() > 0.0 {
+			return b.vals[i:]
+		}
+	}
+
+	return nil
+}
+
+// Stream logs from the buffer
+// Close the channel when you want to stop.
+func (b *Buffer) Stream() (<-chan *Entry, chan bool) {
+	b.Lock()
+	defer b.Unlock()
+
+	entries := make(chan *Entry, 128)
+	id := uuid.New().String()
+	stop := make(chan bool)
+
+	b.streams[id] = &Stream{
+		Id:      id,
+		Entries: entries,
+		Stop:    stop,
+	}
+
+	return entries, stop
+}
+
+// Size returns the size of the ring buffer.
+func (b *Buffer) Size() int {
+	return b.size
+}
+
+// New returns a new buffer of the given size.
+func New(i int) *Buffer {
+	return &Buffer{
+		size:    i,
+		streams: make(map[string]*Stream),
+	}
+}

internal/util/ring/buffer_test.go

@@ -0,0 +1,79 @@
+package ring
+
+import (
+	"testing"
+	"time"
+)
+
+func TestBuffer(t *testing.T) {
+	b := New(10)
+
+	// test one value
+	b.Put("foo")
+	v := b.Get(1)
+
+	if val := v[0].Value.(string); val != "foo" {
+		t.Fatalf("expected foo got %v", val)
+	}
+
+	b = New(10)
+
+	// test 10 values
+	for i := 0; i < 10; i++ {
+		b.Put(i)
+	}
+
+	d := time.Now()
+	v = b.Get(10)
+
+	for i := 0; i < 10; i++ {
+		val := v[i].Value.(int)
+
+		if val != i {
+			t.Fatalf("expected %d got %d", i, val)
+		}
+	}
+
+	// test more values
+
+	for i := 0; i < 10; i++ {
+		v := i * 2
+		b.Put(v)
+	}
+
+	v = b.Get(10)
+
+	for i := 0; i < 10; i++ {
+		val := v[i].Value.(int)
+		expect := i * 2
+		if val != expect {
+			t.Fatalf("expected %d got %d", expect, val)
+		}
+	}
+
+	// sleep 100 ms
+	time.Sleep(time.Millisecond * 100)
+
+	// assume we'll get everything
+	v = b.Since(d)
+
+	if len(v) != 10 {
+		t.Fatalf("expected 10 entries but got %d", len(v))
+	}
+
+	// write 1 more entry
+	d = time.Now()
+	b.Put(100)
+
+	// sleep 100 ms
+	time.Sleep(time.Millisecond * 100)
+
+	v = b.Since(d)
+	if len(v) != 1 {
+		t.Fatalf("expected 1 entries but got %d", len(v))
+	}
+
+	if v[0].Value.(int) != 100 {
+		t.Fatalf("expected value 100 got %v", v[0])
+	}
+}