feat(f1): add typed logging configuration options

Add parse helpers and display methods for the typed logging API:

- ParseLogLevel(string) (slog.Level, error) — accepts "debug", "info",
  "warn", "error" (case-insensitive) plus legacy aliases
- ParseLogFormat(string) (LogFormat, error) — accepts "text", "json"
- LogFormat.String() — returns "text" or "json"

These helpers keep string parsing and validation inside f1, so users
who receive log level/format from config files or CLI args can convert
to typed values without reimplementing the logic.

Tests cover valid inputs, case insensitivity, legacy aliases, empty
defaults, and invalid input error messages.

Author: nvloff-f3

docs/CODEBASE_REVIEW.md

@@ -52,7 +52,7 @@
 - **Scenarios:** `WithDescription`, `WithParameter`; `Scenario.RunFn` populated by framework during setup.
 - **f1testing.T:** `NewTWithOptions(scenarioName, ...TOption)`; `WithLogger`, `WithIteration`, `WithVUID`; `Error`/`Fatal`/`Log` with `args ...any` (testing.T compatible).
 - **Options:** All consolidated in `options.go`; types in `settings.go`. Precedence: programmatic options > env vars > defaults. `WithLogger` takes precedence over log level/format options.
-- **Design decisions:** No `Config` struct (bundles unrelated concerns), no `SettingsProvider` (lazy eval adds no benefit). `WithSettings(Settings{})` replaces `WithoutEnvSettings()` — explicit, no order-dependence. Typed logging APIs (`slog.Level`, `LogFormat`) instead of strings.
+- **Design decisions:** No `Config` struct (bundles unrelated concerns), no `SettingsProvider` (lazy eval adds no benefit). `WithSettings(Settings{})` replaces `WithoutEnvSettings()` — explicit, no order-dependence. Typed logging APIs (`slog.Level`, `LogFormat`) instead of strings. `ParseLogLevel`/`ParseLogFormat` helpers for users who need string-to-type conversion (e.g., from config files); validation lives inside f1.
 
 ### Suggested Improvements
 

docs/V3_PLAN.md

@@ -90,6 +90,8 @@ type RunFn func(ctx context.Context, t *T)
   - Public types: `Settings`, `PrometheusSettings`, `LoggingSettings`, `LogFormat` (no string-key API)
   - `WithSettings(Settings)` replaces baseline (pass `Settings{}` to ignore env vars); replaces `WithoutEnvSettings`
   - `WithLogLevel(slog.Level)`, `WithLogFormat(LogFormat)` — strongly typed
+  - `ParseLogLevel(string)`, `ParseLogFormat(string)` — parse helpers with validation
+  - `LogFormat.String()` — display helper
   - `WithPrometheusPushGateway`, `WithPrometheusNamespace`, `WithPrometheusLabelID`, `WithLogFilePath` — fine-grained overrides
   - `DefaultSettings()` — loads from env vars (backward-compat baseline)
   - All options consolidated in `options.go`; types in `settings.go`

docs/plan.md

@@ -131,6 +131,11 @@ func WithLogFilePath(path string) Option
 func WithLogLevel(level slog.Level) Option    // typed; compile-time safe
 func WithLogFormat(format LogFormat) Option   // typed; compile-time safe
 
