logger

Jul 19, 2024

Changes in this version

+ const FieldRestricted

+ func FormatAnnotations(tf TextFormatter, keyColor ansi.Color, annotations Annotations) string

+ func GetLabel(ctx context.Context, key string) (string, bool)

+ func GetRestricted(ctx context.Context) bool

+ func WithRestricted(ctx context.Context, restricted bool) context.Context

type ErrorEvent

+ Restricted bool

type ErrorEventOption

+ func OptErrorEventRestricted(restricted bool) ErrorEventOption

+ type LinesWriter struct

+ func NewLinesWriter(w io.Writer) *LinesWriter

+ func (lw *LinesWriter) Write(p []byte) (int, error)

type MessageEvent

+ Restricted bool

type MessageEventOption

+ func OptMessageRestricted(restricted bool) MessageEventOption

type Scope

+ Restricted bool

type ScopeOption

+ func OptScopeRestriction(restricted bool) ScopeOption

type TextOutputFormatter

+ func (tf TextOutputFormatter) FormatAnnotations(annotations Annotations) string

Jan 29, 2022

Changes in this version

+ func WithPathAppend(ctx context.Context, path ...string) context.Context

Sep 17, 2021

Changes in this version

+ type Drainer interface

+ Drain func()

Jul 27, 2021

Changes in this version

+ type NopCloserWriter struct

+ func (ncw NopCloserWriter) Close() error

Apr 2, 2021

Changes in this version

type Listener

+ func NewScopedErrorEventListener(listener func(context.Context, ErrorEvent), scopes *Scopes) Listener

Feb 21, 2021

Changes in this version

+ type ApplyContexter interface

+ ApplyContext func(context.Context) context.Context

Feb 16, 2021

Changes in this version

+ const ScopeAll

+ var DefaultScopes = []string

+ var DefaultWritableScopes = []string

type Config

+ Scopes []string

+ WritableScopes []string

+ func (c Config) ScopesOrDefault() []string

+ func (c Config) WritableScopesOrDefault() []string

type Logger

+ Scopes *Scopes

+ WritableScopes *Scopes

type Option

+ func OptAllScopes() Option

+ func OptAllWritableScopes() Option

+ func OptDisabledScopes(scopes ...string) Option

+ func OptDisabledWritableScopes(scopes ...string) Option

+ func OptEnabledScopes(scopes ...string) Option

+ func OptEnabledWritableScopes(scopes ...string) Option

+ func OptNoneScopes() Option

+ func OptNoneWritableScopes() Option

+ func OptScopes(scopes *Scopes) Option

+ func OptWritableScopes(scopes *Scopes) Option

+ type Scopes struct

+ func NewScopes(scopes ...string) *Scopes

+ func ScopesAll() *Scopes

+ func ScopesNone() *Scopes

+ func (s *Scopes) All() bool

+ func (s *Scopes) Disable(scopes ...string)

+ func (s *Scopes) Enable(scopes ...string)

+ func (s *Scopes) None() bool

+ func (s *Scopes) SetAll()

+ func (s *Scopes) SetNone()

+ func (s Scopes) IsEnabled(scopePath ...string) bool

+ func (s Scopes) Scopes() []string

+ func (s Scopes) String() string

Feb 15, 2021

Changes in this version

+ func WithSetLabels(ctx context.Context, labels Labels) context.Context

Jan 3, 2021

Changes in this version

+ func MaybeDrainContext(ctx context.Context, log interface{})

+ type Flagged interface

+ GetFlags func() *Flags

+ GetWritable func() *Flags

type Logger

+ func (l *Logger) GetFlags() *Flags

+ func (l *Logger) GetWritable() *Flags

Dec 4, 2020

Changes in this version

+ const DefaultJSONPretty

+ const DefaultShimWriterMessageFlag

+ const DefaultWorkerQueueDepth

+ const EnvVarFlags

+ const EnvVarHideTime

+ const EnvVarNoColor

+ const FieldAnnotations

+ const FieldElapsed

+ const FieldFlag

+ const FieldLabels

+ const FieldScopePath

+ const FieldText

+ const FieldTimestamp

+ const FormatJSON

+ const FormatText

+ const Newline

+ const Space

+ var DefaultFlagsWritable = []string

+ func BackgroundErrors(log ErrorReceiver, errors <-chan error)

+ func FlagTextColor(flag string) ansi.Color

+ func FormatLabels(tf TextFormatter, keyColor ansi.Color, labels Labels) string

+ func GetEventTimestamp(ctx context.Context, e Event) time.Time

+ func GetPath(ctx context.Context) []string

+ func GetTimestamp(ctx context.Context) time.Time

+ func GetTriggerTimestamp(ctx context.Context) time.Time

+ func IsLoggerSet(log interface{}) bool

+ func IsSkipTrigger(ctx context.Context) bool

+ func IsSkipWrite(ctx context.Context) bool

+ func MaybeDebug(log DebugReceiver, args ...interface{})

+ func MaybeDebugContext(ctx context.Context, log DebugReceiver, args ...interface{})

+ func MaybeDebugfContext(ctx context.Context, log DebugfReceiver, format string, args ...interface{})

+ func MaybeErrorContext(ctx context.Context, log ErrorReceiver, err error)

+ func MaybeErrorfContext(ctx context.Context, log ErrorfReceiver, format string, args ...interface{})

+ func MaybeFatalContext(ctx context.Context, log FatalReceiver, err error)

+ func MaybeFatalExit(log FatalCloser, err error)

+ func MaybeFatalfContext(ctx context.Context, log FatalfReceiver, format string, args ...interface{})

+ func MaybeInfo(log InfoReceiver, args ...interface{})

+ func MaybeInfoContext(ctx context.Context, log InfoReceiver, args ...interface{})

+ func MaybeInfofContext(ctx context.Context, log InfofReceiver, format string, args ...interface{})

+ func MaybeTrigger(ctx context.Context, log Triggerable, e Event)

+ func MaybeTriggerContext(ctx context.Context, log Triggerable, e Event)

+ func MaybeWarningContext(ctx context.Context, log WarningReceiver, err error)

+ func MaybeWarningfContext(ctx context.Context, log WarningfReceiver, format string, args ...interface{})

+ func ShimWriterErrorEventProvider(flag string, opts ...ErrorEventOption) func([]byte) Event

+ func ShimWriterMessageEventProvider(flag string, opts ...MessageEventOption) func([]byte) Event

+ func StdlibShim(handler Triggerable, opts ...ShimWriterOption) *log.Logger

+ func WithAnnotation(ctx context.Context, key, value string) context.Context

+ func WithAnnotations(ctx context.Context, annotations Annotations) context.Context

+ func WithLabel(ctx context.Context, key, value string) context.Context

+ func WithLabels(ctx context.Context, labels Labels) context.Context

+ func WithLogger(ctx context.Context, log Log) context.Context

+ func WithPath(ctx context.Context, path ...string) context.Context

