add type, start/end time to segments, constructor for BasicData, get test start/end time from segments

Author: Tofel

lib/client/loki.go

@@ -171,15 +171,23 @@ func (lc *LokiClient) extractRawLogEntries(lokiResp LokiResponse) []LokiLogEntry
 
 	for _, result := range lokiResp.Data.Result {
 		for _, entry := range result.Values {
+			if len(entry) != 2 {
+				lc.Logger.Error().Interface("Log entry", entry).Msgf("Error parsing log entry. Expected 2 elements, got %d", len(entry))
+				continue
+			}
 			var timestamp string
+			if entry[0] == nil {
+				lc.Logger.Error().Msg("Error parsing timestamp. Entry at index 0, that should be a timestamp, is nil")
+				continue
+			}
 			if timestampString, ok := entry[0].(string); ok {
 				timestamp = timestampString
 			} else if timestampInt, ok := entry[0].(int); ok {
 				timestamp = fmt.Sprintf("%d", timestampInt)
 			} else if timestampFloat, ok := entry[0].(float64); ok {
 				timestamp = fmt.Sprintf("%f", timestampFloat)
 			} else {
-				lc.Logger.Error().Msg("Error parsing timestamp")
+				lc.Logger.Error().Msgf("Error parsing timestamp. Expected string, int, or float64, got %T", entry[0])
 				continue
 			}
 			logLine := entry[1].(string)

wasp/benchspy/basic.go

@@ -22,6 +22,64 @@ type BasicData struct {
 	GeneratorConfigs map[string]*wasp.Config `json:"generator_configs"`
 }
 
+func MustNewBasicData(commitOrTag string, generators ...*wasp.Generator) BasicData {
+	b, err := NewBasicData(commitOrTag, generators...)
+	if err != nil {
+		panic(err)
+	}
+
+	return *b
+}
+
+func NewBasicData(commitOrTag string, generators ...*wasp.Generator) (*BasicData, error) {
+	if len(generators) == 0 {
+		return nil, errors.New("at least one generator is required")
+	}
+
+	if generators[0].Cfg.T == nil {
+		return nil, errors.New("generators are not associated with a testing.T instance. Please set it as generator.Cfg.T and try again")
+	}
+
+	b := &BasicData{
+		TestName:         generators[0].Cfg.T.Name(),
+		CommitOrTag:      commitOrTag,
+		GeneratorConfigs: make(map[string]*wasp.Config),
+	}
+
+	for _, g := range generators {
+		b.GeneratorConfigs[g.Cfg.GenName] = g.Cfg
+	}
+
+	return b, nil
+}
+
+func (b *BasicData) FillStartEndTimes() error {
+	earliestTime := time.Now()
+	var latestTime time.Time
+
+	for _, cfg := range b.GeneratorConfigs {
+		for _, segment := range cfg.Schedule {
+			if segment.StartTime.IsZero() {
+				return fmt.Errorf("start time is missing in one of the segments belonging to generator %s. Did that generator run?", cfg.GenName)
+			}
+			if segment.StartTime.Before(earliestTime) {
+				earliestTime = segment.StartTime
+			}
+			if segment.EndTime.IsZero() {
+				return fmt.Errorf("end time is missing in one of the segments belonging to generator %s. Did that generator finish running?", cfg.GenName)
+			}
+			if segment.EndTime.After(latestTime) {
+				latestTime = segment.EndTime
+			}
+		}
+	}
+
+	b.TestStart = earliestTime
+	b.TestEnd = latestTime
+
+	return nil
+}
+
 func (b *BasicData) Validate() error {
 	if b.TestStart.IsZero() {
 		return errors.New("test start time is missing. We cannot query Loki without a time range. Please set it and try again")
@@ -59,8 +117,6 @@ func (b *BasicData) IsComparable(otherData BasicData) error {
 		}
 	}
 
-	// TODO: would be good to be able to check if Gun and VU are the same, but idk yet how we could do that easily [hash the code?]
-
 	return nil
 }
 
@@ -73,6 +129,10 @@ func compareGeneratorConfigs(cfg1, cfg2 *wasp.Config) error {
 		return fmt.Errorf("schedules are different. Expected %d, got %d", len(cfg1.Schedule), len(cfg2.Schedule))
 	}
 
+	var areSegmentsEqual = func(segment1, segment2 *wasp.Segment) bool {
+		return segment1.From == segment2.From && segment1.Duration == segment2.Duration && segment1.Type == segment2.Type
+	}
+
 	for i, segment1 := range cfg1.Schedule {
 		segment2 := cfg2.Schedule[i]
 		if segment1 == nil {
@@ -81,7 +141,7 @@ func compareGeneratorConfigs(cfg1, cfg2 *wasp.Config) error {
 		if segment2 == nil {
 			return fmt.Errorf("schedule at index %d is nil in the other report", i)
 		}
-		if *segment1 != *segment2 {
+		if !areSegmentsEqual(segment1, segment2) {
 			return fmt.Errorf("schedules at index %d are different. Expected %s, got %s", i, mustMarshallSegment(segment1), mustMarshallSegment(segment2))
 		}
 	}

wasp/benchspy/report.go

@@ -25,6 +25,11 @@ func (b *StandardReport) Load() error {
 }
 
 func (b *StandardReport) FetchData(ctx context.Context) error {
+	startEndErr := b.BasicData.FillStartEndTimes()
+	if startEndErr != nil {
+		return startEndErr
+	}
+
 	basicErr := b.BasicData.Validate()
 	if basicErr != nil {
 		return basicErr

wasp/benchspy_test.go

@@ -141,14 +141,7 @@ func TestBenchSpyWithTwoLokiQueries(t *testing.T) {
 	require.NoError(t, err)
 
 	currentReport := benchspy.StandardReport{
-		BasicData: benchspy.BasicData{
-			GeneratorConfigs: map[string]*wasp.Config{
-				gen.Cfg.GenName: gen.Cfg,
-			},
-			TestName:    t.Name(),
-			TestStart:   time.Now(),
-			CommitOrTag: "e7fc5826a572c09f8b93df3b9f674113372ce924",
-		},
+		BasicData: benchspy.MustNewBasicData("e7fc5826a572c09f8b93df3b9f674113372ce924", gen),
 		ResourceReporter: benchspy.ResourceReporter{
 			ExecutionEnvironment: benchspy.ExecutionEnvironment_Docker,
 		},
@@ -164,7 +157,6 @@ func TestBenchSpyWithTwoLokiQueries(t *testing.T) {
 	currentReport.QueryExecutors = append(currentReport.QueryExecutors, lokiQueryExecutor)
 
 	gen.Run(true)
-	currentReport.TestEnd = time.Now()
 
 	fetchCtx, cancelFn := context.WithTimeout(context.Background(), 60*time.Second)
 	defer cancelFn()

wasp/schedule.go

@@ -17,6 +17,7 @@ func Plain(from int64, duration time.Duration) []*Segment {
 		{
 			From:     from,
 			Duration: duration,
+			Type:     SegmentType_Plain,
 		},
 	}
 }
@@ -30,6 +31,7 @@ func Steps(from, increase int64, steps int, duration time.Duration) []*Segment {
 		segments = append(segments, &Segment{
 			From:     newFrom,
 			Duration: perStepDuration,
+			Type:     SegmentType_Steps,
 		})
 	}
 	return segments