+// Parse helpers for string-to-typed conversion (validation inside f1):
+func ParseLogLevel(string) (slog.Level, error)
+func ParseLogFormat(string) (LogFormat, error)
+func (LogFormat) String() string              // "text" or "json"
+
 func New(opts ...Option) *F1
 ```
 

pkg/f1/options_test.go

@@ -171,3 +171,80 @@ func TestDefaultSettingsReturnsDefaults(t *testing.T) {
 	require.Equal(t, slog.LevelInfo, s.Logging.Level)
 	require.Equal(t, f1.LogFormatText, s.Logging.Format)
 }
+
+func TestParseLogLevel(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		input string
+		want  slog.Level
+	}{
+		{"debug", slog.LevelDebug},
+		{"DEBUG", slog.LevelDebug},
+		{"trace", slog.LevelDebug},
+		{"info", slog.LevelInfo},
+		{"INFO", slog.LevelInfo},
+		{"", slog.LevelInfo},
+		{"warn", slog.LevelWarn},
+		{"warning", slog.LevelWarn},
+		{"error", slog.LevelError},
+		{"fatal", slog.LevelError},
+		{"panic", slog.LevelError},
+	}
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			t.Parallel()
+
+			got, err := f1.ParseLogLevel(tt.input)
+			require.NoError(t, err)
+			require.Equal(t, tt.want, got)
+		})
+	}
+}
+
+func TestParseLogLevelInvalid(t *testing.T) {
+	t.Parallel()
+
+	_, err := f1.ParseLogLevel("invalid")
+	require.Error(t, err)
+	require.ErrorContains(t, err, "unknown log level")
+}
+
+func TestParseLogFormat(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		input string
+		want  f1.LogFormat
+	}{
+		{"text", f1.LogFormatText},
+		{"TEXT", f1.LogFormatText},
+		{"", f1.LogFormatText},
+		{"json", f1.LogFormatJSON},
+		{"JSON", f1.LogFormatJSON},
+	}
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			t.Parallel()
+
+			got, err := f1.ParseLogFormat(tt.input)
+			require.NoError(t, err)
+			require.Equal(t, tt.want, got)
+		})
+	}
+}
+
+func TestParseLogFormatInvalid(t *testing.T) {
+	t.Parallel()
+
+	_, err := f1.ParseLogFormat("yaml")
+	require.Error(t, err)
+	require.ErrorContains(t, err, "unknown log format")
+}
+
+func TestLogFormatString(t *testing.T) {
+	t.Parallel()
+
+	require.Equal(t, "text", f1.LogFormatText.String())
+	require.Equal(t, "json", f1.LogFormatJSON.String())
+}

pkg/f1/settings.go

@@ -1,6 +1,7 @@
 package f1
 
 import (
+	"fmt"
 	"log/slog"
 	"strings"
 
@@ -17,6 +18,54 @@ const (
 	LogFormatJSON
 )
 
+const (
+	logFormatTextStr = "text"
+	logFormatJSONStr = "json"
+	logLevelInfoStr  = "info"
+)
+
+// String returns "text" or "json".
+func (f LogFormat) String() string {
+	if f == LogFormatJSON {
+		return logFormatJSONStr
+	}
+
+	return logFormatTextStr
+}
+
+// ParseLogLevel parses a log level string into slog.Level.
+// Accepted values (case-insensitive): "debug", "info", "warn", "error".
+// Also accepts legacy aliases: "trace" (→ Debug), "warning" (→ Warn),
+// "fatal"/"panic" (→ Error). Empty string defaults to Info.
+func ParseLogLevel(s string) (slog.Level, error) {
+	switch strings.ToLower(strings.TrimSpace(s)) {
+	case "debug", "trace":
+		return slog.LevelDebug, nil
+	case logLevelInfoStr, "":
+		return slog.LevelInfo, nil
+	case "warn", "warning":
+		return slog.LevelWarn, nil
+	case "error", "fatal", "panic":
+		return slog.LevelError, nil
+	default:
+		return 0, fmt.Errorf("unknown log level %q: use debug, info, warn, or error", s)
+	}
+}
+
+// ParseLogFormat parses a log format string into LogFormat.
+// Accepted values (case-insensitive): "text", "json".
+// Empty string defaults to LogFormatText.
+func ParseLogFormat(s string) (LogFormat, error) {
+	switch strings.ToLower(strings.TrimSpace(s)) {
+	case logFormatTextStr, "":
+		return LogFormatText, nil
+	case logFormatJSONStr:
+		return LogFormatJSON, nil
+	default:
+		return 0, fmt.Errorf("unknown log format %q: use %s or %s", s, logFormatTextStr, logFormatJSONStr)
+	}
+}
+
 // LoggingSettings configures the default logger built by f1.
 // These settings have no effect when WithLogger is used.
 type LoggingSettings struct {
@@ -67,7 +116,7 @@ func DefaultSettings() Settings {
 func (s Settings) toInternal() envsettings.Settings {
 	var format string
 	if s.Logging.Format == LogFormatJSON {
-		format = "json"
+		format = logFormatJSONStr
 	}
 
 	return envsettings.Settings{
@@ -85,7 +134,7 @@ func (s Settings) toInternal() envsettings.Settings {
 }
 
 func logFormatFromEnv(s string) LogFormat {
-	if strings.EqualFold(s, "json") {
+	if strings.EqualFold(s, logFormatJSONStr) {
 		return LogFormatJSON
 	}
 
@@ -97,12 +146,12 @@ func slogLevelToString(level slog.Level) string {
 	case slog.LevelDebug:
 		return "debug"
 	case slog.LevelInfo:
-		return "info"
+		return logLevelInfoStr
 	case slog.LevelWarn:
 		return "warn"
 	case slog.LevelError:
 		return "error"
 	default:
-		return "info"
+		return logLevelInfoStr
 	}
 }