feat!: NewRun accepts ...RunOption directly

Replace options.Apply(...) with NewRun(scenarios, trigger, ...,
opts ...RunOption). Matches f1.New pattern and removes
the extra Apply indirection.

BREAKING CHANGE: NewRun signature changed from
(options.RunOptions, scenarios, trigger, ...) to
(scenarios, trigger, ..., opts ...RunOption).
Remove options.Apply() from call sites.

Author: nvloff-f3

internal/options/run_options.go

@@ -16,6 +16,52 @@ type RunOptions struct {
 	WaitForCompletionTimeout time.Duration
 }
 
+type RunOption func(*RunOptions)
+
+func WithScenario(s string) RunOption {
+	return func(o *RunOptions) { o.Scenario = s }
+}
+
+func WithMaxDuration(d time.Duration) RunOption {
+	return func(o *RunOptions) { o.MaxDuration = d }
+}
+
+func WithConcurrency(n int) RunOption {
+	return func(o *RunOptions) { o.Concurrency = n }
+}
+
+func WithMaxIterations(n uint64) RunOption {
+	return func(o *RunOptions) { o.MaxIterations = n }
+}
+
+func WithMaxFailures(n uint64) RunOption {
+	return func(o *RunOptions) { o.MaxFailures = n }
+}
+
+func WithMaxFailuresRate(n int) RunOption {
+	return func(o *RunOptions) { o.MaxFailuresRate = n }
+}
+
+func WithVerbose(v bool) RunOption {
+	return func(o *RunOptions) { o.Verbose = v }
+}
+
+func WithIgnoreDropped(v bool) RunOption {
+	return func(o *RunOptions) { o.IgnoreDropped = v }
+}
+
+func WithWaitForCompletionTimeout(d time.Duration) RunOption {
+	return func(o *RunOptions) { o.WaitForCompletionTimeout = d }
+}
+
+func DefaultRunOptions() RunOptions {
+	return RunOptions{
+		MaxDuration:              time.Second,
+		Concurrency:              100,
+		WaitForCompletionTimeout: 10 * time.Second,
+	}
+}
+
 func (o *RunOptions) LogToFile() bool {
 	return !o.Verbose
 }

internal/run/run_cmd.go

@@ -186,17 +186,17 @@ func runCmdExecute(
 			return fmt.Errorf("getting flag: %w", err)
 		}
 
-		run, err := NewRun(options.RunOptions{
-			Scenario:                 scenarioName,
-			MaxDuration:              duration,
-			Concurrency:              concurrency,
-			Verbose:                  verbose,
-			MaxIterations:            maxIterations,
-			MaxFailures:              maxFailures,
-			MaxFailuresRate:          maxFailuresRate,
-			IgnoreDropped:            ignoreDropped,
-			WaitForCompletionTimeout: waitForCompletionTimeout,
-		}, s, trig, settings, metricsInstance, output)
+		run, err := NewRun(s, trig, settings, metricsInstance, output,
+			options.WithScenario(scenarioName),
+			options.WithMaxDuration(duration),
+			options.WithConcurrency(concurrency),
+			options.WithVerbose(verbose),
+			options.WithMaxIterations(maxIterations),
+			options.WithMaxFailures(maxFailures),
+			options.WithMaxFailuresRate(maxFailuresRate),
+			options.WithIgnoreDropped(ignoreDropped),
+			options.WithWaitForCompletionTimeout(waitForCompletionTimeout),
+		)
 		if err != nil {
 			return fmt.Errorf("new run: %w", err)
 		}

internal/run/run_stage_test.go

