Benson Wong
fd3c28ffc5
- inference handles to store an activity record for all inference endpoints - add path, status code, and content type to Activities page - toggle on/off columns no Activities page - add configurable capture level for inference endpoints so large binary blobs are not stored in memory - store captures in compressed binary format
103 lines
1.7 KiB
Go
103 lines
1.7 KiB
Go
package cache
|
|
|
|
import (
|
|
"errors"
|
|
"sync"
|
|
)
|
|
|
|
var (
|
|
ErrExceedsMaxSize = errors.New("item exceeds maximum cache size")
|
|
ErrNotFound = errors.New("item not found")
|
|
)
|
|
|
|
type Cache struct {
|
|
mu sync.Mutex
|
|
items map[int][]byte
|
|
order []int
|
|
size int
|
|
maxSize int
|
|
}
|
|
|
|
func New(maxBytes int) *Cache {
|
|
return &Cache{
|
|
items: make(map[int][]byte),
|
|
order: make([]int, 0),
|
|
maxSize: maxBytes,
|
|
}
|
|
}
|
|
|
|
func (c *Cache) Add(id int, data []byte) error {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
|
|
dataSize := len(data)
|
|
if dataSize > c.maxSize {
|
|
return ErrExceedsMaxSize
|
|
}
|
|
|
|
// If key already exists, remove old entry from size and order
|
|
if old, exists := c.items[id]; exists {
|
|
c.size -= len(old)
|
|
c.removeOrder(id)
|
|
}
|
|
|
|
// Evict oldest (FIFO) until room available
|
|
for c.size+dataSize > c.maxSize && len(c.order) > 0 {
|
|
oldestID := c.order[0]
|
|
c.order = c.order[1:]
|
|
if evicted, exists := c.items[oldestID]; exists {
|
|
c.size -= len(evicted)
|
|
delete(c.items, oldestID)
|
|
}
|
|
}
|
|
|
|
c.items[id] = data
|
|
c.order = append(c.order, id)
|
|
c.size += dataSize
|
|
return nil
|
|
}
|
|
|
|
func (c *Cache) removeOrder(id int) {
|
|
for i, v := range c.order {
|
|
if v == id {
|
|
c.order = append(c.order[:i], c.order[i+1:]...)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
func (c *Cache) Get(id int) ([]byte, error) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
|
|
data, exists := c.items[id]
|
|
if !exists {
|
|
return nil, ErrNotFound
|
|
}
|
|
return data, nil
|
|
}
|
|
|
|
func (c *Cache) Has(id int) bool {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
|
|
_, exists := c.items[id]
|
|
return exists
|
|
}
|
|
|
|
func (c *Cache) Size() int {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
|
|
return c.size
|
|
}
|
|
|
|
func (c *Cache) Clear() {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
|
|
c.items = make(map[int][]byte)
|
|
c.order = c.order[:0]
|
|
c.size = 0
|
|
}
|