13440912774

Committed 20 Feb 2025 05:14PM UTC coverage: 57.697% (-1.1%) from 58.802%

Build # 13440912774

Build Type

Pull #9535

github

Committed by

guggero

Commit Message

GitHub: remove duplicate caching

Turns out that actions/setup-go starting with @v4 also adds caching.
With that, our cache size on disk has almost doubled, leading to the
GitHub runner running out of space in certain situation.
We fix that by disabling the automated caching since we already have our
own, custom-tailored version.

Pull Request Pull Request #9535: GitHub: remove duplicate caching

Run Details

103519 of 179417 relevant lines covered (57.7%)

24825.3 hits per line

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

40.71

/build/sub_logger.go

package build

import (
        "fmt"
        "sort"
        "strings"
        "sync"

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

// SubLogCreator can be used to create a new logger for a particular subsystem.
type SubLogCreator interface {
        // Logger returns a new logger for a particular subsystem.
        Logger(subsystemTag string) btclog.Logger
}

// SubLoggerManager manages a set of subsystem loggers. Level updates will be
// applied to all the loggers managed by the manager.
type SubLoggerManager struct {
        genLogger SubLogCreator

        loggers SubLoggers
        mu      sync.Mutex
}

// A compile time check to ensure SubLoggerManager implements the
// LeveledSubLogger interface.
var _ LeveledSubLogger = (*SubLoggerManager)(nil)

// NewSubLoggerManager constructs a new SubLoggerManager.
func NewSubLoggerManager(handlers ...btclog.Handler) *SubLoggerManager {
        return &SubLoggerManager{
                loggers: make(SubLoggers),
                genLogger: newSubLogGenerator(
                        newHandlerSet(btclog.LevelInfo, handlers...),
                ),
        }
}

// GenSubLogger creates a new sub-logger and adds it to the set managed by the
// SubLoggerManager. A shutdown callback function is provided to be able to shut
// down in case of a critical error.
func (r *SubLoggerManager) GenSubLogger(subsystem string,
        shutdown func()) btclog.Logger {

        // Create a new logger with the given subsystem tag.
        logger := r.genLogger.Logger(subsystem)

        // Wrap the new logger in a Shutdown logger so that the shutdown
        // call back is called if a critical log is ever written via this new
        // logger.
        l := NewShutdownLogger(logger, shutdown)

        r.RegisterSubLogger(subsystem, l)

        return l
}

// RegisterSubLogger registers the given logger under the given subsystem name.
func (r *SubLoggerManager) RegisterSubLogger(subsystem string,
        logger btclog.Logger) {

        // Add the new logger to the set of loggers managed by the manager.
        r.mu.Lock()
        r.loggers[subsystem] = logger
        r.mu.Unlock()
}

// SubLoggers returns all currently registered subsystem loggers for this log
// writer.
//
// NOTE: This is part of the LeveledSubLogger interface.
func (r *SubLoggerManager) SubLoggers() SubLoggers {
        r.mu.Lock()
        defer r.mu.Unlock()

        return r.loggers
}

// SupportedSubsystems returns a sorted string slice of all keys in the
// subsystems map, corresponding to the names of the subsystems.
//
// NOTE: This is part of the LeveledSubLogger interface.
func (r *SubLoggerManager) SupportedSubsystems() []string {
        r.mu.Lock()
        defer r.mu.Unlock()

        // Convert the subsystemLoggers map keys to a string slice.
        subsystems := make([]string, 0, len(r.loggers))
        for subsysID := range r.loggers {
                subsystems = append(subsystems, subsysID)
        }

        // Sort the subsystems for stable display.
        sort.Strings(subsystems)

        return subsystems
}

// SetLogLevel sets the logging level for provided subsystem. Invalid
// subsystems are ignored. Uninitialized subsystems are dynamically created as
// needed.
//
// NOTE: This is part of the LeveledSubLogger interface.
func (r *SubLoggerManager) SetLogLevel(subsystemID string, logLevel string) {
        r.mu.Lock()
        defer r.mu.Unlock()

        r.setLogLevelUnsafe(subsystemID, logLevel)
}

// setLogLevelUnsafe sets the logging level for provided subsystem. Invalid
// subsystems are ignored. Uninitialized subsystems are dynamically created as
// needed.
//
// NOTE: the SubLoggerManager mutex must be held before calling this method.
func (r *SubLoggerManager) setLogLevelUnsafe(subsystemID string,
        logLevel string) {

        // Ignore invalid subsystems.
        logger, ok := r.loggers[subsystemID]
        if !ok {
                return
        }

        // Defaults to info if the log level is invalid.
        level, _ := btclog.LevelFromString(logLevel)

        logger.SetLevel(level)
}

// SetLogLevels sets the log level for all subsystem loggers to the passed
// level. It also dynamically creates the subsystem loggers as needed, so it
// can be used to initialize the logging system.
//
// NOTE: This is part of the LeveledSubLogger interface.
func (r *SubLoggerManager) SetLogLevels(logLevel string) {
        r.mu.Lock()
        defer r.mu.Unlock()

        // Configure all sub-systems with the new logging level. Dynamically
        // create loggers as needed.
        for subsystemID := range r.loggers {
                r.setLogLevelUnsafe(subsystemID, logLevel)
        }
}

// SubLoggers is a type that holds a map of subsystem loggers keyed by their
// subsystem name.
type SubLoggers map[string]btclog.Logger

// LeveledSubLogger provides the ability to retrieve the subsystem loggers of
// a logger and set their log levels individually or all at once.
type LeveledSubLogger interface {
        // SubLoggers returns the map of all registered subsystem loggers.
        SubLoggers() SubLoggers

        // SupportedSubsystems returns a slice of strings containing the names
        // of the supported subsystems. Should ideally correspond to the keys
        // of the subsystem logger map and be sorted.
        SupportedSubsystems() []string

        // SetLogLevel assigns an individual subsystem logger a new log level.
        SetLogLevel(subsystemID string, logLevel string)

        // SetLogLevels assigns all subsystem loggers the same new log level.
        SetLogLevels(logLevel string)
}

// ParseAndSetDebugLevels attempts to parse the specified debug level and set
// the levels accordingly on the given logger. An appropriate error is returned
// if anything is invalid.
func ParseAndSetDebugLevels(level string, logger LeveledSubLogger) error {
        // Split at the delimiter.
        levels := strings.Split(level, ",")
        if len(levels) == 0 {
                return fmt.Errorf("invalid log level: %v", level)
        }

        // If the first entry has no =, treat is as the log level for all
        // subsystems.
        globalLevel := levels[0]
        if !strings.Contains(globalLevel, "=") {
                // Validate debug log level.
                if !validLogLevel(globalLevel) {
                        str := "the specified debug level [%v] is invalid"

                        return fmt.Errorf(str, globalLevel)
                }

                // Change the logging level for all subsystems.
                logger.SetLogLevels(globalLevel)

                // The rest will target specific subsystems.
                levels = levels[1:]
        }

        // Go through the subsystem/level pairs while detecting issues and
        // update the log levels accordingly.
        for _, logLevelPair := range levels {
                if !strings.Contains(logLevelPair, "=") {
                        str := "the specified debug level contains an " +
                                "invalid subsystem/level pair [%v]"

                        return fmt.Errorf(str, logLevelPair)
                }

                // Extract the specified subsystem and log level.
                fields := strings.Split(logLevelPair, "=")
                if len(fields) != 2 {
                        str := "the specified debug level has an invalid " +
                                "format [%v] -- use format subsystem1=level1," +
                                "subsystem2=level2"

                        return fmt.Errorf(str, logLevelPair)
                }
                subsysID, logLevel := fields[0], fields[1]
                subLoggers := logger.SubLoggers()

                // Validate subsystem.
                if _, exists := subLoggers[subsysID]; !exists {
                        str := "the specified subsystem [%v] is invalid -- " +
                                "supported subsystems are %v"

                        return fmt.Errorf(
                                str, subsysID, logger.SupportedSubsystems(),
                        )
                }

                // Validate log level.
                if !validLogLevel(logLevel) {
                        str := "the specified debug level [%v] is invalid"
                        return fmt.Errorf(str, logLevel)
                }

                logger.SetLogLevel(subsysID, logLevel)
        }

        return nil
}

// validLogLevel returns whether or not logLevel is a valid debug log level.
func validLogLevel(logLevel string) bool {
        switch logLevel {
        case "trace":
                fallthrough
        case "debug":
                fallthrough
        case "info":
                fallthrough
        case "warn":
                fallthrough
        case "error":
                fallthrough
        case "critical":
                fallthrough
        case "off":
                return true
        }

        return false
}

1	package build
2
3	import (
4	"fmt"
5	"sort"
6	"strings"
7	"sync"
8
9	"github.com/btcsuite/btclog/v2"
10	)
11
12	// SubLogCreator can be used to create a new logger for a particular subsystem.
13	type SubLogCreator interface {
14	// Logger returns a new logger for a particular subsystem.
15	Logger(subsystemTag string) btclog.Logger
16	}
17
18	// SubLoggerManager manages a set of subsystem loggers. Level updates will be
19	// applied to all the loggers managed by the manager.
20	type SubLoggerManager struct {
21	genLogger SubLogCreator
22
23	loggers SubLoggers
24	mu sync.Mutex
25	}
26
27	// A compile time check to ensure SubLoggerManager implements the
28	// LeveledSubLogger interface.
29	var _ LeveledSubLogger = (*SubLoggerManager)(nil)
30
31	// NewSubLoggerManager constructs a new SubLoggerManager.
32	func NewSubLoggerManager(handlers ...btclog.Handler) *SubLoggerManager {	×
33	return &SubLoggerManager{	×
34	loggers: make(SubLoggers),	×
35	genLogger: newSubLogGenerator(	×
36	newHandlerSet(btclog.LevelInfo, handlers...),	×
37	),	×
38	}	×
39	}	×
40
41	// GenSubLogger creates a new sub-logger and adds it to the set managed by the
42	// SubLoggerManager. A shutdown callback function is provided to be able to shut
43	// down in case of a critical error.
44	func (r *SubLoggerManager) GenSubLogger(subsystem string,
45	shutdown func()) btclog.Logger {	×
46		×
47	// Create a new logger with the given subsystem tag.	×
48	logger := r.genLogger.Logger(subsystem)	×
49		×
50	// Wrap the new logger in a Shutdown logger so that the shutdown	×
51	// call back is called if a critical log is ever written via this new	×
52	// logger.	×
53	l := NewShutdownLogger(logger, shutdown)	×
54		×
55	r.RegisterSubLogger(subsystem, l)	×
56		×
57	return l	×
58	}	×
59
60	// RegisterSubLogger registers the given logger under the given subsystem name.
61	func (r *SubLoggerManager) RegisterSubLogger(subsystem string,
62	logger btclog.Logger) {	×
63		×
64	// Add the new logger to the set of loggers managed by the manager.	×
65	r.mu.Lock()	×
66	r.loggers[subsystem] = logger	×
67	r.mu.Unlock()	×
68	}	×
69
70	// SubLoggers returns all currently registered subsystem loggers for this log
71	// writer.
72	//
73	// NOTE: This is part of the LeveledSubLogger interface.
74	func (r *SubLoggerManager) SubLoggers() SubLoggers {	×
75	r.mu.Lock()	×
76	defer r.mu.Unlock()	×
77		×
78	return r.loggers	×
79	}	×
80
81	// SupportedSubsystems returns a sorted string slice of all keys in the
82	// subsystems map, corresponding to the names of the subsystems.
83	//
84	// NOTE: This is part of the LeveledSubLogger interface.
85	func (r *SubLoggerManager) SupportedSubsystems() []string {	×
86	r.mu.Lock()	×
87	defer r.mu.Unlock()	×
88		×
89	// Convert the subsystemLoggers map keys to a string slice.	×
90	subsystems := make([]string, 0, len(r.loggers))	×
91	for subsysID := range r.loggers {	×
92	subsystems = append(subsystems, subsysID)	×
93	}	×
94
95	// Sort the subsystems for stable display.
96	sort.Strings(subsystems)	×
97		×
98	return subsystems	×
99	}
100
101	// SetLogLevel sets the logging level for provided subsystem. Invalid
102	// subsystems are ignored. Uninitialized subsystems are dynamically created as
103	// needed.
104	//
105	// NOTE: This is part of the LeveledSubLogger interface.
106	func (r *SubLoggerManager) SetLogLevel(subsystemID string, logLevel string) {	×
107	r.mu.Lock()	×
108	defer r.mu.Unlock()	×
109		×
110	r.setLogLevelUnsafe(subsystemID, logLevel)	×
111	}	×
112
113	// setLogLevelUnsafe sets the logging level for provided subsystem. Invalid
114	// subsystems are ignored. Uninitialized subsystems are dynamically created as
115	// needed.
116	//
117	// NOTE: the SubLoggerManager mutex must be held before calling this method.
118	func (r *SubLoggerManager) setLogLevelUnsafe(subsystemID string,
119	logLevel string) {	×
120		×
121	// Ignore invalid subsystems.	×
122	logger, ok := r.loggers[subsystemID]	×
123	if !ok {	×
124	return	×
125	}	×
126
127	// Defaults to info if the log level is invalid.
128	level, _ := btclog.LevelFromString(logLevel)	×
129		×
130	logger.SetLevel(level)	×
131	}
132
133	// SetLogLevels sets the log level for all subsystem loggers to the passed
134	// level. It also dynamically creates the subsystem loggers as needed, so it
135	// can be used to initialize the logging system.
136	//
137	// NOTE: This is part of the LeveledSubLogger interface.
138	func (r *SubLoggerManager) SetLogLevels(logLevel string) {	×
139	r.mu.Lock()	×
140	defer r.mu.Unlock()	×
141		×
142	// Configure all sub-systems with the new logging level. Dynamically	×
143	// create loggers as needed.	×
144	for subsystemID := range r.loggers {	×
145	r.setLogLevelUnsafe(subsystemID, logLevel)	×
146	}	×
147	}
148
149	// SubLoggers is a type that holds a map of subsystem loggers keyed by their
150	// subsystem name.
151	type SubLoggers map[string]btclog.Logger
152
153	// LeveledSubLogger provides the ability to retrieve the subsystem loggers of
154	// a logger and set their log levels individually or all at once.
155	type LeveledSubLogger interface {
156	// SubLoggers returns the map of all registered subsystem loggers.
157	SubLoggers() SubLoggers
158
159	// SupportedSubsystems returns a slice of strings containing the names
160	// of the supported subsystems. Should ideally correspond to the keys
161	// of the subsystem logger map and be sorted.
162	SupportedSubsystems() []string
163
164	// SetLogLevel assigns an individual subsystem logger a new log level.
165	SetLogLevel(subsystemID string, logLevel string)
166
167	// SetLogLevels assigns all subsystem loggers the same new log level.
168	SetLogLevels(logLevel string)
169	}
170
171	// ParseAndSetDebugLevels attempts to parse the specified debug level and set
172	// the levels accordingly on the given logger. An appropriate error is returned
173	// if anything is invalid.
174	func ParseAndSetDebugLevels(level string, logger LeveledSubLogger) error {	8✔
175	// Split at the delimiter.	8✔
176	levels := strings.Split(level, ",")	8✔
177	if len(levels) == 0 {	8✔
178	return fmt.Errorf("invalid log level: %v", level)	×
179	}	×
180
181	// If the first entry has no =, treat is as the log level for all
182	// subsystems.
183	globalLevel := levels[0]	8✔
184	if !strings.Contains(globalLevel, "=") {	13✔
185	// Validate debug log level.	5✔
186	if !validLogLevel(globalLevel) {	7✔
187	str := "the specified debug level [%v] is invalid"	2✔
188		2✔
189	return fmt.Errorf(str, globalLevel)	2✔
190	}	2✔
191
192	// Change the logging level for all subsystems.
193	logger.SetLogLevels(globalLevel)	3✔
194		3✔
195	// The rest will target specific subsystems.	3✔
196	levels = levels[1:]	3✔
197	}
198
199	// Go through the subsystem/level pairs while detecting issues and
200	// update the log levels accordingly.
201	for _, logLevelPair := range levels {	14✔
202	if !strings.Contains(logLevelPair, "=") {	10✔
203	str := "the specified debug level contains an " +	2✔
204	"invalid subsystem/level pair [%v]"	2✔
205		2✔
206	return fmt.Errorf(str, logLevelPair)	2✔
207	}	2✔
208
209	// Extract the specified subsystem and log level.
210	fields := strings.Split(logLevelPair, "=")	6✔
211	if len(fields) != 2 {	6✔
212	str := "the specified debug level has an invalid " +	×
213	"format [%v] -- use format subsystem1=level1," +	×
214	"subsystem2=level2"	×
215		×
216	return fmt.Errorf(str, logLevelPair)	×
217	}	×
218	subsysID, logLevel := fields[0], fields[1]	6✔
219	subLoggers := logger.SubLoggers()	6✔
220		6✔
221	// Validate subsystem.	6✔
222	if _, exists := subLoggers[subsysID]; !exists {	7✔
223	str := "the specified subsystem [%v] is invalid -- " +	1✔
224	"supported subsystems are %v"	1✔
225		1✔
226	return fmt.Errorf(	1✔
227	str, subsysID, logger.SupportedSubsystems(),	1✔
228	)	1✔
229	}	1✔
230
231	// Validate log level.
232	if !validLogLevel(logLevel) {	5✔
233	str := "the specified debug level [%v] is invalid"	×
234	return fmt.Errorf(str, logLevel)	×
235	}	×
236
237	logger.SetLogLevel(subsysID, logLevel)	5✔
238	}
239
240	return nil	3✔
241	}
242
243	// validLogLevel returns whether or not logLevel is a valid debug log level.
244	func validLogLevel(logLevel string) bool {	10✔
245	switch logLevel {	10✔
246	case "trace":	1✔
247	fallthrough	1✔
248	case "debug":	5✔
249	fallthrough	5✔
250	case "info":	8✔
251	fallthrough	8✔
252	case "warn":	8✔
253	fallthrough	8✔
254	case "error":	8✔
255	fallthrough	8✔
256	case "critical":	8✔
257	fallthrough	8✔
258	case "off":	8✔
259	return true	8✔
260	}
261
262	return false	2✔
263	}

lightningnetwork / lnd / 13440912774

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