+ func WithSkipTrigger(ctx context.Context, skipTrigger bool) context.Context

+ func WithSkipWrite(ctx context.Context, skipWrite bool) context.Context

+ func WithTimestamp(ctx context.Context, ts time.Time) context.Context

+ func WithTriggerTimestamp(ctx context.Context, ts time.Time) context.Context

type Annotations

+ func CombineAnnotations(annotations ...Annotations) Annotations

+ func GetAnnotations(ctx context.Context) Annotations

type AuditEvent

+ func (e AuditEvent) Decompose() map[string]interface{}

+ func (e AuditEvent) GetFlag() string

+ type AuditEventOption func(*AuditEvent)

+ func OptAuditContext(value string) AuditEventOption

+ func OptAuditExtra(values map[string]string) AuditEventOption

+ func OptAuditNoun(value string) AuditEventOption

+ func OptAuditPrincipal(value string) AuditEventOption

+ func OptAuditProperty(value string) AuditEventOption

+ func OptAuditRemoteAddress(value string) AuditEventOption

+ func OptAuditSubject(value string) AuditEventOption

+ func OptAuditUserAgent(value string) AuditEventOption

+ func OptAuditVerb(value string) AuditEventOption

+ type Closer interface

+ Close func()

type Config

+ Format string

+ Writable []string

+ func (c *Config) Resolve(ctx context.Context) error

+ func (c Config) FlagsOrDefault() []string

+ func (c Config) FormatOrDefault() string

+ func (c Config) Formatter() WriteFormatter

+ func (c Config) WritableOrDefault() []string

+ type DebugReceiver interface

+ Debug func(...interface{})

+ DebugContext func(context.Context, ...interface{})

+ type DebugfReceiver interface

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

+ DebugfContext func(context.Context, string, ...interface{})

type ErrorEvent

+ Flag string

+ func (ee ErrorEvent) Decompose() map[string]interface{}

+ func (ee ErrorEvent) GetFlag() string

+ type ErrorEventOption = func(*ErrorEvent)

+ func OptErrorEventState(state interface{}) ErrorEventOption

type ErrorReceiver

+ ErrorContext func(context.Context, error, ...ErrorEventOption)

+ type Errorable interface

+ type ErrorfReceiver interface

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

+ ErrorfContext func(context.Context, string, ...interface{})

type Event

+ GetFlag func() string

+ type EventContext struct

+ ContextPath []string

+ type EventWithContext struct

+ type FatalCloser interface

+ type FatalReceiver interface

+ Fatal func(error, ...ErrorEventOption)

+ FatalContext func(context.Context, error, ...ErrorEventOption)

+ type FatalfReceiver interface

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

+ FatalfContext func(context.Context, string, ...interface{})

+ type Filter func(context.Context, Event) (e Event, filter bool)

+ func NewAuditEventFilter(filter func(context.Context, AuditEvent) (AuditEvent, bool)) Filter

+ func NewErrorEventFilter(filter func(context.Context, ErrorEvent) (ErrorEvent, bool)) Filter

+ func NewMessageEventFilter(filter func(context.Context, MessageEvent) (MessageEvent, bool)) Filter

+ type FilterListenable interface

+ type Filterable interface

+ Filter func(flag string, label string, filter Filter)

+ type Flags struct

+ func FlagsAll() *Flags

+ func FlagsNone() *Flags

+ func NewFlags(flags ...string) *Flags

+ func (efs *Flags) All() bool

+ func (efs *Flags) Disable(flags ...string)

+ func (efs *Flags) Enable(flags ...string)

+ func (efs *Flags) None() bool

+ func (efs *Flags) SetAll()

+ func (efs *Flags) SetNone()

+ func (efs Flags) Flags() []string

+ func (efs Flags) IsEnabled(flag string) bool

+ func (efs Flags) MergeWith(other *Flags)

+ func (efs Flags) String() string

+ type FullLog interface

+ type InfoReceiver interface

+ Info func(...interface{})

+ InfoContext func(context.Context, ...interface{})

+ type InfofReceiver interface

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

+ InfofContext func(context.Context, string, ...interface{})

type InterlockedWriter

+ Output io.Writer

+ type JSONConfig struct

+ Pretty bool

+ PrettyIndent string

+ PrettyPrefix string

+ func (jc JSONConfig) PrettyIndentOrDefault() string

+ func (jc JSONConfig) PrettyPrefixOrDefault() string

+ type JSONOutputFormatter struct

+ BufferPool *bufferutil.Pool

+ Pretty bool

+ PrettyIndent string

+ PrettyPrefix string

+ func NewJSONOutputFormatter(options ...JSONOutputFormatterOption) *JSONOutputFormatter

+ func (jw JSONOutputFormatter) CombineFields(fields ...map[string]interface{}) map[string]interface{}

+ func (jw JSONOutputFormatter) GetScopeFields(ctx context.Context, e Event) map[string]interface{}

+ func (jw JSONOutputFormatter) PrettyIndentOrDefault() string

+ func (jw JSONOutputFormatter) PrettyPrefixOrDefault() string

+ func (jw JSONOutputFormatter) WriteFormat(ctx context.Context, output io.Writer, e Event) error

+ type JSONOutputFormatterOption func(*JSONOutputFormatter)

+ func OptJSONConfig(cfg JSONConfig) JSONOutputFormatterOption

+ func OptJSONPretty() JSONOutputFormatterOption

+ func OptJSONPrettyIndent(prettyIndent string) JSONOutputFormatterOption

+ func OptJSONPrettyPrefix(prettyPrefix string) JSONOutputFormatterOption

type JSONWritable

+ Decompose func() map[string]interface{}

type Labels

+ func CombineLabels(labels ...Labels) Labels

+ func GetLabels(ctx context.Context) Labels

+ type Log interface

+ func GetLogger(ctx context.Context) Log

type Logger

+ Errors chan error

+ Filters map[string]map[string]Filter

+ Formatter WriteFormatter

+ Listeners map[string]map[string]*Worker

+ Output io.Writer

+ RecoverPanics bool

+ Writable *Flags

+ func Memory(buffer io.Writer, options ...Option) *Logger

+ func MustNew(options ...Option) *Logger

+ func Prod(options ...Option) *Logger

+ func (l *Logger) Dispatch(ctx context.Context, e Event)

+ func (l *Logger) DrainContext(ctx context.Context)

+ func (l *Logger) Filter(flag, filterName string, filter Filter)

+ func (l *Logger) HasFilter(flag, filterName string) bool

+ func (l *Logger) HasFilters(flag string) bool

+ func (l *Logger) RemoveFilter(flag, filterName string)

+ func (l *Logger) RemoveFilters(flag string)

type MessageEvent

+ Elapsed time.Duration

+ Flag string

+ Text string

+ func NewMessageEvent(flag, text string, options ...MessageEventOption) MessageEvent

