slog

package module

Go to main page

Versions in this module

v0

v0.5.5

Feb 5, 2024

Changes in this version

type Logger

+ func (l *Logger) Reused() *Record

+ func (l *Logger) WithExtra(ext M) *Record

+ func (l *Logger) WithValue(key string, value any) *Record

type Record

+ EnableStack bool

+ func WithExtra(ext M) *Record

+ func WithValue(key string, value any) *Record

+ func (r *Record) Release()

+ func (r *Record) Reused() *Record

v0.5.4

Jul 28, 2023

Changes in this version

+ func Close() error

+ func MustClose()

type Logger

+ func (l *Logger) HandlersNum() int

+ func (l *Logger) MustClose()

v0.5.3

Jul 12, 2023

Changes in this version

+ func StopDaemon()

+ type CallerFormatFn func(rf *runtime.Frame) (cs string)

+ type FormatterWrapper struct

+ func (f *FormatterWrapper) Format(record *Record) ([]byte, error)

+ func (f *FormatterWrapper) Formatter() Formatter

+ func (f *FormatterWrapper) SetFormatter(formatter Formatter)

type JSONFormatter

+ CallerFormatFunc CallerFormatFn

+ type LevelFormatting struct

+ func NewLevelsFormatting(levels []Level) *LevelFormatting

+ func NewMaxLevelFormatting(maxLevel Level) *LevelFormatting

+ type LevelHandling struct

+ func (h *LevelHandling) IsHandling(level Level) bool

+ func (h *LevelHandling) SetLimitLevels(levels []Level)

+ func (h *LevelHandling) SetMaxLevel(maxLv Level)

+ type LevelMode uint8

+ const LevelModeList

+ const LevelModeMax

+ func (m LevelMode) String() string

type LevelWithFormatter

+ func (h *LevelWithFormatter) SetMaxLevel(maxLv Level)

type LevelsWithFormatter

+ func (h *LevelsWithFormatter) SetLimitLevels(levels []Level)

type Logger

+ ChannelName string

+ FlushInterval time.Duration

+ func (l *Logger) StopDaemon()

type TextFormatter

+ CallerFormatFunc CallerFormatFn

+ func (f *TextFormatter) Configure(fn func(*TextFormatter)) *TextFormatter

+ func (f *TextFormatter) WithEnableColor(enable bool) *TextFormatter

v0.5.2

Jun 19, 2023

Changes in this version

type Logger

+ BackupArgs bool

type Record

+ Args []any

+ Fmt string

+ func WithContext(ctx context.Context) *Record

+ func WithField(name string, value any) *Record

+ func (r *Record) Field(key string) any

+ func (r *Record) Value(key string) any

type SugaredLogger

+ func NewStd(fns ...SugaredLoggerFn) *SugaredLogger

+ func NewSugared(out io.Writer, level Level, fns ...SugaredLoggerFn) *SugaredLogger

v0.5.1

Apr 15, 2023

Changes in this version

type Processor

+ func AppendCtxKeys(keys ...string) Processor

type Record

+ func (r *Record) WithCtx(ctx context.Context) *Record

v0.5.0

Apr 7, 2023

Changes in this version

+ const CallerFlagPkgFnl

+ type FormattableTrait struct

+ func (f *FormattableTrait) Format(record *Record) ([]byte, error)

+ func (f *FormattableTrait) Formatter() Formatter

+ func (f *FormattableTrait) SetFormatter(formatter Formatter)

type JSONFormatter

+ func AsJSONFormatter(f Formatter) *JSONFormatter

type TextFormatter

+ func AsTextFormatter(f Formatter) *TextFormatter

v0.4.0

Dec 30, 2022

Changes in this version

type Logger

+ func (l *Logger) WithCtx(ctx context.Context) *Record

+ type LoggerFn func(l *Logger)

type Record

+ func (r *Record) SetCtx(ctx context.Context) *Record

+ type SugaredLoggerFn func(sl *SugaredLogger)

v0.3.4

Oct 25, 2022

Changes in this version

+ const CallerFlagFcLine

v0.3.3

Jun 13, 2022

v0.3.2

Jun 8, 2022

Changes in this version

type Logger

+ func (l *Logger) LastErr() error

v0.3.1

May 18, 2022

Changes in this version

+ func FatalErr(err error)

+ func PanicErr(err error)

v0.3.0

May 5, 2022

Changes in this version

+ const CallerFlagFcName

+ const CallerFlagFnLine

+ const CallerFlagFnlFcn

+ const CallerFlagFpLine

