Use monotonic instead of time

Author: erezsh

data_diff/__main__.py

@@ -189,7 +189,7 @@ def _main(
         for db in dbs:
             db.enable_interactive()
 
-    start = time.time()
+    start = time.monotonic()
 
     try:
         options = dict(
@@ -281,7 +281,7 @@ def _main(
 
             sys.stdout.flush()
 
-    end = time.time()
+    end = time.monotonic()
 
     logging.info(f"Duration: {end-start:.2f} seconds.")
 

data_diff/diff_tables.py

@@ -225,11 +225,11 @@ def count(self) -> Tuple[int, int]:
 
     def count_and_checksum(self) -> Tuple[int, int]:
         """Count and checksum the rows in the segment, in one pass."""
-        start = time.time()
+        start = time.monotonic()
         count, checksum = self.database.query(
             self._make_select(columns=[Count(), Checksum(self._relevant_columns_repr)]), tuple
         )
-        duration = time.time() - start
+        duration = time.monotonic() - start
         if duration > RECOMMENDED_CHECKSUM_DURATION:
             logger.warning(
                 f"Checksum is taking longer than expected ({duration:.2f}s). "
@@ -336,7 +336,7 @@ def diff_tables(self, table1: TableSegment, table2: TableSegment) -> DiffResult:
             send_event_json(event_json)
 
         self.stats["diff_count"] = 0
-        start = time.time()
+        start = time.monotonic()
         try:
 
             # Query and validate schema
@@ -384,7 +384,7 @@ def diff_tables(self, table1: TableSegment, table2: TableSegment) -> DiffResult:
             error = e
         finally:
             if is_tracking_enabled():
-                runtime = time.time() - start
+                runtime = time.monotonic() - start
                 table1_count = self.stats.get("table1_count")
                 table2_count = self.stats.get("table2_count")
                 diff_count = self.stats.get("diff_count")

tests/test_database_types.py

@@ -527,7 +527,7 @@ def tearDown(self) -> None:
 
     @parameterized.expand(type_pairs, name_func=expand_params)
     def test_types(self, source_db, target_db, source_type, target_type, type_category):
-        start = time.time()
+        start = time.monotonic()
 
         self.src_conn = src_conn = CONNS[source_db]
         self.dst_conn = dst_conn = CONNS[target_db]
@@ -550,12 +550,12 @@ def test_types(self, source_db, target_db, source_type, target_type, type_catego
         self.src_table = src_table = ".".join(map(src_conn.quote, src_table_path))
         self.dst_table = dst_table = ".".join(map(dst_conn.quote, dst_table_path))
 
-        start = time.time()
+        start = time.monotonic()
         if not BENCHMARK:
             _drop_table_if_exists(src_conn, src_table)
         _create_table_with_indexes(src_conn, src_table, source_type)
         _insert_to_table(src_conn, src_table, enumerate(sample_values, 1), source_type)
-        insertion_source_duration = time.time() - start
+        insertion_source_duration = time.monotonic() - start
 
         values_in_source = PaginatedTable(src_table, src_conn)
         if source_db is db.Presto or source_db is db.Trino:
@@ -564,12 +564,12 @@ def test_types(self, source_db, target_db, source_type, target_type, type_catego
             elif source_type.startswith("timestamp"):
                 values_in_source = ((a, datetime.fromisoformat(b.rstrip(" UTC"))) for a, b in values_in_source)
 
-        start = time.time()
+        start = time.monotonic()
         if not BENCHMARK:
             _drop_table_if_exists(dst_conn, dst_table)
         _create_table_with_indexes(dst_conn, dst_table, target_type)
         _insert_to_table(dst_conn, dst_table, values_in_source, target_type)
-        insertion_target_duration = time.time() - start
+        insertion_target_duration = time.monotonic() - start
 
         if type_category == "uuid":
             self.table = TableSegment(self.src_conn, src_table_path, "col", None, ("id",), case_sensitive=False)
@@ -578,13 +578,13 @@ def test_types(self, source_db, target_db, source_type, target_type, type_catego
             self.table = TableSegment(self.src_conn, src_table_path, "id", None, ("col",), case_sensitive=False)
             self.table2 = TableSegment(self.dst_conn, dst_table_path, "id", None, ("col",), case_sensitive=False)
 
-        start = time.time()
+        start = time.monotonic()
         self.assertEqual(N_SAMPLES, self.table.count())
-        count_source_duration = time.time() - start
+        count_source_duration = time.monotonic() - start
 
-        start = time.time()
+        start = time.monotonic()
         self.assertEqual(N_SAMPLES, self.table2.count())
-        count_target_duration = time.time() - start
+        count_target_duration = time.monotonic() - start
 
         # When testing, we configure these to their lowest possible values for
         # the DEFAULT_N_SAMPLES.
@@ -598,9 +598,9 @@ def test_types(self, source_db, target_db, source_type, target_type, type_catego
             bisection_factor=ch_factor,
             max_threadpool_size=ch_threads,
         )
-        start = time.time()
+        start = time.monotonic()
         diff = list(differ.diff_tables(self.table, self.table2))
-        checksum_duration = time.time() - start
+        checksum_duration = time.monotonic() - start
         expected = []
         self.assertEqual(expected, diff)
         self.assertEqual(0, differ.stats.get("rows_downloaded", 0))
@@ -617,9 +617,9 @@ def test_types(self, source_db, target_db, source_type, target_type, type_catego
         differ = TableDiffer(
             bisection_threshold=dl_threshold, bisection_factor=dl_factor, max_threadpool_size=dl_threads
         )
-        start = time.time()
+        start = time.monotonic()
         diff = list(differ.diff_tables(self.table, self.table2))
-        download_duration = time.time() - start
+        download_duration = time.monotonic() - start
         expected = []
         self.assertEqual(expected, diff)
         self.assertEqual(len(sample_values), differ.stats.get("rows_downloaded", 0))