+ func (e MessageEvent) Decompose() map[string]interface{}

+ func (e MessageEvent) GetFlag() string

+ type MessageEventOption func(*MessageEvent)

+ func OptMessageElapsed(elapsed time.Duration) MessageEventOption

+ func OptMessageFlag(flag string) MessageEventOption

+ func OptMessageText(text string) MessageEventOption

+ type Option func(*Logger) error

+ func OptAll() Option

+ func OptAllWritable() Option

+ func OptConfig(cfg Config) Option

+ func OptConfigFromEnv() Option

+ func OptDisabled(flags ...string) Option

+ func OptDisabledWritable(flags ...string) Option

+ func OptEnabled(flags ...string) Option

+ func OptEnabledWritable(flags ...string) Option

+ func OptFlags(flags *Flags) Option

+ func OptFormatter(formatter WriteFormatter) Option

+ func OptJSON(opts ...JSONOutputFormatterOption) Option

+ func OptLabels(labels ...Labels) Option

+ func OptNone() Option

+ func OptNoneWritable() Option

+ func OptOutput(output io.Writer) Option

+ func OptPath(path ...string) Option

+ func OptText(opts ...TextOutputFormatterOption) Option

+ func OptWritable(flags *Flags) Option

+ type PrintReceiver interface

+ Print func(...interface{})

+ type PrintfReceiver interface

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

+ type PrintlnReceiver interface

+ Println func(...interface{})

+ type Scope struct

+ Logger *Logger

+ Path []string

+ func NewScope(log *Logger, options ...ScopeOption) Scope

+ func (sc Scope) ApplyContext(ctx context.Context) context.Context

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

+ func (sc Scope) DebugContext(ctx context.Context, args ...interface{})

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

+ func (sc Scope) DebugfContext(ctx context.Context, format string, args ...interface{})

+ func (sc Scope) Error(err error, opts ...ErrorEventOption)

+ func (sc Scope) ErrorContext(ctx context.Context, err error, opts ...ErrorEventOption)

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

+ func (sc Scope) ErrorfContext(ctx context.Context, format string, args ...interface{})

+ func (sc Scope) Fatal(err error, opts ...ErrorEventOption)

+ func (sc Scope) FatalContext(ctx context.Context, err error, opts ...ErrorEventOption)

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

+ func (sc Scope) FatalfContext(ctx context.Context, format string, args ...interface{})

+ func (sc Scope) FromContext(ctx context.Context) Scope

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

+ func (sc Scope) InfoContext(ctx context.Context, args ...interface{})

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

+ func (sc Scope) InfofContext(ctx context.Context, format string, args ...interface{})

+ func (sc Scope) Trigger(event Event)

+ func (sc Scope) TriggerContext(ctx context.Context, event Event)

+ func (sc Scope) Warning(err error, opts ...ErrorEventOption)

+ func (sc Scope) WarningContext(ctx context.Context, err error, opts ...ErrorEventOption)

+ func (sc Scope) Warningf(format string, args ...interface{})

+ func (sc Scope) WarningfContext(ctx context.Context, format string, args ...interface{})

+ func (sc Scope) WithAnnotations(annotations Annotations) Scope

+ func (sc Scope) WithLabels(labels Labels) Scope

+ func (sc Scope) WithPath(paths ...string) Scope

+ type ScopeOption func(*Scope)

+ func OptScopeAnnotations(annotations ...Annotations) ScopeOption

+ func OptScopeLabels(labels ...Labels) ScopeOption

+ func OptScopePath(path ...string) ScopeOption

+ type Scoper interface

+ ApplyContext func(context.Context) context.Context

+ FromContext func(context.Context) Scope

+ WithAnnotations func(Annotations) Scope

+ WithLabels func(Labels) Scope

+ WithPath func(...string) Scope

+ type ShimWriter struct

+ Context context.Context

+ EventProvider func([]byte) Event

+ Log Triggerable

+ func NewShimWriter(log Triggerable, opts ...ShimWriterOption) ShimWriter

+ func (sw ShimWriter) Write(contents []byte) (count int, err error)

+ type ShimWriterOption func(*ShimWriter)

+ func OptShimWriterContext(ctx context.Context) ShimWriterOption

+ func OptShimWriterEventProvider(provider func([]byte) Event) ShimWriterOption

+ type TextConfig struct

+ HideFields bool

+ HideTimestamp bool

+ NoColor bool

+ TimeFormat string

+ func (twc TextConfig) TimeFormatOrDefault() string

+ type TextOutputFormatter struct

+ BufferPool *bufferutil.Pool

+ HideFields bool

+ HideTimestamp bool

+ NoColor bool

+ TimeFormat string

+ func NewTextOutputFormatter(options ...TextOutputFormatterOption) *TextOutputFormatter

+ func (tf TextOutputFormatter) Colorize(value string, color ansi.Color) string

+ func (tf TextOutputFormatter) FormatFlag(flag string, color ansi.Color) string

+ func (tf TextOutputFormatter) FormatLabels(labels Labels) string

+ func (tf TextOutputFormatter) FormatPath(path ...string) string

+ func (tf TextOutputFormatter) FormatTimestamp(ts time.Time) string

+ func (tf TextOutputFormatter) TimeFormatOrDefault() string

+ func (tf TextOutputFormatter) WriteFormat(ctx context.Context, output io.Writer, e Event) error

+ type TextOutputFormatterOption func(*TextOutputFormatter)

+ func OptTextConfig(cfg TextConfig) TextOutputFormatterOption

+ func OptTextHideFields() TextOutputFormatterOption

+ func OptTextHideTimestamp() TextOutputFormatterOption

+ func OptTextNoColor() TextOutputFormatterOption

+ func OptTextTimeFormat(format string) TextOutputFormatterOption

+ type TimestampProvider interface

+ GetTimestamp func() time.Time

type Triggerable

+ TriggerContext func(context.Context, Event)

+ type WarningReceiver interface

+ Warning func(error, ...ErrorEventOption)

+ WarningContext func(context.Context, error, ...ErrorEventOption)

+ type WarningfReceiver interface

+ Warningf func(string, ...interface{})

+ WarningfContext func(context.Context, string, ...interface{})

type Worker

+ Errors chan error

+ func (w *Worker) AbortContext(ctx context.Context) error

+ func (w *Worker) DispatchWork()

+ func (w *Worker) Stop() error

+ func (w *Worker) StopContext(ctx context.Context) error

+ type Writable interface

+ Write func(context.Context, Event)

+ type WriteFormatter interface

+ WriteFormat func(context.Context, io.Writer, Event) error

+ type WriteTriggerable interface

Dec 5, 2018

Changes in this version

+ func MaybeDebugf(log *Logger, format string, args ...interface{})

+ func MaybeError(log *Logger, err error)

+ func MaybeErrorf(log *Logger, format string, args ...interface{})

+ func MaybeFatal(log *Logger, err error)

