13236757158

Committed 10 Feb 2025 08:39AM UTC coverage: 57.649% (-1.2%) from 58.815%

Build # 13236757158

Build Type

Pull #9493

github

Committed by

ziggie1984

Commit Message

lncli: for some cmds we don't replace the data of the response.

For some cmds it is not very practical to replace the json output
because we might pipe it into other commands. For example when
creating the route we want to pipe it into sendtoRoute.

Pull Request Pull Request #9493: For some lncli cmds we should not replace the content with other data

Run Details

0 of 9 new or added lines in 2 files covered. (0.0%)

19535 existing lines in 252 files now uncovered.

103517 of 179563 relevant lines covered (57.65%)

24878.49 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/build/handler_sets.go

package build

import (
        "context"
        "log/slog"

        btclogv1 "github.com/btcsuite/btclog"
        "github.com/btcsuite/btclog/v2"
)

// handlerSet is an implementation of Handler that abstracts away multiple
// Handlers.
type handlerSet struct {
        level btclogv1.Level
        set   []btclog.Handler
}

// newHandlerSet constructs a new HandlerSet.
func newHandlerSet(level btclogv1.Level, set ...btclog.Handler) *handlerSet {
        h := &handlerSet{
                set:   set,
                level: level,
        }
        h.SetLevel(level)

        return h
}

// Enabled reports whether the handler handles records at the given level.
//
// NOTE: this is part of the slog.Handler interface.
func (h *handlerSet) Enabled(ctx context.Context, level slog.Level) bool {
        for _, handler := range h.set {
                if !handler.Enabled(ctx, level) {
                        return false
                }
        }

        return true
}

// Handle handles the Record.
//
// NOTE: this is part of the slog.Handler interface.
func (h *handlerSet) Handle(ctx context.Context, record slog.Record) error {
        for _, handler := range h.set {
                if err := handler.Handle(ctx, record); err != nil {
                        return err
                }
        }

        return nil
}

// WithAttrs returns a new Handler whose attributes consist of both the
// receiver's attributes and the arguments.
//
// NOTE: this is part of the slog.Handler interface.
func (h *handlerSet) WithAttrs(attrs []slog.Attr) slog.Handler {
        newSet := &reducedSet{set: make([]slog.Handler, len(h.set))}
        for i, handler := range h.set {
                newSet.set[i] = handler.WithAttrs(attrs)
        }

        return newSet
}

// WithGroup returns a new Handler with the given group appended to the
// receiver's existing groups.
//
// NOTE: this is part of the slog.Handler interface.
func (h *handlerSet) WithGroup(name string) slog.Handler {
        newSet := &reducedSet{set: make([]slog.Handler, len(h.set))}
        for i, handler := range h.set {
                newSet.set[i] = handler.WithGroup(name)
        }

        return newSet
}

// SubSystem creates a new Handler with the given sub-system tag.
//
// NOTE: this is part of the Handler interface.
func (h *handlerSet) SubSystem(tag string) btclog.Handler {
        newSet := &handlerSet{set: make([]btclog.Handler, len(h.set))}
        for i, handler := range h.set {
                newSet.set[i] = handler.SubSystem(tag)
        }

        return newSet
}

// SetLevel changes the logging level of the Handler to the passed
// level.
//
// NOTE: this is part of the btclog.Handler interface.
func (h *handlerSet) SetLevel(level btclogv1.Level) {
        for _, handler := range h.set {
                handler.SetLevel(level)
        }
        h.level = level
}

// Level returns the current logging level of the Handler.
//
// NOTE: this is part of the btclog.Handler interface.
func (h *handlerSet) Level() btclogv1.Level {
        return h.level
}

// WithPrefix returns a copy of the Handler but with the given string prefixed
// to each log message.
//
// NOTE: this is part of the btclog.Handler interface.
func (h *handlerSet) WithPrefix(prefix string) btclog.Handler {
        newSet := &handlerSet{set: make([]btclog.Handler, len(h.set))}
        for i, handler := range h.set {
                newSet.set[i] = handler.WithPrefix(prefix)
        }

        return newSet
}

// A compile-time check to ensure that handlerSet implements btclog.Handler.
var _ btclog.Handler = (*handlerSet)(nil)

// reducedSet is an implementation of the slog.Handler interface which is
// itself backed by multiple slog.Handlers. This is used by the handlerSet
// WithGroup and WithAttrs methods so that we can apply the WithGroup and
// WithAttrs to the underlying handlers in the set. These calls, however,
// produce slog.Handlers and not btclog.Handlers. So the reducedSet represents
// the resulting set produced.
type reducedSet struct {
        set []slog.Handler
}

// Enabled reports whether the handler handles records at the given level.
//
// NOTE: this is part of the slog.Handler interface.
func (r *reducedSet) Enabled(ctx context.Context, level slog.Level) bool {
        for _, handler := range r.set {
                if !handler.Enabled(ctx, level) {
                        return false
                }
        }

        return true
}

// Handle handles the Record.
//
// NOTE: this is part of the slog.Handler interface.
func (r *reducedSet) Handle(ctx context.Context, record slog.Record) error {
        for _, handler := range r.set {
                if err := handler.Handle(ctx, record); err != nil {
                        return err
                }
        }

        return nil
}

