0x1d
0bfdb2c2d7
- Add tests for internal/config package (90.9% coverage) - Test all viperConfig getter methods - Test LoadConfig with default and environment-specific configs - Test error handling for missing config files - Add tests for internal/di package (88.1% coverage) - Test Container lifecycle (NewContainer, Start, Stop) - Test providers (ProvideConfig, ProvideLogger, CoreModule) - Test lifecycle hooks registration - Include mock implementations for testing - Add tests for internal/logger package (96.5% coverage) - Test zapLogger with JSON and console formats - Test all logging levels and methods - Test middleware (RequestIDMiddleware, LoggingMiddleware) - Test context helper functions - Include benchmark tests - Update CI workflow to skip tests when no test files exist - Add conditional test execution based on test file presence - Add timeout for test execution - Verify build when no tests are present All tests follow Go best practices with table-driven patterns, parallel execution where safe, and comprehensive coverage.
134 lines
3.4 KiB
Go
134 lines
3.4 KiB
Go
package logger
|
|
|
|
import (
|
|
"context"
|
|
|
|
"git.dcentral.systems/toolz/goplt/pkg/logger"
|
|
"go.uber.org/zap"
|
|
"go.uber.org/zap/zapcore"
|
|
)
|
|
|
|
const (
|
|
// Context keys for extracting values from context
|
|
requestIDKey = "request_id"
|
|
userIDKey = "user_id"
|
|
)
|
|
|
|
// zapLogger implements the Logger interface using zap.
|
|
type zapLogger struct {
|
|
zap *zap.Logger
|
|
}
|
|
|
|
// NewZapLogger creates a new zap-based logger.
|
|
// The format parameter determines the output format:
|
|
// - "json": JSON format (production)
|
|
// - "console": Human-readable format (development)
|
|
func NewZapLogger(level string, format string) (logger.Logger, error) {
|
|
var zapConfig zap.Config
|
|
var zapLevel zapcore.Level
|
|
|
|
// Parse log level
|
|
if err := zapLevel.UnmarshalText([]byte(level)); err != nil {
|
|
zapLevel = zapcore.InfoLevel
|
|
}
|
|
|
|
// Configure based on format
|
|
if format == "json" {
|
|
zapConfig = zap.NewProductionConfig()
|
|
} else {
|
|
zapConfig = zap.NewDevelopmentConfig()
|
|
}
|
|
|
|
zapConfig.Level = zap.NewAtomicLevelAt(zapLevel)
|
|
zapConfig.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
|
|
|
|
z, err := zapConfig.Build()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &zapLogger{zap: z}, nil
|
|
}
|
|
|
|
// Debug logs a message at debug level.
|
|
func (zl *zapLogger) Debug(msg string, fields ...logger.Field) {
|
|
zl.zap.Debug(msg, convertFields(fields)...)
|
|
}
|
|
|
|
// Info logs a message at info level.
|
|
func (zl *zapLogger) Info(msg string, fields ...logger.Field) {
|
|
zl.zap.Info(msg, convertFields(fields)...)
|
|
}
|
|
|
|
// Warn logs a message at warning level.
|
|
func (zl *zapLogger) Warn(msg string, fields ...logger.Field) {
|
|
zl.zap.Warn(msg, convertFields(fields)...)
|
|
}
|
|
|
|
// Error logs a message at error level.
|
|
func (zl *zapLogger) Error(msg string, fields ...logger.Field) {
|
|
zl.zap.Error(msg, convertFields(fields)...)
|
|
}
|
|
|
|
// With creates a child logger with the specified fields.
|
|
func (zl *zapLogger) With(fields ...logger.Field) logger.Logger {
|
|
return &zapLogger{
|
|
zap: zl.zap.With(convertFields(fields)...),
|
|
}
|
|
}
|
|
|
|
// WithContext creates a child logger with fields extracted from context.
|
|
func (zl *zapLogger) WithContext(ctx context.Context) logger.Logger {
|
|
fields := make([]logger.Field, 0)
|
|
|
|
// Extract request ID from context
|
|
if requestID, ok := ctx.Value(requestIDKey).(string); ok && requestID != "" {
|
|
fields = append(fields, zap.String("request_id", requestID))
|
|
}
|
|
|
|
// Extract user ID from context
|
|
if userID, ok := ctx.Value(userIDKey).(string); ok && userID != "" {
|
|
fields = append(fields, zap.String("user_id", userID))
|
|
}
|
|
|
|
if len(fields) == 0 {
|
|
return zl
|
|
}
|
|
|
|
return &zapLogger{
|
|
zap: zl.zap.With(convertFields(fields)...),
|
|
}
|
|
}
|
|
|
|
// convertFields converts logger.Field to zap.Field.
|
|
// Since Field is an alias for zap.Field, we can cast directly.
|
|
func convertFields(fields []logger.Field) []zap.Field {
|
|
if len(fields) == 0 {
|
|
return nil
|
|
}
|
|
|
|
zapFields := make([]zap.Field, 0, len(fields))
|
|
for _, f := range fields {
|
|
// Type assert to zap.Field
|
|
if zf, ok := f.(zap.Field); ok {
|
|
zapFields = append(zapFields, zf)
|
|
} else {
|
|
// Fallback: convert to Any field
|
|
zapFields = append(zapFields, zap.Any("field", f))
|
|
}
|
|
}
|
|
return zapFields
|
|
}
|
|
|
|
// RequestIDKey returns the context key for request ID.
|
|
// This is exported so modules can use it to set request IDs in context.
|
|
func RequestIDKey() string {
|
|
return requestIDKey
|
|
}
|
|
|
|
// UserIDKey returns the context key for user ID.
|
|
// This is exported so modules can use it to set user IDs in context.
|
|
func UserIDKey() string {
|
|
return userIDKey
|
|
}
|