+ func MaybeFatalf(log *Logger, format string, args ...interface{})

+ func MaybeInfof(log *Logger, format string, args ...interface{})

+ func MaybeSyncDebugf(log *Logger, format string, args ...interface{})

+ func MaybeSyncError(log *Logger, err error)

+ func MaybeSyncErrorf(log *Logger, format string, args ...interface{})

+ func MaybeSyncFatal(log *Logger, err error)

+ func MaybeSyncFatalf(log *Logger, format string, args ...interface{})

+ func MaybeSyncInfof(log *Logger, format string, args ...interface{})

+ func MaybeSyncWarning(log *Logger, err error)

+ func MaybeSyncWarningf(log *Logger, format string, args ...interface{})

+ func MaybeWarning(log *Logger, err error)

+ func MaybeWarningf(log *Logger, format string, args ...interface{})

Oct 31, 2018

Changes in this version

+ func CompressWhitespace(text string) (output string)

Oct 17, 2018

Changes in this version

type AuditEvent

+ func (e *AuditEvent) Context() string

+ func (e *AuditEvent) WithContext(context string) *AuditEvent

Oct 5, 2018

Changes in this version

+ const ColorBlack

+ const ColorBlue

+ const ColorCyan

+ const ColorGray

+ const ColorGreen

+ const ColorLightBlack

+ const ColorLightBlue

+ const ColorLightCyan

+ const ColorLightGreen

+ const ColorLightPurple

+ const ColorLightRed

+ const ColorLightWhite

+ const ColorLightYellow

+ const ColorPurple

+ const ColorRed

+ const ColorReset

+ const ColorWhite

+ const ColorYellow

+ const DefaultBufferPoolSize

+ const DefaultJSONIncludeTimestamp

+ const DefaultJSONWriterPretty

+ const DefaultListenerName

+ const DefaultListenerQueueDepth

+ const DefaultRecoverPanics

+ const DefaultTextTimeFormat

+ const DefaultTextWriterShowHeadings

+ const DefaultTextWriterShowTimestamp

+ const DefaultTextWriterUseColor

+ const DefaultWriteQueueDepth

+ const EnvVarEventFlags

+ const EnvVarFormat

+ const EnvVarHeading

+ const EnvVarHiddenEventFlags

+ const EnvVarJSONPretty

+ const EnvVarShowHeadings

+ const EnvVarShowTime

+ const EnvVarTimeFormat

+ const EnvVarUseColor

+ const Gigabyte

+ const JSONFieldElapsed

+ const JSONFieldErr

+ const JSONFieldEventHeadings

+ const JSONFieldFlag

+ const JSONFieldMessage

+ const JSONFieldTimestamp

+ const Kilobyte

+ const LoggerStarted

+ const LoggerStopped

+ const LoggerStopping

+ const Megabyte

+ const NanosecondsPerSecond

+ const RuneNewline

+ const RuneSpace

+ var DefaultFlagSet = NewFlagSet(DefaultFlags)

+ var DefaultFlagTextColor = ColorLightWhite

+ var DefaultFlagTextColors = map[Flag]AnsiColor

+ var DefaultFlags = []Flag

+ var DefaultHiddenFlags []Flag

+ var DefaultListenerWorkers = runtime.NumCPU()

+ func AsStrings(values ...Flag) (output []string)

+ func ColorizeByStatusCode(statusCode int, value string) string

+ func ColorizeStatusCode(statusCode int) string

+ func FatalExit(err error)

+ func FormatFileSize(sizeBytes int) string

+ func MeanOfDuration(input []time.Duration) time.Duration

+ func Microseconds(d time.Duration) float64

+ func Milliseconds(d time.Duration) float64

+ func NewInterlockedWriter(output io.Writer) io.Writer

+ func Seconds(d time.Duration) float64

+ func SumOfDuration(values []time.Duration) time.Duration

+ func TextWriteHTTPRequest(tf TextFormatter, buf *bytes.Buffer, req *http.Request)

+ func TextWriteHTTPResponse(tf TextFormatter, buf *bytes.Buffer, req *http.Request, ...)

+ func UnixNano(t time.Time) (int64, int64)

+ type Annotations = map[string]string

+ type AnsiColor string

+ func GetFlagTextColor(flag Flag) AnsiColor

+ func (acc AnsiColor) Apply(text string) string

+ type Any = interface

+ type AsyncLogger interface

+ type AuditEvent struct

+ func NewAuditEvent(principal, verb string) *AuditEvent

+ func (e *AuditEvent) WithAnnotation(key, value string) *AuditEvent

+ func (e *AuditEvent) WithExtra(extra map[string]string) *AuditEvent

+ func (e *AuditEvent) WithFlag(f Flag) *AuditEvent

+ func (e *AuditEvent) WithHeadings(headings ...string) *AuditEvent

+ func (e *AuditEvent) WithLabel(key, value string) *AuditEvent

+ func (e *AuditEvent) WithNoun(noun string) *AuditEvent

+ func (e *AuditEvent) WithPrincipal(principal string) *AuditEvent

+ func (e *AuditEvent) WithProperty(property string) *AuditEvent

+ func (e *AuditEvent) WithRemoteAddress(remoteAddr string) *AuditEvent

+ func (e *AuditEvent) WithSubject(subject string) *AuditEvent

+ func (e *AuditEvent) WithTimestamp(ts time.Time) *AuditEvent

+ func (e *AuditEvent) WithUserAgent(userAgent string) *AuditEvent

+ func (e *AuditEvent) WithVerb(verb string) *AuditEvent

+ func (e AuditEvent) Extra() map[string]string

+ func (e AuditEvent) Noun() string

+ func (e AuditEvent) Principal() string

+ func (e AuditEvent) Property() string

+ func (e AuditEvent) RemoteAddress() string

+ func (e AuditEvent) Subject() string

+ func (e AuditEvent) UserAgent() string

+ func (e AuditEvent) Verb() string

+ func (e AuditEvent) WriteJSON() JSONObj

+ func (e AuditEvent) WriteText(formatter TextFormatter, buf *bytes.Buffer)

+ type BufferPool struct

+ func NewBufferPool(bufferSize int) *BufferPool

+ func (bp *BufferPool) Get() *bytes.Buffer

+ func (bp *BufferPool) Put(b *bytes.Buffer)

+ type Config struct

+ Flags []string

+ Heading string

+ HiddenFlags []string

+ JSON JSONWriterConfig

+ ListenerQueueDepth int

+ OutputFormat string

+ RecoverPanics *bool

+ Text TextWriterConfig

+ WriteQueueDepth int

+ func MustNewConfigFromEnv() *Config

+ func NewConfigFromEnv() (*Config, error)

+ func (c Config) GetFlags() []string

+ func (c Config) GetHeading() string

+ func (c Config) GetHiddenFlags() []string

+ func (c Config) GetListenerQueueDepth(defaults ...int) int

+ func (c Config) GetOutputFormat() OutputFormat

