Support levels string in env vars

For backward compatibility with v1, support parsing the environment variable as a levels string if it does not appear to be a JSON object.

Author: Russ Egan

v2/config_from_env.go

@@ -6,6 +6,7 @@ import (
 	"io"
 	"log/slog"
 	"os"
+	"strings"
 	"sync"
 
 	"github.com/ansel1/console-slog"
@@ -65,15 +66,31 @@ func MustConfigFromEnv(envvars ...string) {
 
 func UnmarshalEnv(o *HandlerOptions, envvars ...string) error {
 	for _, v := range envvars {
-		if configString := os.Getenv(v); configString != "" {
-			// todo: need to add a branch here to handle when the environment variable is
-			// set to a raw levels string, and isn't JSON
+		configString := os.Getenv(v)
+		if configString == "" {
+			continue
+		}
+		if strings.HasPrefix(configString, "{") {
 			err := json.Unmarshal([]byte(configString), o)
 			if err != nil {
 				return fmt.Errorf("parsing configuration from environment variable %v: %w", v, err)
 			}
 			return nil
 		}
+
+		// parse the value like a levels string
+		var levels Levels
+		err := levels.UnmarshalText([]byte(configString))
+		if err != nil {
+			return fmt.Errorf("parsing levels string from environment variable %v: %w", v, err)
+		}
+		opts := HandlerOptions{}
+		if defLvl, ok := levels["*"]; ok {
+			opts.Level = defLvl
+			delete(levels, "*")
+		}
+		opts.Levels = levels
+		*o = opts
 	}
 	return nil
 }

v2/config_from_env_test.go

@@ -16,7 +16,7 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestConfig_UnmarshalEnv(t *testing.T) {
+func TestUnmarshalEnv(t *testing.T) {
 	tests := []struct {
 		name        string
 		env         map[string]string
@@ -55,11 +55,32 @@ func TestConfig_UnmarshalEnv(t *testing.T) {
 		{
 			name: "parse error",
 			env: map[string]string{
-				"FLUME": `not json`,
+				"FLUME": `{{not json}}`,
 			},
 			envvars:     DefaultConfigEnvVars,
 			expectError: "parsing configuration from environment variable FLUME: invalid character",
 		},
+		{
+			name: "levels string error",
+			env: map[string]string{
+				"FLUME": `blue=RED`,
+			},
+			envvars:     DefaultConfigEnvVars,
+			expectError: "parsing levels string from environment variable FLUME: invalid log levels: invalid log level 'RED': slog: level string \"RED\": unknown name",
+		},
+		{
+			name: "parse levels string",
+			env: map[string]string{
+				"FLUME": `*=DBG,blue=WRN`,
+			},
+			envvars: DefaultConfigEnvVars,
+			expected: HandlerOptions{
+				Level: LevelDebug,
+				Levels: map[string]slog.Leveler{
+					"blue": LevelWarn,
+				},
+			},
+		},
 	}
 
 	for _, test := range tests {
@@ -112,9 +133,9 @@ func TestConfigFromEnv(t *testing.T) {
 		{
 			name: "parse error",
 			env: map[string]string{
-				"FLUME": `not json`,
+				"FLUME": `{{not json}}`,
 			},
-			expectError: "parsing configuration from environment variable FLUME: invalid character",
+			expectError: "parsing configuration from environment variable FLUME: invalid character '{' looking for beginning of object key string",
 		},
 	}
 
@@ -131,77 +152,25 @@ func TestConfigFromEnv(t *testing.T) {
 			}
 			err := ConfigFromEnv(test.envvars...)
 			if test.expectError != "" {
-				assert.ErrorContains(t, err, test.expectError)
-				return
-			}
-
-			require.NoError(t, err)
-			assert.Equal(t, test.expectedLevel, Default().HandlerOptions().Level)
-		})
-	}
-}
-
-func TestMustConfigFromEnv(t *testing.T) {
-	testCases := []struct {
-		name          string
-		env           map[string]string
-		envvars       []string
-		expectedLevel slog.Leveler
-		expectPanic   string
-	}{
-		{
-			name: "default",
-			env: map[string]string{
-				"FLUME": `{"level":"WRN"}`,
-			},
-			expectedLevel: slog.LevelWarn,
-		},
-		{
-			name: "search envvars",
-			env: map[string]string{
-				"EMPTY":     "",
-				"LOGCONFIG": `{"level":"WRN"}`,
-			},
-			envvars:       []string{"EMPTY", "LOGCONFIG"},
-			expectedLevel: slog.LevelWarn,
-		},
-		{
-			name:          "no-op",
-			envvars:       []string{"EMPTY", "LOGCONFIG"},
-			expectedLevel: nil,
-		},
-		{
-			name: "parse error",
-			env: map[string]string{
-				"FLUME": `not json`,
-			},
-			expectPanic: "parsing configuration from environment variable FLUME: invalid character 'o' in literal null (expecting 'u')",
-		},
-	}
-	for _, tC := range testCases {
-		t.Run(tC.name, func(t *testing.T) {
-			// make sure the default handler is restored after the test
-			ogOpts := Default().HandlerOptions()
-			t.Cleanup(func() {
-				Default().SetHandlerOptions(ogOpts)
-			})
-
-			for k, v := range tC.env {
-				t.Setenv(k, v)
+				assert.Error(t, err, test.expectError) //nolint:testifylint
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, test.expectedLevel, Default().HandlerOptions().Level)
 			}
 
-			if tC.expectPanic != "" {
-				assert.PanicsWithError(t, tC.expectPanic, func() {
-					MustConfigFromEnv(tC.envvars...)
+			// also test MustConfig
+			if test.expectError != "" {
+				assert.PanicsWithError(t, test.expectError, func() {
+					MustConfigFromEnv(test.envvars...)
 				})
-				return
+			} else {
+				MustConfigFromEnv(test.envvars...)
+				assert.Equal(t, test.expectedLevel, Default().HandlerOptions().Level)
 			}
-
-			MustConfigFromEnv(tC.envvars...)
-			assert.Equal(t, tC.expectedLevel, Default().HandlerOptions().Level)
 		})
 	}
 }
+
 func TestRegisterHandlerFn(t *testing.T) {
 	tests := []struct {
 		name        string

v2/middleware.go

@@ -301,8 +301,6 @@ func (h *replaceAttrsMiddleware) Enabled(ctx context.Context, level slog.Level)
 }
 
 func (h *replaceAttrsMiddleware) Handle(ctx context.Context, record slog.Record) error {
-	// TODO: apply ReplaceAttrs to the built-in attrs as well
-
 	var replacedBuiltIns [3]slog.Attr
 	replaced := replacedBuiltIns[:0]