178 lines
4.4 KiB
Go
178 lines
4.4 KiB
Go
// Package logging builds archied's logger and reads its JSON log files.
|
|
package logging
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"log/slog"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
)
|
|
|
|
// Options configures the logger. The zero value is a stderr-only JSON logger
|
|
// at info level, which is what archied did before file logging existed.
|
|
type Options struct {
|
|
// Feed receives structured live entries in addition to configured sinks.
|
|
Feed *Feed
|
|
// File is the log file path. Empty disables file logging.
|
|
File string
|
|
// MaxSizeMB rotates the file once it exceeds this size. Zero selects
|
|
// DefaultMaxSizeMB.
|
|
MaxSizeMB int
|
|
// Keep is how many rotated files to retain. Zero selects DefaultKeep.
|
|
Keep int
|
|
// Level is "debug", "info", "warn" or "error". Empty selects info.
|
|
Level string
|
|
// Stderr also writes to stderr. Kept on by default so journald and an
|
|
// interactive terminal still see output when a file is configured.
|
|
Stderr bool
|
|
}
|
|
|
|
// Rotation defaults. Sized so a busy daemon keeps roughly a week of history
|
|
// without an unbounded file.
|
|
const (
|
|
DefaultMaxSizeMB = 20
|
|
DefaultKeep = 5
|
|
)
|
|
|
|
// New builds a logger and a closer for its file sink. A file that cannot be
|
|
// opened is reported, not fatal.
|
|
func New(opts Options) (*slog.Logger, io.Closer, error) {
|
|
level := parseLevel(opts.Level)
|
|
handlerOpts := &slog.HandlerOptions{Level: level}
|
|
|
|
if opts.File == "" {
|
|
return slog.New(withFeed(slog.NewJSONHandler(os.Stderr, handlerOpts), opts.Feed)), noopCloser{}, nil
|
|
}
|
|
|
|
w, err := newRotatingFile(opts.File, opts.MaxSizeMB, opts.Keep)
|
|
if err != nil {
|
|
return slog.New(withFeed(slog.NewJSONHandler(os.Stderr, handlerOpts), opts.Feed)), noopCloser{},
|
|
fmt.Errorf("logging: open %s: %w", opts.File, err)
|
|
}
|
|
|
|
var sink io.Writer = w
|
|
if opts.Stderr {
|
|
sink = io.MultiWriter(os.Stderr, w)
|
|
}
|
|
return slog.New(withFeed(slog.NewJSONHandler(sink, handlerOpts), opts.Feed)), w, nil
|
|
}
|
|
|
|
func withFeed(handler slog.Handler, feed *Feed) slog.Handler {
|
|
if feed == nil {
|
|
return WithTrace(handler)
|
|
}
|
|
return WithTrace(NewFeedHandler(handler, feed))
|
|
}
|
|
|
|
func parseLevel(s string) slog.Level {
|
|
switch strings.ToLower(strings.TrimSpace(s)) {
|
|
case "debug":
|
|
return slog.LevelDebug
|
|
case "warn", "warning":
|
|
return slog.LevelWarn
|
|
case "error":
|
|
return slog.LevelError
|
|
default:
|
|
return slog.LevelInfo
|
|
}
|
|
}
|
|
|
|
// rotatingFile is a size-rotating io.WriteCloser.
|
|
type rotatingFile struct {
|
|
path string
|
|
maxSize int64
|
|
keep int
|
|
|
|
mu sync.Mutex
|
|
f *os.File
|
|
size int64
|
|
}
|
|
|
|
func newRotatingFile(path string, maxSizeMB, keep int) (*rotatingFile, error) {
|
|
if maxSizeMB <= 0 {
|
|
maxSizeMB = DefaultMaxSizeMB
|
|
}
|
|
if keep <= 0 {
|
|
keep = DefaultKeep
|
|
}
|
|
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
|
|
return nil, err
|
|
}
|
|
r := &rotatingFile{
|
|
path: path,
|
|
maxSize: int64(maxSizeMB) * 1024 * 1024,
|
|
keep: keep,
|
|
}
|
|
if err := r.open(); err != nil {
|
|
return nil, err
|
|
}
|
|
return r, nil
|
|
}
|
|
|
|
// openFile is os.OpenFile by default; tests override it to inject a
|
|
// deterministic reopen failure without needing filesystem-permission
|
|
// tricks that a failed rename would also trip.
|
|
var openFile = os.OpenFile
|
|
|
|
func (r *rotatingFile) open() error {
|
|
f, err := openFile(r.path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o640)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
info, err := f.Stat()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
r.f, r.size = f, info.Size()
|
|
return nil
|
|
}
|
|
|
|
func (r *rotatingFile) Write(p []byte) (int, error) {
|
|
r.mu.Lock()
|
|
defer r.mu.Unlock()
|
|
|
|
if r.size+int64(len(p)) > r.maxSize {
|
|
// A failed rotation must not lose the line: fall through and keep
|
|
// writing to the current file rather than dropping it.
|
|
_ = r.rotate()
|
|
}
|
|
n, err := r.f.Write(p)
|
|
r.size += int64(n)
|
|
return n, err
|
|
}
|
|
|
|
// rotate shifts path to path.1, dropping generations past keep, and opens a
|
|
// new file. The old descriptor stays usable until the new one opens.
|
|
func (r *rotatingFile) rotate() error {
|
|
// Oldest first, so each rename lands on a free slot.
|
|
_ = os.Remove(fmt.Sprintf("%s.%d", r.path, r.keep))
|
|
for i := r.keep - 1; i >= 1; i-- {
|
|
_ = os.Rename(fmt.Sprintf("%s.%d", r.path, i), fmt.Sprintf("%s.%d", r.path, i+1))
|
|
}
|
|
if err := os.Rename(r.path, r.path+".1"); err != nil {
|
|
return err
|
|
}
|
|
old := r.f
|
|
if err := r.open(); err != nil {
|
|
r.f = old
|
|
return err
|
|
}
|
|
return old.Close()
|
|
}
|
|
|
|
func (r *rotatingFile) Close() error {
|
|
r.mu.Lock()
|
|
defer r.mu.Unlock()
|
|
if r.f == nil {
|
|
return nil
|
|
}
|
|
return r.f.Close()
|
|
}
|
|
|
|
type noopCloser struct{}
|
|
|
|
func (noopCloser) Close() error { return nil }
|