Пакет slog
Обзор
Пакет slog предоставляет структурированный логгирование, в котором записи лога включают сообщение, уровень серьезности и различные другие атрибуты, выраженные в виде пар ключ-значение.
Он определяет тип Logger, который предоставляет несколько методов (таких как Logger.Info и Logger.Error) для отслеживания событий.
Каждый Logger связан с Handler. Метод вывода Logger создает Record из аргументов метода и передает его Handler, который определяет, как обработать его. Существует по умолчанию Logger, доступный через функции верхнего уровня (такие как Info и Error), которые вызывают соответствующие методы Logger.
Запись лога состоит из времени, уровня, сообщения и набора пар ключ-значение, где ключи — строки, а значения могут быть любого типа. Например,
slog.Info("hello", "count", 3)
создает запись, содержащую время вызова, уровень Info, сообщение "hello" и одну пару с ключом "count" и значением 3.
Функция верхнего уровня Info вызывает метод Logger.Info в Logger по умолчанию. Помимо Logger.Info, существуют методы для уровней Debug, Warn и Error. Помимо этих удобных методов для общих уровней, также есть метод Logger.Log, который принимает уровень в качестве аргумента. Каждый из этих методов имеет соответствующую функцию верхнего уровня, использующую логгер по умолчанию.
Обработчик по умолчанию форматирует сообщение, время, уровень и атрибуты записи лога в строку и передает ее пакету log.
2022/11/08 15:28:26 INFO hello count=3
Для большего контроля над форматом вывода создайте логгер с другим обработчиком. Это утверждение использует New для создания нового логгера с TextHandler, который записывает структурированные записи в текстовом формате в стандартный вывод ошибок:
logger := slog.New(slog.NewTextHandler(os.Stderr, nil))
TextHandler выводит последовательность пар ключ=значение, которые легко и однозначно парсятся машиной. Это утверждение:
logger.Info("hello", "count", 3)
выводит этот результат:
time=2022-11-08T15:28:26.000-05:00 level=INFO msg=hello count=3
Пакет также предоставляет JSONHandler, чьим выводом являются разделительные JSON-строки:
logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
logger.Info("hello", "count", 3)
выводит этот результат:
{"time":"2022-11-08T15:28:26.000000000-05:00","level":"INFO","msg":"hello","count":3}
И TextHandler, и JSONHandler могут быть настроены с помощью HandlerOptions. Существуют параметры для установки минимального уровня (см. Уровни ниже), отображения файла и строки вызова лога и изменения атрибутов перед их записью.
Установление логгера в качестве значения по умолчанию с помощью
slog.SetDefault(logger)
приведет к тому, что функции верхнего уровня, такие как Info, будут использовать его. SetDefault также обновляет логгер по умолчанию, используемый пакетом log, так что существующие приложения, использующие log.Printf и связанные функции, будут отправлять записи лога в обработчик логгера без необходимости переписывания.
Некоторые атрибуты являются общими для многих вызовов лога. Например, вы можете включить URL-адрес или идентификатор трассировки запроса сервера во всех событиях лога, возникающих в результате запроса. Вместо того чтобы повторять атрибут в каждом вызове лога, вы можете использовать Logger.With для построения нового Logger, содержащего атрибуты:
logger2 := logger.With("url", r.URL)
Аргументы для With — те же пары ключ-значение, что и в Logger.Info. Результатом является новый Logger с тем же обработчиком, что и исходный, но с дополнительными атрибутами, которые будут отображаться в выводе каждого вызова.
Уровни
Уровень — целое число, представляющее важность или серьезность события лога. Чем выше уровень, тем более серьезное событие. В этом пакете определены константы для наиболее распространенных уровней, но в качестве уровня может использоваться любое целое число.
В приложении вы можете захотеть регистрировать сообщения только на определенном уровне или выше. Один из распространенных способов настройки — регистрировать сообщения на уровнях Info или выше, подавляя отладку до тех пор, пока она не потребуется. Встроенные обработчики могут быть настроены с минимальным уровнем вывода, установив [HandlerOptions.Level]. Это обычно делает функция `main` программы. Значение по умолчанию — LevelInfo.
Установка поля [HandlerOptions.Level] в значение Level устанавливает минимальный уровень обработчика на протяжении всего его жизненного цикла. Установка его в LevelVar позволяет динамически изменять уровень. LevelVar содержит Level и безопасен для чтения или записи из нескольких горутин.
var programLevel = new(slog.LevelVar) // Info by default
Затем используйте LevelVar для построения обработчика и сделайте его значением по умолчанию:
h := slog.NewJSONHandler(os.Stderr, &slog.HandlerOptions{Level: programLevel})
slog.SetDefault(slog.New(h))
Теперь программа может изменить уровень ведения журнала одной строкой:
programLevel.Set(slog.LevelDebug)
Группы
Атрибуты могут быть объединены в группы. Группа имеет имя, которое используется для квалификации имен ее атрибутов. Как отображается это квалификация зависит от обработчика. TextHandler разделяет имена группы и атрибута точкой. JSONHandler рассматривает каждую группу как отдельный JSON-объект, где имя группы является ключом.
Используйте Group для создания атрибута Group из имени и списка пар ключ-значение:
slog.Group("request",
"method", r.Method,
"url", r.URL)
TextHandler отобразил бы эту группу как
request.method=GET request.url=http://example.com
JSONHandler отобразил бы ее как
"request":{"method":"GET","url":"http://example.com"}
Используйте Logger.WithGroup для квалификации всего вывода Logger с именем группы. Вызов WithGroup для Logger приводит к новому Logger с тем же обработчиком, что и исходный, но со всеми его атрибутами, квалифицированными именем группы.
Это может помочь избежать дублирования ключей атрибутов в больших системах, где подсистемы могут использовать одни и те же ключи. Передайте каждой подсистеме отдельный Logger со своим именем группы, чтобы потенциальные дубликаты были квалифицированы:
logger := slog.Default().With("id", systemID)
parserLogger := logger.WithGroup("parser")
parseInput(input, parserLogger)
Когда parseInput регистрирует с помощью parserLogger, его ключи будут квалифицированы с "parser", поэтому даже если он использует общий ключ "id", строка лога будет иметь отдельные ключи.
Контексты
Некоторые обработчики могут захотеть включить информацию из context.Context, которая доступна в месте вызова. Одним из примеров такой информации является идентификатор текущего раздела при включенной трассировке.
Методы Logger.Log и Logger.LogAttrs принимают контекст в качестве первого аргумента, как и соответствующие функции верхнего уровня.
Хотя удобные методы Logger (Info и т. д.) и соответствующие функции верхнего уровня не принимают контекст, альтернативы, оканчивающиеся на "Context", принимают. Например,
slog.InfoContext(ctx, "message")
Рекомендуется передавать контекст методу вывода, если он доступен.
Атрибуты и значения
Атрибут (Attr) — это пара ключ-значение. Методы вывода Logger принимают атрибуты, а также чередующиеся ключи и значения. Выражение
slog.Info("hello", slog.Int("count", 3))
эквивалентно
slog.Info("hello", "count", 3)
Существуют удобные конструкторы для Attr, такие как Int, String и Bool для общих типов, а также функция Any для создания атрибутов любого типа.
Часть значения атрибута — это тип, называемый Value. Как и [any], Value может хранить любое значение Go, но может представлять типичные значения, включая все числа и строки, без выделения памяти.
Для наиболее эффективного вывода лога используйте Logger.LogAttrs. Он похож на Logger.Log, но принимает только атрибуты, а не чередующиеся ключи и значения; это позволяет ему также избежать выделения памяти.
Вызов
logger.LogAttrs(ctx, slog.LevelInfo, "hello", slog.Int("count", 3))
является наиболее эффективным способом достижения такого же результата, что и
slog.InfoContext(ctx, "hello", "count", 3)
Настройка поведения логгирования типа
Если тип реализует интерфейс LogValuer, Value, возвращаемый методом LogValue, используется для логгирования. Вы можете использовать это для управления тем, как значения типа отображаются в логах. Например, вы можете замаскировать конфиденциальную информацию, такую как пароли, или собрать поля структуры в группе. Подробности см. в примерах в разделе LogValuer.
Метод LogValue может вернуть Value, который сам реализует LogValuer. Метод Value.Resolve тщательно обрабатывает эти случаи, избегая бесконечных циклов и неограниченной рекурсии. Авторы обработчиков и другие могут захотеть использовать Value.Resolve вместо прямого вызова LogValue.
Обертывание методов вывода
Функции логгера используют рефлексию над стеком вызовов для определения имени файла и номера строки вызова логгирования в приложении. Это может привести к неправильной информации о источнике для функций, которые оборачивают slog. Например, если вы определите эту функцию в файле mylog.go:
func Infof(logger *slog.Logger, format string, args ...any) {
logger.Info(fmt.Sprintf(format, args...))
}
и вызовете ее так в main.go:
Infof(slog.Default(), "hello, %s", "world")
тогда slog будет отображать исходный файл как mylog.go, а не main.go.
Правильная реализация Infof получит местоположение источника (pc) и передаст его в NewRecord. Функция Infof в примере на уровне пакета, называемом "обертывание", демонстрирует, как это сделать.
Работа с записями
Иногда обработчику потребуется изменить запись перед передачей ее другому обработчику или обратному выводу. Запись содержит смесь простых общедоступных полей (например, Time, Level, Message) и скрытых полей, которые косвенно ссылаются на состояние (например, атрибуты). Это означает, что изменение простой копии записи (например, путем вызова Record.Add или Record.AddAttrs для добавления атрибутов) может иметь непредвиденные последствия для исходной записи. Перед изменением записи используйте Record.Clone для создания копии, которая не разделяет состояние с оригиналом, или создайте новую запись с помощью NewRecord и постройте ее атрибуты, пройдясь по старым с помощью Record.Attrs.
Учитывание производительности
Если при профилировании приложения выясняется, что логгирование занимает значительное время, следующие рекомендации могут помочь.
Если многие строки лога имеют общий атрибут, используйте Logger.With для создания Logger с этим атрибутом. Встроенные обработчики отформатируют этот атрибут только один раз при вызове Logger.With. Интерфейс Handler разработан для поддержки этой оптимизации, и хорошо написанный обработчик должен использовать ее.
Аргументы вызова функции log всегда вычисляются, даже если событие лога отбрасывается. Если возможно, отложите вычисление, чтобы оно происходило только в том случае, если значение фактически записывается в лог. Например, рассмотрите вызов
slog.Info("starting request", "url", r.URL.String()) // may compute String unnecessarily
Метод URL.String будет вызываться, даже если логгер отбрасывает события уровня Info. Вместо этого передайте URL напрямую:
slog.Info("starting request", "url", &r.URL) // calls URL.String only if needed
Встроенный TextHandler будет вызывать свой метод String, но только если событие лога включено. Избежание вызова String также сохраняет структуру базового значения. Например, JSONHandler выводит компоненты разобранного URL в виде JSON-объекта. Если вы хотите избежать преждевременной оплаты затрат вызова String без того, чтобы заставить обработчик потенциально исследовать структуру значения, оберните значение в реализацию fmt.Stringer, которая скрывает свои методы Marshal.
Вы также можете использовать интерфейс LogValuer, чтобы избежать ненужной работы в вызовах лога, которые отключены. Предположим, вам нужно записать в лог какое-то дорогостоящее значение:
slog.Debug("frobbing", "value", computeExpensiveValue(arg))
Даже если эта строка отключена, computeExpensiveValue будет вызван. Чтобы этого избежать, определите тип, реализующий LogValuer:
type expensive struct { arg int }
func (e expensive) LogValue() slog.Value {
return slog.AnyValue(computeExpensiveValue(e.arg))
}
Затем используйте значение этого типа в вызовах лога:
slog.Debug("frobbing", "value", expensive{arg})
Теперь computeExpensiveValue будет вызван только тогда, когда строка включена.
Встроенные обработчики блокируют выполнение перед вызовом io.Writer.Write, чтобы гарантировать, что ровно одна запись Record записывается целиком за раз. Хотя каждый журнал событий имеет отметку времени, встроенные обработчики не используют это время для сортировки записываемых записей. Пользовательские обработчики отвечают за свою блокировку и сортировку.
Написание обработчика
Для руководства по написанию пользовательского обработчика см. https://golang.org/s/slog-handler-guide.
Пример (DiscardHandler)
Код:
// A slog.TextHandler can output log messages.
logger1 := slog.New(slog.NewTextHandler(
os.Stdout,
&slog.HandlerOptions{ReplaceAttr: slogtest.RemoveTime},
))
logger1.Info("message 1")
// A slog.DiscardHandler will discard all messages.
logger2 := slog.New(slog.DiscardHandler)
logger2.Info("message 2")
Вывод:
level=INFO msg="message 1"
Пример (Обертывание)
Код:
package slog_test
import (
"context"
"fmt"
"log/slog"
"os"
"path/filepath"
"runtime"
"time"
)
// Infof is an example of a user-defined logging function that wraps slog.
// The log record contains the source position of the caller of Infof.
func Infof(logger *slog.Logger, format string, args ...any) {
if !logger.Enabled(context.Background(), slog.LevelInfo) {
return
}
var pcs [1]uintptr
runtime.Callers(2, pcs[:]) // skip [Callers, Infof]
r := slog.NewRecord(time.Now(), slog.LevelInfo, fmt.Sprintf(format, args...), pcs[0])
_ = logger.Handler().Handle(context.Background(), r)
}
func Example_wrapping() {
replace := func(groups []string, a slog.Attr) slog.Attr {
// Remove time.
if a.Key == slog.TimeKey && len(groups) == 0 {
return slog.Attr{}
}
// Remove the directory from the source's filename.
if a.Key == slog.SourceKey {
source := a.Value.Any().(*slog.Source)
source.File = filepath.Base(source.File)
}
return a
}
logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{AddSource: true, ReplaceAttr: replace}))
Infof(logger, "message, %s", "formatted")
// Output:
// level=INFO source=example_wrap_test.go:43 msg="message, formatted"
}
Индекс
Примеры
Файлы пакета
attr.go doc.go handler.go json_handler.go level.go logger.go record.go text_handler.go value.go
Константы
Ключи для "встроенных" атрибутов.
const (
// TimeKey is the key used by the built-in handlers for the time
// when the log method is called. The associated Value is a [time.Time].
TimeKey = "time"
// LevelKey is the key used by the built-in handlers for the level
// of the log call. The associated value is a [Level].
LevelKey = "level"
// MessageKey is the key used by the built-in handlers for the
// message of the log call. The associated value is a string.
MessageKey = "msg"
// SourceKey is the key used by the built-in handlers for the source file
// and line of the log call. The associated value is a *[Source].
SourceKey = "source"
) Функция Debug 1.21
func Debug(msg string, args ...any)
Debug вызывает Logger.Debug для логгера по умолчанию.
Функция DebugContext 1.21
func DebugContext(ctx context.Context, msg string, args ...any)
DebugContext вызывает Logger.DebugContext для логгера по умолчанию.
Функция Error 1.21
func Error(msg string, args ...any)
Error вызывает Logger.Error для логгера по умолчанию.
Функция ErrorContext 1.21
func ErrorContext(ctx context.Context, msg string, args ...any)
ErrorContext вызывает Logger.ErrorContext для логгера по умолчанию.
Функция Info 1.21
func Info(msg string, args ...any)
Info вызывает Logger.Info для логгера по умолчанию.
Функция InfoContext 1.21
func InfoContext(ctx context.Context, msg string, args ...any)
InfoContext вызывает Logger.InfoContext для логгера по умолчанию.
Функция Log 1.21
func Log(ctx context.Context, level Level, msg string, args ...any)
Log вызывает Logger.Log для логгера по умолчанию.
Функция LogAttrs 1.21
func LogAttrs(ctx context.Context, level Level, msg string, attrs ...Attr)
LogAttrs вызывает Logger.LogAttrs для логгера по умолчанию.
Функция NewLogLogger 1.21
func NewLogLogger(h Handler, level Level) *log.Logger
NewLogLogger возвращает новый log.Logger, такой что каждый вызов его метода Output отправляет запись Record указанному обработчику. Логгер действует как мост от старого API логов к новым обработчикам структурированной записи.
Функция SetDefault 1.21
func SetDefault(l *Logger)
SetDefault делает l логгером по умолчанию (Logger), который используется в основных функциях, таких как Info, Debug и т.д. После этого вызова вывод из логгера по умолчанию пакета log (как с log.Print и т.д.) будет записываться с помощью обработчика l, на уровне, контролируемом SetLogLoggerLevel.
Функция Warn 1.21
func Warn(msg string, args ...any)
Warn вызывает Logger.Warn для логгера по умолчанию.
Функция WarnContext 1.21
func WarnContext(ctx context.Context, msg string, args ...any)
WarnContext вызывает Logger.WarnContext для логгера по умолчанию.
Тип Attr 1.21
Attr — это пара ключ-значение.
type Attr struct {
Key string
Value Value
}
Функция Any 1.21
func Any(key string, value any) Attr
Any возвращает Attr для предоставленного значения. См. AnyValue для того, как обрабатываются значения.
Функция Bool 1.21
func Bool(key string, v bool) Attr
Bool возвращает Attr для bool.
Функция Duration 1.21
func Duration(key string, v time.Duration) Attr
Duration возвращает Attr для time.Duration.
Функция Float64 1.21
func Float64(key string, v float64) Attr
Float64 возвращает Attr для числа с плавающей точкой.
Функция Group 1.21
func Group(key string, args ...any) Attr
Group возвращает Attr для группы Value. Первый аргумент — ключ; остальные аргументы преобразуются в Attrs так же, как в Logger.Log.
Используйте Group для объединения нескольких пар ключ-значение под одним ключом в строке лога или в результате LogValue для записи одного значения как нескольких Attrs.
Пример
Код:
r, _ := http.NewRequest("GET", "localhost", nil)
// ...
logger := slog.New(
slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr {
if a.Key == slog.TimeKey && len(groups) == 0 {
return slog.Attr{}
}
return a
},
}),
)
logger.Info("finished",
slog.Group("req",
slog.String("method", r.Method),
slog.String("url", r.URL.String())),
slog.Int("status", http.StatusOK),
slog.Duration("duration", time.Second))
Вывод:
level=INFO msg=finished req.method=GET req.url=localhost status=200 duration=1s
Функция Int 1.21
func Int(key string, value int) Attr
Int преобразует int в int64 и возвращает Attr с этим значением.
Функция Int64 1.21
func Int64(key string, value int64) Attr
Int64 возвращает Attr для int64.
Функция String 1.21
func String(key, value string) Attr
String возвращает Attr для строкового значения.
Функция Time 1.21
func Time(key string, v time.Time) Attr
Time возвращает Attr для time.Time. Она отбрасывает монотонную часть.
Функция Uint64 1.21
func Uint64(key string, v uint64) Attr
Uint64 возвращает Attr для uint64.
Функция (Attr) Equal 1.21
func (a Attr) Equal(b Attr) bool
Equal сообщает, имеют ли a и b равные ключи и значения.
Функция (Attr) String 1.21
func (a Attr) String() string
Тип Handler 1.21
Handler обрабатывает записи логов, созданные Logger.
Типичный обработчик может выводить записи логов в стандартный поток ошибок, записывать их в файл или базу данных, или, возможно, дополнять их дополнительными атрибутами и передавать их другому обработчику.
Любой из методов Handler может быть вызван одновременно с самим собой или с другими методами. Ответственность Handler заключается в управлении этой одновременностью.
Пользователи пакета slog не должны вызывать методы Handler напрямую. Вместо этого они должны использовать методы Logger.
type Handler interface {
// Enabled reports whether the handler handles records at the given level.
// The handler ignores records whose level is lower.
// It is called early, before any arguments are processed,
// to save effort if the log event should be discarded.
// If called from a Logger method, the first argument is the context
// passed to that method, or context.Background() if nil was passed
// or the method does not take a context.
// The context is passed so Enabled can use its values
// to make a decision.
Enabled(context.Context, Level) bool
// Handle handles the Record.
// It will only be called when Enabled returns true.
// The Context argument is as for Enabled.
// It is present solely to provide Handlers access to the context's values.
// Canceling the context should not affect record processing.
// (Among other things, log messages may be necessary to debug a
// cancellation-related problem.)
//
// Handle methods that produce output should observe the following rules:
// - If r.Time is the zero time, ignore the time.
// - If r.PC is zero, ignore it.
// - Attr's values should be resolved.
// - If an Attr's key and value are both the zero value, ignore the Attr.
// This can be tested with attr.Equal(Attr{}).
// - If a group's key is empty, inline the group's Attrs.
// - If a group has no Attrs (even if it has a non-empty key),
// ignore it.
Handle(context.Context, Record) error
// WithAttrs returns a new Handler whose attributes consist of
// both the receiver's attributes and the arguments.
// The Handler owns the slice: it may retain, modify or discard it.
WithAttrs(attrs []Attr) Handler
// WithGroup returns a new Handler with the given group appended to
// the receiver's existing groups.
// The keys of all subsequent attributes, whether added by With or in a
// Record, should be qualified by the sequence of group names.
//
// How this qualification happens is up to the Handler, so long as
// this Handler's attribute keys differ from those of another Handler
// with a different sequence of group names.
//
// A Handler should treat WithGroup as starting a Group of Attrs that ends
// at the end of the log event. That is,
//
// logger.WithGroup("s").LogAttrs(ctx, level, msg, slog.Int("a", 1), slog.Int("b", 2))
//
// should behave like
//
// logger.LogAttrs(ctx, level, msg, slog.Group("s", slog.Int("a", 1), slog.Int("b", 2)))
//
// If the name is empty, WithGroup returns the receiver.
WithGroup(name string) Handler
} DiscardHandler отбрасывает весь вывод лога. DiscardHandler.Enabled возвращает false для всех уровней.
var DiscardHandler Handler = discardHandler{} Пример (LevelHandler)
В этом примере показано, как использовать LevelHandler для изменения уровня существующего Handler, сохраняя при этом его другое поведение. В этом примере показано повышение уровня лога для уменьшения вывода логгера. Другое типичное использование состояло бы в снижении уровня лога (например, до LevelDebug) во время части программы, которая, по предположению, содержала ошибку.
Код:
package slog_test
import (
"context"
"log/slog"
"log/slog/internal/slogtest"
"os"
)
// A LevelHandler wraps a Handler with an Enabled method
// that returns false for levels below a minimum.
type LevelHandler struct {
level slog.Leveler
handler slog.Handler
}
// NewLevelHandler returns a LevelHandler with the given level.
// All methods except Enabled delegate to h.
func NewLevelHandler(level slog.Leveler, h slog.Handler) *LevelHandler {
// Optimization: avoid chains of LevelHandlers.
if lh, ok := h.(*LevelHandler); ok {
h = lh.Handler()
}
return &LevelHandler{level, h}
}
// Enabled implements Handler.Enabled by reporting whether
// level is at least as large as h's level.
func (h *LevelHandler) Enabled(_ context.Context, level slog.Level) bool {
return level >= h.level.Level()
}
// Handle implements Handler.Handle.
func (h *LevelHandler) Handle(ctx context.Context, r slog.Record) error {
return h.handler.Handle(ctx, r)
}
// WithAttrs implements Handler.WithAttrs.
func (h *LevelHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
return NewLevelHandler(h.level, h.handler.WithAttrs(attrs))
}
// WithGroup implements Handler.WithGroup.
func (h *LevelHandler) WithGroup(name string) slog.Handler {
return NewLevelHandler(h.level, h.handler.WithGroup(name))
}
// Handler returns the Handler wrapped by h.
func (h *LevelHandler) Handler() slog.Handler {
return h.handler
}
// This example shows how to Use a LevelHandler to change the level of an
// existing Handler while preserving its other behavior.
//
// This example demonstrates increasing the log level to reduce a logger's
// output.
//
// Another typical use would be to decrease the log level (to LevelDebug, say)
// during a part of the program that was suspected of containing a bug.
func ExampleHandler_levelHandler() {
th := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{ReplaceAttr: slogtest.RemoveTime})
logger := slog.New(NewLevelHandler(slog.LevelWarn, th))
logger.Info("not printed")
logger.Warn("printed")
// Output:
// level=WARN msg=printed
}
Тип HandlerOptions 1.21
HandlerOptions — это параметры для TextHandler или JSONHandler. HandlerOptions по умолчанию состоит целиком из значений по умолчанию.
type HandlerOptions struct {
// AddSource causes the handler to compute the source code position
// of the log statement and add a SourceKey attribute to the output.
AddSource bool
// Level reports the minimum record level that will be logged.
// The handler discards records with lower levels.
// If Level is nil, the handler assumes LevelInfo.
// The handler calls Level.Level for each record processed;
// to adjust the minimum level dynamically, use a LevelVar.
Level Leveler
// ReplaceAttr is called to rewrite each non-group attribute before it is logged.
// The attribute's value has been resolved (see [Value.Resolve]).
// If ReplaceAttr returns a zero Attr, the attribute is discarded.
//
// The built-in attributes with keys "time", "level", "source", and "msg"
// are passed to this function, except that time is omitted
// if zero, and source is omitted if AddSource is false.
//
// The first argument is a list of currently open groups that contain the
// Attr. It must not be retained or modified. ReplaceAttr is never called
// for Group attributes, only their contents. For example, the attribute
// list
//
// Int("a", 1), Group("g", Int("b", 2)), Int("c", 3)
//
// results in consecutive calls to ReplaceAttr with the following arguments:
//
// nil, Int("a", 1)
// []string{"g"}, Int("b", 2)
// nil, Int("c", 3)
//
// ReplaceAttr can be used to change the default keys of the built-in
// attributes, convert types (for example, to replace a `time.Time` with the
// integer seconds since the Unix epoch), sanitize personal information, or
// remove attributes from the output.
ReplaceAttr func(groups []string, a Attr) Attr
}
Пример (CustomLevels)
В этом примере показано использование настраиваемых уровней логов и настраиваемых имен уровней логов. В дополнение к стандартным уровням логов он вводит уровни Trace, Notice и Emergency. ReplaceAttr изменяет способ вывода уровней для как стандартных уровней логов, так и настраиваемых.
Код:
// Exported constants from a custom logging package.
const (
LevelTrace = slog.Level(-8)
LevelDebug = slog.LevelDebug
LevelInfo = slog.LevelInfo
LevelNotice = slog.Level(2)
LevelWarning = slog.LevelWarn
LevelError = slog.LevelError
LevelEmergency = slog.Level(12)
)
th := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
// Set a custom level to show all log output. The default value is
// LevelInfo, which would drop Debug and Trace logs.
Level: LevelTrace,
ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr {
// Remove time from the output for predictable test output.
if a.Key == slog.TimeKey {
return slog.Attr{}
}
// Customize the name of the level key and the output string, including
// custom level values.
if a.Key == slog.LevelKey {
// Rename the level key from "level" to "sev".
a.Key = "sev"
// Handle custom level values.
level := a.Value.Any().(slog.Level)
// This could also look up the name from a map or other structure, but
// this demonstrates using a switch statement to rename levels. For
// maximum performance, the string values should be constants, but this
// example uses the raw strings for readability.
switch {
case level < LevelDebug:
a.Value = slog.StringValue("TRACE")
case level < LevelInfo:
a.Value = slog.StringValue("DEBUG")
case level < LevelNotice:
a.Value = slog.StringValue("INFO")
case level < LevelWarning:
a.Value = slog.StringValue("NOTICE")
case level < LevelError:
a.Value = slog.StringValue("WARNING")
case level < LevelEmergency:
a.Value = slog.StringValue("ERROR")
default:
a.Value = slog.StringValue("EMERGENCY")
}
}
return a
},
})
logger := slog.New(th)
ctx := context.Background()
logger.Log(ctx, LevelEmergency, "missing pilots")
logger.Error("failed to start engines", "err", "missing fuel")
logger.Warn("falling back to default value")
logger.Log(ctx, LevelNotice, "all systems are running")
logger.Info("initiating launch")
logger.Debug("starting background job")
logger.Log(ctx, LevelTrace, "button clicked")
Вывод:
sev=EMERGENCY msg="missing pilots" sev=ERROR msg="failed to start engines" err="missing fuel" sev=WARNING msg="falling back to default value" sev=NOTICE msg="all systems are running" sev=INFO msg="initiating launch" sev=DEBUG msg="starting background job" sev=TRACE msg="button clicked"
Тип JSONHandler 1.21
JSONHandler — это Handler, который записывает Record в io.Writer как строки, разделенные JSON-объектами.
type JSONHandler struct {
// contains filtered or unexported fields
}
Функция NewJSONHandler 1.21
func NewJSONHandler(w io.Writer, opts *HandlerOptions) *JSONHandler
NewJSONHandler создает JSONHandler, который записывает в w, используя заданные параметры. Если opts равно nil, используются параметры по умолчанию.
Функция (*JSONHandler) Enabled 1.21
func (h *JSONHandler) Enabled(_ context.Context, level Level) bool
Enabled сообщает, обрабатывает ли обработчик записи на данном уровне. Обработчик игнорирует записи, уровень которых ниже.
Функция (*JSONHandler) Handle 1.21
func (h *JSONHandler) Handle(_ context.Context, r Record) error
Handle форматирует свой аргумент Record как JSON-объект в одной строке.
Если время Record равно нулю, время опускается. В противном случае ключ — "time", а значение выводится так же, как с json.Marshal.
Если уровень Record равен нулю, уровень опускается. В противном случае ключ — "level", а значение Level.String выводится.
Если параметр AddSource установлен и доступна информация о источнике, ключ — "source", а значение — запись типа Source.
Ключ сообщения — "msg".
Для изменения этих или других атрибутов или удаления их из вывода используйте [HandlerOptions.ReplaceAttr].
Значения форматируются как с помощью encoding/json.Encoder с SetEscapeHTML(false), за двумя исключениями.
Во-первых, Attr, значение которого является типом error, форматируется как строка, вызывая его метод Error. Только ошибки в Attrs получают такое специальное обращение, а не ошибки, встроенные в структуры, срезы, карты или другие структуры данных, которые обрабатываются пакетом encoding/json.
Во-вторых, ошибка кодирования не вызывает возврат Handle с ошибкой. Вместо этого сообщение об ошибке форматируется как строка.
Каждый вызов Handle приводит к одной сериализованной операции записи в io.Writer.
Функция (*JSONHandler) WithAttrs 1.21
func (h *JSONHandler) WithAttrs(attrs []Attr) Handler
WithAttrs возвращает новый JSONHandler, атрибуты которого состоят из атрибутов h, после которых следуют attrs.
Функция (*JSONHandler) WithGroup 1.21
func (h *JSONHandler) WithGroup(name string) Handler
Тип Kind 1.21
Kind — это тип Value.
type Kind int
const (
KindAny Kind = iota
KindBool
KindDuration
KindFloat64
KindInt64
KindString
KindTime
KindUint64
KindGroup
KindLogValuer
) Функция (Kind) String 1.21
func (k Kind) String() string
Тип Level 1.21
Уровень — это важность или серьезность события в журнале. Чем выше уровень, тем важнее или серьезнее событие.
type Level int
Названия общих уровней.
Номера уровней по своей природе условны, но мы выбрали их, чтобы удовлетворить три ограничения. Любая система может отобразить их в другой системе нумерации, если пожелает.
Во-первых, мы хотели, чтобы уровнем по умолчанию был Info, так как уровни — это целые числа, Info — это значение по умолчанию для целого числа, ноль.
Во-вторых, мы хотели сделать удобным использование уровней для указания подробности ведения журнала. Поскольку более высокий уровень означает более серьезное событие, журнал, принимающий события с меньшим (или более отрицательным) уровнем, означает более подробный журнал. Подробность журнала — это отрицание серьезности события, а значение подробности по умолчанию 0 принимает все события, по крайней мере, не менее серьезные, чем INFO.
В-третьих, мы хотели иметь некоторый зазор между уровнями, чтобы вместить схемы с именованными уровнями между нашими. Например, Google Cloud Logging определяет уровень «Notice» между уровнями «Info» и «Warn». Поскольку таких промежуточных уровней немного, разница между числами не должна быть большой. Наша разница в 4 соответствует отображению OpenTelemetry. Вычитание 9 из уровня OpenTelemetry в диапазонах DEBUG, INFO, WARN и ERROR преобразует его в соответствующий диапазон уровней slog. OpenTelemetry также имеет имена TRACE и FATAL, которых нет в slog. Но эти уровни OpenTelemetry все равно можно представить как уровни slog, используя соответствующие целые числа.
const (
LevelDebug Level = -4
LevelInfo Level = 0
LevelWarn Level = 4
LevelError Level = 8
) func SetLogLoggerLevel 1.22
func SetLogLoggerLevel(level Level) (oldLevel Level)
SetLogLoggerLevel управляет уровнем для моста с пакетом log.
Перед вызовом SetDefault функции ведения журнала верхнего уровня slog вызывают по умолчанию log.Logger. В этом режиме SetLogLoggerLevel устанавливает минимальный уровень для этих вызовов. По умолчанию минимальный уровень — Info, поэтому вызовы Debug (а также вызовы ведения журнала верхнего уровня на более низких уровнях) не будут переданы в log.Logger. После вызова
slog.SetLogLoggerLevel(slog.LevelDebug)
вызовы Debug будут переданы в log.Logger.
После вызова SetDefault вызовы к по умолчанию log.Logger передаются в обработчик slog по умолчанию. В этом режиме SetLogLoggerLevel устанавливает уровень, на котором эти вызовы регистрируются. То есть, после вызова
slog.SetLogLoggerLevel(slog.LevelDebug)
Вызов log.Printf приведет к выводу на уровне LevelDebug.
SetLogLoggerLevel возвращает предыдущее значение.
Пример (Журнал)
Этот пример показывает, как использовать slog.SetLogLoggerLevel для изменения минимального уровня внутреннего обработчика по умолчанию для пакета slog перед вызовом slog.SetDefault.
Код:
defer log.SetFlags(log.Flags()) // revert changes after the example
log.SetFlags(0)
defer log.SetOutput(log.Writer()) // revert changes after the example
log.SetOutput(os.Stdout)
// Default logging level is slog.LevelInfo.
log.Print("log debug") // log debug
slog.Debug("debug") // no output
slog.Info("info") // INFO info
// Set the default logging level to slog.LevelDebug.
currentLogLevel := slog.SetLogLoggerLevel(slog.LevelDebug)
defer slog.SetLogLoggerLevel(currentLogLevel) // revert changes after the example
log.Print("log debug") // log debug
slog.Debug("debug") // DEBUG debug
slog.Info("info") // INFO info
Вывод:
log debug INFO info log debug DEBUG debug INFO info
Пример (Slog)
Этот пример показывает, как использовать slog.SetLogLoggerLevel для изменения минимального уровня внутреннего записывающего устройства, использующего пользовательский обработчик для пакета log, после вызова slog.SetDefault.
Код:
// Set the default logging level to slog.LevelError.
currentLogLevel := slog.SetLogLoggerLevel(slog.LevelError)
defer slog.SetLogLoggerLevel(currentLogLevel) // revert changes after the example
defer slog.SetDefault(slog.Default()) // revert changes after the example
slog.SetDefault(slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{ReplaceAttr: slogtest.RemoveTime})))
log.Print("error") // level=ERROR msg=error
Вывод:
level=ERROR msg=error
func (Level) AppendText 1.24
func (l Level) AppendText(b []byte) ([]byte, error)
AppendText реализует encoding.TextAppender путём вызова Level.String.
func (Level) Level 1.21
func (l Level) Level() Level
Level возвращает получателя. Он реализует Leveler.
func (Level) MarshalJSON 1.21
func (l Level) MarshalJSON() ([]byte, error)
MarshalJSON реализует encoding/json.Marshaler, заключая в кавычки результат вызова Level.String.
func (Level) MarshalText 1.21
func (l Level) MarshalText() ([]byte, error)
MarshalText реализует encoding.TextMarshaler путём вызова Level.AppendText.
func (Level) String 1.21
func (l Level) String() string
String возвращает имя уровня. Если уровень имеет имя, то возвращается это имя в верхнем регистре. Если уровень находится между именованными значениями, то к имени в верхнем регистре добавляется целое число. Примеры:
LevelWarn.String() => "WARN" (LevelInfo+2).String() => "INFO+2"
func (*Level) UnmarshalJSON 1.21
func (l *Level) UnmarshalJSON(data []byte) error
UnmarshalJSON реализует encoding/json.Unmarshaler. Он принимает любую строку, сгенерированную Level.MarshalJSON, игнорируя регистр. Он также принимает числовые смещения, которые приведут к другой строке на выходе. Например, «Error-8» будет сериализовано как «INFO».
func (*Level) UnmarshalText 1.21
func (l *Level) UnmarshalText(data []byte) error
UnmarshalText реализует encoding.TextUnmarshaler. Он принимает любую строку, сгенерированную Level.MarshalText, игнорируя регистр. Он также принимает числовые смещения, которые приведут к другой строке на выходе. Например, «Error-8» будет сериализовано как «INFO».
type LevelVar 1.21
Переменная LevelVar — это переменная типа Level, позволяющая динамически изменять уровень Handler. Она реализует Leveler, а также метод Set и безопасна для использования несколькими горутинами. Нулевая LevelVar соответствует LevelInfo.
type LevelVar struct {
// contains filtered or unexported fields
}
func (*LevelVar) AppendText 1.24
func (v *LevelVar) AppendText(b []byte) ([]byte, error)
AppendText реализует encoding.TextAppender путём вызова Level.AppendText.
func (*LevelVar) Level 1.21
func (v *LevelVar) Level() Level
Level возвращает уровень v.
func (*LevelVar) MarshalText 1.21
func (v *LevelVar) MarshalText() ([]byte, error)
MarshalText реализует encoding.TextMarshaler путём вызова LevelVar.AppendText.
func (*LevelVar) Set 1.21
func (v *LevelVar) Set(l Level)
Set устанавливает уровень v в l.
func (*LevelVar) String 1.21
func (v *LevelVar) String() string
func (*LevelVar) UnmarshalText 1.21
func (v *LevelVar) UnmarshalText(data []byte) error
UnmarshalText реализует encoding.TextUnmarshaler, вызывая Level.UnmarshalText.
type Leveler 1.21
Интерфейс Leveler предоставляет значение Level.
Так как сам Level реализует Leveler, клиенты обычно передают значение Level везде, где требуется Leveler, например, в HandlerOptions. Клиенты, которым нужно динамически изменять уровень, могут предоставить более сложное реализацию Leveler, например, *LevelVar.
type Leveler interface {
Level() Level
} type LogValuer 1.21
LogValuer — это любое значение Go, которое может преобразовать себя в значение для ведения журнала.
Этот механизм может использоваться для отложенного выполнения дорогостоящих операций до тех пор, пока они не понадобятся, или для расширения одного значения в последовательность компонентов.
type LogValuer interface {
LogValue() Value
} Пример (Группа)
Код:
package slog_test
import "log/slog"
type Name struct {
First, Last string
}
// LogValue implements slog.LogValuer.
// It returns a group containing the fields of
// the Name, so that they appear together in the log output.
func (n Name) LogValue() slog.Value {
return slog.GroupValue(
slog.String("first", n.First),
slog.String("last", n.Last))
}
func ExampleLogValuer_group() {
n := Name{"Perry", "Platypus"}
slog.Info("mission accomplished", "agent", n)
// JSON Output would look in part like:
// {
// ...
// "msg": "mission accomplished",
// "agent": {
// "first": "Perry",
// "last": "Platypus"
// }
// }
}
Пример (Секрет)
Этот пример демонстрирует значение Value, которое заменяет себя альтернативным представлением, чтобы избежать раскрытия секретов.
Код:
package slog_test
import (
"log/slog"
"log/slog/internal/slogtest"
"os"
)
// A token is a secret value that grants permissions.
type Token string
// LogValue implements slog.LogValuer.
// It avoids revealing the token.
func (Token) LogValue() slog.Value {
return slog.StringValue("REDACTED_TOKEN")
}
// This example demonstrates a Value that replaces itself
// with an alternative representation to avoid revealing secrets.
func ExampleLogValuer_secret() {
t := Token("shhhh!")
logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{ReplaceAttr: slogtest.RemoveTime}))
logger.Info("permission granted", "user", "Perry", "token", t)
// Output:
// level=INFO msg="permission granted" user=Perry token=REDACTED_TOKEN
}
type Logger 1.21
Logger записывает структурированную информацию о каждом вызове своих методов Log, Debug, Info, Warn и Error. Для каждого вызова он создаёт запись Record и передаёт её в Handler.
Для создания нового Logger вызовите New или метод Logger, начинающийся с «With».
type Logger struct {
// contains filtered or unexported fields
}
func Default 1.21
func Default() *Logger
Default возвращает по умолчанию Logger.
func New 1.21
func New(h Handler) *Logger
New создаёт новый Logger с заданным ненулевым Handler.
func With 1.21
func With(args ...any) *Logger
With вызывает Logger.With на логгере по умолчанию.
func (*Logger) Debug 1.21
func (l *Logger) Debug(msg string, args ...any)
Debug регистрирует на уровне LevelDebug.
func (*Logger) DebugContext 1.21
func (l *Logger) DebugContext(ctx context.Context, msg string, args ...any)
DebugContext регистрирует на уровне LevelDebug с заданным контекстом.
func (*Logger) Enabled 1.21
func (l *Logger) Enabled(ctx context.Context, level Level) bool
Enabled проверяет, генерирует ли l записи журналов в данном контексте и на данном уровне.
func (*Logger) Error 1.21
func (l *Logger) Error(msg string, args ...any)
Error регистрирует на уровне LevelError.
func (*Logger) ErrorContext 1.21
func (l *Logger) ErrorContext(ctx context.Context, msg string, args ...any)
ErrorContext регистрирует на уровне LevelError с заданным контекстом.
func (*Logger) Handler 1.21
func (l *Logger) Handler() Handler
Handler возвращает Handler l.
func (*Logger) Info 1.21
func (l *Logger) Info(msg string, args ...any)
Info регистрирует на уровне LevelInfo.
func (*Logger) InfoContext 1.21
func (l *Logger) InfoContext(ctx context.Context, msg string, args ...any)
InfoContext регистрирует на уровне LevelInfo с заданным контекстом.
func (*Logger) Log 1.21
func (l *Logger) Log(ctx context.Context, level Level, msg string, args ...any)
Log генерирует запись журнала со текущим временем, заданным уровнем и сообщением. Атрибуты Record содержат атрибуты Logger, после которых следуют Attrs, заданные в args.
Атрибуты аргументов обрабатываются следующим образом:
- Если аргумент — это Attr, он используется как есть.
- Если аргумент — строка, а это не последний аргумент, следующий аргумент обрабатывается как значение, и оба объединяются в Attr.
- В противном случае аргумент обрабатывается как значение с ключом "!BADKEY".
func (*Logger) LogAttrs 1.21
func (l *Logger) LogAttrs(ctx context.Context, level Level, msg string, attrs ...Attr)
LogAttrs — более эффективный вариант Logger.Log, принимающий только Attrs.
func (*Logger) Warn 1.21
func (l *Logger) Warn(msg string, args ...any)
Warn регистрирует на уровне LevelWarn.
func (*Logger) WarnContext 1.21
func (l *Logger) WarnContext(ctx context.Context, msg string, args ...any)
WarnContext записывает в журнал на уровне LevelWarn с заданным контекстом.
func (*Logger) With 1.21
func (l *Logger) With(args ...any) *Logger
With возвращает Logger, включающий заданные атрибуты в каждой операции вывода. Аргументы преобразуются в атрибуты так же, как в Logger.Log.
func (*Logger) WithGroup 1.21
func (l *Logger) WithGroup(name string) *Logger
WithGroup возвращает Logger, который начинает группу, если имя не пустое. Ключи всех атрибутов, добавленных в Logger, будут квалифицированы данным именем. (Как происходит эта квалификация зависит от метода [Handler.WithGroup] обработчика Logger.)
Если имя пустое, WithGroup возвращает получатель.
type Record 1.21
Record содержит информацию о событии логирования. Копии Record используют общее состояние. Не изменяйте Record после передачи копии. Используйте NewRecord для создания нового Record. Используйте Record.Clone для создания копии без общего состояния.
type Record struct {
// The time at which the output method (Log, Info, etc.) was called.
Time time.Time
// The log message.
Message string
// The level of the event.
Level Level
// The program counter at the time the record was constructed, as determined
// by runtime.Callers. If zero, no program counter is available.
//
// The only valid use for this value is as an argument to
// [runtime.CallersFrames]. In particular, it must not be passed to
// [runtime.FuncForPC].
PC uintptr
// contains filtered or unexported fields
}
func NewRecord 1.21
func NewRecord(t time.Time, level Level, msg string, pc uintptr) Record
NewRecord создаёт Record из заданных аргументов. Используйте Record.AddAttrs для добавления атрибутов в Record.
NewRecord предназначен для API логирования, которые хотят поддерживать Handler в качестве бэкенда.
func (*Record) Add 1.21
func (r *Record) Add(args ...any)
Add преобразует args в Attrs, как описано в Logger.Log, затем добавляет Attrs в список Attrs Record. Пустые группы игнорируются.
func (*Record) AddAttrs 1.21
func (r *Record) AddAttrs(attrs ...Attr)
AddAttrs добавляет заданные Attrs в список Attrs Record. Пустые группы игнорируются.
func (Record) Attrs 1.21
func (r Record) Attrs(f func(Attr) bool)
Attrs вызывает f для каждого Attr в Record. Итерация прекращается, если f возвращает false.
func (Record) Clone 1.21
func (r Record) Clone() Record
Clone возвращает копию записи без общего состояния. Исходная запись и клон могут быть изменены без взаимного влияния.
func (Record) NumAttrs 1.21
func (r Record) NumAttrs() int
NumAttrs возвращает количество атрибутов в Record.
type Source 1.21
Source описывает расположение строки исходного кода.
type Source struct {
// Function is the package path-qualified function name containing the
// source line. If non-empty, this string uniquely identifies a single
// function in the program. This may be the empty string if not known.
Function string `json:"function"`
// File and Line are the file name and line number (1-based) of the source
// line. These may be the empty string and zero, respectively, if not known.
File string `json:"file"`
Line int `json:"line"`
}
type TextHandler 1.21
TextHandler — это Handler, который записывает Record в io.Writer как последовательность пар ключ=значение, разделённых пробелами, и завершаемых новой строкой.
type TextHandler struct {
// contains filtered or unexported fields
}
func NewTextHandler 1.21
func NewTextHandler(w io.Writer, opts *HandlerOptions) *TextHandler
NewTextHandler создаёт TextHandler, который записывает в w, используя заданные параметры. Если opts равно nil, используются параметры по умолчанию.
func (*TextHandler) Enabled 1.21
func (h *TextHandler) Enabled(_ context.Context, level Level) bool
Enabled сообщает, обрабатывает ли обработчик записи на заданном уровне. Обработчик игнорирует записи, уровень которых ниже.
func (*TextHandler) Handle 1.21
func (h *TextHandler) Handle(_ context.Context, r Record) error
Handle форматирует свой аргумент Record как одну строку с элементами ключ=значение, разделёнными пробелами.
Если время Record равно нулю, время пропускается. В противном случае, ключ — "time", а значение выводится в формате RFC3339 с миллисекундной точностью.
Если уровень Record равен нулю, уровень пропускается. В противном случае, ключ — "level", а значение Level.String выводится.
Если опция AddSource установлена и информация о источнике доступна, ключ — "source", а значение выводится как FILE:LINE.
Ключ сообщения — "msg".
Чтобы изменить эти или другие атрибуты или удалить их из вывода, используйте [HandlerOptions.ReplaceAttr].
Если значение реализует encoding.TextMarshaler, записывается результат MarshalText. В противном случае записывается результат fmt.Sprint.
Ключи и значения заключаются в кавычки с помощью strconv.Quote, если они содержат пробелы Unicode, непечатаемые символы, '"' или '='.
Ключи внутри групп состоят из компонентов (ключей или имён групп), разделённых точками. Дальнейшее экранирование не выполняется. Таким образом, невозможно определить из ключа "a.b.c", есть ли две группы "a" и "b" и ключ "c", или одна группа "a.b" и ключ "c", или одна группа "a" и ключ "b.c". Если необходимо восстановить структуру группы ключа даже при наличии точек внутри компонентов, используйте [HandlerOptions.ReplaceAttr] для кодирования этой информации в ключе.
Каждый вызов Handle приводит к одному сериализованному вызову io.Writer.Write.
func (*TextHandler) WithAttrs 1.21
func (h *TextHandler) WithAttrs(attrs []Attr) Handler
WithAttrs возвращает новый TextHandler, атрибуты которого состоят из атрибутов h, после которых следуют attrs.
func (*TextHandler) WithGroup 1.21
func (h *TextHandler) WithGroup(name string) Handler
type Value 1.21
Value может представлять любое значение Go, но в отличие от типа any, он может представлять большинство небольших значений без выделения памяти. Нулевое значение Value соответствует nil.
type Value struct {
// contains filtered or unexported fields
}
func AnyValue 1.21
func AnyValue(v any) Value
AnyValue возвращает Value для заданного значения.
Если заданное значение типа Value, оно возвращается без изменений.
Для значений предопределённых типов Go, таких как строка, булево значение или (не комплексное) числовое значение, AnyValue возвращает Value типа KindString, KindBool, KindUint64, KindInt64 или KindFloat64. Разрядность исходного числового типа не сохраняется.
Для значений time.Time или time.Duration AnyValue возвращает Value типа KindTime или KindDuration. Монотонное время не сохраняется.
Для nil или значений других типов, включая именованные типы, основанные на числовых типах, AnyValue возвращает значение типа KindAny.
func BoolValue 1.21
func BoolValue(v bool) Value
BoolValue возвращает Value для bool.
func DurationValue 1.21
func DurationValue(v time.Duration) Value
DurationValue возвращает Value для time.Duration.
func Float64Value 1.21
func Float64Value(v float64) Value
Float64Value возвращает Value для числа с плавающей точкой.
func GroupValue 1.21
func GroupValue(as ...Attr) Value
GroupValue возвращает новый Value для списка Attrs. Вызывающая сторона не должна впоследствии изменять переданный срез.
func Int64Value 1.21
func Int64Value(v int64) Value
Int64Value возвращает Value для int64.
func IntValue 1.21
func IntValue(v int) Value
IntValue возвращает Value для int.
func StringValue 1.21
func StringValue(value string) Value
StringValue возвращает новый Value для строки.
func TimeValue 1.21
func TimeValue(v time.Time) Value
TimeValue возвращает Value для time.Time. Он отбрасывает монотонную часть.
func Uint64Value 1.21
func Uint64Value(v uint64) Value
Uint64Value возвращает Value для uint64.
func (Value) Any 1.21
func (v Value) Any() any
Any возвращает значение v как любое.
func (Value) Bool 1.21
func (v Value) Bool() bool
Bool возвращает значение v как bool. Он вызывает панику, если v не является bool.
func (Value) Duration 1.21
func (v Value) Duration() time.Duration
Duration возвращает значение v как time.Duration. Он вызывает панику, если v не является time.Duration.
func (Value) Equal 1.21
func (v Value) Equal(w Value) bool
Equal проверяет, представляют ли v и w одно и то же значение Go.
func (Value) Float64 1.21
func (v Value) Float64() float64
Float64 возвращает значение v как float64. Он вызывает панику, если v не является float64.
func (Value) Group 1.21
func (v Value) Group() []Attr
Group возвращает значение v как []Attr. Он вызывает панику, если Kind v не является KindGroup.
func (Value) Int64 1.21
func (v Value) Int64() int64
Int64 возвращает значение v как int64. Он вызывает панику, если v не является целым числом со знаком.
func (Value) Kind 1.21
func (v Value) Kind() Kind
Kind возвращает Kind v.
func (Value) LogValuer 1.21
func (v Value) LogValuer() LogValuer
LogValuer возвращает значение v как LogValuer. Он вызывает панику, если v не является LogValuer.
func (Value) Resolve 1.21
func (v Value) Resolve() (rv Value)
Resolve многократно вызывает LogValue на v, пока он реализует LogValuer, и возвращает результат. Если v разрешается до группы, значения атрибутов группы не рекурсивно разрешаются. Если количество вызовов LogValue превышает порог, возвращается Value, содержащий ошибку. Возвращаемое значение Resolve гарантированно не будет типа Kind KindLogValuer.
func (Value) String 1.21
func (v Value) String() string
String возвращает значение Value в виде строки, отформатированной как fmt.Sprint. В отличие от методов Int64, Float64 и так далее, которые вызывают ошибку panic, если v имеет неправильный тип, String никогда не вызывает ошибку panic.
func (Value) Time 1.21
func (v Value) Time() time.Time
Time возвращает значение v как time.Time. Возвращает ошибку panic, если v не является time.Time.
func (Value) Uint64 1.21
func (v Value) Uint64() uint64
Uint64 возвращает значение v как uint64. Возвращает ошибку panic, если v не является беззнаковым целым числом.
Подкаталоги
| Имя | Описание |
|---|---|
| .. | |
© Google, Inc.
Licensed under the Creative Commons Attribution License 3.0.
http://golang.org/pkg/log/slog/