// WithAttrs returns a new Handler whose attributes consist of both the
// receiver's attributes and the arguments.
//
// NOTE: this is part of the slog.Handler interface.
func (r *reducedSet) WithAttrs(attrs []slog.Attr) slog.Handler {
        newSet := &reducedSet{set: make([]slog.Handler, len(r.set))}
        for i, handler := range r.set {
                newSet.set[i] = handler.WithAttrs(attrs)
        }

        return newSet
}

// WithGroup returns a new Handler with the given group appended to the
// receiver's existing groups.
//
// NOTE: this is part of the slog.Handler interface.
func (r *reducedSet) WithGroup(name string) slog.Handler {
        newSet := &reducedSet{set: make([]slog.Handler, len(r.set))}
        for i, handler := range r.set {
                newSet.set[i] = handler.WithGroup(name)
        }

        return newSet
}

// A compile-time check to ensure that handlerSet implements slog.Handler.
var _ slog.Handler = (*reducedSet)(nil)

// subLogGenerator implements the SubLogCreator backed by a Handler.
type subLogGenerator struct {
        handler btclog.Handler
}

// newSubLogGenerator constructs a new subLogGenerator from a Handler.
func newSubLogGenerator(handler btclog.Handler) *subLogGenerator {
        return &subLogGenerator{
                handler: handler,
        }
}

// Logger returns a new logger for a particular sub-system.
//
// NOTE: this is part of the SubLogCreator interface.
func (b *subLogGenerator) Logger(subsystemTag string) btclog.Logger {
        handler := b.handler.SubSystem(subsystemTag)

        return btclog.NewSLogger(handler)
}

// A compile-time check to ensure that handlerSet implements slog.Handler.
var _ SubLogCreator = (*subLogGenerator)(nil)