+ func (c Config) GetRecoverPanics(defaults ...bool) bool

+ func (c Config) GetWriteQueueDepth(defaults ...int) int

+ func (c Config) GetWriters() []Writer

+ type ErrorEvent struct

+ func Errorf(flag Flag, format string, args ...Any) *ErrorEvent

+ func NewErrorEvent(flag Flag, err error) *ErrorEvent

+ func NewErrorEventWithState(flag Flag, err error, state Any) *ErrorEvent

+ func (e *ErrorEvent) Err() error

+ func (e *ErrorEvent) IsError() bool

+ func (e *ErrorEvent) State() Any

+ func (e *ErrorEvent) WithAnnotation(key, value string) *ErrorEvent

+ func (e *ErrorEvent) WithErr(err error) *ErrorEvent

+ func (e *ErrorEvent) WithFlag(flag Flag) *ErrorEvent

+ func (e *ErrorEvent) WithFlagTextColor(color AnsiColor) *ErrorEvent

+ func (e *ErrorEvent) WithHeadings(headings ...string) *ErrorEvent

+ func (e *ErrorEvent) WithLabel(key, value string) *ErrorEvent

+ func (e *ErrorEvent) WithState(state Any) *ErrorEvent

+ func (e *ErrorEvent) WithTimestamp(ts time.Time) *ErrorEvent

+ func (e *ErrorEvent) WriteJSON() JSONObj

+ func (e *ErrorEvent) WriteText(formatter TextFormatter, buf *bytes.Buffer)

+ type ErrorOutputReceiver interface

+ Errorf func(string, ...Any)

+ Fatalf func(string, ...Any)

+ Warningf func(string, ...Any)

+ type ErrorReceiver interface

+ Error func(error)

+ Fatal func(error)

+ Warning func(error)

+ type Event interface

+ Flag func() Flag

+ Timestamp func() time.Time

+ func MarshalEvent(obj interface{}) (Event, bool)

+ type EventAnnotations interface

+ Annotations func() map[string]string

+ type EventEnabled interface

+ IsEnabled func() bool

+ func MarshalEventEnabled(obj interface{}) (EventEnabled, bool)

+ type EventEntity interface

+ Entity func() string

+ SetEntity func(string)

+ type EventError interface

+ IsError func() bool

+ type EventHeadings interface

+ Headings func() []string

+ SetHeadings func(...string)

+ func MarshalEventHeadings(obj interface{}) (EventHeadings, bool)

+ type EventLabels interface

+ Labels func() map[string]string

+ type EventMeta struct

+ func NewEventMeta(flag Flag) *EventMeta

+ func (em *EventMeta) AddAnnotationValue(key, value string)

+ func (em *EventMeta) AddLabelValue(key, value string)

+ func (em *EventMeta) Annotations() Annotations

+ func (em *EventMeta) Entity() string

+ func (em *EventMeta) Flag() Flag

+ func (em *EventMeta) FlagTextColor() AnsiColor

+ func (em *EventMeta) Headings() []string

+ func (em *EventMeta) Labels() Labels

+ func (em *EventMeta) SetAnnotations(annotations Annotations)

+ func (em *EventMeta) SetEntity(value string)

+ func (em *EventMeta) SetFlag(flag Flag)

+ func (em *EventMeta) SetFlagTextColor(color AnsiColor)

+ func (em *EventMeta) SetHeadings(headings ...string)

+ func (em *EventMeta) SetLabels(labels Labels)

+ func (em *EventMeta) SetTimestamp(ts time.Time)

+ func (em *EventMeta) Timestamp() time.Time

+ type EventMetaProvider interface

+ func MarshalEventMetaProvider(obj interface{}) (EventMetaProvider, bool)

+ type EventWritable interface

+ IsWritable func() bool

+ func MarshalEventWritable(obj interface{}) (EventWritable, bool)

+ type Flag string

+ const Audit

+ const Debug

+ const Error

+ const Fatal

+ const FlagAll

+ const FlagNone

+ const HTTPRequest

+ const HTTPResponse

+ const Info

+ const Query

+ const RPC

+ const Silly

+ const Warning

+ func AsFlags(values ...string) (output []Flag)

+ type FlagSet struct

+ func AllFlags() *FlagSet

+ func NewFlagSet(flags ...Flag) *FlagSet

+ func NewFlagSetAll() *FlagSet

+ func NewFlagSetFromEnv() *FlagSet

+ func NewFlagSetFromValues(flags ...string) *FlagSet

+ func NewFlagSetNone() *FlagSet

+ func NewHiddenFlagSetFromEnv() *FlagSet

+ func NoneFlags() *FlagSet

+ func (efs *FlagSet) All() bool

+ func (efs *FlagSet) CoalesceWith(other *FlagSet)

+ func (efs *FlagSet) Disable(flag Flag)

+ func (efs *FlagSet) Enable(flag Flag)

+ func (efs *FlagSet) None() bool

+ func (efs *FlagSet) SetAll()

+ func (efs *FlagSet) SetNone()

+ func (efs *FlagSet) WithDisabled(flags ...Flag) *FlagSet

+ func (efs *FlagSet) WithEnabled(flags ...Flag) *FlagSet

+ func (efs FlagSet) IsEnabled(flag Flag) bool

+ func (efs FlagSet) String() string

+ type FlagTextColorProvider interface

+ FlagTextColor func() AnsiColor

+ type FullLogger interface

+ type FullReceiver interface

+ type HTTPRequestEvent struct

+ func NewHTTPRequestEvent(req *http.Request) *HTTPRequestEvent

+ func (e *HTTPRequestEvent) Request() *http.Request

+ func (e *HTTPRequestEvent) Route() string

+ func (e *HTTPRequestEvent) State() map[interface{}]interface{}

+ func (e *HTTPRequestEvent) WithAnnotation(key, value string) *HTTPRequestEvent

+ func (e *HTTPRequestEvent) WithFlag(flag Flag) *HTTPRequestEvent

+ func (e *HTTPRequestEvent) WithHeadings(headings ...string) *HTTPRequestEvent

+ func (e *HTTPRequestEvent) WithLabel(key, value string) *HTTPRequestEvent

+ func (e *HTTPRequestEvent) WithRequest(req *http.Request) *HTTPRequestEvent

+ func (e *HTTPRequestEvent) WithRoute(route string) *HTTPRequestEvent

+ func (e *HTTPRequestEvent) WithState(state map[interface{}]interface{}) *HTTPRequestEvent

+ func (e *HTTPRequestEvent) WithTimestamp(ts time.Time) *HTTPRequestEvent

+ func (e *HTTPRequestEvent) WriteJSON() JSONObj

+ func (e *HTTPRequestEvent) WriteText(formatter TextFormatter, buf *bytes.Buffer)

+ type HTTPResponseEvent struct

+ func NewHTTPResponseEvent(req *http.Request) *HTTPResponseEvent

