11216766535

Committed 07 Oct 2024 01:37PM UTC coverage: 57.817% (-1.0%) from 58.817%

Build # 11216766535

Build Type

Pull #9148

github

Committed by

ProofOfKeags

Commit Message

lnwire: remove kickoff feerate from propose/commit

Pull Request Pull Request #9148: DynComms [2/n]: lnwire: add authenticated wire messages for Dyn*

Run Details

571 of 879 new or added lines in 16 files covered. (64.96%)

23253 existing lines in 251 files now uncovered.

99022 of 171268 relevant lines covered (57.82%)

38420.67 hits per line

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

10.23

/build/logrotator.go

package build

import (
        "compress/gzip"
        "fmt"
        "io"
        "os"
        "path/filepath"
        "sort"

        "github.com/btcsuite/btclog"
        "github.com/jrick/logrotate/rotator"
        "github.com/klauspost/compress/zstd"
)

// RotatingLogWriter is a wrapper around the LogWriter that supports log file
// rotation.
type RotatingLogWriter struct {
        logWriter *LogWriter

        backendLog *btclog.Backend

        logRotator *rotator.Rotator

        subsystemLoggers SubLoggers
}

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

// NewRotatingLogWriter creates a new file rotating log writer.
//
// NOTE: `InitLogRotator` must be called to set up log rotation after creating
// the writer.
func NewRotatingLogWriter() *RotatingLogWriter {
        logWriter := &LogWriter{}
        backendLog := btclog.NewBackend(logWriter)
        return &RotatingLogWriter{
                logWriter:        logWriter,
                backendLog:       backendLog,
                subsystemLoggers: SubLoggers{},
        }
}

// GenSubLogger creates a new sublogger. A shutdown callback function
// is provided to be able to shutdown in case of a critical error.
func (r *RotatingLogWriter) GenSubLogger(tag string, shutdown func()) btclog.Logger {
        logger := r.backendLog.Logger(tag)
        return NewShutdownLogger(logger, shutdown)
}

// RegisterSubLogger registers a new subsystem logger.
func (r *RotatingLogWriter) RegisterSubLogger(subsystem string,
        logger btclog.Logger) {

        r.subsystemLoggers[subsystem] = logger
}

// InitLogRotator initializes the log file rotator to write logs to logFile and
// create roll files in the same directory. It should be called as early on
// startup and possible and must be closed on shutdown by calling `Close`.
func (r *RotatingLogWriter) InitLogRotator(logFile, logCompressor string,
        maxLogFileSize int, maxLogFiles int) error {

        logDir, _ := filepath.Split(logFile)
        err := os.MkdirAll(logDir, 0700)
        if err != nil {
                return fmt.Errorf("failed to create log directory: %w", err)
        }
        r.logRotator, err = rotator.New(
                logFile, int64(maxLogFileSize*1024), false, maxLogFiles,
        )
        if err != nil {
                return fmt.Errorf("failed to create file rotator: %w", err)
        }

        // Reject unknown compressors.
        if !SuportedLogCompressor(logCompressor) {
                return fmt.Errorf("unknown log compressor: %v", logCompressor)
        }

        var c rotator.Compressor
        switch logCompressor {
        case Gzip:
                c = gzip.NewWriter(nil)

        case Zstd:
                c, err = zstd.NewWriter(nil)
                if err != nil {
                        return fmt.Errorf("failed to create zstd compressor: "+
                                "%w", err)
                }
        }

        // Apply the compressor and its file suffix to the log rotator.
        r.logRotator.SetCompressor(c, logCompressors[logCompressor])

        // Run rotator as a goroutine now but make sure we catch any errors
        // that happen in case something with the rotation goes wrong during
        // runtime (like running out of disk space or not being allowed to
        // create a new logfile for whatever reason).
        pr, pw := io.Pipe()
        go func() {
                err := r.logRotator.Run(pr)
                if err != nil {
                        _, _ = fmt.Fprintf(os.Stderr,
                                "failed to run file rotator: %v\n", err)
                }
        }()

        r.logWriter.RotatorPipe = pw
        return nil
}

// Close closes the underlying log rotator if it has already been created.
func (r *RotatingLogWriter) Close() error {
        if r.logRotator != nil {
                return r.logRotator.Close()
        }
        return nil
}

