func reportHumanFormat()

in internal/benchrunner/runners/rally/report.go [93:206]
102 lines of code
11 McCabe index (conditional complexity)

func reportHumanFormat(r *report) []byte {
	var report strings.Builder
	report.WriteString(renderBenchmarkTable(
		"info",
		"benchmark", r.Info.Benchmark,
		"description", r.Info.Description,
		"run ID", r.Info.RunID,
		"package", r.Info.Package,
		"start ts (s)", r.Info.StartTs,
		"end ts (s)", r.Info.EndTs,
		"duration", r.Info.Duration,
		"generated corpora file", r.Info.GeneratedCorporaFile,
	) + "\n")

	pkvs := []interface{}{
		"package version", r.Parameters.PackageVersion,
	}

	pkvs = append(pkvs, "data_stream.name", r.Parameters.DataStream.Name)

	if r.Parameters.Corpora.Generator != nil {
		pkvs = append(pkvs,
			"corpora.generator.total_events", r.Parameters.Corpora.Generator.TotalEvents,
			"corpora.generator.template.path", r.Parameters.Corpora.Generator.Template.Path,
			"corpora.generator.template.raw", r.Parameters.Corpora.Generator.Template.Raw,
			"corpora.generator.template.type", r.Parameters.Corpora.Generator.Template.Type,
			"corpora.generator.config.path", r.Parameters.Corpora.Generator.Config.Path,
			"corpora.generator.config.raw", r.Parameters.Corpora.Generator.Config.Raw,
			"corpora.generator.fields.path", r.Parameters.Corpora.Generator.Fields.Path,
			"corpora.generator.fields.raw", r.Parameters.Corpora.Generator.Fields.Raw,
		)
	}

	report.WriteString(renderBenchmarkTable("parameters", pkvs...) + "\n")

	report.WriteString(renderBenchmarkTable(
		"cluster info",
		"name", r.ClusterName,
		"nodes", r.Nodes,
	) + "\n")

	if r.DataStreamStats != nil {
		report.WriteString(renderBenchmarkTable(
			"data stream stats",
			"data stream", r.DataStreamStats.DataStream,
			"approx total docs ingested", r.TotalHits,
			"backing indices", r.DataStreamStats.BackingIndices,
			"store size bytes", r.DataStreamStats.StoreSizeBytes,
			"maximum ts (ms)", r.DataStreamStats.MaximumTimestamp,
		) + "\n")
	}

	for index, du := range r.DiskUsage {
		adu := du.AllFields
		report.WriteString(renderBenchmarkTable(
			fmt.Sprintf("disk usage for index %s (for all fields)", index),
			"total", humanize.Bytes(adu.TotalInBytes),
			"inverted_index.total", humanize.Bytes(adu.InvertedIndex.TotalInBytes),
			"inverted_index.stored_fields", humanize.Bytes(adu.StoredFieldsInBytes),
			"inverted_index.doc_values", humanize.Bytes(adu.DocValuesInBytes),
			"inverted_index.points", humanize.Bytes(adu.PointsInBytes),
			"inverted_index.norms", humanize.Bytes(adu.NormsInBytes),
			"inverted_index.term_vectors", humanize.Bytes(adu.TermVectorsInBytes),
			"inverted_index.knn_vectors", humanize.Bytes(adu.KnnVectorsInBytes),
		) + "\n")
	}

	for node, pStats := range r.IngestPipelineStats {
		for pipeline, stats := range pStats {
			if stats.Count == 0 {
				continue
			}
			kvs := []interface{}{
				"Totals",
				fmt.Sprintf(
					"Count: %d | Failed: %d | Time: %s",
					stats.Count,
					stats.Failed,
					time.Duration(stats.TimeInMillis)*time.Millisecond,
				),
			}
			for _, procStats := range stats.Processors {
				str := fmt.Sprintf(
					"Count: %d | Failed: %d | Time: %s",
					procStats.Stats.Count,
					procStats.Stats.Failed,
					time.Duration(procStats.Stats.TimeInMillis)*time.Millisecond,
				)
				kvs = append(kvs, fmt.Sprintf("%s (%s)", procStats.Type, procStats.Extra), str)
			}
			report.WriteString(renderBenchmarkTable(
				fmt.Sprintf("pipeline %s stats in node %s", pipeline, node),
				kvs...,
			) + "\n")
		}
	}

	rsvs := make([]interface{}, 0, len(r.RallyStats))
	for _, rs := range r.RallyStats {
		if rs.Metric == "Metric" { // let's skip the header
			continue
		}

		value := rs.Value
		if len(rs.Unit) > 0 {
			value = fmt.Sprintf("%v %s", rs.Value, rs.Unit)
		}
		rsvs = append(rsvs, rs.Metric, value)
	}

	report.WriteString(renderBenchmarkTable("rally stats", rsvs...) + "\n")

	return []byte(report.String())
}