+ func (e *HTTPResponseEvent) ContentEncoding() string

+ func (e *HTTPResponseEvent) ContentLength() int

+ func (e *HTTPResponseEvent) ContentType() string

+ func (e *HTTPResponseEvent) Elapsed() time.Duration

+ func (e *HTTPResponseEvent) Request() *http.Request

+ func (e *HTTPResponseEvent) Route() string

+ func (e *HTTPResponseEvent) State() map[interface{}]interface{}

+ func (e *HTTPResponseEvent) StatusCode() int

+ func (e *HTTPResponseEvent) WithAnnotation(key, value string) *HTTPResponseEvent

+ func (e *HTTPResponseEvent) WithContentEncoding(contentEncoding string) *HTTPResponseEvent

+ func (e *HTTPResponseEvent) WithContentLength(contentLength int) *HTTPResponseEvent

+ func (e *HTTPResponseEvent) WithContentType(contentType string) *HTTPResponseEvent

+ func (e *HTTPResponseEvent) WithElapsed(elapsed time.Duration) *HTTPResponseEvent

+ func (e *HTTPResponseEvent) WithFlag(flag Flag) *HTTPResponseEvent

+ func (e *HTTPResponseEvent) WithHeadings(headings ...string) *HTTPResponseEvent

+ func (e *HTTPResponseEvent) WithLabel(key, value string) *HTTPResponseEvent

+ func (e *HTTPResponseEvent) WithRequest(req *http.Request) *HTTPResponseEvent

+ func (e *HTTPResponseEvent) WithRoute(route string) *HTTPResponseEvent

+ func (e *HTTPResponseEvent) WithState(state map[interface{}]interface{}) *HTTPResponseEvent

+ func (e *HTTPResponseEvent) WithStatusCode(statusCode int) *HTTPResponseEvent

+ func (e *HTTPResponseEvent) WithTimestamp(ts time.Time) *HTTPResponseEvent

+ func (e *HTTPResponseEvent) WriteJSON() JSONObj

+ func (e *HTTPResponseEvent) WriteText(formatter TextFormatter, buf *bytes.Buffer)

+ type InterlockedWriter struct

+ func (iw *InterlockedWriter) Close() (err error)

+ func (iw *InterlockedWriter) Write(buffer []byte) (count int, err error)

+ type JSONObj = Values

+ func JSONWriteHTTPRequest(req *http.Request) JSONObj

+ func JSONWriteHTTPResponse(req *http.Request, statusCode, contentLength int, ...) JSONObj

+ type JSONWritable interface

+ WriteJSON func() JSONObj

+ type JSONWriter struct

+ func NewJSONWriter(output io.Writer) *JSONWriter

+ func NewJSONWriterFromConfig(cfg *JSONWriterConfig) *JSONWriter

+ func NewJSONWriterFromEnv() *JSONWriter

+ func NewJSONWriterStdout() *JSONWriter

+ func (jw *JSONWriter) ErrorOutput() io.Writer

+ func (jw *JSONWriter) IncludeTimestamp() bool

+ func (jw *JSONWriter) Output() io.Writer

+ func (jw *JSONWriter) OutputFormat() OutputFormat

+ func (jw *JSONWriter) Pretty() bool

+ func (jw *JSONWriter) WithErrorOutput(errorOutput io.Writer) *JSONWriter

+ func (jw *JSONWriter) WithIncludeTimestamp(includeTimestamp bool) *JSONWriter

+ func (jw *JSONWriter) WithOutput(output io.Writer) *JSONWriter

+ func (jw *JSONWriter) WithPretty(pretty bool) *JSONWriter

+ func (jw *JSONWriter) Write(e Event) error

+ func (jw *JSONWriter) WriteError(e Event) error

+ type JSONWriterConfig struct

+ Pretty *bool

+ func NewJSONWriterConfigFromEnv() *JSONWriterConfig

+ func (jwc JSONWriterConfig) GetPretty(defaults ...bool) bool

+ type Labels = map[string]string

+ type Listenable interface

+ Listen func(Flag, string, Listener)

+ type Listener func(e Event)

+ func NewAuditEventListener(listener func(me *AuditEvent)) Listener

+ func NewErrorEventListener(listener func(*ErrorEvent)) Listener

+ func NewHTTPRequestEventListener(listener func(*HTTPRequestEvent)) Listener

+ func NewHTTPResponseEventListener(listener func(*HTTPResponseEvent)) Listener

+ func NewMessageEventListener(listener func(*MessageEvent)) Listener

+ func NewQueryEventListener(listener func(e *QueryEvent)) Listener

+ func NewRPCEventListener(listener func(*RPCEvent)) Listener

+ func NewTimedEventListener(listener func(e *TimedEvent)) Listener

+ type Logger struct

+ func All() *Logger

+ func MustNewFromEnv() *Logger

+ func New(flags ...Flag) *Logger

+ func NewFromConfig(cfg *Config) *Logger

+ func NewFromEnv() (*Logger, error)

+ func NewJSON() *Logger

+ func NewText() *Logger

+ func None() *Logger

+ func Sync() *Logger

+ func (l *Logger) CanStart() bool

+ func (l *Logger) CanStop() bool

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

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

+ func (l *Logger) Disable(flags ...Flag)

+ func (l *Logger) Drain() error

+ func (l *Logger) Enable(flags ...Flag)

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

+ func (l *Logger) ErrorWithReq(err error, req *http.Request) error

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

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

+ func (l *Logger) FatalWithReq(err error, req *http.Request) error

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

+ func (l *Logger) Flags() *FlagSet

+ func (l *Logger) HasListener(flag Flag, listenerName string) bool

+ func (l *Logger) HasListeners(flag Flag) bool

+ func (l *Logger) Heading() string

+ func (l *Logger) Hide(flags ...Flag)

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

+ func (l *Logger) IsEnabled(flag Flag) (enabled bool)

+ func (l *Logger) IsHidden(flag Flag) bool

+ func (l *Logger) Listen(flag Flag, listenerName string, listener Listener)

+ func (l *Logger) ListenerWorkerQueueDepth() int

+ func (l *Logger) RecoversPanics() bool

+ func (l *Logger) RemoveListener(flag Flag, listenerName string)

+ func (l *Logger) RemoveListeners(flag Flag)

+ func (l *Logger) Show(flags ...Flag)

+ func (l *Logger) Sillyf(format string, args ...interface{})

+ func (l *Logger) SubContext(heading string) *SubContext

+ func (l *Logger) SyncDebugf(format string, args ...interface{})

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

+ func (l *Logger) SyncErrorf(format string, args ...interface{})

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

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

+ func (l *Logger) SyncFatalf(format string, args ...interface{})

+ func (l *Logger) SyncInfof(format string, args ...interface{})

+ func (l *Logger) SyncSillyf(format string, args ...interface{})

+ func (l *Logger) SyncTrigger(e Event)

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

