github.com/go-logr/logr (go): Package logr defines a general-purpose logging API and abstract interfaces to back that API.  Packages in the Go ecosystem can depend on this package, while callers can implement logging with whatever backend is appropriate.  Logging is done using a Logger instance.  Logger is a concrete type with methods, which defers the actual logging to a LogSink interface.  The main methods of Logger are Info() and Error().  Arguments to Info() and Error() are key/value pairs rather than printf-style formatted strings, emphasizing "structured logging".  With Go's standard log package, we might write:  With logr's structured logging, we'd write:  Errors are much the same.  Instead of:  We'd write:  Info() and Error() are very similar, but they are separate methods so that LogSink implementations can choose to do things like attach additional information (such as stack traces) on calls to Error(). Error() messages are always logged, regardless of the current verbosity.  If there is no error instance available, passing nil is valid.  Often we want to log information only when the application in "verbose mode".  To write log lines that are more verbose, Logger has a V() method. The higher the V-level of a log line, the less critical it is considered. Log-lines with V-levels that are not enabled (as per the LogSink) will not be written.  Level V(0) is the default, and logger.V(0).Info() has the same meaning as logger.Info().  Negative V-levels have the same meaning as V(0). Error messages do not have a verbosity level and are always logged.  Where we might have written:  We can write:  Logger instances can have name strings so that all messages logged through that instance have additional context.  For example, you might want to add a subsystem name:  The WithName() method returns a new Logger, which can be passed to constructors or other functions for further use.  Repeated use of WithName() will accumulate name "segments".  These name segments will be joined in some way by the LogSink implementation.  It is strongly recommended that name segments contain simple identifiers (letters, digits, and hyphen), and do not contain characters that could muddle the log output or confuse the joining operation (e.g. whitespace, commas, periods, slashes, brackets, quotes, etc).  Logger instances can store any number of key/value pairs, which will be logged alongside all messages logged through that instance.  For example, you might want to create a Logger instance per managed object:  With the standard log package, we might write:  With logr we'd write:  Logger has very few hard rules, with the goal that LogSink implementations might have a lot of freedom to differentiate.  There are, however, some things to consider.  The log message consists of a constant message attached to the log line. This should generally be a simple description of what's occurring, and should never be a format string.  Variable information can then be attached using named values.  Keys are arbitrary strings, but should generally be constant values.  Values may be any Go value, but how the value is formatted is determined by the LogSink implementation.  Logger instances are meant to be passed around by value. Code that receives such a value can call its methods without having to check whether the instance is ready for use.  Calling methods with the null logger (Logger{}) as instance will crash because it has no LogSink. Therefore this null logger should never be passed around. For cases where passing a logger is optional, a pointer to Logger should be used.  Keys are not strictly required to conform to any specification or regex, but it is recommended that they:  These guidelines help ensure that log data is processed properly regardless of the log implementation.  For example, log implementations will try to output JSON data or will store data for later database (e.g. SQL) queries.  While users are generally free to use key names of their choice, it's generally best to avoid using the following keys, as they're frequently used by implementations:  Implementations are encouraged to make use of these keys to represent the above concepts, when necessary (for example, in a pure-JSON output form, it would be necessary to represent at least message and timestamp as ordinary named values).  Implementations may choose to give callers access to the underlying logging implementation.  The recommended pattern for this is:  Logger grants access to the sink to enable type assertions like this:  Custom `With*` functions can be implemented by copying the complete Logger struct and replacing the sink in the copy:  Don't use New to construct a new Logger with a LogSink retrieved from an existing Logger. Source code attribution might not work correctly and unexported fields in Logger get lost.  Beware that the same LogSink instance may be shared by different logger instances. Calling functions that modify the LogSink will affect all of those.
Keywords: logger|logging