modified response structs, removed percentileLatencies test cases

Author: mchinta7

api/types/metric.go

@@ -4,19 +4,25 @@ import "time"
 
 // ResponseStats is the report about benchmark result.
 type ResponseStats struct {
+	// List of failures
+	FailureList []error
+	// All the observed latencies
+	Latencies []float64
+	// total bytes read from apiserver
+	TotalReceivedBytes int64
+}
+
+type RunnerMetricReport struct {
 	// Total represents total number of requests.
 	Total int
 	// List of failures
 	FailureList []error
 	// Duration means the time of benchmark.
 	Duration time.Duration
-	// PercentileLatencies represents the latency distribution in seconds.
-	//
-	// NOTE: The key represents quantile.
-	PercentileLatencies map[float64]float64
+	// All the observed latencies
+	Latencies []float64
 	// total bytes read from apiserver
 	TotalReceivedBytes int64
-	// TODO:
-	// 1. Support failures partitioned by http code and verb
-	// 2. Support to dump all latency data
+	// PercentileLatencies represents the latency distribution in seconds.
+	PercentileLatencies [][2]float64 // [2]float64{percentile, value}
 }

cmd/kperf/commands/runner/runner.go

@@ -2,12 +2,9 @@ package runner
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"os"
 	"path/filepath"
-	"sort"
-	"strconv"
 
 	"github.com/Azure/kperf/api/types"
 	"github.com/Azure/kperf/request"
@@ -86,7 +83,7 @@ var runCommand = cli.Command{
 		kubeCfgPath := cliCtx.String("kubeconfig")
 		userAgent := cliCtx.String("user-agent")
 		outputFilePath := cliCtx.String("result")
-		rawData := cliCtx.Bool("raw-data")
+		//rawData := cliCtx.Bool("raw-data")
 
 		conns := profileCfg.Spec.Conns
 		rate := profileCfg.Spec.Rate
@@ -118,7 +115,9 @@ var runCommand = cli.Command{
 			}
 			defer f.Close()
 		}
-		printResponseStats(f, stats, rawData)
+
+		//TODO: add printResponseStats for .json format
+		printResponseStats(f, stats)
 		return nil
 	},
 }
@@ -158,76 +157,7 @@ func loadConfig(cliCtx *cli.Context) (*types.LoadProfile, error) {
 	return &profileCfg, nil
 }
 