+ func (l *Logger) SyncWarningf(format string, args ...interface{})

+ func (l *Logger) Trigger(e Event)

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

+ func (l *Logger) WarningWithReq(err error, req *http.Request) error

+ func (l *Logger) Warningf(format string, args ...interface{}) error

+ func (l *Logger) WithDisabled(flags ...Flag) *Logger

+ func (l *Logger) WithEnabled(flags ...Flag) *Logger

+ func (l *Logger) WithFlags(flags *FlagSet) *Logger

+ func (l *Logger) WithFlagsFromEnv() *Logger

+ func (l *Logger) WithHeading(heading string) *Logger

+ func (l *Logger) WithHidden(flags ...Flag) *Logger

+ func (l *Logger) WithHiddenFlags(flags *FlagSet) *Logger

+ func (l *Logger) WithListenerWorkerQueueDepth(queueDepth int) *Logger

+ func (l *Logger) WithRecoverPanics(value bool) *Logger

+ func (l *Logger) WithWriteWorkerQueueDepth(queueDepth int) *Logger

+ func (l *Logger) WithWriter(writer Writer) *Logger

+ func (l *Logger) WithWriters(writers ...Writer) *Logger

+ func (l *Logger) Write(e Event)

+ func (l *Logger) WriteWorkerQueueDepth() int

+ func (l *Logger) Writers() []Writer

+ type MessageEvent struct

+ func Messagef(flag Flag, format string, args ...Any) *MessageEvent

+ func (e *MessageEvent) Message() string

+ func (e *MessageEvent) String() string

+ func (e *MessageEvent) WithAnnotation(key, value string) *MessageEvent

+ func (e *MessageEvent) WithFlag(flag Flag) *MessageEvent

+ func (e *MessageEvent) WithFlagTextColor(color AnsiColor) *MessageEvent

+ func (e *MessageEvent) WithHeadings(headings ...string) *MessageEvent

+ func (e *MessageEvent) WithLabel(key, value string) *MessageEvent

+ func (e *MessageEvent) WithMessage(message string) *MessageEvent

+ func (e *MessageEvent) WithTimestamp(ts time.Time) *MessageEvent

+ func (e *MessageEvent) WriteJSON() JSONObj

+ func (e *MessageEvent) WriteText(formatter TextFormatter, buf *bytes.Buffer)

+ type OutputFormat string

+ const OutputFormatJSON

+ const OutputFormatText

+ type OutputReceiver interface

+ Debugf func(string, ...Any)

+ Infof func(string, ...Any)

+ Sillyf func(string, ...Any)

+ type QueryEvent struct

+ func NewQueryEvent(body string, elapsed time.Duration) *QueryEvent

+ func (e *QueryEvent) WithAnnotation(key, value string) *QueryEvent

+ func (e *QueryEvent) WithBody(body string) *QueryEvent

+ func (e *QueryEvent) WithDatabase(db string) *QueryEvent

+ func (e *QueryEvent) WithElapsed(elapsed time.Duration) *QueryEvent

+ func (e *QueryEvent) WithEngine(engine string) *QueryEvent

+ func (e *QueryEvent) WithErr(err error) *QueryEvent

+ func (e *QueryEvent) WithFlag(flag Flag) *QueryEvent

+ func (e *QueryEvent) WithHeadings(headings ...string) *QueryEvent

+ func (e *QueryEvent) WithLabel(key, value string) *QueryEvent

+ func (e *QueryEvent) WithQueryLabel(queryLabel string) *QueryEvent

+ func (e *QueryEvent) WithTimestamp(ts time.Time) *QueryEvent

+ func (e *QueryEvent) WithUsername(username string) *QueryEvent

+ func (e QueryEvent) Body() string

+ func (e QueryEvent) Database() string

+ func (e QueryEvent) Elapsed() time.Duration

+ func (e QueryEvent) Engine() string

+ func (e QueryEvent) Err() error

+ func (e QueryEvent) QueryLabel() string

+ func (e QueryEvent) Username() string

+ func (e QueryEvent) WriteJSON() JSONObj

+ func (e QueryEvent) WriteText(tf TextFormatter, buf *bytes.Buffer)

+ type RPCEvent struct

+ func NewRPCEvent(method string, elapsed time.Duration) *RPCEvent

+ func (e *RPCEvent) Authority() string

+ func (e *RPCEvent) ContentType() string

+ func (e *RPCEvent) Elapsed() time.Duration

+ func (e *RPCEvent) UserAgent() string

+ func (e *RPCEvent) WithAnnotation(key, value string) *RPCEvent

+ func (e *RPCEvent) WithAuthority(authority string) *RPCEvent

+ func (e *RPCEvent) WithContentType(contentType string) *RPCEvent

+ func (e *RPCEvent) WithElapsed(elapsed time.Duration) *RPCEvent

+ func (e *RPCEvent) WithEngine(engine string) *RPCEvent

+ func (e *RPCEvent) WithErr(err error) *RPCEvent

+ func (e *RPCEvent) WithFlag(flag Flag) *RPCEvent

+ func (e *RPCEvent) WithHeadings(headings ...string) *RPCEvent

+ func (e *RPCEvent) WithLabel(key, value string) *RPCEvent

+ func (e *RPCEvent) WithMethod(method string) *RPCEvent

+ func (e *RPCEvent) WithPeer(peer string) *RPCEvent

+ func (e *RPCEvent) WithTimestamp(ts time.Time) *RPCEvent

+ func (e *RPCEvent) WithUserAgent(userAgent string) *RPCEvent

+ func (e *RPCEvent) WriteJSON() JSONObj

+ func (e *RPCEvent) WriteText(tf TextFormatter, buf *bytes.Buffer)

+ func (e RPCEvent) Engine() string

+ func (e RPCEvent) Err() error

+ func (e RPCEvent) Method() string

+ func (e RPCEvent) Peer() string

+ type ResponseWrapper interface

+ InnerResponse func() http.ResponseWriter

+ type ResponseWriter struct

+ func NewResponseWriter(w http.ResponseWriter) *ResponseWriter

+ func (rw *ResponseWriter) ContentLength() int

+ func (rw *ResponseWriter) Flush() error

+ func (rw *ResponseWriter) Header() http.Header

+ func (rw *ResponseWriter) InnerWriter() http.ResponseWriter

+ func (rw *ResponseWriter) StatusCode() int

+ func (rw *ResponseWriter) Write(b []byte) (int, error)

+ func (rw *ResponseWriter) WriteHeader(code int)

+ type SubContext struct

+ func (sc *SubContext) Annotations() map[string]string

+ func (sc *SubContext) Debugf(format string, args ...Any)

+ func (sc *SubContext) Error(err error)

+ func (sc *SubContext) Errorf(format string, args ...Any)

+ func (sc *SubContext) Fatal(err error)

+ func (sc *SubContext) Fatalf(format string, args ...Any)

+ func (sc *SubContext) Headings() []string

