adapter

package
v0.0.0-...-80b5034 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 1, 2025 License: BSD-3-Clause Imports: 11 Imported by: 3

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func EmitterFromPrintf 

func EmitterFromPrintf(printf func(format string, args ...any), opts ...types.Option) types.Emitter

EmitterFromPrintf provides a naive types.Emitter based on a given printf-function.

func EmitterFromPrintfer 

func EmitterFromPrintfer(printfer Printfer, opts ...types.Option) types.Emitter

EmitterFromPrintfer provides a naive types.Emitter based on a given Printfer.

func LogFieldsPreprocess 

func LogFieldsPreprocess(
	preHooks types.PreHooks,
	traceIDs belt.TraceIDs,
	level types.Level,
	logLevelSatisfied bool,
	message string,
	fields field.AbstractFields,
) types.PreHookResult

LogFieldsPreprocess checks logging level and calls PreHooks. Returns the total outcome of these two steps.

It will never return Skip=true for message logging levels Panic and Fatal, instead it will ask to skip the logging through Entry property "experimental.EntryPropertySkipAllEmitters".

It is a helper which is supposed to be used in the beginning of a LogFields implementation.

func LogPreprocess 

func LogPreprocess(
	preHooks types.PreHooks,
	traceIDs belt.TraceIDs,
	level types.Level,
	logLevelSatisfied bool,
	values ...any,
) types.PreHookResult

LogPreprocess checks logging level and calls PreHooks. Returns the total outcome of these two steps.

It will never return Skip=true for message logging levels Panic and Fatal, instead it will ask to skip the logging through Entry property "experimental.EntryPropertySkipAllEmitters".

It is a helper which is supposed to be used in the beginning of a Log implementation.

func LogfPreprocess 

func LogfPreprocess(
	preHooks types.PreHooks,
	traceIDs belt.TraceIDs,
	level types.Level,
	logLevelSatisfied bool,
	format string,
	args ...any,
) types.PreHookResult

LogfPreprocess checks logging level and calls PreHooks. Returns the total outcome of these two steps.

It will never return Skip=true for message with logging levels Panic and Fatal, instead it will ask to skip the logging through Entry property "experimental.EntryPropertySkipAllEmitters".

It is a helper which is supposed to be used in the beginning of a Logf implementation.

func LoggerFromAny 

func LoggerFromAny(anyLogger any, opts ...types.Option) types.Logger

LoggerFromAny makes the best effort to convert given logger of an arbitrary type to logger.Logger. Returns an untyped `nil` if was not successful.

func LoggerFromCompactLogger 

func LoggerFromCompactLogger(compactLogger CompactLogger, opts ...types.Option) types.Logger

LoggerFromCompactLogger provides a generic logger.Logger based on a given types.CompactLogger.

func LoggerFromEmitter 

func LoggerFromEmitter(emitter types.Emitter, opts ...types.Option) types.Logger

LoggerFromEmitter provides a generic logger.Logger based on a given types.Emitter.

func LoggerFromPrintf 

func LoggerFromPrintf(printf func(format string, args ...any), opts ...types.Option) types.Logger

LoggerFromPrintf provides a generic naive logger.Logger based on a given printf-function.

func LoggerFromPrintfer 

func LoggerFromPrintfer(printfer Printfer, opts ...types.Option) types.Logger

LoggerFromPrintfer provides a generic naive logger.Logger based on a given Printfer.

func ProcessHooks 

func ProcessHooks(hooks types.Hooks, entry *types.Entry) bool

ProcessHooks executes hooks and never returns false for Panic and Fatal logging levels. In case of a "false" result from hooks for Panic or Fatal it adds EntryProperty "experimental.EntryPropertySkipAllEmitters" and returns true.

It is a helper which is supposed to be used in Logf, LogFields and Log implementations.

Types

type CompactLogger 