// SubLoggers returns all currently registered subsystem loggers for this log
// writer.
//
// NOTE: This is part of the LeveledSubLogger interface.
func (r *RotatingLogWriter) SubLoggers() SubLoggers {
        return r.subsystemLoggers
}

// 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 *RotatingLogWriter) SupportedSubsystems() []string {
        // Convert the subsystemLoggers map keys to a string slice.
        subsystems := make([]string, 0, len(r.subsystemLoggers))
        for subsysID := range r.subsystemLoggers {
                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 *RotatingLogWriter) SetLogLevel(subsystemID string, logLevel string) {
        // Ignore invalid subsystems.
        logger, ok := r.subsystemLoggers[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 *RotatingLogWriter) SetLogLevels(logLevel string) {
        // Configure all sub-systems with the new logging level. Dynamically
        // create loggers as needed.
        for subsystemID := range r.subsystemLoggers {
                r.SetLogLevel(subsystemID, logLevel)
        }
}

1	package build
2
3	import (
4	"compress/gzip"
5	"fmt"
6	"io"
7	"os"
8	"path/filepath"
9	"sort"
10
11	"github.com/btcsuite/btclog"
12	"github.com/jrick/logrotate/rotator"
13	"github.com/klauspost/compress/zstd"
14	)
15
16	// RotatingLogWriter is a wrapper around the LogWriter that supports log file
17	// rotation.
18	type RotatingLogWriter struct {
19	logWriter *LogWriter
20
21	backendLog *btclog.Backend
22
23	logRotator *rotator.Rotator
24
25	subsystemLoggers SubLoggers
26	}
27
28	// A compile time check to ensure RotatingLogWriter implements the
29	// LeveledSubLogger interface.
30	var _ LeveledSubLogger = (*RotatingLogWriter)(nil)
31
32	// NewRotatingLogWriter creates a new file rotating log writer.
33	//
34	// NOTE: `InitLogRotator` must be called to set up log rotation after creating
35	// the writer.
36	func NewRotatingLogWriter() *RotatingLogWriter {	1✔
37	logWriter := &LogWriter{}	1✔
38	backendLog := btclog.NewBackend(logWriter)	1✔
39	return &RotatingLogWriter{	1✔
40	logWriter: logWriter,	1✔
41	backendLog: backendLog,	1✔
42	subsystemLoggers: SubLoggers{},	1✔
43	}	1✔
44	}	1✔
45
46	// GenSubLogger creates a new sublogger. A shutdown callback function
47	// is provided to be able to shutdown in case of a critical error.
UNCOV 48	func (r *RotatingLogWriter) GenSubLogger(tag string, shutdown func()) btclog.Logger {	×
UNCOV 49	logger := r.backendLog.Logger(tag)	×
UNCOV 50	return NewShutdownLogger(logger, shutdown)	×
UNCOV 51	}	×
52
53	// RegisterSubLogger registers a new subsystem logger.
54	func (r *RotatingLogWriter) RegisterSubLogger(subsystem string,
UNCOV 55	logger btclog.Logger) {	×
UNCOV 56		×
UNCOV 57	r.subsystemLoggers[subsystem] = logger	×
UNCOV 58	}	×
59
60	// InitLogRotator initializes the log file rotator to write logs to logFile and
61	// create roll files in the same directory. It should be called as early on
62	// startup and possible and must be closed on shutdown by calling `Close`.
63	func (r *RotatingLogWriter) InitLogRotator(logFile, logCompressor string,
UNCOV 64	maxLogFileSize int, maxLogFiles int) error {	×
UNCOV 65		×
UNCOV 66	logDir, _ := filepath.Split(logFile)	×
UNCOV 67	err := os.MkdirAll(logDir, 0700)	×
UNCOV 68	if err != nil {	×
69	return fmt.Errorf("failed to create log directory: %w", err)	×
70	}	×
UNCOV 71	r.logRotator, err = rotator.New(	×
UNCOV 72	logFile, int64(maxLogFileSize*1024), false, maxLogFiles,	×
UNCOV 73	)	×
UNCOV 74	if err != nil {	×
75	return fmt.Errorf("failed to create file rotator: %w", err)	×
76	}	×
77
78	// Reject unknown compressors.
UNCOV 79	if !SuportedLogCompressor(logCompressor) {	×
80	return fmt.Errorf("unknown log compressor: %v", logCompressor)	×
81	}	×
82
UNCOV 83	var c rotator.Compressor	×
UNCOV 84	switch logCompressor {	×
UNCOV 85	case Gzip:	×
UNCOV 86	c = gzip.NewWriter(nil)	×
87
88	case Zstd:	×
89	c, err = zstd.NewWriter(nil)	×
90	if err != nil {	×
91	return fmt.Errorf("failed to create zstd compressor: "+	×
92	"%w", err)	×
93	}	×
94	}
95
96	// Apply the compressor and its file suffix to the log rotator.
UNCOV 97	r.logRotator.SetCompressor(c, logCompressors[logCompressor])	×
UNCOV 98		×
UNCOV 99	// Run rotator as a goroutine now but make sure we catch any errors	×
UNCOV 100	// that happen in case something with the rotation goes wrong during	×
UNCOV 101	// runtime (like running out of disk space or not being allowed to	×
UNCOV 102	// create a new logfile for whatever reason).	×
UNCOV 103	pr, pw := io.Pipe()	×
UNCOV 104	go func() {	×
UNCOV 105	err := r.logRotator.Run(pr)	×
UNCOV 106	if err != nil {	×
107	_, _ = fmt.Fprintf(os.Stderr,	×
108	"failed to run file rotator: %v\n", err)	×
109	}	×
110	}()
111
UNCOV 112	r.logWriter.RotatorPipe = pw	×
UNCOV 113	return nil	×
114	}
115
116	// Close closes the underlying log rotator if it has already been created.
UNCOV 117	func (r *RotatingLogWriter) Close() error {	×
UNCOV 118	if r.logRotator != nil {	×
UNCOV 119	return r.logRotator.Close()	×
UNCOV 120	}	×
121	return nil	×
122	}
123
124	// SubLoggers returns all currently registered subsystem loggers for this log
125	// writer.
126	//
127	// NOTE: This is part of the LeveledSubLogger interface.
128	func (r *RotatingLogWriter) SubLoggers() SubLoggers {	×
129	return r.subsystemLoggers	×
130	}	×
131
132	// SupportedSubsystems returns a sorted string slice of all keys in the
133	// subsystems map, corresponding to the names of the subsystems.
134	//
135	// NOTE: This is part of the LeveledSubLogger interface.
136	func (r *RotatingLogWriter) SupportedSubsystems() []string {	×
137	// Convert the subsystemLoggers map keys to a string slice.	×
138	subsystems := make([]string, 0, len(r.subsystemLoggers))	×
139	for subsysID := range r.subsystemLoggers {	×
140	subsystems = append(subsystems, subsysID)	×
141	}	×
142
143	// Sort the subsystems for stable display.
144	sort.Strings(subsystems)	×
145	return subsystems	×
146	}
147
148	// SetLogLevel sets the logging level for provided subsystem. Invalid
149	// subsystems are ignored. Uninitialized subsystems are dynamically created as
150	// needed.
151	//
152	// NOTE: This is part of the LeveledSubLogger interface.
UNCOV 153	func (r *RotatingLogWriter) SetLogLevel(subsystemID string, logLevel string) {	×
UNCOV 154	// Ignore invalid subsystems.	×
UNCOV 155	logger, ok := r.subsystemLoggers[subsystemID]	×
UNCOV 156	if !ok {	×
157	return	×
158	}	×
159
160	// Defaults to info if the log level is invalid.
UNCOV 161	level, _ := btclog.LevelFromString(logLevel)	×
UNCOV 162	logger.SetLevel(level)	×
163	}
164
165	// SetLogLevels sets the log level for all subsystem loggers to the passed
166	// level. It also dynamically creates the subsystem loggers as needed, so it
167	// can be used to initialize the logging system.
168	//
169	// NOTE: This is part of the LeveledSubLogger interface.
UNCOV 170	func (r *RotatingLogWriter) SetLogLevels(logLevel string) {	×
UNCOV 171	// Configure all sub-systems with the new logging level. Dynamically	×
UNCOV 172	// create loggers as needed.	×
UNCOV 173	for subsystemID := range r.subsystemLoggers {	×
UNCOV 174	r.SetLogLevel(subsystemID, logLevel)	×
UNCOV 175	}	×
176	}

lightningnetwork / lnd / 11216766535

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