-func printResponseStats(f *os.File, stats *types.ResponseStats, rawData bool) {
-	percentileLatencies := make(map[string]string)
-	for i, v := range stats.PercentileLatencies {
-		iCopy := strconv.FormatFloat(i, 'f', 2, 64)
-		percentileLatencies[iCopy] = strconv.FormatFloat(v, 'f', 3, 64)
-	}
-
-	if rawData {
-		total, err := json.MarshalIndent(stats.Total, "", " ")
-		if err != nil {
-			fmt.Println(err)
-			return
-		}
-		fList, err := json.MarshalIndent(stats.FailureList, "", " ")
-		if err != nil {
-			fmt.Println(err)
-			return
-		}
-		bytes, err := json.MarshalIndent(stats.TotalReceivedBytes, "", " ")
-		if err != nil {
-			fmt.Println(err)
-			return
-		}
-		duration, err := json.MarshalIndent(stats.Duration, "", " ")
-		if err != nil {
-			fmt.Println(err)
-			return
-		}
-		pLatencies, err := json.MarshalIndent(percentileLatencies, "", " ")
-		if err != nil {
-			fmt.Println(err)
-			return
-		}
-		fmt.Fprint(f, "{\n")
-		fmt.Fprintf(f, " \"Total\": %s,\n", string(total))
-		fmt.Fprintf(f, " \"Failure List\": %s,\n", string(fList))
-		fmt.Fprintf(f, " \"Total Received Bytes\":%s,\n", string(bytes))
-		fmt.Fprintf(f, " \"Duration\":%s,\n", string(duration))
-		fmt.Fprintf(f, " \"Percentile Latencies\":%s,\n", pLatencies)
-		fmt.Fprint(f, "}")
-
-	} else {
-		fmt.Fprint(f, "Response Stat: \n")
-		fmt.Fprintf(f, "  Total: %v\n", stats.Total)
-
-		fmt.Fprintf(f, "  Total Failures: %d\n", len(stats.FailureList))
-
-		for _, v := range stats.FailureList {
-			fmt.Fprintf(f, "	%v\n", v)
-		}
-
-		fmt.Fprintf(f, "  Observed Bytes: %v\n", stats.TotalReceivedBytes)
-
-		fmt.Fprintf(f, "  Duration: %v\n", stats.Duration.String())
-
-		requestsPerSec := float64(stats.Total) / stats.Duration.Seconds()
-
-		fmt.Fprintf(f, "  Requests/sec: %.2f\n", requestsPerSec)
-
-		fmt.Fprint(f, "  Latency Distribution:\n")
-		keys := make([]float64, 0, len(stats.PercentileLatencies))
-		for q := range stats.PercentileLatencies {
-			keys = append(keys, q)
-		}
-
-		sort.Float64s(keys)
-
-		for _, q := range keys {
-			fmt.Fprintf(f, "    [%.2f] %.3fs\n", q/100.0, stats.PercentileLatencies[q])
-		}
-	}
+// TODO: Complete this function
+func printResponseStats(f *os.File, stats *request.Result) {
 
 }

metrics/request.go

@@ -6,6 +6,8 @@ import (
 	"sort"
 	"sync"
 	"sync/atomic"
+
+	"github.com/Azure/kperf/api/types"
 )
 
 // ResponseMetric is a measurement related to http response.
@@ -17,7 +19,7 @@ type ResponseMetric interface {
 	// ObserveReceivedBytes observes the bytes read from apiserver.
 	ObserveReceivedBytes(bytes int64)
 	// Gather returns the summary.
-	Gather() (latencies []float64, percentileLatencies map[float64]float64, failureList []error, bytes int64)
+	Gather() types.ResponseStats
 }
 
 type responseMetricImpl struct {
@@ -55,9 +57,14 @@ func (m *responseMetricImpl) ObserveReceivedBytes(bytes int64) {
 }
 
 // Gather implements ResponseMetric.
-func (m *responseMetricImpl) Gather() ([]float64, map[float64]float64, []error, int64) {
+func (m *responseMetricImpl) Gather() types.ResponseStats {
 	latencies := m.dumpLatencies()
-	return latencies, buildPercentileLatencies(latencies), m.failureList, atomic.LoadInt64(&m.receivedBytes)
+	return types.ResponseStats{
+		FailureList:        m.failureList,
+		Latencies:          latencies,
+		TotalReceivedBytes: atomic.LoadInt64(&m.receivedBytes),
+	}
+	//return latencies, buildPercentileLatencies(latencies), m.failureList, atomic.LoadInt64(&m.receivedBytes)
 }
 
 func (m *responseMetricImpl) dumpLatencies() []float64 {

metrics/request_test.go

@@ -16,8 +16,17 @@ import (
 
 const defaultTimeout = 60 * time.Second
 
+// Result contains responseStats vlaues from Gather() and adds Duration and Total values separately
+type Result struct {
+	types.ResponseStats
+	// Duration means the time of benchmark.
+	Duration time.Duration
+	// Total means the total number of requests.
+	Total int
+}
+
 // Schedule files requests to apiserver based on LoadProfileSpec.
-func Schedule(ctx context.Context, spec *types.LoadProfileSpec, restCli []rest.Interface) (*types.ResponseStats, error) {
+func Schedule(ctx context.Context, spec *types.LoadProfileSpec, restCli []rest.Interface) (*Result, error) {
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 
@@ -81,12 +90,10 @@ func Schedule(ctx context.Context, spec *types.LoadProfileSpec, restCli []rest.I
 	wg.Wait()
 
 	totalDuration := time.Since(start)
-	_, percentileLatencies, failureList, bytes := respMetric.Gather()
-	return &types.ResponseStats{
-		Total:               spec.Total,
-		FailureList:         failureList,
-		Duration:            totalDuration,
-		TotalReceivedBytes:  bytes,
-		PercentileLatencies: percentileLatencies,
+	responseStats := respMetric.Gather()
+	return &Result{
+		ResponseStats: responseStats,
+		Duration:      totalDuration,
+		Total:         spec.Total,
 	}, nil
 }