textlogger

Documentation

Overview

Package textlogger contains an implementation of the logr interface which is producing the exact same output as klog. It does not route output through klog (i.e. ignores k8s.io/klog/v2.InitFlags). Instead, all settings must be configured through its own NewConfig and Config.AddFlags.

Index

• Variables
• func NewLogger(c *Config) logr.Logger
• type Config
  • func NewConfig(opts ...ConfigOption) *Config
  • func (c *Config) AddFlags(fs *flag.FlagSet)
  • func (c *Config) VModule() flag.Value
  • func (c *Config) Verbosity() flag.Value
• type ConfigOption
  • func Backtrace(unwind func(skip int) (filename string, line int)) ConfigOption
  • func FixedTime(ts time.Time) ConfigOption
  • func Output(output io.Writer) ConfigOption
  • func VModuleFlagName(name string) ConfigOption
  • func Verbosity(level int) ConfigOption
  • func VerbosityFlagName(name string) ConfigOption
• type KlogBufferWriter

Examples

• Backtrace
• Config.Verbosity
• NewLogger

Variables

var (
	// TimeNow is used to retrieve the current time. May be changed for testing.
	TimeNow = time.Now
)

Functions

func NewLogger

func NewLogger(c *Config) logr.Logger

NewLogger constructs a new logger.

Verbosity can be modified at any time through the Config.V and Config.VModule API.

Example

ts, _ := time.Parse(time.RFC3339, "2000-12-24T12:30:40Z")
internal.Pid = 123 // To get consistent output for each run.
config := textlogger.NewConfig(
	textlogger.FixedTime(ts), // To get consistent output for each run.
	textlogger.Verbosity(4),  // Matches Kubernetes "debug" level.
	textlogger.Output(os.Stdout),
)
logger := textlogger.NewLogger(config)

logger.V(4).Info("A debug message")
logger.V(5).Info("A debug message with even lower level, not printed.")
logger.Info("An info message")
logger.Error(errors.New("fake error"), "An error")
logger.WithValues("int", 42).Info("With values",
	"duration", time.Second,
	"float", 3.12,
	"coordinates", coordinatesMarshaler{x: 100, y: 200},
	"variables", variables{A: 1, B: 2},
)
// The logr API supports skipping functions during stack unwinding, in contrast to slog.
someHelper(logger, "hello world")

Output:

I1224 12:30:40.000000     123 textlogger_test.go:54] "A debug message"
I1224 12:30:40.000000     123 textlogger_test.go:56] "An info message"
E1224 12:30:40.000000     123 textlogger_test.go:57] "An error" err="fake error"
I1224 12:30:40.000000     123 textlogger_test.go:58] "With values" int=42 duration="1s" float=3.12 coordinates={"X":100,"Y":200} variables={"A":1,"B":2}
I1224 12:30:40.000000     123 textlogger_test.go:65] "hello world"

Types

type Config

type Config struct {
	// contains filtered or unexported fields
}

Config influences logging in a text logger. To make this configurable via command line flags, instantiate this once per program and use AddFlags to bind command line flags to the instance before passing it to NewTestContext.

Must be constructed with NewConfig.

func NewConfig

func NewConfig(opts ...ConfigOption) *Config

NewConfig returns a configuration with recommended defaults and optional modifications. Command line flags are not bound to any FlagSet yet.

func (*Config) AddFlags

func (c *Config) AddFlags(fs *flag.FlagSet)

AddFlags registers the command line flags that control the configuration.

The default flag names are the same as in klog, so unless those defaults are changed, either klog.InitFlags or Config.AddFlags can be used for the same flag set, but not both.

func (*Config) VModule

func (c *Config) VModule() flag.Value

VModule returns a value instance that can be used to query (via String) or modify (via Set) the vmodule settings. This is thread-safe and can be done at runtime.

func (*Config) Verbosity

func (c *Config) Verbosity() flag.Value

Verbosity returns a value instance that can be used to query (via String) or modify (via Set) the verbosity threshold. This is thread-safe and can be done at runtime.

Example

package main

import (
	"bytes"
	"fmt"
	"regexp"

	"k8s.io/klog/v2/textlogger"
)