1	package build
2
3	import (
4	"context"
5	"log/slog"
6
7	btclogv1 "github.com/btcsuite/btclog"
8	"github.com/btcsuite/btclog/v2"
9	)
10
11	// handlerSet is an implementation of Handler that abstracts away multiple
12	// Handlers.
13	type handlerSet struct {
14	level btclogv1.Level
15	set []btclog.Handler
16	}
17
18	// newHandlerSet constructs a new HandlerSet.
UNCOV 19	func newHandlerSet(level btclogv1.Level, set ...btclog.Handler) *handlerSet {	×
UNCOV 20	h := &handlerSet{	×
UNCOV 21	set: set,	×
UNCOV 22	level: level,	×
UNCOV 23	}	×
UNCOV 24	h.SetLevel(level)	×
UNCOV 25		×
UNCOV 26	return h	×
UNCOV 27	}	×
28
29	// Enabled reports whether the handler handles records at the given level.
30	//
31	// NOTE: this is part of the slog.Handler interface.
UNCOV 32	func (h *handlerSet) Enabled(ctx context.Context, level slog.Level) bool {	×
UNCOV 33	for _, handler := range h.set {	×
UNCOV 34	if !handler.Enabled(ctx, level) {	×
UNCOV 35	return false	×
UNCOV 36	}	×
37	}
38
UNCOV 39	return true	×
40	}
41
42	// Handle handles the Record.
43	//
44	// NOTE: this is part of the slog.Handler interface.
UNCOV 45	func (h *handlerSet) Handle(ctx context.Context, record slog.Record) error {	×
UNCOV 46	for _, handler := range h.set {	×
UNCOV 47	if err := handler.Handle(ctx, record); err != nil {	×
48	return err	×
49	}	×
50	}
51
UNCOV 52	return nil	×
53	}
54
55	// WithAttrs returns a new Handler whose attributes consist of both the
56	// receiver's attributes and the arguments.
57	//
58	// NOTE: this is part of the slog.Handler interface.
59	func (h *handlerSet) WithAttrs(attrs []slog.Attr) slog.Handler {	×
60	newSet := &reducedSet{set: make([]slog.Handler, len(h.set))}	×
61	for i, handler := range h.set {	×
62	newSet.set[i] = handler.WithAttrs(attrs)	×
63	}	×
64
65	return newSet	×
66	}
67
68	// WithGroup returns a new Handler with the given group appended to the
69	// receiver's existing groups.
70	//
71	// NOTE: this is part of the slog.Handler interface.
72	func (h *handlerSet) WithGroup(name string) slog.Handler {	×
73	newSet := &reducedSet{set: make([]slog.Handler, len(h.set))}	×
74	for i, handler := range h.set {	×
75	newSet.set[i] = handler.WithGroup(name)	×
76	}	×
77
78	return newSet	×
79	}
80
81	// SubSystem creates a new Handler with the given sub-system tag.
82	//
83	// NOTE: this is part of the Handler interface.
UNCOV 84	func (h *handlerSet) SubSystem(tag string) btclog.Handler {	×
UNCOV 85	newSet := &handlerSet{set: make([]btclog.Handler, len(h.set))}	×
UNCOV 86	for i, handler := range h.set {	×
UNCOV 87	newSet.set[i] = handler.SubSystem(tag)	×
UNCOV 88	}	×
89
UNCOV 90	return newSet	×
91	}
92
93	// SetLevel changes the logging level of the Handler to the passed
94	// level.
95	//
96	// NOTE: this is part of the btclog.Handler interface.
UNCOV 97	func (h *handlerSet) SetLevel(level btclogv1.Level) {	×
UNCOV 98	for _, handler := range h.set {	×
UNCOV 99	handler.SetLevel(level)	×
UNCOV 100	}	×
UNCOV 101	h.level = level	×
102	}
103
104	// Level returns the current logging level of the Handler.
105	//
106	// NOTE: this is part of the btclog.Handler interface.
UNCOV 107	func (h *handlerSet) Level() btclogv1.Level {	×
UNCOV 108	return h.level	×
UNCOV 109	}	×
110
111	// WithPrefix returns a copy of the Handler but with the given string prefixed
112	// to each log message.
113	//
114	// NOTE: this is part of the btclog.Handler interface.
UNCOV 115	func (h *handlerSet) WithPrefix(prefix string) btclog.Handler {	×
UNCOV 116	newSet := &handlerSet{set: make([]btclog.Handler, len(h.set))}	×
UNCOV 117	for i, handler := range h.set {	×
UNCOV 118	newSet.set[i] = handler.WithPrefix(prefix)	×
UNCOV 119	}	×
120
UNCOV 121	return newSet	×
122	}
123
124	// A compile-time check to ensure that handlerSet implements btclog.Handler.
125	var _ btclog.Handler = (*handlerSet)(nil)
126
127	// reducedSet is an implementation of the slog.Handler interface which is
128	// itself backed by multiple slog.Handlers. This is used by the handlerSet
129	// WithGroup and WithAttrs methods so that we can apply the WithGroup and
130	// WithAttrs to the underlying handlers in the set. These calls, however,
131	// produce slog.Handlers and not btclog.Handlers. So the reducedSet represents
132	// the resulting set produced.
133	type reducedSet struct {
134	set []slog.Handler
135	}
136
137	// Enabled reports whether the handler handles records at the given level.
138	//
139	// NOTE: this is part of the slog.Handler interface.
140	func (r *reducedSet) Enabled(ctx context.Context, level slog.Level) bool {	×
141	for _, handler := range r.set {	×
142	if !handler.Enabled(ctx, level) {	×
143	return false	×
144	}	×
145	}
146
147	return true	×
148	}
149
150	// Handle handles the Record.
151	//
152	// NOTE: this is part of the slog.Handler interface.
153	func (r *reducedSet) Handle(ctx context.Context, record slog.Record) error {	×
154	for _, handler := range r.set {	×
155	if err := handler.Handle(ctx, record); err != nil {	×
156	return err	×
157	}	×
158	}
159
160	return nil	×
161	}
162
163	// WithAttrs returns a new Handler whose attributes consist of both the
164	// receiver's attributes and the arguments.
165	//
166	// NOTE: this is part of the slog.Handler interface.
167	func (r *reducedSet) WithAttrs(attrs []slog.Attr) slog.Handler {	×
168	newSet := &reducedSet{set: make([]slog.Handler, len(r.set))}	×
169	for i, handler := range r.set {	×
170	newSet.set[i] = handler.WithAttrs(attrs)	×
171	}	×
172
173	return newSet	×
174	}
175
176	// WithGroup returns a new Handler with the given group appended to the
177	// receiver's existing groups.
178	//
179	// NOTE: this is part of the slog.Handler interface.
180	func (r *reducedSet) WithGroup(name string) slog.Handler {	×
181	newSet := &reducedSet{set: make([]slog.Handler, len(r.set))}	×
182	for i, handler := range r.set {	×
183	newSet.set[i] = handler.WithGroup(name)	×
184	}	×
185
186	return newSet	×
187	}
188
189	// A compile-time check to ensure that handlerSet implements slog.Handler.
190	var _ slog.Handler = (*reducedSet)(nil)
191
192	// subLogGenerator implements the SubLogCreator backed by a Handler.
193	type subLogGenerator struct {
194	handler btclog.Handler
195	}
196
197	// newSubLogGenerator constructs a new subLogGenerator from a Handler.
UNCOV 198	func newSubLogGenerator(handler btclog.Handler) *subLogGenerator {	×
UNCOV 199	return &subLogGenerator{	×
UNCOV 200	handler: handler,	×
UNCOV 201	}	×
UNCOV 202	}	×
203
204	// Logger returns a new logger for a particular sub-system.
205	//
206	// NOTE: this is part of the SubLogCreator interface.
UNCOV 207	func (b *subLogGenerator) Logger(subsystemTag string) btclog.Logger {	×
UNCOV 208	handler := b.handler.SubSystem(subsystemTag)	×
UNCOV 209		×
UNCOV 210	return btclog.NewSLogger(handler)	×
UNCOV 211	}	×
212
213	// A compile-time check to ensure that handlerSet implements slog.Handler.
214	var _ SubLogCreator = (*subLogGenerator)(nil)

lightningnetwork / lnd / 13236757158

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous