Addr constructs a field that carries an any addr as is.

Apply overwrites the behaviour of default package logger by provided reasons.

Bool constructs a field with the given key and value.

Boolp constructs a field that carries a *bool.

Complex128 constructs a field with the given key and value.

Complex64 constructs a field with the given key and value.

Debug is the same as Log(Level.Debug, args...).

Debuge is the same as Loge(Level.Debug, err, args...).

Debugec is the same as Logec(Level.Debug, err, errorCode, args...).

DebugecStrict is the same as LogecStrict(Level.Debug, err, errorCode, fields...).

DebugeStrict is the same as LogeStrict(Level.Debug, err, fields...).

Debugf is the same as Logf(Level.Debug, format, args...).

DebugfStrict is the same as LogfStrict(Level.Debug, format, args...).

DebugStrict is the same as LogStrict(Level.Debug, args...).

Debugw is the same as Logw(Level.Debug, msg, fields...).

Error is the same as Log(Level.Error, args...).

Errore is the same as Loge(Level.Error, err, args...).

Errorec is the same as Logec(Level.Error, err, errorCode, args...).

ErrorecStrict is the same as LogecStrict(Level.Error, err, errorCode, fields...).

ErroreStrict is the same as LogeStrict(Level.Error, err, fields...).

Errorf is the same as Logf(Level.Error, format, args...).

ErrorfStrict is the same as LogfStrict(Level.Error, format, args...).

ErrorStrict is the same as LogStrict(Level.Error, args...).

Errorw is the same as Logw(Level.Error, msg, fields...).

Fatal is the same as Log(Level.Fatal, args...), but also then calls death.Die(1).

Fatale is the same as Loge(Level.Fatal, err, args...), but also then calls death.Die(1).

Fatalec is the same as Logec(Level.Fatal, err, errorCode, args...).

FatalecStrict is the same as LogecStrict(Level.Fatal, err, errorCode, fields...).

FataleStrict is the same as LogeStrict(Level.Fatal, err, fields...), but also then calls death.Die(1).

Fatalf is the same as Logf(Level.Fatal, format, args...), but also then calls death.Die(1).

FatalfStrict is the same as LogfStrict(Level.Fatal, format, args...), but also then calls death.Die(1).

FatalStrict is the same as LogStrict(Level.Fatal, args...), but also then calls death.Die(1).

Fatalw is the same as Logw(Level.Fatal, msg, fields...), but also then calls death.Die(1).

Float32 constructs a field with the given key and value.

Float32p constructs a field that carries a *float32.

Float64 constructs a field with the given key and value.

Float64p constructs a field that carries a *float64.

If returns package logger if 'cond' == 'true', otherwise nil.

Info is the same as Log(Level.Info, args...).

Infoe is the same as Loge(Level.Info, err, args...).

Infoec is the same as Logec(Level.Info, err, errorCode, args...).

InfoecStrict is the same as LogecStrict(Level.Debug, err, errorCode, fields...).

InfoeStrict is the same as LogeStrict(Level.Info, err, fields...).

Infof is the same as Logf(Level.Info, format, args...).

InfofStrict is the same as LogfStrict(Level.Info, format, args...).

InfoStrict is the same as LogStrict(Level.Info, args...).

Infow is the same as Logw(Level.Info, msg, fields...).

Int constructs a field with the given key and value.

Int16 constructs a field with the given key and value.

Int16p constructs a field that carries a *int16.

Int32 constructs a field with the given key and value.

Int32p constructs a field that carries a *int32.

Int64 constructs a field with the given key and value.

Int64p constructs a field that carries a *int64.

Int8 constructs a field with the given key and value.

Int8p constructs a field that carries a *int8.

Intp constructs a field that carries a *int.