+ const CallerFlagFull

+ const CallerFlagFunc

+ const CallerFlagPkg

+ var DefaultClockFn = ClockFn(func() time.Time { ... })

+ var DefaultPanicFn = func(v interface{})

+ var DoNothingOnPanic = func(v interface{})

+ var FieldKeyDate = "date"

+ type ClockFn func() time.Time

+ func (fn ClockFn) Now() time.Time

type Formattable

+ func (f *Formattable) Format(record *Record) ([]byte, error)

type JSONFormatter

+ func (f *JSONFormatter) AddField(name string) *JSONFormatter

type Level

+ func LevelByName(ln string) Level

+ type LevelFormattable interface

+ IsHandling func(level Level) bool

+ type LevelWithFormatter struct

+ Level Level

+ func NewLvFormatter(lv Level) *LevelWithFormatter

+ func (h *LevelWithFormatter) IsHandling(level Level) bool

+ type LevelsWithFormatter struct

+ Levels []Level

+ func NewLvsFormatter(levels []Level) *LevelsWithFormatter

+ func (h *LevelsWithFormatter) IsHandling(level Level) bool

type Logger

+ CallerFlag uint8

+ PanicFunc func(v interface{})

+ TimeClock ClockFn

+ func (l *Logger) Config(fns ...func(l *Logger)) *Logger

+ func (l *Logger) DoNothingOnPanicFatal()

+ func (l *Logger) MustFlush()

+ func (l *Logger) Record() *Record

+ func (l *Logger) WithField(name string, value interface{}) *Record

type Record

+ CallerFlag uint8

+ CallerSkip int

+ func (r *Record) GoString() string

+ func (r *Record) Warn(args ...interface{})

+ func (r *Record) Warnf(format string, args ...interface{})

+ type SLogger interface

+ Log func(level Level, v ...interface{})

+ Logf func(level Level, format string, v ...interface{})

type SugaredLogger

+ func (sl *SugaredLogger) Config(fn func(sl *SugaredLogger)) *SugaredLogger

v0.2.2

Apr 15, 2022

Changes in this version

type Logger

+ CallerSkip int

v0.2.1

Feb 26, 2022

Changes in this version

+ func MustFlush()

v0.2.0

Feb 26, 2022

Changes in this version

+ func EncodeToString(v interface{}) string

type Logger

+ func (l *Logger) Fatalln(args ...interface{})

+ func (l *Logger) Panicln(args ...interface{})

type M

+ func (m M) String() string

type Record

+ func (r *Record) Fatalln(args ...interface{})

+ func (r *Record) Init(lowerLevelName bool)

+ func (r *Record) Panicln(args ...interface{})

+ func (r *Record) Print(args ...interface{})

+ func (r *Record) Printf(format string, args ...interface{})

+ func (r *Record) Println(args ...interface{})

+ func (r *Record) SetExtraValue(k string, v interface{})

type SugaredLogger

+ func NewStdLogger() *SugaredLogger

type TextFormatter

+ func (f *TextFormatter) Fields() []string

v0.1.5

Apr 22, 2021

Changes in this version

+ func ErrorT(err error)

type Logger

+ func (l *Logger) ErrorT(err error)

v0.1.4

Apr 14, 2021

Changes in this version

type Record

+ func (r *Record) MicroSecond() int

v0.1.3

Jan 18, 2021

Changes in this version

+ var DoNothingOnExit = func(code int)

+ func PushHandlers(hs ...Handler)

type Level

+ func (l Level) ShouldHandling(curLevel Level) bool

type Logger

+ func (l *Logger) PushHandlers(hs ...Handler)

v0.1.2

Dec 29, 2020

Changes in this version

+ var DangerLevels = Levels

+ var NormalLevels = Levels

+ func PushHandler(h Handler)

v0.1.1

Dec 29, 2020

Changes in this version

+ func FlushDaemon()

+ func FlushTimeout(timeout time.Duration)

+ type BaseLoggerFace interface

+ Fatal func(v ...interface{})

+ Fatalf func(format string, v ...interface{})

+ Panic func(v ...interface{})

+ Panicf func(format string, v ...interface{})

+ Print func(v ...interface{})

+ Printf func(format string, v ...interface{})

+ type FlushCloseWriter interface

+ Flush func() error

+ type FormatterWriterHandler interface

+ Formatter func() Formatter

+ Writer func() io.Writer

type Logger

+ func (l *Logger) FlushTimeout(timeout time.Duration)

type SugaredLogger

+ func (sl *SugaredLogger) FlushAll() error

