func systemCommandAction()

in cmd/benchmark.go [540:654]
93 lines of code
20 McCabe index (conditional complexity)

func systemCommandAction(cmd *cobra.Command, args []string) error {
	cmd.Println("Run system benchmarks for the package")

	variant, err := cmd.Flags().GetString(cobraext.VariantFlagName)
	if err != nil {
		return cobraext.FlagParsingError(err, cobraext.VariantFlagName)
	}

	benchPath, err := cmd.Flags().GetString(cobraext.BenchPathFlagName)
	if err != nil {
		return cobraext.FlagParsingError(err, cobraext.BenchPathFlagName)
	}

	benchName, err := cmd.Flags().GetString(cobraext.BenchNameFlagName)
	if err != nil {
		return cobraext.FlagParsingError(err, cobraext.BenchNameFlagName)
	}

	deferCleanup, err := cmd.Flags().GetDuration(cobraext.DeferCleanupFlagName)
	if err != nil {
		return cobraext.FlagParsingError(err, cobraext.DeferCleanupFlagName)
	}

	metricsInterval, err := cmd.Flags().GetDuration(cobraext.BenchMetricsIntervalFlagName)
	if err != nil {
		return cobraext.FlagParsingError(err, cobraext.BenchMetricsIntervalFlagName)
	}

	dataReindex, err := cmd.Flags().GetBool(cobraext.BenchReindexToMetricstoreFlagName)
	if err != nil {
		return cobraext.FlagParsingError(err, cobraext.BenchReindexToMetricstoreFlagName)
	}

	packageRootPath, found, err := packages.FindPackageRoot()
	if !found {
		return errors.New("package root not found")
	}
	if err != nil {
		return fmt.Errorf("locating package root failed: %w", err)
	}

	profile, err := cobraext.GetProfileFlag(cmd)
	if err != nil {
		return err
	}

	ctx, stop := signal.Enable(cmd.Context(), logger.Info)
	defer stop()

	esClient, err := stack.NewElasticsearchClientFromProfile(profile)
	if err != nil {
		return fmt.Errorf("can't create Elasticsearch client: %w", err)
	}
	err = esClient.CheckHealth(ctx)
	if err != nil {
		return err
	}

	kc, err := stack.NewKibanaClientFromProfile(profile)
	if err != nil {
		return fmt.Errorf("can't create Kibana client: %w", err)
	}

	withOpts := []system.OptionFunc{
		system.WithVariant(variant),
		system.WithBenchmarkPath(benchPath),
		system.WithBenchmarkName(benchName),
		system.WithDeferCleanup(deferCleanup),
		system.WithMetricsInterval(metricsInterval),
		system.WithDataReindexing(dataReindex),
		system.WithPackageRootPath(packageRootPath),
		system.WithESAPI(esClient.API),
		system.WithKibanaClient(kc),
		system.WithProfile(profile),
	}

	esMetricsClient, err := initializeESMetricsClient(ctx)
	if err != nil {
		return fmt.Errorf("can't create Elasticsearch metrics client: %w", err)
	}
	if esMetricsClient != nil {
		withOpts = append(withOpts, system.WithESMetricsAPI(esMetricsClient.API))
	}

	runner := system.NewSystemBenchmark(system.NewOptions(withOpts...))

	r, err := benchrunner.Run(ctx, runner)
	if err != nil {
		return fmt.Errorf("error running package system benchmarks: %w", err)
	}

	multiReport, ok := r.(reporters.MultiReportable)
	if !ok {
		return fmt.Errorf("system benchmark is expected to return multiple reports")
	}

	reports := multiReport.Split()
	if len(reports) != 2 {
		return fmt.Errorf("system benchmark is expected to return a human an a file report")
	}

	// human report will always be the first
	human := reports[0]
	if err := reporters.WriteReportable(reporters.Output(outputs.ReportOutputSTDOUT), human); err != nil {
		return fmt.Errorf("error writing benchmark report: %w", err)
	}

	// file report will always be the second
	file := reports[1]
	if err := reporters.WriteReportable(reporters.Output(outputs.ReportOutputFile), file); err != nil {
		return fmt.Errorf("error writing benchmark report: %w", err)
	}

	return nil
}