@@ -197,16 +197,16 @@ func (s *RunTestStage) setupRun() {
 	logger := log.NewLogger(&s.stdout, logutils.NewLogConfigFromSettings(s.settings))
 	outputer := ui.NewOutput(logger, printer, s.interactive, false)
 
-	r, err := run.NewRun(options.RunOptions{
-		Scenario:                 s.scenario,
-		MaxDuration:              s.duration,
-		Concurrency:              s.concurrency,
-		MaxIterations:            s.maxIterations,
-		MaxFailures:              s.maxFailures,
-		MaxFailuresRate:          s.maxFailuresRate,
-		Verbose:                  s.verbose,
-		WaitForCompletionTimeout: s.waitForCompletionTimeout,
-	}, s.f1.GetScenarios(), s.build_trigger(), s.settings, s.metrics, outputer)
+	r, err := run.NewRun(s.f1.GetScenarios(), s.build_trigger(), s.settings, s.metrics, outputer,
+		options.WithScenario(s.scenario),
+		options.WithMaxDuration(s.duration),
+		options.WithConcurrency(s.concurrency),
+		options.WithMaxIterations(s.maxIterations),
+		options.WithMaxFailures(s.maxFailures),
+		options.WithMaxFailuresRate(s.maxFailuresRate),
+		options.WithVerbose(s.verbose),
+		options.WithWaitForCompletionTimeout(s.waitForCompletionTimeout),
+	)
 
 	s.require.NoError(err)
 	s.runInstance = r

internal/run/test_runner.go

@@ -43,36 +43,41 @@ type Run struct {
 }
 
 func NewRun(
-	options options.RunOptions,
 	scenarios *scenarios.Scenarios,
 	trigger *api.Trigger,
 	settings envsettings.Settings,
 	metricsInstance *metrics.Metrics,
 	parentOutput *ui.Output,
+	opts ...options.RunOption,
 ) (*Run, error) {
+	runOptions := options.DefaultRunOptions()
+	for _, opt := range opts {
+		opt(&runOptions)
+	}
+
 	progressStats := &progress.Stats{}
 	viewsInstance := views.New()
 
-	scenario := scenarios.GetScenario(options.Scenario)
+	scenario := scenarios.GetScenario(runOptions.Scenario)
 	if scenario == nil {
-		return nil, fmt.Errorf("scenario not defined: %s", options.Scenario)
+		return nil, fmt.Errorf("scenario not defined: %s", runOptions.Scenario)
 	}
 
-	result := NewResult(options, viewsInstance, progressStats)
+	result := NewResult(runOptions, viewsInstance, progressStats)
 
 	outputer := ui.NewOutput(
 		parentOutput.Logger.With(log.ScenarioAttr(scenario.Name)),
 		parentOutput.Printer,
 		parentOutput.Interactive,
-		options.LogToFile(),
+		runOptions.LogToFile(),
 	)
 
 	scenarioLogger := NewScenarioLogger(outputer)
 	result.LogFilePath = scenarioLogger.Open(
 		LogFilePathOrDefault(settings.Log.FilePath, scenario.Name),
 		logutils.NewLogConfigFromSettings(settings),
 		scenario.Name,
-		options.LogToFile(),
+		runOptions.LogToFile(),
 	)
 
 	progressRunner, err := newProgressRunner(result, outputer)
@@ -90,7 +95,7 @@ func NewRun(
 	pusher := newMetricsPusher(settings, scenario.Name, metricsInstance)
 
 	return &Run{
-		options:        options,
+		options:        runOptions,
 		trigger:        trigger,
 		metrics:        metricsInstance,
 		views:          viewsInstance,

pkg/f1/f1.go

@@ -38,34 +38,40 @@ type f1Options struct {
 	staticMetrics map[string]string
 }
 
-// New instantiates a new instance of an F1 CLI.
-func New() *F1 {
+// Option configures an F1 instance at construction.
+type Option func(*F1)
+
+// WithLogger specifies the logger for internal and scenario logs.
+// This disables F1_LOG_LEVEL and F1_LOG_FORMAT.
+func WithLogger(logger *slog.Logger) Option {
+	return func(f *F1) {
+		f.options.output = ui.NewDefaultOutputWithLogger(logger)
+	}
+}
+
+// WithStaticMetrics registers additional labels with fixed values for f1 metrics.
+func WithStaticMetrics(labels map[string]string) Option {
+	return func(f *F1) {
+		f.options.staticMetrics = labels
+	}
+}
+
+// New instantiates a new F1 CLI. Pass options to configure logger, metrics, etc.
+func New(opts ...Option) *F1 {
 	settings := envsettings.Get()
 
-	return &F1{
+	f := &F1{
 		scenarios: scenarios.New(),
 		profiling: &profiling{},
 		settings:  settings,
 		options: &f1Options{
-			output: ui.NewDefaultOutput(settings.Log.SlogLevel(), settings.Log.IsFormatJSON()),
+			output:        ui.NewDefaultOutput(settings.Log.SlogLevel(), settings.Log.IsFormatJSON()),
+			staticMetrics: nil,
 		},
 	}
-}
-
-// WithLogger allows specifying logger to be used for all internal and scenario logs
-//
-// This will disable the F1_LOG_LEVEL and F1_LOG_FORMAT options, as they only relate to the built-in
-// logger.
-//
-// The logger will be used for non-interactive output, file logs or when `--verbose` is specified.
-func (f *F1) WithLogger(logger *slog.Logger) *F1 {
-	f.options.output = ui.NewDefaultOutputWithLogger(logger)
-	return f
-}
-
-// WithStaticMetrics registers additional labels with fixed values to the f1 metrics
-func (f *F1) WithStaticMetrics(labels map[string]string) *F1 {
-	f.options.staticMetrics = labels
+	for _, opt := range opts {
+		opt(f)
+	}
 	return f
 }
 

pkg/f1/f1_stage_test.go

@@ -52,7 +52,7 @@ func (s *f1Stage) and() *f1Stage {
 
 func (s *f1Stage) a_custom_logger_is_configured_with_attr(key, value string) *f1Stage {
 	logger := log.NewTestLogger(&s.logOutput).With(key, value)
-	s.f1 = f1.New().WithLogger(logger)
+	s.f1 = f1.New(f1.WithLogger(logger))
 
 	return s
 }

pkg/f1/scenarios/scenario_builder.go

@@ -30,13 +30,13 @@ type ScenarioParameter struct {
 
 type ScenarioOption func(info *Scenario)
 
-func Description(d string) ScenarioOption {
+func WithDescription(d string) ScenarioOption {
 	return func(i *Scenario) {
 		i.Description = d
 	}
 }
 
-func Parameter(parameter ScenarioParameter) ScenarioOption {
+func WithParameter(parameter ScenarioParameter) ScenarioOption {
 	return func(i *Scenario) {
 		i.Parameters = append(i.Parameters, parameter)
 	}