14348138892

Committed 08 Apr 2025 01:35PM UTC coverage: 86.087%. Remained the same

Build # 14348138892

Build Type

Pull #570

github

Committed by

web-flow

Commit Message

fix(deps): update module github.com/prometheus/client_golang to v1.22.0

Pull Request Pull Request #570: fix(deps): update module github.com/prometheus/client_golang to v1.22.0

Run Details

5408 of 6282 relevant lines covered (86.09%)

46.62 hits per line

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

76.09

/pkg/s3-proxy/log/instance.go

package log

import (
        "fmt"
        "os"
        "path/filepath"
        "strings"

        "emperror.dev/errors"
        logrus "github.com/sirupsen/logrus"
)

const (
        LogFileMode     = 0o666
        LogTraceIDField = "trace_id"
)

type loggerIns struct {
        logrus.FieldLogger
}

// This is dirty pkg/errors.
type stackTracer interface {
        StackTrace() errors.StackTrace
}

func (ll *loggerIns) GetTracingLogger() TracingLogger {
        return &tracingLogger{
                logger: ll,
        }
}

func (ll *loggerIns) GetCorsLogger() CorsLogger {
        return &corsLogger{
                logger: ll,
        }
}

func (ll *loggerIns) Configure(level string, format string, filePath string) error {
        // Parse log level
        lvl, err := logrus.ParseLevel(level)
        // Check error
        if err != nil {
                return errors.WithStack(err)
        }

        // Get logrus logger
        lll, _ := ll.FieldLogger.(*logrus.Logger)

        // Set log level
        lll.SetLevel(lvl)

        // Set format
        if format == "json" {
                lll.SetFormatter(&logrus.JSONFormatter{})
        } else {
                lll.SetFormatter(&logrus.TextFormatter{})
        }

        if filePath != "" {
                // Create directory if necessary
                err2 := os.MkdirAll(filepath.Dir(filePath), os.ModePerm)
                // Check error
                if err2 != nil {
                        return errors.WithStack(err2)
                }

                // Open file
                f, err := os.OpenFile(filePath, os.O_WRONLY|os.O_APPEND|os.O_CREATE, LogFileMode)
                // Check error
                if err != nil {
                        return errors.WithStack(err)
                }

                // Set output file
                lll.SetOutput(f)
        }

        return nil
}

func (ll *loggerIns) WithField(key string, value interface{}) Logger {
        // Create new field logger
        fieldL := ll.FieldLogger.WithField(key, value)

        return &loggerIns{
                FieldLogger: fieldL,
        }
}

func (ll *loggerIns) WithFields(fields map[string]interface{}) Logger {
        // Transform fields
        var ff logrus.Fields = fields
        // Create new field logger
        fieldL := ll.FieldLogger.WithFields(ff)

        return &loggerIns{
                FieldLogger: fieldL,
        }
}

func (ll *loggerIns) WithError(err error) Logger {
        // Create new field logger with error
        fieldL := ll.addPotentialWithError(err)
        // Return new logger
        return &loggerIns{
                FieldLogger: fieldL,
        }
}

func (ll *loggerIns) addPotentialWithError(elem interface{}) logrus.FieldLogger {
        // Try to cast element to error
        err, ok := elem.(error)
        // Check if can be casted to error
        if ok {
                // Create new field logger
                fieldL := ll.FieldLogger.WithError(err)

                addStackTrace := func(pError stackTracer) {
                        // Get stack trace from error
                        st := pError.StackTrace()
                        // Stringify stack trace
                        valued := fmt.Sprintf("%+v", st)
                        // Remove all tabs
                        valued = strings.ReplaceAll(valued, "\t", "")
                        // Split on new line
                        stack := strings.Split(valued, "\n")
                        // Remove first empty string
                        stack = stack[1:]
                        // Add stack trace to field logger
                        fieldL = fieldL.WithField("stack", strings.Join(stack, ","))
                }

                // Check if error as an hidden stackTracer
                var st stackTracer
                if errors.As(err, &st) {
                        addStackTrace(st)
                }

                return fieldL
        }

        // Default
        return ll.FieldLogger
}

