logging: configure default fallbacks for NewFromEnv (#420)

Author: sethvargo

logging/logger.go

@@ -89,39 +89,119 @@ func New(w io.Writer, level slog.Level, format Format, debug bool) *slog.Logger
 //   - LOG_LEVEL: string representation of the log level. It panics if no such log level exists.
 //   - LOG_FORMAT: format in which to output logs (e.g. json, text). It panics if no such format exists.
 //   - LOG_DEBUG: enable the most detailed debug logging. It panics iff the given value is not a valid boolean.
-func NewFromEnv(envPrefix string) *slog.Logger {
-	return newFromEnv(envPrefix, os.Getenv)
+//
+// You can customize the default values for when no environment variables are
+// found using [Option] like [WithDefaultLevel].
+func NewFromEnv(envPrefix string, opts ...Option) *slog.Logger {
+	return newFromEnv(envPrefix, opts...)
+}
+
+// options is a holding structure for configurable options.
+type options struct {
+	level  slog.Level
+	format Format
+	debug  bool
+	target *os.File
+	getenv func(s string) string
+}
+
+// Option represents a configuration function for the logger. It's primarily
+// used with [NewFromEnv] to set defaults.
+type Option func(o *options) *options
+
+// WithDefaultLevel sets the default level of the logger if no value is set.
+func WithDefaultLevel(l slog.Level) Option {
+	return func(o *options) *options {
+		o.level = l
+		return o
+	}
+}
+
+// WithDefaultFormat sets the default format of the logger if no value is set.
+func WithDefaultFormat(f Format) Option {
+	return func(o *options) *options {
+		o.format = f
+		return o
+	}
+}
+
+// WithDefaultDebug sets the default debug mode of the logger if no value is set.
+func WithDefaultDebug(b bool) Option {
+	return func(o *options) *options {
+		o.debug = b
+		return o
+	}
+}
+
+// WithDefaultTarget sets the default output of the logger if no value is set.
+// If you use something other than [os.Stdout] or [os.Stderr], the caller is
+// responsible for closing the provided [os.File] handle.
+func WithDefaultTarget(t *os.File) Option {
+	return func(o *options) *options {
+		o.target = t
+		return o
+	}
+}
+
+// WithGetenv overrides the function to get envvars. It's primarily used for
+// testing.
+func WithGetenv(f func(string) string) Option {
+	return func(o *options) *options {
+		o.getenv = f
+		return o
+	}
 }
 
 // newFromEnv is a helper that makes it easier to test [NewFromEnv].
-func newFromEnv(envPrefix string, getenvFunc func(string) string) *slog.Logger {
-	levelEnvVarKey, levelEnvVarValue := multiGetenv(getenvFunc, envPrefix+"LOG_LEVEL", "LOG_LEVEL")
-	level, err := LookupLevel(levelEnvVarValue)
-	if err != nil {
-		panic(fmt.Sprintf("log level: invalid value for %s: %s", levelEnvVarKey, err))
+func newFromEnv(envPrefix string, opts ...Option) *slog.Logger {
+	o := &options{
+		level:  slog.LevelInfo,
+		format: FormatJSON,
+		target: os.Stdout,
+		debug:  false,
+		getenv: os.Getenv,
+	}
+	for _, opt := range opts {
+		o = opt(o)
+	}
+
+	levelEnvVarKey, levelEnvVarValue := multiGetenv(o.getenv, envPrefix+"LOG_LEVEL", "LOG_LEVEL")
+	if levelEnvVarValue != "" {
+		level, err := LookupLevel(levelEnvVarValue)
+		if err != nil {
+			panic(fmt.Sprintf("log level: invalid value for %s: %s", levelEnvVarKey, err))
+		}
+		o.level = level
 	}
 
-	formatEnvVarKey, formatEnvVarValue := multiGetenv(getenvFunc, envPrefix+"LOG_FORMAT", "LOG_FORMAT")
-	format, err := LookupFormat(formatEnvVarValue)
-	if err != nil {
-		panic(fmt.Sprintf("log format: invalid value for %s: %s", formatEnvVarKey, err))
+	formatEnvVarKey, formatEnvVarValue := multiGetenv(o.getenv, envPrefix+"LOG_FORMAT", "LOG_FORMAT")
+	if formatEnvVarValue != "" {
+		format, err := LookupFormat(formatEnvVarValue)
+		if err != nil {
+			panic(fmt.Sprintf("log format: invalid value for %s: %s", formatEnvVarKey, err))
+		}
+		o.format = format
 	}
 
-	debugEnvVarKey, debugEnvVarValue := multiGetenv(getenvFunc, envPrefix+"LOG_DEBUG", "LOG_DEBUG")
-	debug, err := strconv.ParseBool(debugEnvVarValue)
-	if err != nil {
-		if debugEnvVarValue != "" {
+	debugEnvVarKey, debugEnvVarValue := multiGetenv(o.getenv, envPrefix+"LOG_DEBUG", "LOG_DEBUG")
+	if debugEnvVarValue != "" {
+		debug, err := strconv.ParseBool(debugEnvVarValue)
+		if err != nil {
 			panic(fmt.Sprintf("log debug: invalid value for %s: %s", debugEnvVarKey, err))
 		}
+		o.debug = debug
 	}
 
-	targetEnvVarKey, targetEnvVarValue := multiGetenv(getenvFunc, envPrefix+"LOG_TARGET", "LOG_TARGET")
-	target, err := LookupTarget(targetEnvVarValue)
-	if err != nil {
-		panic(fmt.Sprintf("log target: invalid value for %s: %s", targetEnvVarKey, err))
+	targetEnvVarKey, targetEnvVarValue := multiGetenv(o.getenv, envPrefix+"LOG_TARGET", "LOG_TARGET")
+	if targetEnvVarValue != "" {
+		target, err := LookupTarget(targetEnvVarValue)
+		if err != nil {
+			panic(fmt.Sprintf("log target: invalid value for %s: %s", targetEnvVarKey, err))
+		}
+		o.target = target
 	}
 
-	return New(target, level, format, debug)
+	return New(o.target, o.level, o.format, o.debug)
 }
 
 // multiGetenv is a helper function for looking up a collection of environment

logging/logger_test.go

@@ -197,9 +197,9 @@ func TestNewFromEnv(t *testing.T) {
 				}
 			}()
 
-			logger := newFromEnv(tc.envPrefix, func(k string) string {
+			logger := newFromEnv(tc.envPrefix, WithGetenv(func(k string) string {
 				return tc.env[k]
-			})
+			}))
 
 			if !logger.Handler().Enabled(ctx, tc.wantLevel) {
 				t.Errorf("expected handler to be at least %s", tc.wantLevel)