var headerRe = regexp.MustCompile(`([IE])[[:digit:]]{4} [[:digit:]]{2}:[[:digit:]]{2}:[[:digit:]]{2}\.[[:digit:]]{6}[[:space:]]+[[:digit:]]+ example_test.go:[[:digit:]]+\] `)

func main() {
	var buffer bytes.Buffer
	config := textlogger.NewConfig(textlogger.Verbosity(1), textlogger.Output(&buffer))
	logger := textlogger.NewLogger(config)

	logger.Info("initial verbosity", "v", config.Verbosity().String())
	logger.V(2).Info("now you don't see me")
	if err := config.Verbosity().Set("2"); err != nil {
		logger.Error(err, "setting verbosity to 2")
	}
	logger.V(2).Info("now you see me")
	if err := config.Verbosity().Set("1"); err != nil {
		logger.Error(err, "setting verbosity to 1")
	}
	logger.V(2).Info("now I'm gone again")

	fmt.Print(headerRe.ReplaceAllString(buffer.String(), "${1}...] "))

}

Output:

I...] "initial verbosity" v="1"
I...] "now you see me"

type ConfigOption

type ConfigOption func(co *configOptions)

ConfigOption implements functional parameters for NewConfig.

func Backtrace

func Backtrace(unwind func(skip int) (filename string, line int)) ConfigOption

Backtrace overrides the default mechanism for determining the call site. The callback is invoked with the number of function calls between itself and the call site. It must return the file name and line number. An empty file name indicates that the information is unknown.

Experimental

Notice: This function is EXPERIMENTAL and may be changed or removed in a later release.

Example

package main

import (
	"os"
	"time"

	internal "k8s.io/klog/v2/internal/buffer"
	"k8s.io/klog/v2/textlogger"
)

func main() {
	ts, _ := time.Parse(time.RFC3339, "2000-12-24T12:30:40Z")
	internal.Pid = 123 // To get consistent output for each run.
	backtraceCounter := 0
	config := textlogger.NewConfig(
		textlogger.FixedTime(ts), // To get consistent output for each run.
		textlogger.Backtrace(func(_ /* skip */ int) (filename string, line int) {
			backtraceCounter++
			if backtraceCounter == 1 {
				// Simulate "missing information".
				return "", 0
			}
			return "fake.go", 42

			// A real implementation could use Ginkgo:
			//
			// import ginkgotypes "github.com/onsi/ginkgo/v2/types"
			//
			// location := ginkgotypes.NewCodeLocation(skip + 1)
			// return location.FileName, location.LineNumber
		}),
		textlogger.Output(os.Stdout),
	)
	logger := textlogger.NewLogger(config)

	logger.Info("First message")
	logger.Info("Second message")

}

Output:

I1224 12:30:40.000000     123 ???:1] "First message"
I1224 12:30:40.000000     123 fake.go:42] "Second message"

func FixedTime

func FixedTime(ts time.Time) ConfigOption

FixedTime overrides the actual time with a fixed time. Useful only for testing.

Experimental

Notice: This function is EXPERIMENTAL and may be changed or removed in a later release.

func Output

func Output(output io.Writer) ConfigOption

Output overrides stderr as the output stream.

func VModuleFlagName

func VModuleFlagName(name string) ConfigOption

VModulFlagName overrides the default -vmodule for the per-module verbosity levels.

func Verbosity

func Verbosity(level int) ConfigOption

Verbosity overrides the default verbosity level of 0. See https://github.com/kubernetes/community/blob/9406b4352fe2d5810cb21cc3cb059ce5886de157/contributors/devel/sig-instrumentation/logging.md#logging-conventions for log level conventions in Kubernetes.

func VerbosityFlagName

func VerbosityFlagName(name string) ConfigOption

VerbosityFlagName overrides the default -v for the verbosity level.

type KlogBufferWriter

type KlogBufferWriter interface {
	// WriteKlogBuffer takes a pre-formatted buffer prepared by klog and
	// writes it unchanged to the output stream. Can be used with
	// klog.WriteKlogBuffer when setting a logger through
	// klog.SetLoggerWithOptions.
	WriteKlogBuffer([]byte)
}

KlogBufferWriter is implemented by the textlogger LogSink.