type CompactLogger interface {
	belt.Tool

	// Logf logs an unstructured message. Though, of course, all
	// contextual structured fields will also be logged.
	//
	// This method exists mostly for convenience, for people who
	// has not got used to proper structured logging, yet.
	// See `LogFields` and `Log`. If one have variables they want to
	// log, it is better for scalable observability to log them
	// as structured values, instead of injecting them into a
	// non-structured string.
	Logf(level types.Level, format string, args ...any)

	// LogFields logs structured fields with a explanation message.
	//
	// Anything that implements field.AbstractFields might be used
	// as a collection of fields to be logged.
	//
	// Examples:
	//
	// 	l.LogFields(logger.LevelDebug, "new_request", field.Fields{{Key: "user_id", Value: userID}, {Key: "group_id", Value: groupID}})
	// 	l.LogFields(logger.LevelInfo, "affected entries", field.Field{Key: "mysql_affected", Value: affectedRows})
	// 	l.LogFields(logger.LevelError, "unable to fetch user info", request) // where `request` implements field.AbstractFields
	//
	// Sometimes it is inconvenient to manually describe each field,
	// and for such cases see method `Log`.
	LogFields(level types.Level, message string, fields field.AbstractFields)

	// Log extracts structured fields from provided values, joins
	// the rest into an unstructured message and logs the result.
	//
	// This function provides convenience (relatively to LogFields)
	// at cost of a bit of performance.
	//
	// There are few ways to extract structured fields, which are
	// applied for each value from `values` (in descending priority order):
	// 1. If a `value` is an `*Entry` then the Entry is used (with its fields)
	// 2. If a `value` implements field.AbstractFields then ForEachField method
	//    is used (so it is become similar to LogFields).
	// 3. If a `value` is a structure (or a pointer to a structure) then
	//    fields of the structure are interpreted as structured fields
	//    to be logged (see explanation below).
	// 4. If a `value` is a map then fields a constructed out of this map.
	//
	// Everything that does not fit into any of the rules above is just
	// joined into an unstructured message (and works the same way
	// as `message` in LogFields).
	//
	// How structures are parsed:
	// Structures are parsed recursively. Each field name of the path in a tree
	// of structures is added to the resulting field name (for example int "struct{A struct{B int}}"
	// the field name will be `A.B`).
	// To enforce another name use tag `log` (for example "struct{A int `log:"anotherName"`}"),
	// to prevent a field from logging use tag `log:"-"`.
	//
	// Examples:
	//
	// 	user, err := getUser()
	// 	if err != nil {
	// 		l.Log(logger.LevelError, err)
	// 		return err
	// 	}
	// 	l.Log(logger.LevelDebug, "current user", user) // fields of structure "user" will be logged
	// 	l.Log(logger.LevelDebug, map[string]any{"user_id": user.ID, "group_id", user.GroupID})
	// 	l.Log(logger.LevelDebug, field.Fields{{Key: "user_id", Value: user.ID}, {Key: "group_id", Value: user.GroupID}})
	// 	l.Log(logger.LevelDebug, "current user ID is ", user.ID, " and group ID is ", user.GroupID) // will result into message "current user ID is 1234 and group ID is 5678".
	Log(level types.Level, values ...any)

	// Emitter returns the Emitter (see the description of interface "Emitter").
	Emitter() types.Emitter

	// Level returns the current logging level (see description of "Level").
	Level() types.Level

	// WithLevel returns a logger with logger level set to the given argument.
	//
	// See also the description of type "Level".
	WithLevel(types.Level) CompactLogger

	// WithPreHooks returns a Logger which includes/appends pre-hooks from the arguments.
	//
	// See also description of "PreHook".
	//
	// Special case: to reset hooks use `WithHooks()` (without any arguments).
	WithPreHooks(...types.PreHook) CompactLogger

	// WithHooks returns a Logger which includes/appends hooks from the arguments.
	//
	// See also description of "Hook".
	//
	// Special case: to reset hooks use `WithHooks()` (without any arguments).
	WithHooks(...types.Hook) CompactLogger

	// WithField returns the logger with the added field (used for structured logging).
	WithField(key string, value any, props ...field.Property) CompactLogger

	// WithFields returns the logger with the fields added (used for structured logging).
	WithFields(fields field.AbstractFields) CompactLogger

	// WithMessagePrefix adds a string to all messages logged through the derived logger
	WithMessagePrefix(prefix string) CompactLogger

	// WithEntryProperties adds props to EntryProperties of each emitted Entry.
	// This could be used only for enabling implementation-specific behavior.
	WithEntryProperties(props ...types.EntryProperty) CompactLogger
}

CompactLogger is an optimized interface of an abstract generic structured logger. For the full interface see "Logger".

It is easier to implement a CompactLogger and then wrap it to an adapter.GenericSugar to get a Logger, than to implement a full Logger.

All methods are thread-safe.

type GenericLogger 

type GenericLogger struct {
	Emitters        types.Emitters
	CurrentLevel    types.Level
	Fields          *field.FieldsChain
	TraceIDs        belt.TraceIDs
	CurrentPreHooks types.PreHooks
	CurrentHooks    types.Hooks
	MessagePrefix   string
	GetCallerFunc   types.GetCallerPC
	EntryProperties types.EntryProperties
}