+ func (sc *SubContext) Infof(format string, args ...Any)

+ func (sc *SubContext) Labels() map[string]string

+ func (sc *SubContext) Logger() *Logger

+ func (sc *SubContext) Sillyf(format string, args ...Any)

+ func (sc *SubContext) SubContext(heading string) *SubContext

+ func (sc *SubContext) SyncDebugf(format string, args ...Any)

+ func (sc *SubContext) SyncError(err error)

+ func (sc *SubContext) SyncErrorf(format string, args ...Any)

+ func (sc *SubContext) SyncFatal(err error)

+ func (sc *SubContext) SyncFatalf(format string, args ...Any)

+ func (sc *SubContext) SyncInfof(format string, args ...Any)

+ func (sc *SubContext) SyncSillyf(format string, args ...Any)

+ func (sc *SubContext) SyncTrigger(e Event)

+ func (sc *SubContext) SyncWarning(err error)

+ func (sc *SubContext) SyncWarningf(format string, args ...Any)

+ func (sc *SubContext) Trigger(e Event)

+ func (sc *SubContext) Warning(err error)

+ func (sc *SubContext) Warningf(format string, args ...Any)

+ func (sc *SubContext) WithAnnotation(key, value string) *SubContext

+ func (sc *SubContext) WithAnnotations(annotations map[string]string) *SubContext

+ func (sc *SubContext) WithLabel(key, value string) *SubContext

+ func (sc *SubContext) WithLabels(labels map[string]string) *SubContext

+ type SyncErrorOutputReceiver interface

+ SyncErrorf func(string, ...Any)

+ SyncFatalf func(string, ...Any)

+ SyncWarningf func(string, ...Any)

+ type SyncErrorReceiver interface

+ SyncError func(error)

+ SyncFatal func(error)

+ SyncWarning func(error)

+ type SyncLogger interface

+ type SyncOutputReceiver interface

+ SyncDebugf func(string, ...Any)

+ SyncInfof func(string, ...Any)

+ SyncSillyf func(string, ...Any)

+ type SyncTriggerable interface

+ SyncTrigger func(Event)

+ type TextFormatter interface

+ Colorize func(value string, color AnsiColor) string

+ ColorizeByStatusCode func(code int, value string) string

+ ColorizeStatusCode func(code int) string

+ type TextWritable interface

+ WriteText func(formatter TextFormatter, buf *bytes.Buffer)

+ type TextWriter struct

+ func NewTextWriter(output io.Writer) *TextWriter

+ func NewTextWriterFromConfig(cfg *TextWriterConfig) *TextWriter

+ func NewTextWriterFromEnv() *TextWriter

+ func NewTextWriterStdout() *TextWriter

+ func (wr *TextWriter) Colorize(value string, color AnsiColor) string

+ func (wr *TextWriter) ColorizeByStatusCode(statusCode int, value string) string

+ func (wr *TextWriter) ColorizeStatusCode(statusCode int) string

+ func (wr *TextWriter) ErrorOutput() io.Writer

+ func (wr *TextWriter) FormatEntity(entity string, color AnsiColor) string

+ func (wr *TextWriter) FormatFlag(flag Flag, color AnsiColor) string

+ func (wr *TextWriter) FormatHeadings(headings ...string) string

+ func (wr *TextWriter) FormatTimestamp(optionalTime ...time.Time) string

+ func (wr *TextWriter) GetBuffer() *bytes.Buffer

+ func (wr *TextWriter) Output() io.Writer

+ func (wr *TextWriter) OutputFormat() OutputFormat

+ func (wr *TextWriter) PutBuffer(buffer *bytes.Buffer)

+ func (wr *TextWriter) ShowHeadings() bool

+ func (wr *TextWriter) ShowTimestamp() bool

+ func (wr *TextWriter) TimeFormat() string

+ func (wr *TextWriter) UseColor() bool

+ func (wr *TextWriter) WithErrorOutput(errorOutput io.Writer) *TextWriter

+ func (wr *TextWriter) WithOutput(output io.Writer) *TextWriter

+ func (wr *TextWriter) WithShowHeadings(showHeadings bool) *TextWriter

+ func (wr *TextWriter) WithShowTimestamp(showTime bool) *TextWriter

+ func (wr *TextWriter) WithTimeFormat(timeFormat string) *TextWriter

+ func (wr *TextWriter) WithUseColor(useColor bool) *TextWriter

+ func (wr *TextWriter) Write(e Event) error

+ func (wr *TextWriter) WriteError(e Event) error

+ type TextWriterConfig struct

+ ShowHeadings *bool

+ ShowTimestamp *bool

+ TimeFormat string

+ UseColor *bool

+ func NewTextWriterConfigFromEnv() *TextWriterConfig

+ func (twc TextWriterConfig) GetShowHeadings(defaults ...bool) bool

+ func (twc TextWriterConfig) GetShowTimestamp(defaults ...bool) bool

+ func (twc TextWriterConfig) GetTimeFormat(defaults ...string) string

+ func (twc TextWriterConfig) GetUseColor(defaults ...bool) bool

+ type TimedEvent struct

+ func Timedf(flag Flag, elapsed time.Duration, format string, args ...Any) *TimedEvent

+ func (e *TimedEvent) WithAnnotation(key, value string) *TimedEvent

+ func (e *TimedEvent) WithElapsed(elapsed time.Duration) *TimedEvent

+ func (e *TimedEvent) WithFlag(flag Flag) *TimedEvent

+ func (e *TimedEvent) WithHeadings(headings ...string) *TimedEvent

+ func (e *TimedEvent) WithLabel(key, value string) *TimedEvent

+ func (e *TimedEvent) WithMessage(message string) *TimedEvent

+ func (e *TimedEvent) WithTimestamp(ts time.Time) *TimedEvent

+ func (e TimedEvent) Elapsed() time.Duration

+ func (e TimedEvent) Message() string

+ func (e TimedEvent) String() string

+ func (e TimedEvent) WriteJSON() JSONObj

+ func (e TimedEvent) WriteText(tf TextFormatter, buf *bytes.Buffer)

+ type Triggerable interface

+ Trigger func(Event)

+ type Values = map[string]interface

+ type Worker struct

+ Abort chan struct{}

+ Aborted chan struct{}

+ Listener Listener

+ Parent *Logger

+ Work chan Event

+ func NewWorker(parent *Logger, listener Listener, queueDepth int) *Worker

+ func (w *Worker) Close() error

+ func (w *Worker) Drain()

+ func (w *Worker) Process(e Event)

+ func (w *Worker) ProcessLoop()

+ func (w *Worker) Start()

+ type Writer interface

+ ErrorOutput func() io.Writer

+ Output func() io.Writer

+ OutputFormat func() OutputFormat

+ Write func(Event) error

+ WriteError func(Event) error

+ func NewWriter(format OutputFormat) Writer

+ func NewWriterFromEnv() Writer