20213714844

Committed 14 Dec 2025 08:29PM UTC coverage: 86.02% (-0.07%) from 86.089%

Build # 20213714844

Build Type

push

github

Committed by

oxyno-zeta

Commit Message

chore(deps): update gomock monorepo to v0.6.0

Run Details

5427 of 6309 relevant lines covered (86.02%)

46.55 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, format, 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 any) Logger {
        // Create new field logger
        fieldL := ll.FieldLogger.WithField(key, value)

        return &loggerIns{
                FieldLogger: fieldL,
        }
}

func (ll *loggerIns) WithFields(fields map[string]any) 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 any) 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 ...any) {
        // Add potential "WithError"
        l := ll.addPotentialWithError(args[0])

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

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

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

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

        // Log error
        ll.Error(err)
}

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

        // Log fatal
        ll.Fatal(err)
}

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

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

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

oxyno-zeta / s3-proxy / 20213714844

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