You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
111 lines
3.3 KiB
111 lines
3.3 KiB
package eventlog
|
|
|
|
import (
|
|
"time"
|
|
)
|
|
|
|
// checkPrune checks whether the log has exceeded its boundaries of size or
|
|
// age, and if so prunes the log and updates the head.
|
|
func (lg *Log) checkPrune(head *logEntry, size int, age time.Duration) error {
|
|
// To avoid potentially re-pruning for every event, don't trigger an age
|
|
// prune until we're at least this far beyond the designated size.
|
|
const windowSlop = 30 * time.Second
|
|
|
|
if age < (lg.windowSize+windowSlop) && (lg.maxItems <= 0 || size <= lg.maxItems) {
|
|
lg.numItemsGauge.Set(float64(lg.numItems))
|
|
return nil // no pruning is needed
|
|
}
|
|
|
|
var newState logState
|
|
var err error
|
|
|
|
switch {
|
|
case lg.maxItems > 0 && size > lg.maxItems:
|
|
// We exceeded the size cap. In this case, age does not matter: count off
|
|
// the newest items and drop the unconsumed tail. Note that we prune by a
|
|
// fraction rather than an absolute amount so that we only have to prune
|
|
// for size occasionally.
|
|
|
|
// TODO(creachadair): We may want to spill dropped events to secondary
|
|
// storage rather than dropping them. The size cap is meant as a safety
|
|
// valve against unexpected extremes, but if a network has "expected"
|
|
// spikes that nevertheless exceed any safe buffer size (e.g., Osmosis
|
|
// epochs), we may want to have a fallback so that we don't lose events
|
|
// that would otherwise fall within the window.
|
|
newSize := 3 * size / 4
|
|
newState, err = lg.pruneSize(head, newSize)
|
|
|
|
default:
|
|
// We did not exceed the size cap, but some items are too old.
|
|
newState = lg.pruneAge(head)
|
|
}
|
|
|
|
// Note that when we update the head after pruning, we do not need to signal
|
|
// any waiters; pruning never adds new material to the log so anyone waiting
|
|
// should continue doing so until a subsequent Add occurs.
|
|
lg.mu.Lock()
|
|
defer lg.mu.Unlock()
|
|
lg.numItems = newState.size
|
|
lg.numItemsGauge.Set(float64(newState.size))
|
|
lg.oldestCursor = newState.oldest
|
|
lg.head = newState.head
|
|
return err
|
|
}
|
|
|
|
// pruneSize returns a new log state by pruning head to newSize.
|
|
// Precondition: newSize ≤ len(head).
|
|
func (lg *Log) pruneSize(head *logEntry, newSize int) (logState, error) {
|
|
// Special case for size 0 to simplify the logic below.
|
|
if newSize == 0 {
|
|
return logState{}, ErrLogPruned // drop everything
|
|
}
|
|
|
|
// Initialize: New head has the same item as the old head.
|
|
first := &logEntry{item: head.item} // new head
|
|
last := first // new tail (last copied cons)
|
|
|
|
cur := head.next
|
|
for i := 1; i < newSize; i++ {
|
|
cp := &logEntry{item: cur.item}
|
|
last.next = cp
|
|
last = cp
|
|
|
|
cur = cur.next
|
|
}
|
|
var err error
|
|
if head.item.Cursor.Diff(last.item.Cursor) <= lg.windowSize {
|
|
err = ErrLogPruned
|
|
}
|
|
|
|
return logState{
|
|
oldest: last.item.Cursor,
|
|
newest: first.item.Cursor,
|
|
size: newSize,
|
|
head: first,
|
|
}, err
|
|
}
|
|
|
|
// pruneAge returns a new log state by pruning items older than the window
|
|
// prior to the head element.
|
|
func (lg *Log) pruneAge(head *logEntry) logState {
|
|
first := &logEntry{item: head.item}
|
|
last := first
|
|
|
|
size := 1
|
|
for cur := head.next; cur != nil; cur = cur.next {
|
|
diff := head.item.Cursor.Diff(cur.item.Cursor)
|
|
if diff > lg.windowSize {
|
|
break // all remaining items are older than the window
|
|
}
|
|
cp := &logEntry{item: cur.item}
|
|
last.next = cp
|
|
last = cp
|
|
size++
|
|
}
|
|
return logState{
|
|
oldest: last.item.Cursor,
|
|
newest: first.item.Cursor,
|
|
size: size,
|
|
head: first,
|
|
}
|
|
}
|