GenericLogger is a generic implementation of types.CompactLogger given Emitters.

func (*GenericLogger) Emitter 

func (l *GenericLogger) Emitter() types.Emitter

Emitter implements types.CompactLogger.

func (*GenericLogger) Flush 

func (l *GenericLogger) Flush()

Flush implements types.CompactLogger.

func (*GenericLogger) Level 

func (l *GenericLogger) Level() types.Level

Level implements types.CompactLogger.

func (*GenericLogger) Log 

func (l *GenericLogger) Log(level types.Level, values ...any)

Log implements types.CompactLogger.

func (*GenericLogger) LogFields 

func (l *GenericLogger) LogFields(level types.Level, message string, fields field.AbstractFields)

LogFields implements types.CompactLogger.

func (*GenericLogger) Logf 

func (l *GenericLogger) Logf(level types.Level, format string, args ...any)

Logf implements types.CompactLogger.

func (*GenericLogger) WithContextFields 

func (l *GenericLogger) WithContextFields(allFields *field.FieldsChain, newFields int) belt.Tool

WithContextFields implements types.CompactLogger.

func (*GenericLogger) WithEntryProperties 

func (l *GenericLogger) WithEntryProperties(props ...types.EntryProperty) CompactLogger

WithMessagePrefix implements types.CompactLogger.

func (*GenericLogger) WithField 

func (l *GenericLogger) WithField(
	key field.Key,
	value field.Value,
	props ...field.Property,
) CompactLogger

WithField implements types.CompactLogger.

func (*GenericLogger) WithFields 

func (l *GenericLogger) WithFields(fields field.AbstractFields) CompactLogger

WithFields implements types.CompactLogger.

func (*GenericLogger) WithHooks 

func (l *GenericLogger) WithHooks(hooks ...types.Hook) CompactLogger

WithHooks implements types.CompactLogger.

func (*GenericLogger) WithLevel 

func (l *GenericLogger) WithLevel(newLevel types.Level) CompactLogger

WithLevel implements types.CompactLogger.

func (*GenericLogger) WithMessagePrefix 

func (l *GenericLogger) WithMessagePrefix(prefix string) CompactLogger

WithMessagePrefix implements types.CompactLogger.

func (*GenericLogger) WithPreHooks 

func (l *GenericLogger) WithPreHooks(preHooks ...types.PreHook) CompactLogger

WithPreHooks implements types.CompactLogger.

func (*GenericLogger) WithTraceIDs 

func (l *GenericLogger) WithTraceIDs(allTraceIDs belt.TraceIDs, newTraceIDs int) belt.Tool

WithTraceIDs implements types.CompactLogger.

type GenericSugar 

type GenericSugar struct {
	CompactLogger CompactLogger
}

GenericSugar is a generic implementation of sugar-methods for a given types.CompactLogger.

It does not contain any logic, it is just a bunch of method-wrappers to provide logger.Logger implementation using a given types.CompactLogger.

func (GenericSugar) Debug 

func (l GenericSugar) Debug(values ...any)

Debug implements logger.Logger.

func (GenericSugar) DebugFields 

func (l GenericSugar) DebugFields(message string, fields field.AbstractFields)

DebugFields implements logger.Logger.

func (GenericSugar) Debugf 

func (l GenericSugar) Debugf(format string, args ...any)

Debugf implements logger.Logger.

func (GenericSugar) Emitter 

func (l GenericSugar) Emitter() types.Emitter

Emitter implements logger.Logger.

func (GenericSugar) Error 

func (l GenericSugar) Error(values ...any)

Error implements logger.Logger.

func (GenericSugar) ErrorFields 

func (l GenericSugar) ErrorFields(message string, fields field.AbstractFields)

ErrorFields implements logger.Logger.

func (GenericSugar) Errorf 

func (l GenericSugar) Errorf(format string, args ...any)

Errorf implements logger.Logger.

func (GenericSugar) Fatal 

func (l GenericSugar) Fatal(values ...any)

Fatal implements logger.Logger.

func (GenericSugar) FatalFields 

func (l GenericSugar) FatalFields(message string, fields field.AbstractFields)

FatalFields implements logger.Logger.

func (GenericSugar) Fatalf 

func (l GenericSugar) Fatalf(format string, args ...any)

Fatalf implements logger.Logger.

func (GenericSugar) Flush 

func (l GenericSugar) Flush()

