move interval merge inside MergeContinuousProfileCandidate

internal/flamegraph/flamegraph.go

@@ -94,7 +94,7 @@ func GetFlamegraphFromProfiles(
 					// the profile.timestamps to be consistent with the sample/node
 					// 'start' and 'end'
 					relativeIntervalsFromAbsoluteTimestamp(&spans, uint64(p.Timestamp().UnixNano()))
-					sortedSpans := mergeIntervals(&spans)
+					sortedSpans := utils.MergeIntervals(&spans)
 					for tid, callTree := range callTrees {
 						callTrees[tid] = sliceCallTree(&callTree, &sortedSpans)
 					}
@@ -572,8 +572,7 @@ func GetFlamegraphFromCandidates(
 
 			for tid, callTree := range result.CallTrees {
 				if intervals, ok := result.Intervals[tid]; ok {
-					sortedAndMergedIntervals := mergeIntervals(&intervals)
-					for _, interval := range sortedAndMergedIntervals {
+					for _, interval := range intervals {
 						intervalExample := utils.NewExampleFromProfilerChunk(
 							result.Chunk.ProjectID,
 							result.Chunk.ProfilerID,

internal/flamegraph/span_util.go

@@ -2,36 +2,12 @@ package flamegraph
 
 import (
 	"math"
-	"sort"
 	"time"
 
 	"github.com/getsentry/vroom/internal/nodetree"
 	"github.com/getsentry/vroom/internal/utils"
 )
 
-func mergeIntervals(intervals *[]utils.Interval) []utils.Interval {
-	if len(*intervals) == 0 {
-		return *intervals
-	}
-	sort.SliceStable((*intervals), func(i, j int) bool {
-		if (*intervals)[i].Start == (*intervals)[j].Start {
-			return (*intervals)[i].End < (*intervals)[j].End
-		}
-		return (*intervals)[i].Start < (*intervals)[j].Start
-	})
-
-	newIntervals := []utils.Interval{(*intervals)[0]}
-	for _, interval := range (*intervals)[1:] {
-		if interval.Start <= newIntervals[len(newIntervals)-1].End {
-			newIntervals[len(newIntervals)-1].End = max(newIntervals[len(newIntervals)-1].End, interval.End)
-		} else {
-			newIntervals = append(newIntervals, interval)
-		}
-	}
-
-	return newIntervals
-}
-
 func relativeIntervalsFromAbsoluteTimestamp(intervals *[]utils.Interval, t uint64) {
 	for i, v := range *intervals {
 		// safety check: in case the start/end should be

internal/flamegraph/span_util_test.go

@@ -9,26 +9,6 @@ import (
 	"github.com/getsentry/vroom/internal/utils"
 )
 
-func TestMergeIntervals(t *testing.T) {
-	inputIntervals := []utils.Interval{
-		{Start: 8, End: 11},
-		{Start: 3, End: 6},
-		{Start: 7, End: 12},
-		{Start: 1, End: 3},
-	}
-
-	expectedResult := []utils.Interval{
-		{Start: 1, End: 6},
-		{Start: 7, End: 12},
-	}
-
-	result := mergeIntervals(&inputIntervals)
-
-	if diff := testutil.Diff(result, expectedResult); diff != "" {
-		t.Fatalf("Result mismatch: got - want +\n%s", diff)
-	}
-}
-
 func TestGetTotalOvelappingDuration(t *testing.T) {
 	tests := []struct {
 		name      string
@@ -91,7 +71,7 @@ func TestGetTotalOvelappingDuration(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			intervals := mergeIntervals(&test.intervals)
+			intervals := utils.MergeIntervals(&test.intervals)
 			result := getTotalOverlappingDuration(&test.node, &intervals)
 
 			if diff := testutil.Diff(result, test.output); diff != "" {
@@ -302,7 +282,7 @@ func TestSliceCallTree(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			intervals := mergeIntervals(&test.intervals)
+			intervals := utils.MergeIntervals(&test.intervals)
 			result := sliceCallTree(&test.callTree, &intervals)
 			if diff := testutil.Diff(result, test.output); diff != "" {
 				t.Fatalf("Result mismatch: got - want +\n%s", diff)

internal/utils/struct_test.go

@@ -57,8 +57,7 @@ func TestMergeContinuousProfileCandidate(t *testing.T) {
 					ChunkID:    "1111",
 					Intervals: map[string][]Interval{
 						t1: {
-							{Start: 100, End: 200},
-							{Start: 200, End: 400},
+							{Start: 100, End: 400},
 						},
 						t2: {
 							{Start: 100, End: 300},
@@ -75,13 +74,65 @@ func TestMergeContinuousProfileCandidate(t *testing.T) {
 				},
 			}, // end want
 		},
+		{
+			name: "Merge candidates with overlapping time-range",
+			candidates: []ContinuousProfileCandidate{
+				{
+					ProjectID:  1,
+					ProfilerID: "1111",
+					ChunkID:    "1111",
+					ThreadID:   &t1,
+					Start:      100,
+					End:        200,
+				},
+				{
+					ProjectID:  1,
+					ProfilerID: "1111",
+					ChunkID:    "1111",
+					ThreadID:   &t1,
+					Start:      190,
+					End:        300,
+				},
+			}, // end candidates
+			want: []ContinuousProfileCandidate{
+				{
+					ProjectID:  1,
+					ProfilerID: "1111",
+					ChunkID:    "1111",
+					Intervals: map[string][]Interval{
+						t1: {
+							{Start: 100, End: 300},
+						},
+					},
+				},
+			}, // end want
+		},
 	} // end tests
 
 	for _, test := range tests {
 		newCandidates := MergeContinuousProfileCandidate(test.candidates)
-		t.Logf("%+v\n", newCandidates)
 		if diff := testutil.Diff(newCandidates, test.want); diff != "" {
 			t.Fatalf("Result mismatch: got - want +\n%s", diff)
 		}
 	}
 }
+
+func TestMergeIntervals(t *testing.T) {
+	inputIntervals := []Interval{
+		{Start: 8, End: 11},
+		{Start: 3, End: 6},
+		{Start: 7, End: 12},
+		{Start: 1, End: 3},
+	}
+
+	expectedResult := []Interval{
+		{Start: 1, End: 6},
+		{Start: 7, End: 12},
+	}
+
+	result := MergeIntervals(&inputIntervals)
+
+	if diff := testutil.Diff(result, expectedResult); diff != "" {
+		t.Fatalf("Result mismatch: got - want +\n%s", diff)
+	}
+}

internal/utils/structs.go

@@ -1,5 +1,9 @@
 package utils
 
+import (
+	"sort"
+)
+
 type (
 	Interval struct {
 		Start          uint64  `json:"start,string"`
@@ -128,5 +132,36 @@ func MergeContinuousProfileCandidate(candidates []ContinuousProfileCandidate) []
 			newCandidates = append(newCandidates, candidate)
 		}
 	} // end loop candidates
+	for i, candidate := range newCandidates {
+		if len(candidate.Intervals) > 0 {
+			for tid, intervals := range candidate.Intervals {
+				sortedMergedIntervals := MergeIntervals(&intervals)
+				newCandidates[i].Intervals[tid] = sortedMergedIntervals
+			}
+		}
+	}
 	return newCandidates
 }
+
+func MergeIntervals(intervals *[]Interval) []Interval {
+	if len(*intervals) == 0 {
+		return *intervals
+	}
+	sort.SliceStable((*intervals), func(i, j int) bool {
+		if (*intervals)[i].Start == (*intervals)[j].Start {
+			return (*intervals)[i].End < (*intervals)[j].End
+		}
+		return (*intervals)[i].Start < (*intervals)[j].Start
+	})
+
+	newIntervals := []Interval{(*intervals)[0]}
+	for _, interval := range (*intervals)[1:] {
+		if interval.Start <= newIntervals[len(newIntervals)-1].End {
+			newIntervals[len(newIntervals)-1].End = max(newIntervals[len(newIntervals)-1].End, interval.End)
+		} else {
+			newIntervals = append(newIntervals, interval)
+		}
+	}
+
+	return newIntervals
+}