v0.1.0

Dec 28, 2020

Changes in this version

+ func Panic(args ...interface{})

+ func Panicf(format string, args ...interface{})

+ func TimeoutFlush(timeout time.Duration)

type Formattable

+ func (f *Formattable) FormatRecord(record *Record) ([]byte, error)

type Logger

+ func (logger *Logger) Flush()

+ func (logger *Logger) NewRecord() *Record

v0.0.8

Dec 24, 2020

Changes in this version

+ const FieldKeyFLine

v0.0.7

Dec 24, 2020

Changes in this version

+ const FieldKeyFcName

+ const FieldKeyPkg

+ const FieldKeySPos

+ func Flush() error

+ type FullLoggerFace interface

+ Log func(level Level, args ...interface{})

+ Logf func(level Level, format string, args ...interface{})

+ Notice func(args ...interface{})

+ Noticef func(format string, args ...interface{})

+ Panic func(args ...interface{})

+ Panicf func(format string, args ...interface{})

+ Trace func(args ...interface{})

+ Tracef func(format string, args ...interface{})

+ type LoggerFace interface

+ Debug func(args ...interface{})

+ Debugf func(format string, args ...interface{})

+ Error func(args ...interface{})

+ Errorf func(format string, args ...interface{})

+ Fatal func(args ...interface{})

+ Fatalf func(format string, args ...interface{})

+ Info func(args ...interface{})

+ Infof func(format string, args ...interface{})

+ Print func(args ...interface{})

+ Printf func(format string, args ...interface{})

+ Warn func(args ...interface{})

+ Warnf func(format string, args ...interface{})

type TextFormatter

+ func (f *TextFormatter) SetTemplate(fmtTpl string)

v0.0.6

Dec 23, 2020

Changes in this version

+ func SetLogLevel(l Level)

type Level

+ func MustLevelByName(ln string) Level

v0.0.5

Dec 23, 2020

Changes in this version

+ type Levels []Level

+ func (ls Levels) Contains(level Level) bool

v0.0.4

Sep 24, 2020

v0.0.3

Sep 15, 2020

Changes in this version

+ var PrintLevel = NoticeLevel

+ func Print(args ...interface{})

+ func Printf(format string, args ...interface{})

+ func Println(args ...interface{})

type Logger

+ func (logger *Logger) Print(args ...interface{})

+ func (logger *Logger) Printf(format string, args ...interface{})

+ func (logger *Logger) Println(args ...interface{})

type Processor

+ func AddUniqueID(fieldName string) Processor

type SugaredLogger

+ Formatter Formatter

v0.0.2

Aug 5, 2020

Changes in this version

+ const NamedTemplate

type TextFormatter

+ Template string

v0.0.1

Aug 5, 2020

Changes in this version

+ const DefaultTemplate

+ const FieldKeyCaller

+ const FieldKeyChannel

+ const FieldKeyData

+ const FieldKeyDatetime

+ const FieldKeyError

+ const FieldKeyExtra

+ const FieldKeyFile

+ const FieldKeyFunc

+ const FieldKeyLevel

+ const FieldKeyMessage

+ const FieldKeyPosition

+ const FieldKeyTime

+ const FieldKeyTimestamp

+ var AllLevels = []Level

+ var ColorTheme = map[Level]color.Color

+ var DefaultChannelName = "application"

+ var DefaultFields = []string

+ var DefaultTimeFormat = "2006/01/02 15:04:05"

+ var ErrorKey = "error"

+ var FieldKeys = struct{ ... }

+ var LevelNames = map[Level]string

+ var NoTimeFields = []string

+ func AddHandler(h Handler)

+ func AddHandlers(hs ...Handler)

+ func AddProcessor(p Processor)

+ func AddProcessors(ps ...Processor)

+ func Configure(fn func(logger *SugaredLogger))

+ func Debug(args ...interface{})

+ func Debugf(format string, args ...interface{})

+ func Error(args ...interface{})

+ func Errorf(format string, args ...interface{})

+ func Exit(code int)

+ func ExitHandlers() []func()

+ func Fatal(args ...interface{})

+ func Fatalf(format string, args ...interface{})

+ func Info(args ...interface{})

+ func Infof(format string, args ...interface{})

+ func LevelName(l Level) string

+ func Notice(args ...interface{})

+ func Noticef(format string, args ...interface{})

+ func PrependExitHandler(handler func())

+ func RegisterExitHandler(handler func())

+ func Reset()

+ func ResetExitHandlers(applyToStd bool)

