PseudoStruct is a list of key-value pairs that gets logged as a struct.

Will be handled via reflection instead of type assertions.

CallDepthLogSink represents a LogSink that knows how to climb the call stack to identify the original call site and can offset the depth by a specifie

CallStackHelperLogSink represents a LogSink that knows how to climb the call stack to identify the original call site and can skip intermediate helper

Caller represents the original call site for a log line, after considering logr.Logger.WithCallDepth and logr.Logger.WithCallStackHelper. The File an

ComplexObjectRef contains more fields than it wants to get logged.

Formatter is an opaque struct which can be embedded in a LogSink implementation. It should be constructed with NewFormatter. Some of its methods direc

LogSink represents a logging implementation. End-users will generally not interact with this type.

Logger is an interface to an abstract logging implementation. This is a concrete type for performance reasons, but all the real work is passed on to

Marshaler is an optional interface that logged values may choose to implement. Loggers with structured output, such as JSON, should log the object ret

MessageClass indicates which category or categories of messages to consider.

ObjectRef references a Kubernetes object

Options carries parameters which influence the way logs are generated.

Options carries parameters which influence the way logs are generated.

RuntimeInfo holds information that the logr "core" library knows which LogSinks might want to know.

SlogSink is an optional interface that a LogSink can implement to support logging through the slog.Logger or slog.Handler APIs better. It then should

Logging this should result in the Error() value.

Logging this should result in a panic.

TestingT is an interface wrapper around testing.T, testing.B and testing.F.

Logging this should result in the MarshalLog() value.

Logging this should result in a panic.

Logging this should result in the String() value.

Logging this should result in a panic.

Underlier is implemented by the LogSink returned by NewFromLogHandler.

Underlier exposes access to the underlying testing.T instance. Since callers only have a logr.Logger, they have to know which implementation is in use

Underlier exposes access to the underlying logging function. Since callers only have a logr.Logger, they have to know which implementation is in use,

UnderlierInterface exposes access to the underlying TestingT instance. Since callers only have a logr.Logger, they have to know which implementation i

contextKey is how we find Loggers in a context.Context. With Go < 1.21, the value is always a Logger value. With Go >= 1.21, the value can be a Logger

fnlogger inherits some of its LogSink implementation from Formatter and just needs to add some glue code.

notFoundError exists to carry an IsNotFound method.

outputFormat indicates which outputFormat to use.

passthruLogSink is a trivial LogSink implementation, which implements the logr.LogSink methods in terms of a slog.Handler.

passthruSlogSink is a trivial SlogSink implementation, which stubs out the logr.LogSink methods and passes Logr.SlogSink thru to a slog.Handler.

point implements encoding.TextMarshaler and can be used as a map key.

pointErr implements encoding.TextMarshaler but returns an error.

tabLogSink is a sample logr.LogSink that logs to stderr. It's terribly inefficient, and is only a basic example.

testLogSink is a trivial LogSink implementation, just for testing, which calls (optional) hooks on each method.

testSlogSink is a trivial SlogSink implementation, just for testing, which calls (optional) hooks on each method.

This type exists to wrap and modify the method-set of testloggerInterface. In particular, it changes the GetUnderlying() method.