6734984523

Committed 02 Nov 2023 03:48PM UTC coverage: 76.135% (-0.5%) from 76.649%

Build # 6734984523

Build Type

push

github

Committed by

web-flow

Commit Message

fixed injectables (#5)

* fixed zap logger injectable context key
* ensured xxxFromContext does not panic when nil
* added lock to guard global die function

Signed-off-by: Frederic BIDON <fredbi@yahoo.com>

Run Details

19 of 19 new or added lines in 4 files covered. (100.0%)

587 of 771 relevant lines covered (76.13%)

16.28 hits per line

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

35.42

/cli/injectable/logger.go

package injectable

import (
        "context"
        "log/slog"

        "go.uber.org/zap"
)

var (
        _ ContextInjectable = &SLogger{}
        _ ContextInjectable = &ZapLogger{}
)

type (
        SLogger struct {
                logger *slog.Logger
        }

        ZapLogger struct {
                logger *zap.Logger
        }
)

func NewSLogger(l *slog.Logger) *SLogger {
        return &SLogger{logger: l}
}

func NewZapLogger(l *zap.Logger) *ZapLogger {
        return &ZapLogger{logger: l}
}

func (c *SLogger) Context(ctx context.Context) context.Context {
        return context.WithValue(ctx, ctxSLogger, c.logger)
}

func (c SLogger) FromContext(ctx context.Context) interface{} {
        logger, ok := ctx.Value(ctxSLogger).(*slog.Logger)
        if !ok {
                return nil
        }

        return logger
}

func (c *ZapLogger) Context(ctx context.Context) context.Context {
        return context.WithValue(ctx, ctxZapLogger, c.logger)
}

func (c ZapLogger) FromContext(ctx context.Context) interface{} {
        logger, ok := ctx.Value(ctxZapLogger).(*zap.Logger)
        if !ok {
                return nil
        }

        return logger
}

// SLoggerFromContext retrieves a standard structured logger from the context.
//
// Optional defaulters can be added to deal with a non-existing logger.
func SLoggerFromContext(ctx context.Context, defaulters ...func() *slog.Logger) *slog.Logger {
        var c SLogger

        logger := c.FromContext(ctx)
        if logger == nil {
                for _, defaulter := range defaulters {
                        logger = defaulter()
                }
        }
        if logger == nil {
                return nil
        }

        return logger.(*slog.Logger)
}

// ZapLoggerFromContext retrieves a zap logger from the context.
//
// Optional defaulters can be added to deal with a non-existing logger.
func ZapLoggerFromContext(ctx context.Context, defaulters ...func() *zap.Logger) *zap.Logger {
        var c ZapLogger

        logger := c.FromContext(ctx)
        if logger == nil {
                for _, defaulter := range defaulters {
                        logger = defaulter()
                }
        }
        if logger == nil {
                return nil
        }

        return logger.(*zap.Logger)
}

1	package injectable
2
3	import (
4	"context"
5	"log/slog"
6
7	"go.uber.org/zap"
8	)
9
10	var (
11	_ ContextInjectable = &SLogger{}
12	_ ContextInjectable = &ZapLogger{}
13	)
14
15	type (
16	SLogger struct {
17	logger *slog.Logger
18	}
19
20	ZapLogger struct {
21	logger *zap.Logger
22	}
23	)
24
25	func NewSLogger(l slog.Logger) SLogger {	1✔
26	return &SLogger{logger: l}	1✔
27	}	1✔
28
29	func NewZapLogger(l zap.Logger) ZapLogger {	×
30	return &ZapLogger{logger: l}	×
31	}	×
32
33	func (c *SLogger) Context(ctx context.Context) context.Context {	1✔
34	return context.WithValue(ctx, ctxSLogger, c.logger)	1✔
35	}	1✔
36
37	func (c SLogger) FromContext(ctx context.Context) interface{} {	1✔
38	logger, ok := ctx.Value(ctxSLogger).(*slog.Logger)	1✔
39	if !ok {	1✔
40	return nil	×
41	}	×
42
43	return logger	1✔
44	}
45
46	func (c *ZapLogger) Context(ctx context.Context) context.Context {	×
47	return context.WithValue(ctx, ctxZapLogger, c.logger)	×
48	}	×
49
50	func (c ZapLogger) FromContext(ctx context.Context) interface{} {	×
51	logger, ok := ctx.Value(ctxZapLogger).(*zap.Logger)	×
52	if !ok {	×
53	return nil	×
54	}	×
55
56	return logger	×
57	}
58
59	// SLoggerFromContext retrieves a standard structured logger from the context.
60	//
61	// Optional defaulters can be added to deal with a non-existing logger.
62	func SLoggerFromContext(ctx context.Context, defaulters ...func() slog.Logger) slog.Logger {	1✔
63	var c SLogger	1✔
64		1✔
65	logger := c.FromContext(ctx)	1✔
66	if logger == nil {	1✔
67	for _, defaulter := range defaulters {	×
68	logger = defaulter()	×
69	}	×
70	}
71	if logger == nil {	1✔
72	return nil	×
73	}	×
74
75	return logger.(*slog.Logger)	1✔
76	}
77
78	// ZapLoggerFromContext retrieves a zap logger from the context.
79	//
80	// Optional defaulters can be added to deal with a non-existing logger.
81	func ZapLoggerFromContext(ctx context.Context, defaulters ...func() zap.Logger) zap.Logger {	×
82	var c ZapLogger	×
83		×
84	logger := c.FromContext(ctx)	×
85	if logger == nil {	×
86	for _, defaulter := range defaulters {	×
87	logger = defaulter()	×
88	}	×
89	}
90	if logger == nil {	×
91	return nil	×
92	}	×
93
94	return logger.(*zap.Logger)	×
95	}

fredbi / go-cli / 6734984523

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