+ func SetExitFunc(fn func(code int))

+ func SetFormatter(f Formatter)

+ func Trace(args ...interface{})

+ func Tracef(format string, args ...interface{})

+ func Warn(args ...interface{})

+ func Warnf(format string, args ...interface{})

+ type FlushSyncWriter interface

+ Flush func() error

+ Sync func() error

+ type Formattable struct

+ func (f *Formattable) Formatter() Formatter

+ func (f *Formattable) SetFormatter(formatter Formatter)

+ type FormattableHandler interface

+ Formatter func() Formatter

+ SetFormatter func(Formatter)

+ type Formatter interface

+ Format func(record *Record) ([]byte, error)

+ func GetFormatter() Formatter

+ type FormatterFunc func(r *Record) ([]byte, error)

+ func (fn FormatterFunc) Format(r *Record) ([]byte, error)

+ type Handler interface

+ Flush func() error

+ Handle func(*Record) error

+ IsHandling func(level Level) bool

+ type JSONFormatter struct

+ Aliases StringMap

+ Fields []string

+ PrettyPrint bool

+ TimeFormat string

+ func NewJSONFormatter(fn ...func(*JSONFormatter)) *JSONFormatter

+ func (f *JSONFormatter) Configure(fn func(*JSONFormatter)) *JSONFormatter

+ func (f *JSONFormatter) Format(r *Record) ([]byte, error)

+ type Level uint32

+ const DebugLevel

+ const ErrorLevel

+ const FatalLevel

+ const InfoLevel

+ const NoticeLevel

+ const PanicLevel

+ const TraceLevel

+ const WarnLevel

+ func Name2Level(ln string) (Level, error)

+ func (l Level) LowerName() string

+ func (l Level) Name() string

+ func (l Level) String() string

+ type Logger struct

+ ExitFunc func(code int)

+ LowerLevelName bool

+ MaxCallerDepth int

+ ReportCaller bool

+ func New() *Logger

+ func NewWithConfig(fn func(logger *Logger)) *Logger

+ func NewWithHandlers(hs ...Handler) *Logger

+ func NewWithName(name string) *Logger

+ func (logger *Logger) AddHandler(h Handler)

+ func (logger *Logger) AddHandlers(hs ...Handler)

+ func (logger *Logger) AddProcessor(p Processor)

+ func (logger *Logger) AddProcessors(ps ...Processor)

+ func (logger *Logger) Close()

+ func (logger *Logger) Configure(fn func(logger *Logger)) *Logger

+ func (logger *Logger) Debug(args ...interface{})

+ func (logger *Logger) Debugf(format string, args ...interface{})

+ func (logger *Logger) Error(args ...interface{})

+ func (logger *Logger) Errorf(format string, args ...interface{})

+ func (logger *Logger) Exit(code int)

+ func (logger *Logger) ExitHandlers() []func()

+ func (logger *Logger) Fatal(args ...interface{})

+ func (logger *Logger) Fatalf(format string, args ...interface{})

+ func (logger *Logger) FlushAll()

+ func (logger *Logger) FlushDaemon()

+ func (logger *Logger) Info(args ...interface{})

+ func (logger *Logger) Infof(format string, args ...interface{})

+ func (logger *Logger) Log(level Level, args ...interface{})

+ func (logger *Logger) Logf(level Level, format string, args ...interface{})

+ func (logger *Logger) Name() string

+ func (logger *Logger) Notice(args ...interface{})

+ func (logger *Logger) Noticef(format string, args ...interface{})

+ func (logger *Logger) Panic(args ...interface{})

+ func (logger *Logger) Panicf(format string, args ...interface{})

+ func (logger *Logger) PrependExitHandler(handler func())

+ func (logger *Logger) PushHandler(h Handler)

+ func (logger *Logger) PushProcessor(p Processor)

+ func (logger *Logger) RegisterExitHandler(handler func())

+ func (logger *Logger) Reset()

+ func (logger *Logger) ResetExitHandlers()

+ func (logger *Logger) ResetHandlers()

+ func (logger *Logger) ResetProcessors()

+ func (logger *Logger) SetHandlers(hs []Handler)

+ func (logger *Logger) SetName(name string) *Logger

+ func (logger *Logger) SetProcessors(ps []Processor)

+ func (logger *Logger) Sync() error

+ func (logger *Logger) Trace(args ...interface{})

+ func (logger *Logger) Tracef(format string, args ...interface{})

+ func (logger *Logger) VisitAll(fn func(handler Handler) error)

