database_observability: move time-related functions to a separate file (#3923)

database_observability: move time-related functions to a separate file

Move stuff related to time, uptime and overflows to a separate file
to make it easier to test and reuse.

Author: cristiangreco

internal/component/database_observability/mysql/collector/query_sample.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"database/sql"
 	"fmt"
-	"math"
 	"time"
 
 	"github.com/go-kit/log"
@@ -293,7 +292,7 @@ func (c *QuerySample) fetchQuerySamples(ctx context.Context) error {
 		}
 
 		serverStartTime := now - uptime
-		row.TimestampMilliseconds = c.calculateWallTime(serverStartTime, row.TimerEndPicoseconds.Float64)
+		row.TimestampMilliseconds = calculateWallTime(serverStartTime, row.TimerEndPicoseconds.Float64, uptime)
 
 		digestText, err := c.sqlParser.CleanTruncatedText(row.DigestText.String)
 		if err != nil {
@@ -382,26 +381,6 @@ func (c *QuerySample) fetchQuerySamples(ctx context.Context) error {
 	return nil
 }
 
-func (c *QuerySample) calculateWallTime(serverStartTime, timer float64) float64 {
-	// timer indicates event timing since server startup.
-	// The timer value is in picoseconds with a column type of bigint unsigned. This value can overflow after about ~213 days.
-	// We need to account for this overflow when calculating the timestamp.
-
-	// Knowing the number of overflows that occurred, we can calculate how much overflow time to compensate.
-	previousOverflows := calculateNumberOfOverflows(c.lastUptime)
-	overflowTime := float64(previousOverflows) * picosecondsOverflowInSeconds
-	// We then add this overflow compensation to the server start time, and also add the timer value (remember this is counted from server start).
-	// The resulting value is the timestamp in seconds at which an event happened.
-	timerSeconds := picosecondsToSeconds(timer)
-	timestampSeconds := serverStartTime + overflowTime + timerSeconds
-
-	return secondsToMilliseconds(timestampSeconds)
-}
-
-func calculateNumberOfOverflows(uptime float64) int {
-	return int(math.Floor(uptime / picosecondsOverflowInSeconds))
-}
-
 func (c *QuerySample) determineTimerClauseAndLimit(uptime float64) (string, float64) {
 	timerClause := endOfTimeline
 	currentOverflows := calculateNumberOfOverflows(uptime)
@@ -419,39 +398,3 @@ func (c *QuerySample) determineTimerClauseAndLimit(uptime float64) (string, floa
 
 	return timerClause, limit
 }
-
-// uptimeSinceOverflow calculates the uptime "modulo" overflows (if any): it returns the remainder of the uptime value with any
-// overflowed time removed
-func uptimeSinceOverflow(uptime float64) float64 {
-	overflowAdjustment := float64(calculateNumberOfOverflows(uptime)) * picosecondsOverflowInSeconds
-	return secondsToPicoseconds(uptime - overflowAdjustment)
-}
-
-var picosecondsOverflowInSeconds = picosecondsToSeconds(float64(math.MaxUint64))
-
-const (
-	picosecondsPerSecond      float64 = 1e12
-	millisecondsPerSecond     float64 = 1e3
-	millisecondsPerPicosecond float64 = 1e9
-	nanosecondsPerMillisecond float64 = 1e6
-)
-
-func picosecondsToSeconds(picoseconds float64) float64 {
-	return picoseconds / picosecondsPerSecond
-}
-
-func picosecondsToMilliseconds(picoseconds float64) float64 {
-	return picoseconds / millisecondsPerPicosecond
-}
-
-func millisecondsToNanoseconds(milliseconds float64) float64 {
-	return milliseconds * nanosecondsPerMillisecond
-}
-
-func secondsToPicoseconds(seconds float64) float64 {
-	return seconds * picosecondsPerSecond
-}
-
-func secondsToMilliseconds(seconds float64) float64 {
-	return seconds * millisecondsPerSecond
-}

internal/component/database_observability/mysql/collector/query_sample_test.go

@@ -2152,54 +2152,6 @@ func TestQuerySample_handles_timer_overflows(t *testing.T) {
 	})
 }
 
-func TestQuerySample_calculateWallTime(t *testing.T) {
-	t.Run("calculates the timestamp at which an event happened", func(t *testing.T) {
-		c := &QuerySample{}
-		serverStartTime := float64(2)
-		timer := 2e12 // Timer indicates event timing, counted since server startup. 2 seconds in picoseconds
-
-		result := c.calculateWallTime(serverStartTime, timer)
-		assert.Equalf(t, float64(4000), result, "got %f, want 4000", result)
-	})
-
-	t.Run("calculates the timestamp, taking into account the overflows", func(t *testing.T) {
-		c := &QuerySample{lastUptime: picosecondsToSeconds(math.MaxUint64) + 1}
-		serverStartTime := float64(3)
-		timer := 2e12 // 2 seconds in picoseconds
-
-		result := c.calculateWallTime(serverStartTime, timer)
-
-		assert.Equalf(t, 18446749073.709553, result, "got %f, want 18446749073.709553", result)
-	})
-
-	t.Run("calculates another timestamp when timer approaches overflow", func(t *testing.T) {
-		c := &QuerySample{lastUptime: picosecondsToSeconds(math.MaxUint64) + 1}
-		serverStartTime := float64(3)
-		timer := float64(math.MaxUint64 - 5)
-
-		result := c.calculateWallTime(serverStartTime, timer)
-
-		assert.Equalf(t, 3.6893491147419106e+10, result, "got %f, want 3.6893491147419106e+10", result)
-	})
-}
-
-func TestQuerySample_calculateNumberOfOverflows(t *testing.T) {
-	testCases := map[string]struct {
-		expected uint64
-		uptime   float64
-	}{
-		"0 overflows": {0, 5},
-		"1 overflow":  {1, picosecondsToSeconds(math.MaxUint64) + 5},
-		"2 overflows": {2, picosecondsToSeconds(math.MaxUint64)*2 + 5},
-	}
-
-	for name, tc := range testCases {
-		t.Run(name, func(t *testing.T) {
-			assert.EqualValues(t, tc.expected, calculateNumberOfOverflows(tc.uptime))
-		})
-	}
-}
-
 func TestQuerySample_calculateTimerClauseAndLimit(t *testing.T) {
 	tests := map[string]struct {
 		lastUptime          float64

internal/component/database_observability/mysql/collector/time.go

@@ -0,0 +1,62 @@
+package collector
+
+import "math"
+
+var picosecondsOverflowInSeconds = picosecondsToSeconds(float64(math.MaxUint64))
+
+const (
+	picosecondsPerSecond      float64 = 1e12
+	millisecondsPerSecond     float64 = 1e3
+	millisecondsPerPicosecond float64 = 1e9
+	nanosecondsPerMillisecond float64 = 1e6
+)
+
+// calculateWallTime calculates the wall-clock timestamp for an event.
+// The timerPicoseconds indicates event timing since server startup.
+// Since this value can overflow after approximately ~213 days (column type of bigint unsigned),
+// this function accounts for overflows by calculating the number of previous overflows and
+// compensating accordingly. Returns the timestamp in milliseconds when the event occurred.
+func calculateWallTime(serverStartTimeSeconds, timerPicoseconds, uptimeSeconds float64) float64 {
+	// Knowing the number of overflows that occurred, we can calculate how much overflow time to compensate
+	previousOverflows := calculateNumberOfOverflows(uptimeSeconds)
+	overflowTime := float64(previousOverflows) * picosecondsOverflowInSeconds
+
+	// We then add this overflow compensation to the server start time, and also add the timer value (remember this is counted from server start).
+	// The resulting value is the timestamp in seconds at which an event happened.
+	timerSeconds := picosecondsToSeconds(timerPicoseconds)
+	timestampSeconds := serverStartTimeSeconds + overflowTime + timerSeconds
+
+	return secondsToMilliseconds(timestampSeconds)
+}
+
+// calculateNumberOfOverflows calculates how many timer overflows have occurred based on the given uptime.
+func calculateNumberOfOverflows(uptimeSeconds float64) int {
+	return int(math.Floor(uptimeSeconds / picosecondsOverflowInSeconds))
+}
+
+// uptimeSinceOverflow calculates the uptime "modulo" overflows (if any): it returns the remainder
+// of the uptime value with any overflowed time removed, in picoseconds.
+func uptimeSinceOverflow(uptimeSeconds float64) float64 {
+	overflowAdjustment := float64(calculateNumberOfOverflows(uptimeSeconds)) * picosecondsOverflowInSeconds
+	return secondsToPicoseconds(uptimeSeconds - overflowAdjustment)
+}
+
+func picosecondsToMilliseconds(picoseconds float64) float64 {
+	return picoseconds / millisecondsPerPicosecond
+}
+
+func millisecondsToNanoseconds(milliseconds float64) float64 {
+	return milliseconds * nanosecondsPerMillisecond
+}
+
+func picosecondsToSeconds(picoseconds float64) float64 {
+	return picoseconds / picosecondsPerSecond
+}
+
+func secondsToPicoseconds(seconds float64) float64 {
+	return seconds * picosecondsPerSecond
+}
+
+func secondsToMilliseconds(seconds float64) float64 {
+	return seconds * millisecondsPerSecond
+}

internal/component/database_observability/mysql/collector/time_test.go

@@ -0,0 +1,54 @@
+package collector
+
+import (
+	"math"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func Test_CalculateWallTime(t *testing.T) {
+	t.Run("calculates the timestamp at which an event happened", func(t *testing.T) {
+		serverStartTime := 2.0
+		timer := secondsToPicoseconds(2)
+		lastUptime := 0.0
+
+		result := calculateWallTime(serverStartTime, timer, lastUptime)
+		require.Equalf(t, 4000.0, result, "got %f, want 4000", result)
+	})
+
+	t.Run("calculates the timestamp, taking into account the overflows", func(t *testing.T) {
+		serverStartTime := 3.0
+		timer := secondsToPicoseconds(2)
+		lastUptime := picosecondsToSeconds(math.MaxUint64) + 1
+
+		result := calculateWallTime(serverStartTime, timer, lastUptime)
+		require.Equalf(t, 18446749073.709553, result, "got %f, want 18446749073.709553", result)
+	})
+
+	t.Run("calculates another timestamp when timer approaches overflow", func(t *testing.T) {
+		serverStartTime := 3.0
+		timer := float64(math.MaxUint64 - 5)
+		lastUptime := picosecondsToSeconds(math.MaxUint64) + 1
+
+		result := calculateWallTime(serverStartTime, timer, lastUptime)
+		require.Equalf(t, 3.6893491147419106e+10, result, "got %f, want 3.6893491147419106e+10", result)
+	})
+}
+
+func Test_CalculateNumberOfOverflows(t *testing.T) {
+	testCases := map[string]struct {
+		expected uint64
+		uptime   float64
+	}{
+		"0 overflows": {0, 5},
+		"1 overflow":  {1, picosecondsToSeconds(math.MaxUint64) + 5},
+		"2 overflows": {2, picosecondsToSeconds(math.MaxUint64)*2 + 5},
+	}
+
+	for name, tc := range testCases {
+		t.Run(name, func(t *testing.T) {
+			require.EqualValues(t, tc.expected, calculateNumberOfOverflows(tc.uptime))
+		})
+	}
+}