Flush implements logger.Logger.

func (GenericSugar) Info 

func (l GenericSugar) Info(values ...any)

Info implements logger.Logger.

func (GenericSugar) InfoFields 

func (l GenericSugar) InfoFields(message string, fields field.AbstractFields)

InfoFields implements logger.Logger.

func (GenericSugar) Infof 

func (l GenericSugar) Infof(format string, args ...any)

Infof implements logger.Logger.

func (GenericSugar) Level 

func (l GenericSugar) Level() types.Level

Level implements logger.Logger.

func (GenericSugar) Log 

func (l GenericSugar) Log(level types.Level, values ...any)

Log implements logger.Logger.

func (GenericSugar) LogFields 

func (l GenericSugar) LogFields(level types.Level, message string, fields field.AbstractFields)

LogFields implements logger.Logger.

func (GenericSugar) Logf 

func (l GenericSugar) Logf(level types.Level, format string, args ...any)

Logf implements logger.Logger.

func (GenericSugar) Panic 

func (l GenericSugar) Panic(values ...any)

Panic implements logger.Logger.

func (GenericSugar) PanicFields 

func (l GenericSugar) PanicFields(message string, fields field.AbstractFields)

PanicFields implements logger.Logger.

func (GenericSugar) Panicf 

func (l GenericSugar) Panicf(format string, args ...any)

Panicf implements logger.Logger.

func (GenericSugar) Trace 

func (l GenericSugar) Trace(values ...any)

Trace implements logger.Logger.

func (GenericSugar) TraceFields 

func (l GenericSugar) TraceFields(message string, fields field.AbstractFields)

TraceFields implements logger.Logger.

func (GenericSugar) Tracef 

func (l GenericSugar) Tracef(format string, args ...any)

Tracef implements logger.Logger.

func (GenericSugar) Warn 

func (l GenericSugar) Warn(values ...any)

Warn implements logger.Logger.

func (GenericSugar) WarnFields 

func (l GenericSugar) WarnFields(message string, fields field.AbstractFields)

WarnFields implements logger.Logger.

func (GenericSugar) Warnf 

func (l GenericSugar) Warnf(format string, args ...any)

Warnf implements logger.Logger.

func (GenericSugar) WithContextFields 

func (l GenericSugar) WithContextFields(allFields *field.FieldsChain, newFields int) belt.Tool

WithContextFields implements logger.Logger.

func (GenericSugar) WithEntryProperties 

func (l GenericSugar) WithEntryProperties(props ...types.EntryProperty) types.Logger

WithMessagePrefix implements logger.Logger.

func (GenericSugar) WithField 

func (l GenericSugar) WithField(
	key field.Key,
	value field.Value,
	props ...field.Property,
) types.Logger

WithField implements logger.Logger.

func (GenericSugar) WithFields 

func (l GenericSugar) WithFields(fields field.AbstractFields) types.Logger

WithFields implements logger.Logger.

func (GenericSugar) WithHooks 

func (l GenericSugar) WithHooks(hooks ...types.Hook) types.Logger

WithHooks implements logger.Logger.

func (GenericSugar) WithLevel 

func (l GenericSugar) WithLevel(newLevel types.Level) types.Logger

WithLevel implements logger.Logger.

func (GenericSugar) WithMessagePrefix 

func (l GenericSugar) WithMessagePrefix(prefix string) types.Logger

WithMessagePrefix implements logger.Logger.

func (GenericSugar) WithPreHooks 

func (l GenericSugar) WithPreHooks(preHooks ...types.PreHook) types.Logger

WithPreHooks implements logger.Logger.

func (GenericSugar) WithTraceIDs 

func (l GenericSugar) WithTraceIDs(allTraceIDs belt.TraceIDs, newTraceIDs int) belt.Tool

WithTraceIDs implements logger.Logger.

type Printfer 

type Printfer interface {
	// Printf is expected to work similarly to fmt.Printf, but having
	// any output destination (not limited to stdout/stderr/whatever).
	Printf(format string, args ...any)
}

Printfer is any object with a Printf method. For example the standard log.(*Logger) also implements this interface.

type PrintferEmitter 

type PrintferEmitter struct {
	Printfer
}

PrintferEmitter is an implementation of a Emitter given only a Printfer.

func (PrintferEmitter) Emit 

func (p PrintferEmitter) Emit(entry *types.Entry)

Emit implements logger.Emitter.

func (PrintferEmitter) Flush 

func (PrintferEmitter) Flush()

Flush implements logger.Emitter.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.