+ func (logger *Logger) Warn(args ...interface{})

+ func (logger *Logger) Warnf(format string, args ...interface{})

+ func (logger *Logger) Warning(args ...interface{})

+ func (logger *Logger) WithContext(ctx context.Context) *Record

+ func (logger *Logger) WithData(data M) *Record

+ func (logger *Logger) WithFields(fields M) *Record

+ func (logger *Logger) WithTime(t time.Time) *Record

+ type M map[string]interface

+ type Processable struct

+ func (p *Processable) AddProcessor(processor Processor)

+ func (p *Processable) ProcessRecord(r *Record)

+ type ProcessableHandler interface

+ AddProcessor func(Processor)

+ ProcessRecord func(record *Record)

+ type Processor interface

+ Process func(record *Record)

+ func AddHostname() Processor

+ type ProcessorFunc func(record *Record)

+ var MemoryUsage ProcessorFunc = func(record *Record) { ... }

+ func (fn ProcessorFunc) Process(record *Record)

+ type Record struct

+ Buffer *bytes.Buffer

+ Caller *runtime.Frame

+ Channel string

+ Ctx context.Context

+ Data M

+ Extra M

+ Fields M

+ Level Level

+ LevelName string

+ Message string

+ Time time.Time

+ func WithData(data M) *Record

+ func WithFields(fields M) *Record

+ func (r *Record) AddData(data M) *Record

+ func (r *Record) AddExtra(data M) *Record

+ func (r *Record) AddField(name string, val interface{}) *Record

+ func (r *Record) AddFields(fields M) *Record

+ func (r *Record) AddValue(key string, value interface{}) *Record

+ func (r *Record) Copy() *Record

+ func (r *Record) Debug(args ...interface{})

+ func (r *Record) Debugf(format string, args ...interface{})

+ func (r *Record) Error(args ...interface{})

+ func (r *Record) Errorf(format string, args ...interface{})

+ func (r *Record) Fatal(args ...interface{})

+ func (r *Record) Fatalf(format string, args ...interface{})

+ func (r *Record) Info(args ...interface{})

+ func (r *Record) Infof(format string, args ...interface{})

+ func (r *Record) Log(level Level, args ...interface{})

+ func (r *Record) Logf(level Level, format string, args ...interface{})

+ func (r *Record) NewBuffer() *bytes.Buffer

+ func (r *Record) Notice(args ...interface{})

+ func (r *Record) Noticef(format string, args ...interface{})

+ func (r *Record) Panic(args ...interface{})

+ func (r *Record) Panicf(format string, args ...interface{})

+ func (r *Record) SetContext(ctx context.Context) *Record

+ func (r *Record) SetData(data M) *Record

+ func (r *Record) SetExtra(data M) *Record

+ func (r *Record) SetFields(fields M) *Record

+ func (r *Record) SetTime(t time.Time) *Record

+ func (r *Record) Trace(args ...interface{})

+ func (r *Record) Tracef(format string, args ...interface{})

+ func (r *Record) WithContext(ctx context.Context) *Record

+ func (r *Record) WithData(data M) *Record

+ func (r *Record) WithError(err error) *Record

+ func (r *Record) WithField(name string, val interface{}) *Record

+ func (r *Record) WithFields(fields M) *Record

+ func (r *Record) WithTime(t time.Time) *Record

+ type StringMap map[string]string

+ type SugaredLogger struct

+ Level Level

+ Output io.Writer

+ func NewJSONSugared(out io.Writer, level Level) *SugaredLogger

+ func NewSugaredLogger(output io.Writer, level Level) *SugaredLogger

+ func Std() *SugaredLogger

+ func (sl *SugaredLogger) Close() error

+ func (sl *SugaredLogger) Configure(fn func(sl *SugaredLogger)) *SugaredLogger

+ func (sl *SugaredLogger) Flush() error

+ func (sl *SugaredLogger) Handle(record *Record) error

+ func (sl *SugaredLogger) IsHandling(level Level) bool

+ func (sl *SugaredLogger) Reset()

+ type SyncWriter interface

+ Sync func() error

+ type TextFormatter struct

+ ColorTheme map[Level]color.Color

+ EnableColor bool

+ EncodeFunc func(v interface{}) string

+ FullDisplay bool

+ TimeFormat string

+ func NewTextFormatter(template ...string) *TextFormatter

+ func (f *TextFormatter) FieldMap() StringMap

+ func (f *TextFormatter) Format(r *Record) ([]byte, error)

+ type WriterHandler interface

+ Writer func() io.Writer

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL