Fix timezone issues by enforcing UTC for all time operations

main.go

@@ -812,7 +812,7 @@ func main() {
 	if startTimestamp != 0 {
 		startTime = time.Unix(0, startTimestamp)
 	} else {
-		startTime = time.Now()
+		startTime = time.Now().UTC()
 	}
 
 	fmt.Println("Configuration")

main_test.go

@@ -608,7 +608,7 @@ func TestMixedModeWithWorkloads(t *testing.T) {
 	partitionCount = 10
 	clusteringRowCount = 5
 	maximumRate = 1000 // Set a non-zero rate for timeseries workload
-	startTime = time.Now()
+	startTime = time.Now().UTC()
 
 	workloads := []string{"sequential", "uniform", "timeseries"}
 
@@ -654,7 +654,7 @@ func TestTimeseriesWorkloadWithMixedMode(t *testing.T) {
 	partitionCount = 10
 	clusteringRowCount = 5
 	maximumRate = 1000
-	startTime = time.Now()
+	startTime = time.Now().UTC()
 
 	// Test that timeseries workload with mixed mode does not panic
 	defer func() {

modes.go

@@ -50,7 +50,7 @@ type MaximumRateLimiter struct {
 func (mxrl *MaximumRateLimiter) Wait() {
 	mxrl.CompletedOperations++
 	nextRequest := mxrl.StartTime.Add(mxrl.Period * time.Duration(mxrl.CompletedOperations))
-	now := time.Now()
+	now := time.Now().UTC()
 	if now.Before(nextRequest) {
 		time.Sleep(nextRequest.Sub(now))
 	}
@@ -67,7 +67,7 @@ func NewRateLimiter(maximumRate int, _ time.Duration) RateLimiter {
 	period := time.Duration(int64(time.Second) / int64(maximumRate))
 	return &MaximumRateLimiter{
 		Period:              period,
-		StartTime:           time.Now(),
+		StartTime:           time.Now().UTC(),
 		CompletedOperations: 0,
 	}
 }
@@ -161,7 +161,7 @@ func RunTest(
 	rateLimiter RateLimiter,
 	test func(rb *results.TestThreadResult) (time.Duration, error),
 ) {
-	start := time.Now()
+	start := time.Now().UTC()
 	partialStart := start
 	iter := NewTestIterator(workload)
 	errorsAtRow := 0
@@ -170,11 +170,11 @@ func RunTest(
 
 		expectedStartTime := rateLimiter.Expected()
 		if expectedStartTime.IsZero() {
-			expectedStartTime = time.Now()
+			expectedStartTime = time.Now().UTC()
 		}
 
 		rawLatency, err := test(threadResult)
-		endTime := time.Now()
+		endTime := time.Now().UTC()
 		switch {
 		case err == nil:
 			errorsAtRow = 0
@@ -194,7 +194,7 @@ func RunTest(
 			}
 		}
 
-		now := time.Now()
+		now := time.Now().UTC()
 		if maxErrorsAtRow > 0 && errorsAtRow >= maxErrorsAtRow {
 			threadResult.SubmitCriticalError(fmt.Errorf(
 				"error limit (maxErrorsAtRow) of %d errors is reached", errorsAtRow))
@@ -216,7 +216,7 @@ func RunTest(
 			partialStart = partialStart.Add(reportInterval)
 		}
 	}
-	end := time.Now()
+	end := time.Now().UTC()
 
 	threadResult.FullResult.ElapsedTime = end.Sub(start)
 	threadResult.ResultChannel <- *threadResult.FullResult
@@ -417,9 +417,9 @@ func createWriteTestFunc(session *gocql.Session, workload workloads.Generator, v
 		queryStr := ""
 		currentAttempts := 0
 		for {
-			requestStart := time.Now()
+			requestStart := time.Now().UTC()
 			err = bound.Exec()
-			requestEnd := time.Now()
+			requestEnd := time.Now().UTC()
 
 			if err == nil {
 				rb.IncOps()
@@ -517,9 +517,9 @@ func DoBatchedWrites(
 			queryStr := ""
 			currentAttempts := 0
 			for {
-				requestStart := time.Now()
+				requestStart := time.Now().UTC()
 				err := session.ExecuteBatch(batch)
-				requestEnd := time.Now()
+				requestEnd := time.Now().UTC()
 
 				if err == nil {
 					rb.IncOps()
@@ -572,9 +572,9 @@ func DoCounterUpdates(
 			queryStr := ""
 			currentAttempts := 0
 			for {
-				requestStart := time.Now()
+				requestStart := time.Now().UTC()
 				err := query.Exec()
-				requestEnd := time.Now()
+				requestEnd := time.Now().UTC()
 
 				if err == nil {
 					rb.IncOps()
@@ -760,9 +760,9 @@ func createReadTestFunc(table string, session *gocql.Session, workload workloads
 		queryStr := query.String()
 
 		for currentAttempts := 0; ; currentAttempts++ {
-			requestStart := time.Now()
+			requestStart := time.Now().UTC()
 			err := executeReadsQuery(query, table, rb, validateData)
-			requestEnd := time.Now()
+			requestEnd := time.Now().UTC()
 
 			if err == nil {
 				rb.IncOps()
@@ -802,13 +802,13 @@ func DoScanTable(session *gocql.Session, threadResult *results.TestThreadResult,
 		queryStr := query.String()
 
 		for currentAttempts := 0; ; currentAttempts++ {
-			requestStart := time.Now()
+			requestStart := time.Now().UTC()
 			query.Bind(currentRange.Start, currentRange.End)
 			iter := query.Iter()
 			for iter.Scan(nil, nil, nil) {
 				rb.IncRows()
 			}
-			requestEnd := time.Now()
+			requestEnd := time.Now().UTC()
 			err := iter.Close()
 
 			if err == nil {
@@ -842,7 +842,7 @@ func DoMixed(
 
 		expectedStartTime := rateLimiter.Expected()
 		if expectedStartTime.IsZero() {
-			expectedStartTime = time.Now()
+			expectedStartTime = time.Now().UTC()
 		}
 
 		// Perform write on even operations, read on odd operations
@@ -852,7 +852,7 @@ func DoMixed(
 			rawLatency, err := writeTestFunc(rb)
 			if err == nil {
 				// Record coordinated omission fixed latency for write operations
-				endTime := time.Now()
+				endTime := time.Now().UTC()
 				rb.RecordWriteCoFixedLatency(endTime.Sub(expectedStartTime))
 			}
 			return rawLatency, err
@@ -861,7 +861,7 @@ func DoMixed(
 		rawLatency, err := readTestFunc(rb)
 		if err == nil {
 			// Record coordinated omission fixed latency for read operations
-			endTime := time.Now()
+			endTime := time.Now().UTC()
 			rb.RecordReadCoFixedLatency(endTime.Sub(expectedStartTime))
 		}
 		return rawLatency, err
@@ -889,9 +889,9 @@ func createMixedWriteTestFunc(session *gocql.Session, workload workloads.Generat
 		queryStr := ""
 		currentAttempts := 0
 		for {
-			requestStart := time.Now()
+			requestStart := time.Now().UTC()
 			err = bound.Exec()
-			requestEnd := time.Now()
+			requestEnd := time.Now().UTC()
 
 			if err == nil {
 				rb.IncOps()
@@ -956,7 +956,7 @@ func createMixedReadTestFunc(table string, session *gocql.Session, workload work
 		queryStr := ""
 		currentAttempts := 0
 		for {
-			requestStart := time.Now()
+			requestStart := time.Now().UTC()
 			iter := query.Iter()
 
 			var (
@@ -985,7 +985,7 @@ func createMixedReadTestFunc(table string, session *gocql.Session, workload work
 				}
 			}
 
-			requestEnd := time.Now()
+			requestEnd := time.Now().UTC()
 			err := iter.Close()
 			if err == nil {
 				rb.IncOps()

modes_test.go

@@ -442,15 +442,15 @@ func TestMixedModeCoFixedLatencyRecording(t *testing.T) {
 
 	// Mock rate limiter that returns a known expected time
 	mockRateLimiter := &MaximumRateLimiter{
-		StartTime: time.Now().Add(-time.Second), // 1 second ago
-		Period:    time.Millisecond * 10,        // 10ms between operations
+		StartTime: time.Now().UTC().Add(-time.Second), // 1 second ago
+		Period:    time.Millisecond * 10,              // 10ms between operations
 	}
 
 	// Test that the DoMixed function structure correctly handles expectedStartTime
 	// by checking that rateLimiter.Expected() is called within the test function
 
 	// Create a test that verifies the logic without database operations
-	testStartTime := time.Now()
+	testStartTime := time.Now().UTC()
 	expectedStartTime := mockRateLimiter.Expected()
 	if expectedStartTime.IsZero() {
 		expectedStartTime = testStartTime

pkg/results/merged_result.go

@@ -31,7 +31,7 @@ type MergedResult struct {
 func NewMergedResult() *MergedResult {
 	result := &MergedResult{}
 	if globalResultConfiguration.measureLatency {
-		result.HistogramStartTime = time.Now().UnixNano()
+		result.HistogramStartTime = time.Now().UTC().UnixNano()
 		result.RawLatency = NewHistogram(
 			&globalResultConfiguration.latencyHistogramConfiguration,
 			"raw",
@@ -165,7 +165,7 @@ func (mr *MergedResult) getLatencyHistogram() *hdrhistogram.Histogram {
 
 func (mr *MergedResult) SaveLatenciesToHdrHistogram(hdrLogWriter *hdrhistogram.HistogramLogWriter) {
 	startTimeMs := mr.HistogramStartTime / 1000000
-	endTimeMs := time.Now().UnixNano() / 1000000
+	endTimeMs := time.Now().UTC().UnixNano() / 1000000
 
 	// Save standard histograms
 	mr.CoFixedLatency.SetStartTimeMs(startTimeMs)

pkg/results/thread_result.go

@@ -217,7 +217,7 @@ func (r *TestThreadResult) RecordWriteCoFixedLatency(latency time.Duration) {
 }
 
 func (r *TestThreadResult) SubmitResult() {
-	now := time.Now()
+	now := time.Now().UTC()
 	if now.Sub(r.partialStart) > time.Second {
 		r.ResultChannel <- *r.PartialResult
 		r.ResetPartialResult()

pkg/results/thread_results.go

@@ -28,7 +28,7 @@ func (tr *TestResults) Init(concurrency int) {
 }
 
 func (tr *TestResults) SetStartTime() {
-	tr.startTime = time.Now()
+	tr.startTime = time.Now().UTC()
 }
 
 func (tr *TestResults) GetTestResult(idx int) *TestThreadResult {
@@ -72,7 +72,7 @@ func (tr *TestResults) GetTotalResults() {
 	//  before reducing it from start time, which is divided by 1000000000 before applied to histogram
 	//  giving small chance that rounded baseTime would be greater than histogram start time and negative
 	//  times in the histogram log
-	baseTime := (time.Now().UnixNano() / 1000000000) * 1000000000
+	baseTime := (time.Now().UTC().UnixNano() / 1000000000) * 1000000000
 
 	var hdrLogWriter *hdrhistogram.HistogramLogWriter
 	if globalResultConfiguration.hdrLatencyFile != "" {

pkg/workloads/workloads.go

@@ -97,7 +97,7 @@ func NewRandomUniform(
 	i int,
 	partitionCount, partitionOffset, clusteringRowCount int64,
 ) *RandomUniform {
-	generator := rand.New(rand.NewSource(int64(time.Now().Nanosecond() * (i + 1))))
+	generator := rand.New(rand.NewSource(int64(time.Now().UTC().Nanosecond() * (i + 1))))
 	return &RandomUniform{
 		generator,
 		int64(partitionCount),
@@ -233,7 +233,7 @@ func NewTimeSeriesReader(
 	default:
 		log.Fatal("unknown distribution", distribution)
 	}
-	generator := rand.New(rand.NewSource(int64(time.Now().Nanosecond() * (threadID + 1))))
+	generator := rand.New(rand.NewSource(int64(time.Now().UTC().Nanosecond() * (threadID + 1))))
 	pkStride := int64(threadCount)
 	pkOffset := (int64(threadID) % pkCount) + basicPkOffset
 	period := time.Second.Nanoseconds() / writeRate
@@ -261,13 +261,13 @@ func (tsw *TimeSeriesRead) NextPartitionKey() int64 {
 	if tsw.PkPosition >= tsw.PkCount+tsw.PkOffset {
 		tsw.PkPosition = tsw.PkOffset
 	}
-	maxGeneration := (time.Now().UnixNano()-tsw.StartTimestamp)/(tsw.Period*tsw.CkCount) + 1
+	maxGeneration := (time.Now().UTC().UnixNano()-tsw.StartTimestamp)/(tsw.Period*tsw.CkCount) + 1
 	tsw.CurrentGeneration = RandomInt64(tsw.Generator, tsw.HalfNormalDist, maxGeneration)
 	return tsw.PkPosition<<32 | tsw.CurrentGeneration
 }
 
 func (tsw *TimeSeriesRead) NextClusteringKey() int64 {
-	maxRange := (time.Now().UnixNano()-tsw.StartTimestamp)/tsw.Period - tsw.CurrentGeneration*tsw.CkCount + 1
+	maxRange := (time.Now().UTC().UnixNano()-tsw.StartTimestamp)/tsw.Period - tsw.CurrentGeneration*tsw.CkCount + 1
 	maxRange = min(tsw.CkCount, maxRange)
 	timestampDelta := (tsw.CurrentGeneration*tsw.CkCount + RandomInt64(tsw.Generator, tsw.HalfNormalDist, maxRange)) * tsw.Period
 	return -(timestampDelta + tsw.StartTimestamp)

pkg/workloads/workloads_test.go

@@ -8,7 +8,7 @@ import (
 )
 
 func TestSequentialWorkload(t *testing.T) {
-	generator := rand.New(rand.NewSource(int64(time.Now().Nanosecond())))
+	generator := rand.New(rand.NewSource(int64(time.Now().UTC().Nanosecond())))
 	testCases := []struct {
 		rowOffset          int64
 		rowCount           int64
@@ -84,7 +84,7 @@ func TestSequentialWorkload(t *testing.T) {
 }
 
 func TestUniformWorkload(t *testing.T) {
-	generator := rand.New(rand.NewSource(int64(time.Now().Nanosecond())))
+	generator := rand.New(rand.NewSource(int64(time.Now().UTC().Nanosecond())))
 	testCases := []struct {
 		partitionCount     int64
 		partitionOffset    int64

random/random.go

@@ -30,7 +30,7 @@ var (
 )
 
 var (
-	globalSeed = uint64(time.Now().UnixNano() + int64(os.Getpid()))
+	globalSeed = uint64(time.Now().UTC().UnixNano() + int64(os.Getpid()))
 	// globalRand is a copy of the rand.globalRand (git.io/fA2Ls) for
 	// user mode package's use only.
 	globalRand    = NewLockedRandom(globalSeed)