feat(logging): add weekly log rotation and retention
This commit is contained in:
@@ -0,0 +1,319 @@
|
||||
package logging
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"io/fs"
|
||||
"log/slog"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
_ "time/tzdata"
|
||||
)
|
||||
|
||||
const weeklyLogRetention = 13
|
||||
|
||||
type logRotationTimer interface {
|
||||
C() <-chan time.Time
|
||||
Stop() bool
|
||||
}
|
||||
|
||||
type realLogRotationTimer struct {
|
||||
*time.Timer
|
||||
}
|
||||
|
||||
func (t realLogRotationTimer) C() <-chan time.Time {
|
||||
return t.Timer.C
|
||||
}
|
||||
|
||||
type weeklyLogRuntime struct {
|
||||
now func() time.Time
|
||||
newTimer func(time.Duration) logRotationTimer
|
||||
rename func(string, string) error
|
||||
diagnostic io.Writer
|
||||
}
|
||||
|
||||
func defaultWeeklyLogRuntime() weeklyLogRuntime {
|
||||
return weeklyLogRuntime{
|
||||
now: time.Now,
|
||||
newTimer: func(duration time.Duration) logRotationTimer {
|
||||
return realLogRotationTimer{Timer: time.NewTimer(duration)}
|
||||
},
|
||||
rename: os.Rename,
|
||||
diagnostic: os.Stderr,
|
||||
}
|
||||
}
|
||||
|
||||
type weeklyLogWriter struct {
|
||||
path string
|
||||
location *time.Location
|
||||
now func() time.Time
|
||||
newTimer func(time.Duration) logRotationTimer
|
||||
rename func(string, string) error
|
||||
diagnostic io.Writer
|
||||
|
||||
mu sync.Mutex
|
||||
file *os.File
|
||||
weekStart time.Time
|
||||
closed bool
|
||||
stop chan struct{}
|
||||
done chan struct{}
|
||||
closeOnce sync.Once
|
||||
closeErr error
|
||||
}
|
||||
|
||||
func newWeeklyLogWriter(path string, location *time.Location, runtime weeklyLogRuntime) (*weeklyLogWriter, error) {
|
||||
if location == nil {
|
||||
location = time.Local
|
||||
}
|
||||
if runtime.now == nil {
|
||||
runtime.now = time.Now
|
||||
}
|
||||
if runtime.newTimer == nil {
|
||||
runtime.newTimer = defaultWeeklyLogRuntime().newTimer
|
||||
}
|
||||
if runtime.rename == nil {
|
||||
runtime.rename = os.Rename
|
||||
}
|
||||
if runtime.diagnostic == nil {
|
||||
runtime.diagnostic = os.Stderr
|
||||
}
|
||||
|
||||
now := runtime.now().In(location)
|
||||
weekStart := logWeekStart(now, location)
|
||||
if info, err := os.Stat(path); err == nil {
|
||||
weekStart = logWeekStart(info.ModTime(), location)
|
||||
} else if !errors.Is(err, os.ErrNotExist) {
|
||||
return nil, fmt.Errorf("inspect active log: %w", err)
|
||||
}
|
||||
|
||||
file, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o666)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
writer := &weeklyLogWriter{
|
||||
path: path,
|
||||
location: location,
|
||||
now: runtime.now,
|
||||
newTimer: runtime.newTimer,
|
||||
rename: runtime.rename,
|
||||
diagnostic: runtime.diagnostic,
|
||||
file: file,
|
||||
weekStart: weekStart,
|
||||
stop: make(chan struct{}),
|
||||
done: make(chan struct{}),
|
||||
}
|
||||
writer.rotateIfNeeded(now)
|
||||
go writer.run()
|
||||
return writer, nil
|
||||
}
|
||||
|
||||
func (w *weeklyLogWriter) Write(data []byte) (int, error) {
|
||||
now := w.now().In(w.location)
|
||||
w.mu.Lock()
|
||||
rotationErr := w.rotateIfNeededLocked(now)
|
||||
if w.closed || w.file == nil {
|
||||
w.mu.Unlock()
|
||||
w.reportRotationError(rotationErr)
|
||||
return 0, os.ErrClosed
|
||||
}
|
||||
n, writeErr := w.file.Write(data)
|
||||
w.mu.Unlock()
|
||||
w.reportRotationError(rotationErr)
|
||||
return n, writeErr
|
||||
}
|
||||
|
||||
func (w *weeklyLogWriter) Close() error {
|
||||
w.closeOnce.Do(func() {
|
||||
close(w.stop)
|
||||
<-w.done
|
||||
|
||||
w.mu.Lock()
|
||||
w.closed = true
|
||||
if w.file != nil {
|
||||
w.closeErr = w.file.Close()
|
||||
w.file = nil
|
||||
}
|
||||
w.mu.Unlock()
|
||||
})
|
||||
return w.closeErr
|
||||
}
|
||||
|
||||
func (w *weeklyLogWriter) run() {
|
||||
defer close(w.done)
|
||||
for {
|
||||
now := w.now().In(w.location)
|
||||
next := nextLogWeekStart(now, w.location)
|
||||
duration := next.Sub(now)
|
||||
if duration <= 0 {
|
||||
duration = time.Nanosecond
|
||||
}
|
||||
timer := w.newTimer(duration)
|
||||
select {
|
||||
case <-timer.C():
|
||||
w.rotateIfNeeded(w.now().In(w.location))
|
||||
case <-w.stop:
|
||||
timer.Stop()
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (w *weeklyLogWriter) rotateIfNeeded(now time.Time) {
|
||||
w.mu.Lock()
|
||||
err := w.rotateIfNeededLocked(now)
|
||||
w.mu.Unlock()
|
||||
w.reportRotationError(err)
|
||||
}
|
||||
|
||||
func (w *weeklyLogWriter) rotateIfNeededLocked(now time.Time) error {
|
||||
if w.closed {
|
||||
return nil
|
||||
}
|
||||
targetWeek := logWeekStart(now, w.location)
|
||||
if !targetWeek.After(w.weekStart) {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Record the attempted week even if rotation fails so every write in a
|
||||
// broken environment does not retry and emit another diagnostic.
|
||||
w.weekStart = targetWeek
|
||||
return w.rotateLocked()
|
||||
}
|
||||
|
||||
func (w *weeklyLogWriter) rotateLocked() error {
|
||||
if w.file == nil {
|
||||
return fmt.Errorf("active log file is unavailable")
|
||||
}
|
||||
if err := w.file.Close(); err != nil {
|
||||
w.file = nil
|
||||
return errors.Join(fmt.Errorf("close active log: %w", err), w.reopenActiveLocked())
|
||||
}
|
||||
w.file = nil
|
||||
|
||||
if err := w.cleanupOlderGenerationsLocked(); err != nil {
|
||||
return errors.Join(err, w.reopenActiveLocked())
|
||||
}
|
||||
if err := removeIfExists(w.generationPath(weeklyLogRetention)); err != nil {
|
||||
return errors.Join(fmt.Errorf("remove oldest weekly log: %w", err), w.reopenActiveLocked())
|
||||
}
|
||||
for generation := weeklyLogRetention - 1; generation >= 1; generation-- {
|
||||
source := w.generationPath(generation)
|
||||
if _, err := os.Stat(source); err != nil {
|
||||
if errors.Is(err, os.ErrNotExist) {
|
||||
continue
|
||||
}
|
||||
return errors.Join(fmt.Errorf("inspect weekly log generation %d: %w", generation, err), w.reopenActiveLocked())
|
||||
}
|
||||
if err := w.rename(source, w.generationPath(generation+1)); err != nil {
|
||||
return errors.Join(fmt.Errorf("shift weekly log generation %d: %w", generation, err), w.reopenActiveLocked())
|
||||
}
|
||||
}
|
||||
|
||||
activeRenamed := false
|
||||
if _, err := os.Stat(w.path); err == nil {
|
||||
if err := w.rename(w.path, w.generationPath(1)); err != nil {
|
||||
return errors.Join(fmt.Errorf("archive active log: %w", err), w.reopenActiveLocked())
|
||||
}
|
||||
activeRenamed = true
|
||||
} else if !errors.Is(err, os.ErrNotExist) {
|
||||
return errors.Join(fmt.Errorf("inspect active log: %w", err), w.reopenActiveLocked())
|
||||
}
|
||||
|
||||
file, err := os.OpenFile(w.path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o666)
|
||||
if err == nil {
|
||||
w.file = file
|
||||
return nil
|
||||
}
|
||||
|
||||
rotationErr := fmt.Errorf("open new active log: %w", err)
|
||||
if activeRenamed {
|
||||
if rollbackErr := w.rename(w.generationPath(1), w.path); rollbackErr != nil {
|
||||
rotationErr = errors.Join(rotationErr, fmt.Errorf("restore archived active log: %w", rollbackErr))
|
||||
}
|
||||
}
|
||||
return errors.Join(rotationErr, w.reopenActiveLocked())
|
||||
}
|
||||
|
||||
func (w *weeklyLogWriter) cleanupOlderGenerationsLocked() error {
|
||||
directory := filepath.Dir(w.path)
|
||||
entries, err := os.ReadDir(directory)
|
||||
if err != nil {
|
||||
return fmt.Errorf("list weekly log directory: %w", err)
|
||||
}
|
||||
base := filepath.Base(w.path)
|
||||
extension := filepath.Ext(base)
|
||||
stem := strings.TrimSuffix(base, extension)
|
||||
prefix := stem + "."
|
||||
|
||||
for _, entry := range entries {
|
||||
if entry.IsDir() {
|
||||
continue
|
||||
}
|
||||
name := entry.Name()
|
||||
if !strings.HasPrefix(name, prefix) || !strings.HasSuffix(name, extension) {
|
||||
continue
|
||||
}
|
||||
generationText := strings.TrimSuffix(strings.TrimPrefix(name, prefix), extension)
|
||||
generation, err := strconv.Atoi(generationText)
|
||||
if err != nil || generation <= weeklyLogRetention {
|
||||
continue
|
||||
}
|
||||
if err := os.Remove(filepath.Join(directory, name)); err != nil && !errors.Is(err, os.ErrNotExist) {
|
||||
return fmt.Errorf("remove weekly log generation %d: %w", generation, err)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (w *weeklyLogWriter) reopenActiveLocked() error {
|
||||
file, err := os.OpenFile(w.path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o666)
|
||||
if err != nil {
|
||||
return fmt.Errorf("reopen active log: %w", err)
|
||||
}
|
||||
w.file = file
|
||||
return nil
|
||||
}
|
||||
|
||||
func (w *weeklyLogWriter) generationPath(generation int) string {
|
||||
extension := filepath.Ext(w.path)
|
||||
stem := strings.TrimSuffix(w.path, extension)
|
||||
return fmt.Sprintf("%s.%d%s", stem, generation, extension)
|
||||
}
|
||||
|
||||
func (w *weeklyLogWriter) reportRotationError(err error) {
|
||||
if err == nil {
|
||||
return
|
||||
}
|
||||
slog.New(slog.NewJSONHandler(w.diagnostic, nil)).Warn(
|
||||
"weekly log rotation failed",
|
||||
"module", "logging",
|
||||
"action", "weekly_log_rotation_failed",
|
||||
"path", w.path,
|
||||
"error.message", err.Error(),
|
||||
)
|
||||
}
|
||||
|
||||
func logWeekStart(value time.Time, location *time.Location) time.Time {
|
||||
local := value.In(location)
|
||||
daysSinceMonday := (int(local.Weekday()) + 6) % 7
|
||||
monday := local.AddDate(0, 0, -daysSinceMonday)
|
||||
return time.Date(monday.Year(), monday.Month(), monday.Day(), 0, 0, 0, 0, location)
|
||||
}
|
||||
|
||||
func nextLogWeekStart(value time.Time, location *time.Location) time.Time {
|
||||
return logWeekStart(value, location).AddDate(0, 0, 7)
|
||||
}
|
||||
|
||||
func removeIfExists(path string) error {
|
||||
err := os.Remove(path)
|
||||
if errors.Is(err, fs.ErrNotExist) {
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
}
|
||||
Reference in New Issue
Block a user