func (ll *loggerIns) Error(args ...interface{}) {
        // Add potential "WithError"
        l := ll.addPotentialWithError(args[0])

        // Call logger error method
        l.Error(args...)
}

func (ll *loggerIns) Fatal(args ...interface{}) {
        // Add potential "WithError"
        l := ll.addPotentialWithError(args[0])

        // Call logger fatal method
        l.Fatal(args...)
}

func (ll *loggerIns) Errorf(format string, args ...interface{}) {
        // Create error
        err := fmt.Errorf(format, args...)

        // Log error
        ll.Error(err)
}

func (ll *loggerIns) Fatalf(format string, args ...interface{}) {
        // Create error
        err := fmt.Errorf(format, args...)

        // Log fatal
        ll.Fatal(err)
}

func (ll *loggerIns) Errorln(args ...interface{}) {
        // Add potential "WithError"
        l := ll.addPotentialWithError(args[0])

        // Log error
        l.Errorln(args...)
}

func (ll *loggerIns) Fatalln(args ...interface{}) {
        // Add potential "WithError"
        l := ll.addPotentialWithError(args[0])

        // Log fatal
        l.Fatalln(args...)
}

1	package log
2
3	import (
4	"fmt"
5	"os"
6	"path/filepath"
7	"strings"
8
9	"emperror.dev/errors"
10	logrus "github.com/sirupsen/logrus"
11	)
12
13	const (
14	LogFileMode = 0o666
15	LogTraceIDField = "trace_id"
16	)
17
18	type loggerIns struct {
19	logrus.FieldLogger
20	}
21
22	// This is dirty pkg/errors.
23	type stackTracer interface {
24	StackTrace() errors.StackTrace
25	}
26
27	func (ll *loggerIns) GetTracingLogger() TracingLogger {	141✔
28	return &tracingLogger{	141✔
29	logger: ll,	141✔
30	}	141✔
31	}	141✔
32
33	func (ll *loggerIns) GetCorsLogger() CorsLogger {	6✔
34	return &corsLogger{	6✔
35	logger: ll,	6✔
36	}	6✔
37	}	6✔
38
39	func (ll *loggerIns) Configure(level string, format string, filePath string) error {	95✔
40	// Parse log level	95✔
41	lvl, err := logrus.ParseLevel(level)	95✔
42	// Check error	95✔
43	if err != nil {	96✔
44	return errors.WithStack(err)	1✔
45	}	1✔
46
47	// Get logrus logger
48	lll, _ := ll.FieldLogger.(*logrus.Logger)	94✔
49		94✔
50	// Set log level	94✔
51	lll.SetLevel(lvl)	94✔
52		94✔
53	// Set format	94✔
54	if format == "json" {	96✔
55	lll.SetFormatter(&logrus.JSONFormatter{})	2✔
56	} else {	94✔
57	lll.SetFormatter(&logrus.TextFormatter{})	92✔
58	}	92✔
59
60	if filePath != "" {	95✔
61	// Create directory if necessary	1✔
62	err2 := os.MkdirAll(filepath.Dir(filePath), os.ModePerm)	1✔
63	// Check error	1✔
64	if err2 != nil {	1✔
65	return errors.WithStack(err2)	×
66	}	×
67
68	// Open file
69	f, err := os.OpenFile(filePath, os.O_WRONLY\|os.O_APPEND\|os.O_CREATE, LogFileMode)	1✔
70	// Check error	1✔
71	if err != nil {	1✔
72	return errors.WithStack(err)	×
73	}	×
74
75	// Set output file
76	lll.SetOutput(f)	1✔
77	}
78
79	return nil	94✔
80	}
81
82	func (ll *loggerIns) WithField(key string, value interface{}) Logger {	32✔
83	// Create new field logger	32✔
84	fieldL := ll.FieldLogger.WithField(key, value)	32✔
85		32✔
86	return &loggerIns{	32✔
87	FieldLogger: fieldL,	32✔
88	}	32✔
89	}	32✔
90
91	func (ll *loggerIns) WithFields(fields map[string]interface{}) Logger {	389✔
92	// Transform fields	389✔
93	var ff logrus.Fields = fields	389✔
94	// Create new field logger	389✔
95	fieldL := ll.FieldLogger.WithFields(ff)	389✔
96		389✔
97	return &loggerIns{	389✔
98	FieldLogger: fieldL,	389✔
99	}	389✔
100	}	389✔
101
102	func (ll *loggerIns) WithError(err error) Logger {	×
103	// Create new field logger with error	×
104	fieldL := ll.addPotentialWithError(err)	×
105	// Return new logger	×
106	return &loggerIns{	×
107	FieldLogger: fieldL,	×
108	}	×
109	}	×
110
111	func (ll *loggerIns) addPotentialWithError(elem interface{}) logrus.FieldLogger {	210✔
112	// Try to cast element to error	210✔
113	err, ok := elem.(error)	210✔
114	// Check if can be casted to error	210✔
115	if ok {	363✔
116	// Create new field logger	153✔
117	fieldL := ll.FieldLogger.WithError(err)	153✔
118		153✔
119	addStackTrace := func(pError stackTracer) {	266✔
120	// Get stack trace from error	113✔
121	st := pError.StackTrace()	113✔
122	// Stringify stack trace	113✔
123	valued := fmt.Sprintf("%+v", st)	113✔
124	// Remove all tabs	113✔
125	valued = strings.ReplaceAll(valued, "\t", "")	113✔
126	// Split on new line	113✔
127	stack := strings.Split(valued, "\n")	113✔
128	// Remove first empty string	113✔
129	stack = stack[1:]	113✔
130	// Add stack trace to field logger	113✔
131	fieldL = fieldL.WithField("stack", strings.Join(stack, ","))	113✔
132	}	113✔
133
134	// Check if error as an hidden stackTracer
135	var st stackTracer	153✔
136	if errors.As(err, &st) {	266✔
137	addStackTrace(st)	113✔
138	}	113✔
139
140	return fieldL	153✔
141	}
142
143	// Default
144	return ll.FieldLogger	57✔
145	}
146
147	func (ll *loggerIns) Error(args ...interface{}) {	156✔
148	// Add potential "WithError"	156✔
149	l := ll.addPotentialWithError(args[0])	156✔
150		156✔
151	// Call logger error method	156✔
152	l.Error(args...)	156✔
153	}	156✔
154
155	func (ll *loggerIns) Fatal(args ...interface{}) {	×
156	// Add potential "WithError"	×
157	l := ll.addPotentialWithError(args[0])	×
158		×
159	// Call logger fatal method	×
160	l.Fatal(args...)	×
161	}	×
162
163	func (ll *loggerIns) Errorf(format string, args ...interface{}) {	38✔
164	// Create error	38✔
165	err := fmt.Errorf(format, args...)	38✔
166		38✔
167	// Log error	38✔
168	ll.Error(err)	38✔
169	}	38✔
170
171	func (ll *loggerIns) Fatalf(format string, args ...interface{}) {	×
172	// Create error	×
173	err := fmt.Errorf(format, args...)	×
174		×
175	// Log fatal	×
176	ll.Fatal(err)	×
177	}	×
178
179	func (ll *loggerIns) Errorln(args ...interface{}) {	54✔
180	// Add potential "WithError"	54✔
181	l := ll.addPotentialWithError(args[0])	54✔
182		54✔
183	// Log error	54✔
184	l.Errorln(args...)	54✔
185	}	54✔
186
187	func (ll *loggerIns) Fatalln(args ...interface{}) {	×
188	// Add potential "WithError"	×
189	l := ll.addPotentialWithError(args[0])	×
190		×
191	// Log fatal	×
192	l.Fatalln(args...)	×
193	}	×

oxyno-zeta / s3-proxy / 14348138892

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