1 //go:build go1.21
2 // +build go1.21
3 4 /*
5 Copyright 2023 The logr Authors.
6 7 Licensed under the Apache License, Version 2.0 (the "License");
8 you may not use this file except in compliance with the License.
9 You may obtain a copy of the License at
10 11 http://www.apache.org/licenses/LICENSE-2.0
12 13 Unless required by applicable law or agreed to in writing, software
14 distributed under the License is distributed on an "AS IS" BASIS,
15 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 See the License for the specific language governing permissions and
17 limitations under the License.
18 */
19 20 package logr
21 22 import (
23 "context"
24 "log/slog"
25 )
26 27 // FromSlogHandler returns a Logger which writes to the slog.Handler.
28 //
29 // The logr verbosity level is mapped to slog levels such that V(0) becomes
30 // slog.LevelInfo and V(4) becomes slog.LevelDebug.
31 func FromSlogHandler(handler slog.Handler) Logger {
32 if handler, ok := handler.(*slogHandler); ok {
33 if handler.sink == nil {
34 return Discard()
35 }
36 return New(handler.sink).V(int(handler.levelBias))
37 }
38 return New(&slogSink{handler: handler})
39 }
40 41 // ToSlogHandler returns a slog.Handler which writes to the same sink as the Logger.
42 //
43 // The returned logger writes all records with level >= slog.LevelError as
44 // error log entries with LogSink.Error, regardless of the verbosity level of
45 // the Logger:
46 //
47 // logger := <some Logger with 0 as verbosity level>
48 // slog.New(ToSlogHandler(logger.V(10))).Error(...) -> logSink.Error(...)
49 //
50 // The level of all other records gets reduced by the verbosity
51 // level of the Logger and the result is negated. If it happens
52 // to be negative, then it gets replaced by zero because a LogSink
53 // is not expected to handled negative levels:
54 //
55 // slog.New(ToSlogHandler(logger)).Debug(...) -> logger.GetSink().Info(level=4, ...)
56 // slog.New(ToSlogHandler(logger)).Warning(...) -> logger.GetSink().Info(level=0, ...)
57 // slog.New(ToSlogHandler(logger)).Info(...) -> logger.GetSink().Info(level=0, ...)
58 // slog.New(ToSlogHandler(logger.V(4))).Info(...) -> logger.GetSink().Info(level=4, ...)
59 func ToSlogHandler(logger Logger) slog.Handler {
60 if sink, ok := logger.GetSink().(*slogSink); ok && logger.GetV() == 0 {
61 return sink.handler
62 }
63 64 handler := &slogHandler{sink: logger.GetSink(), levelBias: slog.Level(logger.GetV())}
65 if slogSink, ok := handler.sink.(SlogSink); ok {
66 handler.slogSink = slogSink
67 }
68 return handler
69 }
70 71 // SlogSink is an optional interface that a LogSink can implement to support
72 // logging through the slog.Logger or slog.Handler APIs better. It then should
73 // also support special slog values like slog.Group. When used as a
74 // slog.Handler, the advantages are:
75 //
76 // - stack unwinding gets avoided in favor of logging the pre-recorded PC,
77 // as intended by slog
78 // - proper grouping of key/value pairs via WithGroup
79 // - verbosity levels > slog.LevelInfo can be recorded
80 // - less overhead
81 //
82 // Both APIs (Logger and slog.Logger/Handler) then are supported equally
83 // well. Developers can pick whatever API suits them better and/or mix
84 // packages which use either API in the same binary with a common logging
85 // implementation.
86 //
87 // This interface is necessary because the type implementing the LogSink
88 // interface cannot also implement the slog.Handler interface due to the
89 // different prototype of the common Enabled method.
90 //
91 // An implementation could support both interfaces in two different types, but then
92 // additional interfaces would be needed to convert between those types in FromSlogHandler
93 // and ToSlogHandler.
94 type SlogSink interface {
95 LogSink
96 97 Handle(ctx context.Context, record slog.Record) error
98 WithAttrs(attrs []slog.Attr) SlogSink
99 WithGroup(name string) SlogSink
100 }
101