package logger import ( "fmt" "git.frostfs.info/TrueCloudLab/zapjournald" "github.com/ssgreg/journald" "go.uber.org/zap" "go.uber.org/zap/zapcore" ) // Logger represents a component // for writing messages to log. type Logger struct { z *zap.Logger lvl zap.AtomicLevel } // Prm groups Logger's parameters. // Successful passing non-nil parameters to the NewLogger (if returned // error is nil) connects the parameters with the returned Logger. // Parameters that have been connected to the Logger support its // configuration changing. // // Passing Prm after a successful connection via the NewLogger, connects // the Prm to a new instance of the Logger. // // See also Reload, SetLevelString. type Prm struct { // link to the created Logger // instance; used for a runtime // reconfiguration _log *Logger // support runtime rereading level zapcore.Level // SamplingHook hook for the zap.Logger SamplingHook func(e zapcore.Entry, sd zapcore.SamplingDecision) // do not support runtime rereading dest string // PrependTimestamp specifies whether to prepend a timestamp in the log PrependTimestamp bool } const ( DestinationUndefined = "" DestinationStdout = "stdout" DestinationJournald = "journald" ) // SetLevelString sets the minimum logging level. Default is // "info". // // Returns an error if s is not a string representation of a // supporting logging level. // // Supports runtime rereading. func (p *Prm) SetLevelString(s string) error { return p.level.UnmarshalText([]byte(s)) } func (p *Prm) SetDestination(d string) error { if d != DestinationStdout && d != DestinationJournald { return fmt.Errorf("invalid logger destination %s", d) } if p != nil { p.dest = d } return nil } // Reload reloads configuration of a connected instance of the Logger. // Returns ErrLoggerNotConnected if no connection has been performed. // Returns any reconfiguration error from the Logger directly. func (p Prm) Reload() error { if p._log == nil { // incorrect logger usage panic("parameters are not connected to any Logger") } return p._log.reload(p) } func defaultPrm() *Prm { return new(Prm) } // NewLogger constructs a new zap logger instance. Constructing with nil // parameters is safe: default values will be used then. // Passing non-nil parameters after a successful creation (non-error) allows // runtime reconfiguration. // // Logger is built from production logging configuration with: // - parameterized level; // - console encoding; // - ISO8601 time encoding. // // Logger records a stack trace for all messages at or above fatal level. func NewLogger(prm *Prm) (*Logger, error) { if prm == nil { prm = defaultPrm() } switch prm.dest { case DestinationUndefined, DestinationStdout: return newConsoleLogger(prm) case DestinationJournald: return newJournaldLogger(prm) default: return nil, fmt.Errorf("unknown destination %s", prm.dest) } } func newConsoleLogger(prm *Prm) (*Logger, error) { lvl := zap.NewAtomicLevelAt(prm.level) c := zap.NewProductionConfig() c.Level = lvl c.Encoding = "console" if prm.SamplingHook != nil { c.Sampling.Hook = prm.SamplingHook } if prm.PrependTimestamp { c.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder } else { c.EncoderConfig.TimeKey = "" } lZap, err := c.Build( zap.AddStacktrace(zap.NewAtomicLevelAt(zap.FatalLevel)), ) if err != nil { return nil, err } l := &Logger{z: lZap, lvl: lvl} prm._log = l return l, nil } func newJournaldLogger(prm *Prm) (*Logger, error) { lvl := zap.NewAtomicLevelAt(prm.level) c := zap.NewProductionConfig() c.Level = lvl c.Encoding = "console" if prm.SamplingHook != nil { c.Sampling.Hook = prm.SamplingHook } if prm.PrependTimestamp { c.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder } else { c.EncoderConfig.TimeKey = "" } encoder := zapjournald.NewPartialEncoder(zapcore.NewConsoleEncoder(c.EncoderConfig), zapjournald.SyslogFields) core := zapjournald.NewCore(lvl, encoder, &journald.Journal{}, zapjournald.SyslogFields) coreWithContext := core.With([]zapcore.Field{ zapjournald.SyslogFacility(zapjournald.LogDaemon), zapjournald.SyslogIdentifier(), zapjournald.SyslogPid(), }) lZap := zap.New(coreWithContext, zap.AddStacktrace(zap.NewAtomicLevelAt(zap.FatalLevel))) l := &Logger{z: lZap, lvl: lvl} prm._log = l return l, nil } func (l *Logger) reload(prm Prm) error { l.lvl.SetLevel(prm.level) return nil } func (l *Logger) WithOptions(options ...zap.Option) { l.z = l.z.WithOptions(options...) } func NewLoggerWrapper(z *zap.Logger) *Logger { return &Logger{ z: z, } }