Log writes log message with desired 'level', analyzing 'args' in the most powerful and smart way: - args[0] could be printf-like format string, then next N args will be its printf values (N - num of format's printf verbs), and M-N (where M is total count of args) will be treated as explicit or implicit fields (depends on what kind of fields are allowed); - args[0] could be an error => error's message will be used as log's one, and wherein, error's message could be printf-like format string, then next N args will be handled as in the case above, and M-N (where M is total count of args) will be treated as explicit or implicit fields (depends on what kind of fields are allowed); - If only explicit fields are enabled (Options.OnlyExplicitFields(true)), all args except explicit fields will be form log's message using fmt.Sprint (the same way as LogStrict does), but you still can pass explicit fields also; - If both of explicit and implicit fields are enabled (by default), only first non-explicit field arg forms log's message using "%+v" printf verb.

Loge writes log's message with desired 'level' using err's message as log's one but does anything only if err != nil.

Logec generates ECXT based on passed 'errorCode', adds ECXT's UUID as error's one to the log's entry then writes log's message using err's message as log's one with desired 'level' but does that all only if err != nil.

LogecStrict is the same as just Logec but no implicit fields supporting, no err's printf style supporting, no group supporting, no options supporting, ..

LogeStrict is the same as just Loge but no implicit fields supporting, no err's printf style supporting, no group supporting, no options supporting, ..

Logf writes log message with desired 'level', generating log's message using fmt.Sprintf(format, args[:N]...), where N is a number of format's printf verbs, and uses args[N:] as explicit or implicit fields (depends on what kind of fields are allowed).

LogfStrict is the same as just Logf but no explicit/implicit fields supporting, no group supporting, no options supporting, ..

LogStrict writes log message with desired 'level', generating log's message using fmt.Sprint(args...).

Logw writes log's message 'msg' with desired 'level', and passed implicit fields.

MarkLevelAsFatal marks passed level as level when you write log with, causes death.Die() (the same behaviour as standard Fatal handlers).

Constructor.

RegisterLevelName registers new log level's name that will be returned by Level.String() method.

SkipStackFrames specified how much stack frames shall be skipped at the stacktrace generation.

SkipStackFramesThis is the same as SkipStackFrames but doesn't create a copy of default package logger.

String constructs a field with the given key and value.

Stringer constructs a field that holds on string generated by fmt.Stringer.String().

SyncThis forces to flush all default package logger's integrator's buffer and makes sure all pending log's entries are written.

Type constructs a field that holds on value's type as string.

Uint constructs a field with the given key and value.

Uint16 constructs a field with the given key and value.

Uint16p constructs a field that carries a *uint16.

Uint32 constructs a field with the given key and value.

Uint32p constructs a field that carries a *uint32.

Uint64 constructs a field with the given key and value.

Uint64p constructs a field that carries a *uint64.

Uint8 constructs a field with the given key and value.

Uint8p constructs a field that carries a *uint8.

Uintp constructs a field that carries a *uint.

Uintptr constructs a field with the given key and value.

Warn is the same as Log(Level.Warn, args...).

Warne is the same as Loge(Level.Warn, err, args...).

Warnec is the same as Logec(Level.Warn, err, errorCode, args...).

WarnecStrict is the same as LogecStrict(Level.Warn, err, errorCode, fields...).

WarneStrict is the same as LogeStrict(Level.Warn, err, fields...).

Warnf is the same as Logf(Level.Warn, format, args...).

WarnfStrict is the same as LogfStrict(Level.Warn, format, args...).

WarnStrict is the same as LogStrict(Level.Warn, args...).

Warnw is the same as Logw(Level.Warn, msg, fields...).

With adds the fields to the default package logger's copy.

WithStrict adds an explicit fields to the default package logger's copy.

WithStrictThis is the same as WithStrict but doesn't create a copy of default package logger.

WithThis is the same as With but doesn't create a copy of default package logger.

can't be handled in almost all cases.

almost all implicit fields have this kind.

.

Levels represents log message's levels.

.

CommonIntegrator is the implementation way of Integrator interface.

.

.

Field is an explicit field's type.

.

Logger is used to generate and write log messages.

Integrator is an interface each type wants to convert log's Entry to some real output shall implement.

BeforeWriteCallback is type of user's callback that fires exactly before log message's entry will be written to all registered destinations.

CommonIntegratorEncoder is the alias to the function that takes an one log message (as Entry type), encodes it (by some rules) and returns the encoded data as RAW bytes.

FieldKind is an alias to uint8.

Level represents the log message's level.