deltacat 1.1.1__py3-none-any.whl → 1.1.2__py3-none-any.whl

deltacat/__init__.py

@@ -44,7 +44,7 @@ from deltacat.types.tables import TableWriteMode
 
 deltacat.logs.configure_deltacat_logger(logging.getLogger(__name__))
 
-__version__ = "1.1.1"
+__version__ = "1.1.2"
 
 
 __all__ = [

deltacat/aws/clients.py

@@ -4,6 +4,7 @@ from typing import Optional
 from http import HTTPStatus
 
 import boto3
+from botocore.exceptions import CredentialRetrievalError
 from boto3.exceptions import ResourceNotExistsError
 from boto3.resources.base import ServiceResource
 from botocore.client import BaseClient
@@ -15,6 +16,8 @@ from tenacity import (
     wait_fixed,
     retry_if_exception,
     stop_after_delay,
+    retry_if_exception_type,
+    wait_random_exponential,
 )
 
 from deltacat import logs
@@ -37,6 +40,13 @@ RETRYABLE_HTTP_STATUS_CODES = [
     HTTPStatus.GATEWAY_TIMEOUT,
 ]
 
+boto_retry_wrapper = Retrying(
+    wait=wait_random_exponential(multiplier=1, max=10),
+    stop=stop_after_delay(60 * 5),
+    # CredentialRetrievalError can still be thrown due to throttling, even if IMDS health checks succeed.
+    retry=retry_if_exception_type(CredentialRetrievalError),
+)
+
 
 class RetryIfRetryableHTTPStatusCode(retry_if_exception):
     """
@@ -183,10 +193,10 @@ def _client(name: str, region: Optional[str], **kwargs) -> BaseClient:
 def resource_cache(name: str, region: Optional[str], **kwargs) -> ServiceResource:
     # we don't use the @lru_cache decorator because Ray can't pickle it
     cached_function = lru_cache()(_resource)
-    return cached_function(name, region, **kwargs)
+    return boto_retry_wrapper(cached_function, name, region, **kwargs)
 
 
 def client_cache(name: str, region: Optional[str], **kwargs) -> BaseClient:
     # we don't use the @lru_cache decorator because Ray can't pickle it
     cached_function = lru_cache()(_client)
-    return cached_function(name, region, **kwargs)
+    return boto_retry_wrapper(cached_function, name, region, **kwargs)

deltacat/aws/constants.py

@@ -3,6 +3,10 @@ from typing import List
 from deltacat.utils.common import env_integer, env_string
 
 DAFT_MAX_S3_CONNECTIONS_PER_FILE = env_integer("DAFT_MAX_S3_CONNECTIONS_PER_FILE", 8)
-BOTO_MAX_RETRIES = env_integer("BOTO_MAX_RETRIES", 15)
+BOTO_MAX_RETRIES = env_integer("BOTO_MAX_RETRIES", 5)
 TIMEOUT_ERROR_CODES: List[str] = ["ReadTimeoutError", "ConnectTimeoutError"]
 AWS_REGION = env_string("AWS_REGION", "us-east-1")
+
+# Metric Names
+DOWNLOAD_MANIFEST_ENTRY_METRIC_PREFIX = "download_manifest_entry"
+UPLOAD_SLICED_TABLE_METRIC_PREFIX = "upload_sliced_table"

deltacat/aws/s3u.py

@@ -25,7 +25,11 @@ from tenacity import (
 from deltacat.utils.ray_utils.concurrency import invoke_parallel
 import deltacat.aws.clients as aws_utils
 from deltacat import logs
-from deltacat.aws.constants import TIMEOUT_ERROR_CODES
+from deltacat.aws.constants import (
+    TIMEOUT_ERROR_CODES,
+    DOWNLOAD_MANIFEST_ENTRY_METRIC_PREFIX,
+    UPLOAD_SLICED_TABLE_METRIC_PREFIX,
+)
 from deltacat.exceptions import NonRetryableError, RetryableError
 from deltacat.storage import (
     DistributedDataset,
@@ -50,6 +54,7 @@ from deltacat.types.tables import (
 )
 from deltacat.types.partial_download import PartialFileDownloadParams
 from deltacat.utils.common import ReadKwargsProvider
+from deltacat.utils.metrics import metrics
 
 logger = logs.configure_deltacat_logger(logging.getLogger(__name__))
 
@@ -238,6 +243,7 @@ def read_file(
         raise e
 
 
+@metrics(prefix=UPLOAD_SLICED_TABLE_METRIC_PREFIX)
 def upload_sliced_table(
     table: Union[LocalTable, DistributedDataset],
     s3_url_prefix: str,
@@ -346,6 +352,7 @@ def upload_table(
     return manifest_entries
 
 
+@metrics(prefix=DOWNLOAD_MANIFEST_ENTRY_METRIC_PREFIX)
 def download_manifest_entry(
     manifest_entry: ManifestEntry,
     token_holder: Optional[Dict[str, Any]] = None,

deltacat/compute/compactor_v2/compaction_session.py

@@ -65,6 +65,7 @@ from deltacat.compute.compactor_v2.utils.task_options import (
     local_merge_resource_options_provider,
 )
 from deltacat.compute.compactor.model.compactor_version import CompactorVersion
+from deltacat.utils.metrics import MetricsActor, METRICS_CONFIG_ACTOR_NAME
 
 if importlib.util.find_spec("memray"):
     import memray
@@ -118,6 +119,15 @@ def _execute_compaction(
     params: CompactPartitionParams, **kwargs
 ) -> Tuple[Optional[Partition], Optional[RoundCompletionInfo], Optional[str]]:
 
+    if params.metrics_config:
+        logger.info(
+            f"Setting metrics config with target: {params.metrics_config.metrics_target}"
+        )
+        metrics_actor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+        ray.get(metrics_actor.set_metrics_config.remote(params.metrics_config))
+
     rcf_source_partition_locator = (
         params.rebase_source_partition_locator or params.source_partition_locator
     )

deltacat/compute/compactor_v2/constants.py

@@ -40,3 +40,31 @@ DROP_DUPLICATES = True
 # This is the observed upper bound inflation for parquet
 # size in metadata to pyarrow table size.
 PARQUET_TO_PYARROW_INFLATION = 4
+
+# Metric Names
+# Time taken for a hash bucket task
+HASH_BUCKET_TIME_IN_SECONDS = "hash_bucket_time"
+
+# Hash bucket success count
+HASH_BUCKET_SUCCESS_COUNT = "hash_bucket_success_count"
+
+# Hash bucket failure count
+HASH_BUCKET_FAILURE_COUNT = "hash_bucket_failure_count"
+
+# Time taken for a merge task
+MERGE_TIME_IN_SECONDS = "merge_time"
+
+# Merge success count
+MERGE_SUCCESS_COUNT = "merge_success_count"
+
+# Merge failure count
+MERGE_FAILURE_COUNT = "merge_failure_count"
+
+# Metric prefix for discover deltas
+DISCOVER_DELTAS_METRIC_PREFIX = "discover_deltas"
+
+# Metric prefix for prepare deletes
+PREPARE_DELETES_METRIC_PREFIX = "prepare_deletes"
+
+# Metric prefix for materialize
+MATERIALIZE_METRIC_PREFIX = "delta_materialize"

deltacat/compute/compactor_v2/deletes/utils.py

@@ -23,6 +23,8 @@ from deltacat.storage import (
     Delta,
 )
 from deltacat import logs
+from deltacat.utils.metrics import metrics
+from deltacat.compute.compactor_v2.constants import PREPARE_DELETES_METRIC_PREFIX
 
 
 logger = logs.configure_deltacat_logger(logging.getLogger(__name__))
@@ -115,6 +117,7 @@ def _get_delete_file_envelopes(
     return delete_file_envelopes
 
 
+@metrics(prefix=PREPARE_DELETES_METRIC_PREFIX)
 def prepare_deletes(
     params: CompactPartitionParams,
     input_deltas: List[Delta],

deltacat/compute/compactor_v2/steps/hash_bucket.py

@@ -25,12 +25,17 @@ from deltacat.utils.ray_utils.runtime import (
 )
 from deltacat.utils.common import ReadKwargsProvider
 from deltacat.utils.performance import timed_invocation
-from deltacat.utils.metrics import emit_timer_metrics
+from deltacat.utils.metrics import emit_timer_metrics, failure_metric, success_metric
 from deltacat.utils.resources import (
     get_current_process_peak_memory_usage_in_bytes,
     ProcessUtilizationOverTimeRange,
 )
 from deltacat.constants import BYTES_PER_GIBIBYTE
+from deltacat.compute.compactor_v2.constants import (
+    HASH_BUCKET_TIME_IN_SECONDS,
+    HASH_BUCKET_FAILURE_COUNT,
+    HASH_BUCKET_SUCCESS_COUNT,
+)
 
 if importlib.util.find_spec("memray"):
     import memray
@@ -91,6 +96,8 @@ def _group_file_records_by_pk_hash_bucket(
     return hb_to_delta_file_envelopes, total_record_count, total_size_bytes
 
 
+@success_metric(name=HASH_BUCKET_SUCCESS_COUNT)
+@failure_metric(name=HASH_BUCKET_FAILURE_COUNT)
 def _timed_hash_bucket(input: HashBucketInput):
     task_id = get_current_ray_task_id()
     worker_id = get_current_ray_worker_id()
@@ -153,7 +160,7 @@ def hash_bucket(input: HashBucketInput) -> HashBucketResult:
         if input.metrics_config:
             emit_result, latency = timed_invocation(
                 func=emit_timer_metrics,
-                metrics_name="hash_bucket",
+                metrics_name=HASH_BUCKET_TIME_IN_SECONDS,
                 value=duration,
                 metrics_config=input.metrics_config,
             )

deltacat/compute/compactor_v2/steps/merge.py

@@ -24,7 +24,7 @@ from deltacat.utils.ray_utils.runtime import (
 )
 from deltacat.compute.compactor.utils import system_columns as sc
 from deltacat.utils.performance import timed_invocation
-from deltacat.utils.metrics import emit_timer_metrics
+from deltacat.utils.metrics import emit_timer_metrics, failure_metric, success_metric
 from deltacat.utils.resources import (
     get_current_process_peak_memory_usage_in_bytes,
     ProcessUtilizationOverTimeRange,
@@ -42,6 +42,11 @@ from deltacat.storage import (
 )
 from deltacat.compute.compactor_v2.utils.dedupe import drop_duplicates
 from deltacat.constants import BYTES_PER_GIBIBYTE
+from deltacat.compute.compactor_v2.constants import (
+    MERGE_TIME_IN_SECONDS,
+    MERGE_SUCCESS_COUNT,
+    MERGE_FAILURE_COUNT,
+)
 
 
 if importlib.util.find_spec("memray"):
@@ -479,6 +484,8 @@ def _copy_manifests_from_hash_bucketing(
     return materialized_results
 
 
+@success_metric(name=MERGE_SUCCESS_COUNT)
+@failure_metric(name=MERGE_FAILURE_COUNT)
 def _timed_merge(input: MergeInput) -> MergeResult:
     task_id = get_current_ray_task_id()
     worker_id = get_current_ray_worker_id()
@@ -578,7 +585,7 @@ def merge(input: MergeInput) -> MergeResult:
         if input.metrics_config:
             emit_result, latency = timed_invocation(
                 func=emit_timer_metrics,
-                metrics_name="merge",
+                metrics_name=MERGE_TIME_IN_SECONDS,
                 value=duration,
                 metrics_config=input.metrics_config,
             )

deltacat/compute/compactor_v2/utils/io.py

@@ -23,10 +23,13 @@ from deltacat.compute.compactor_v2.utils.task_options import (
 from deltacat.compute.compactor_v2.utils.content_type_params import (
     append_content_type_params,
 )
+from deltacat.utils.metrics import metrics
+from deltacat.compute.compactor_v2.constants import DISCOVER_DELTAS_METRIC_PREFIX
 
 logger = logs.configure_deltacat_logger(logging.getLogger(__name__))
 
 
+@metrics(prefix=DISCOVER_DELTAS_METRIC_PREFIX)
 def discover_deltas(
     source_partition_locator: PartitionLocator,
     last_stream_position_to_compact: int,

deltacat/compute/compactor_v2/utils/merge.py

@@ -31,11 +31,14 @@ from deltacat.compute.compactor_v2.deletes.delete_strategy import (
 from deltacat.compute.compactor_v2.deletes.delete_file_envelope import (
     DeleteFileEnvelope,
 )
+from deltacat.utils.metrics import metrics
+from deltacat.compute.compactor_v2.constants import MATERIALIZE_METRIC_PREFIX
 
 
 logger = logs.configure_deltacat_logger(logging.getLogger(__name__))
 
 
+@metrics(prefix=MATERIALIZE_METRIC_PREFIX)
 def materialize(
     input: MergeInput,
     task_index: int,

deltacat/tests/utils/test_metrics.py

@@ -0,0 +1,575 @@
+import unittest
+from unittest.mock import MagicMock, ANY, call
+import ray
+from deltacat.utils.metrics import (
+    metrics,
+    success_metric,
+    failure_metric,
+    latency_metric,
+    MetricsActor,
+    METRICS_CONFIG_ACTOR_NAME,
+    MetricsConfig,
+    MetricsTarget,
+    METRICS_TARGET_TO_EMITTER_DICT,
+)
+from deltacat.utils.performance import timed_invocation
+
+
+def method_not_annotated(mock_func):
+    mock_func("called")
+
+
+@metrics
+def metrics_annotated_method(mock_func):
+    mock_func("called")
+
+
+@metrics
+def metrics_annotated_method_error(mock_func):
+    raise ValueError()
+
+
+@metrics(prefix="test_prefix")
+def metrics_with_prefix_annotated_method(mock_func):
+    mock_func("called")
+
+
+@metrics(prefix="test_prefix")
+def metrics_with_prefix_annotated_method_error(mock_func):
+    raise ValueError()
+
+
+class TestMetricsAnnotation(unittest.TestCase):
+    def test_metrics_annotation_sanity(self):
+        mock, mock_target = MagicMock(), MagicMock()
+        METRICS_TARGET_TO_EMITTER_DICT[MetricsTarget.NOOP] = mock_target
+        metrics_actor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+        config = MetricsConfig("us-east-1", MetricsTarget.NOOP)
+        ray.get(metrics_actor.set_metrics_config.remote(config))
+
+        # action
+        metrics_annotated_method(mock)
+
+        mock.assert_called_once()
+        self.assertEqual(2, mock_target.call_count)
+        mock_target.assert_has_calls(
+            [
+                call(
+                    metrics_name="metrics_annotated_method_time",
+                    metrics_config=ANY,
+                    value=ANY,
+                ),
+                call(
+                    metrics_name="metrics_annotated_method_success_count",
+                    metrics_config=ANY,
+                    value=ANY,
+                ),
+            ],
+            any_order=True,
+        )
+
+    def test_metrics_annotation_when_error(self):
+        mock, mock_target = MagicMock(), MagicMock()
+        METRICS_TARGET_TO_EMITTER_DICT[MetricsTarget.NOOP] = mock_target
+        metrics_actor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+        config = MetricsConfig("us-east-1", MetricsTarget.NOOP)
+        ray.get(metrics_actor.set_metrics_config.remote(config))
+
+        # action
+        self.assertRaises(ValueError, lambda: metrics_annotated_method_error(mock))
+
+        mock.assert_not_called()
+        self.assertEqual(3, mock_target.call_count)
+        mock_target.assert_has_calls(
+            [
+                call(
+                    metrics_name="metrics_annotated_method_error_time",
+                    metrics_config=ANY,
+                    value=ANY,
+                ),
+                call(
+                    metrics_name="metrics_annotated_method_error_failure_count",
+                    metrics_config=ANY,
+                    value=ANY,
+                ),
+                call(
+                    metrics_name="metrics_annotated_method_error_failure_count.ValueError",
+                    metrics_config=ANY,
+                    value=ANY,
+                ),
+            ],
+            any_order=True,
+        )
+
+    def test_metrics_with_prefix_annotation_sanity(self):
+        mock, mock_target = MagicMock(), MagicMock()
+        METRICS_TARGET_TO_EMITTER_DICT[MetricsTarget.NOOP] = mock_target
+        metrics_actor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+        config = MetricsConfig("us-east-1", MetricsTarget.NOOP)
+        ray.get(metrics_actor.set_metrics_config.remote(config))
+
+        # action
+        metrics_with_prefix_annotated_method(mock)
+
+        mock.assert_called_once()
+        self.assertEqual(2, mock_target.call_count)
+        mock_target.assert_has_calls(
+            [
+                call(metrics_name="test_prefix_time", metrics_config=ANY, value=ANY),
+                call(
+                    metrics_name="test_prefix_success_count",
+                    metrics_config=ANY,
+                    value=ANY,
+                ),
+            ],
+            any_order=True,
+        )
+
+    def test_metrics_annotation_performance(self):
+        mock, mock_target = MagicMock(), MagicMock()
+        METRICS_TARGET_TO_EMITTER_DICT[MetricsTarget.NOOP] = mock_target
+        metrics_actor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+        config = MetricsConfig("us-east-1", MetricsTarget.NOOP)
+        ray.get(metrics_actor.set_metrics_config.remote(config))
+
+        # action with annotation
+        _, actual_latency = timed_invocation(metrics_annotated_method, mock)
+        _, second_call_latency = timed_invocation(metrics_annotated_method, mock)
+
+        mock.assert_called()
+        self.assertEqual(4, mock_target.call_count)
+        self.assertLess(
+            second_call_latency,
+            actual_latency,
+            "Second call to actor must be much faster",
+        )
+
+    def test_metrics_with_prefix_annotation_when_error(self):
+        mock, mock_target = MagicMock(), MagicMock()
+        METRICS_TARGET_TO_EMITTER_DICT[MetricsTarget.NOOP] = mock_target
+        metrics_actor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+        config = MetricsConfig("us-east-1", MetricsTarget.NOOP)
+        ray.get(metrics_actor.set_metrics_config.remote(config))
+
+        # action
+        self.assertRaises(
+            ValueError, lambda: metrics_with_prefix_annotated_method_error(mock)
+        )
+
+        mock.assert_not_called()
+        self.assertEqual(3, mock_target.call_count)
+        mock_target.assert_has_calls(
+            [
+                call(metrics_name="test_prefix_time", metrics_config=ANY, value=ANY),
+                call(
+                    metrics_name="test_prefix_failure_count",
+                    metrics_config=ANY,
+                    value=ANY,
+                ),
+                call(
+                    metrics_name="test_prefix_failure_count.ValueError",
+                    metrics_config=ANY,
+                    value=ANY,
+                ),
+            ],
+            any_order=True,
+        )
+
+    def test_metrics_with_prefix_annotation_without_actor(self):
+        mock, mock_target = MagicMock(), MagicMock()
+        METRICS_TARGET_TO_EMITTER_DICT[MetricsTarget.NOOP] = mock_target
+        metrics_actor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+
+        # explicitly making sure actor is killed
+        ray.kill(metrics_actor)
+
+        # action
+        self.assertRaises(
+            ValueError, lambda: metrics_with_prefix_annotated_method_error(mock)
+        )
+
+        mock.assert_not_called()
+        mock_target.assert_not_called()
+
+
+@latency_metric
+def latency_metric_annotated_method(mock_func):
+    mock_func("called")
+
+
+@latency_metric
+def latency_metric_annotated_method_error(mock_func):
+    raise ValueError()
+
+
+@latency_metric(name="test")
+def latency_metric_with_name_annotated_method(mock_func):
+    mock_func("called")
+
+
+@latency_metric(name="test")
+def latency_metric_with_name_annotated_method_error(mock_func):
+    raise ValueError()
+
+
+class TestLatencyMetricAnnotation(unittest.TestCase):
+    def test_annotation_sanity(self):
+        mock, mock_target = MagicMock(), MagicMock()
+        METRICS_TARGET_TO_EMITTER_DICT[MetricsTarget.NOOP] = mock_target
+        metrics_actor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+        config = MetricsConfig("us-east-1", MetricsTarget.NOOP)
+        ray.get(metrics_actor.set_metrics_config.remote(config))
+
+        # action
+        latency_metric_annotated_method(mock)
+
+        mock.assert_called_once()
+        self.assertEqual(1, mock_target.call_count)
+        mock_target.assert_has_calls(
+            [
+                call(
+                    metrics_name="latency_metric_annotated_method_time",
+                    metrics_config=ANY,
+                    value=ANY,
+                )
+            ],
+            any_order=True,
+        )
+
+    def test_annotation_when_error(self):
+        mock, mock_target = MagicMock(), MagicMock()
+        METRICS_TARGET_TO_EMITTER_DICT[MetricsTarget.NOOP] = mock_target
+        metrics_actor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+        config = MetricsConfig("us-east-1", MetricsTarget.NOOP)
+        ray.get(metrics_actor.set_metrics_config.remote(config))
+
+        # action
+        self.assertRaises(
+            ValueError, lambda: latency_metric_annotated_method_error(mock)
+        )
+
+        mock.assert_not_called()
+        self.assertEqual(1, mock_target.call_count)
+        mock_target.assert_has_calls(
+            [
+                call(
+                    metrics_name="latency_metric_annotated_method_error_time",
+                    metrics_config=ANY,
+                    value=ANY,
+                )
+            ],
+            any_order=True,
+        )
+
+    def test_annotation_with_args_sanity(self):
+        mock, mock_target = MagicMock(), MagicMock()
+        METRICS_TARGET_TO_EMITTER_DICT[MetricsTarget.NOOP] = mock_target
+        metrics_actor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+        config = MetricsConfig("us-east-1", MetricsTarget.NOOP)
+        ray.get(metrics_actor.set_metrics_config.remote(config))
+
+        # action
+        latency_metric_with_name_annotated_method(mock)
+
+        mock.assert_called_once()
+        self.assertEqual(1, mock_target.call_count)
+        mock_target.assert_has_calls(
+            [call(metrics_name="test", metrics_config=ANY, value=ANY)], any_order=True
+        )
+
+    def test_annotation_with_args_when_error(self):
+        mock, mock_target = MagicMock(), MagicMock()
+        METRICS_TARGET_TO_EMITTER_DICT[MetricsTarget.NOOP] = mock_target
+        metrics_actor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+        config = MetricsConfig("us-east-1", MetricsTarget.NOOP)
+        ray.get(metrics_actor.set_metrics_config.remote(config))
+
+        # action
+        self.assertRaises(
+            ValueError, lambda: latency_metric_with_name_annotated_method_error(mock)
+        )
+
+        mock.assert_not_called()
+        self.assertEqual(1, mock_target.call_count)
+        mock_target.assert_has_calls(
+            [call(metrics_name="test", metrics_config=ANY, value=ANY)], any_order=True
+        )
+
+    def test_annotation_without_actor(self):
+        mock, mock_target = MagicMock(), MagicMock()
+        METRICS_TARGET_TO_EMITTER_DICT[MetricsTarget.NOOP] = mock_target
+        metrics_actor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+
+        # explicitly making sure actor is killed
+        ray.kill(metrics_actor)
+
+        # action
+        self.assertRaises(
+            ValueError, lambda: latency_metric_with_name_annotated_method_error(mock)
+        )
+
+        mock.assert_not_called()
+        mock_target.assert_not_called()
+
+
+@success_metric
+def success_metric_annotated_method(mock_func):
+    mock_func("called")
+
+
+@success_metric
+def success_metric_annotated_method_error(mock_func):
+    raise ValueError()
+
+
+@success_metric(name="test")
+def success_metric_with_name_annotated_method(mock_func):
+    mock_func("called")
+
+
+@success_metric(name="test")
+def success_metric_with_name_annotated_method_error(mock_func):
+    raise ValueError()
+
+
+class TestSuccessMetricAnnotation(unittest.TestCase):
+    def test_annotation_sanity(self):
+        mock, mock_target = MagicMock(), MagicMock()
+        METRICS_TARGET_TO_EMITTER_DICT[MetricsTarget.NOOP] = mock_target
+        metrics_actor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+        config = MetricsConfig("us-east-1", MetricsTarget.NOOP)
+        ray.get(metrics_actor.set_metrics_config.remote(config))
+
+        # action
+        success_metric_annotated_method(mock)
+
+        mock.assert_called_once()
+        self.assertEqual(1, mock_target.call_count)
+        mock_target.assert_has_calls(
+            [
+                call(
+                    metrics_name="success_metric_annotated_method_success_count",
+                    metrics_config=ANY,
+                    value=ANY,
+                )
+            ],
+            any_order=True,
+        )
+
+    def test_annotation_when_error(self):
+        mock, mock_target = MagicMock(), MagicMock()
+        METRICS_TARGET_TO_EMITTER_DICT[MetricsTarget.NOOP] = mock_target
+        metrics_actor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+        config = MetricsConfig("us-east-1", MetricsTarget.NOOP)
+        ray.get(metrics_actor.set_metrics_config.remote(config))
+
+        # action
+        self.assertRaises(
+            ValueError, lambda: success_metric_annotated_method_error(mock)
+        )
+
+        mock.assert_not_called()
+        mock_target.assert_not_called()
+
+    def test_annotation_with_args_sanity(self):
+        mock, mock_target = MagicMock(), MagicMock()
+        METRICS_TARGET_TO_EMITTER_DICT[MetricsTarget.NOOP] = mock_target
+        metrics_actor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+        config = MetricsConfig("us-east-1", MetricsTarget.NOOP)
+        ray.get(metrics_actor.set_metrics_config.remote(config))
+
+        # action
+        success_metric_with_name_annotated_method(mock)
+
+        mock.assert_called_once()
+        self.assertEqual(1, mock_target.call_count)
+        mock_target.assert_has_calls(
+            [call(metrics_name="test", metrics_config=ANY, value=ANY)], any_order=True
+        )
+
+    def test_annotation_with_args_when_error(self):
+        mock, mock_target = MagicMock(), MagicMock()
+        METRICS_TARGET_TO_EMITTER_DICT[MetricsTarget.NOOP] = mock_target
+        metrics_actor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+        config = MetricsConfig("us-east-1", MetricsTarget.NOOP)
+        ray.get(metrics_actor.set_metrics_config.remote(config))
+
+        # action
+        self.assertRaises(
+            ValueError, lambda: success_metric_with_name_annotated_method_error(mock)
+        )
+
+        mock.assert_not_called()
+        mock_target.assert_not_called()
+
+    def test_annotation_without_actor(self):
+        mock, mock_target = MagicMock(), MagicMock()
+        METRICS_TARGET_TO_EMITTER_DICT[MetricsTarget.NOOP] = mock_target
+        metrics_actor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+
+        # explicitly making sure actor is killed
+        ray.kill(metrics_actor)
+
+        # action
+        success_metric_annotated_method(mock)
+
+        mock.assert_called_once()
+        mock_target.assert_not_called()
+
+
+@failure_metric
+def failure_metric_annotated_method(mock_func):
+    mock_func("called")
+
+
+@failure_metric
+def failure_metric_annotated_method_error(mock_func):
+    raise ValueError()
+
+
+@failure_metric(name="test")
+def failure_metric_with_name_annotated_method(mock_func):
+    mock_func("called")
+
+
+@failure_metric(name="test")
+def failure_metric_with_name_annotated_method_error(mock_func):
+    raise ValueError()
+
+
+class TestFailureMetricAnnotation(unittest.TestCase):
+    def test_annotation_sanity(self):
+        mock, mock_target = MagicMock(), MagicMock()
+        METRICS_TARGET_TO_EMITTER_DICT[MetricsTarget.NOOP] = mock_target
+        metrics_actor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+        config = MetricsConfig("us-east-1", MetricsTarget.NOOP)
+        ray.get(metrics_actor.set_metrics_config.remote(config))
+
+        # action
+        failure_metric_annotated_method(mock)
+
+        mock.assert_called_once()
+        mock_target.assert_not_called()
+
+    def test_annotation_when_error(self):
+        mock, mock_target = MagicMock(), MagicMock()
+        METRICS_TARGET_TO_EMITTER_DICT[MetricsTarget.NOOP] = mock_target
+        metrics_actor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+        config = MetricsConfig("us-east-1", MetricsTarget.NOOP)
+        ray.get(metrics_actor.set_metrics_config.remote(config))
+
+        # action
+        self.assertRaises(
+            ValueError, lambda: failure_metric_annotated_method_error(mock)
+        )
+
+        mock.assert_not_called()
+        self.assertEqual(2, mock_target.call_count)
+        mock_target.assert_has_calls(
+            [
+                call(
+                    metrics_name="failure_metric_annotated_method_error_failure_count.ValueError",
+                    metrics_config=ANY,
+                    value=ANY,
+                ),
+                call(
+                    metrics_name="failure_metric_annotated_method_error_failure_count",
+                    metrics_config=ANY,
+                    value=ANY,
+                ),
+            ],
+            any_order=True,
+        )
+
+    def test_annotation_with_args_sanity(self):
+        mock, mock_target = MagicMock(), MagicMock()
+        METRICS_TARGET_TO_EMITTER_DICT[MetricsTarget.NOOP] = mock_target
+        metrics_actor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+        config = MetricsConfig("us-east-1", MetricsTarget.NOOP)
+        ray.get(metrics_actor.set_metrics_config.remote(config))
+
+        # action
+        failure_metric_with_name_annotated_method(mock)
+
+        mock.assert_called_once()
+        mock_target.assert_not_called()
+
+    def test_annotation_with_args_when_error(self):
+        mock, mock_target = MagicMock(), MagicMock()
+        METRICS_TARGET_TO_EMITTER_DICT[MetricsTarget.NOOP] = mock_target
+        metrics_actor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+        config = MetricsConfig("us-east-1", MetricsTarget.NOOP)
+        ray.get(metrics_actor.set_metrics_config.remote(config))
+
+        # action
+        self.assertRaises(
+            ValueError, lambda: failure_metric_with_name_annotated_method_error(mock)
+        )
+
+        mock.assert_not_called()
+        self.assertEqual(2, mock_target.call_count)
+        mock_target.assert_has_calls(
+            [
+                call(metrics_name="test.ValueError", metrics_config=ANY, value=ANY),
+                call(metrics_name="test", metrics_config=ANY, value=ANY),
+            ],
+            any_order=True,
+        )
+
+    def test_annotation_without_actor(self):
+        mock, mock_target = MagicMock(), MagicMock()
+        METRICS_TARGET_TO_EMITTER_DICT[MetricsTarget.NOOP] = mock_target
+        metrics_actor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+
+        # explicitly making sure actor is killed
+        ray.kill(metrics_actor)
+
+        # action
+        self.assertRaises(
+            ValueError, lambda: failure_metric_with_name_annotated_method_error(mock)
+        )
+
+        mock.assert_not_called()
+        mock_target.assert_not_called()

deltacat/utils/metrics.py

@@ -1,6 +1,10 @@
 from dataclasses import dataclass
+from typing import Optional
 
 import logging
+import ray
+import time
+import functools
 
 from aws_embedded_metrics import metric_scope
 from aws_embedded_metrics.config import get_config
@@ -18,11 +22,13 @@ logger = logs.configure_deltacat_logger(logging.getLogger(__name__))
 DEFAULT_DELTACAT_METRICS_NAMESPACE = "ray-deltacat-metrics"
 DEFAULT_DELTACAT_LOG_GROUP_NAME = "ray-deltacat-metrics-EMF-logs"
 DEFAULT_DELTACAT_LOG_STREAM_CALLABLE = get_node_ip_address
+METRICS_CONFIG_ACTOR_NAME = "metrics-config-actor"
 
 
 class MetricsTarget(str, Enum):
     CLOUDWATCH = "cloudwatch"
     CLOUDWATCH_EMF = "cloudwatch_emf"
+    NOOP = "noop"
 
 
 @dataclass
@@ -42,27 +48,16 @@ class MetricsConfig:
         self.metrics_kwargs = metrics_kwargs
 
 
-class MetricsType(str, Enum):
-    TIMER = "timer"
-
-
-def _build_metrics_name(metrics_type: Enum, metrics_name: str) -> str:
-    metrics_name_with_type = f"{metrics_name}_{metrics_type}"
-    return metrics_name_with_type
-
-
 def _build_cloudwatch_metrics(
     metrics_name: str,
-    metrics_type: Enum,
     value: str,
     metrics_dimensions: List[Dict[str, str]],
     timestamp: datetime,
     **kwargs,
 ) -> Dict[str, Any]:
-    metrics_name_with_type = _build_metrics_name(metrics_type, metrics_name)
     return [
         {
-            "MetricName": f"{metrics_name_with_type}",
+            "MetricName": metrics_name,
             "Dimensions": metrics_dimensions,
             "Timestamp": timestamp,
             "Value": value,
@@ -73,7 +68,6 @@ def _build_cloudwatch_metrics(
 
 def _emit_metrics(
     metrics_name: str,
-    metrics_type: Enum,
     metrics_config: MetricsConfig,
     value: str,
     **kwargs,
@@ -85,7 +79,6 @@ def _emit_metrics(
     if metrics_target in METRICS_TARGET_TO_EMITTER_DICT:
         METRICS_TARGET_TO_EMITTER_DICT.get(metrics_target)(
             metrics_name=metrics_name,
-            metrics_type=metrics_type,
             metrics_config=metrics_config,
             value=value,
             **kwargs,
@@ -94,9 +87,15 @@ def _emit_metrics(
         logger.warning(f"{metrics_target} is not a supported metrics target type.")
 
 
+def _emit_noop_metrics(
+    *args,
+    **kwargs,
+) -> None:
+    pass
+
+
 def _emit_cloudwatch_metrics(
     metrics_name: str,
-    metrics_type: Enum,
     metrics_config: MetricsConfig,
     value: str,
     **kwargs,
@@ -111,7 +110,6 @@ def _emit_cloudwatch_metrics(
 
     metrics_data = _build_cloudwatch_metrics(
         metrics_name,
-        metrics_type,
         value,
         metrics_dimensions,
         current_time,
@@ -128,14 +126,13 @@ def _emit_cloudwatch_metrics(
     except Exception as e:
         logger.warning(
             f"Failed to publish Cloudwatch metrics with name: {metrics_name}, "
-            f"type: {metrics_type}, with exception: {e}, response: {response}"
+            f"with exception: {e}, response: {response}"
         )
 
 
 @metric_scope
 def _emit_cloudwatch_emf_metrics(
     metrics_name: str,
-    metrics_type: Enum,
     metrics_config: MetricsConfig,
     value: str,
     metrics: MetricsLogger,
@@ -155,7 +152,6 @@ def _emit_cloudwatch_emf_metrics(
     dimensions = dict(
         [(dim["Name"], dim["Value"]) for dim in metrics_config.metrics_dimensions]
     )
-    metrics_name_with_type = _build_metrics_name(metrics_type, metrics_name)
     try:
         metrics.set_timestamp(current_time)
         metrics.set_dimensions(dimensions)
@@ -177,25 +173,164 @@ def _emit_cloudwatch_emf_metrics(
             else DEFAULT_DELTACAT_LOG_STREAM_CALLABLE()
         )
 
-        metrics.put_metric(metrics_name_with_type, value)
+        metrics.put_metric(metrics_name, value)
     except Exception as e:
         logger.warning(
-            f"Failed to publish Cloudwatch EMF metrics with name: {metrics_name_with_type}, "
-            f"type: {metrics_type}, with exception: {e}"
+            f"Failed to publish Cloudwatch EMF metrics with name: {metrics_name}", e
         )
 
 
 METRICS_TARGET_TO_EMITTER_DICT: Dict[str, Callable] = {
     MetricsTarget.CLOUDWATCH: _emit_cloudwatch_metrics,
     MetricsTarget.CLOUDWATCH_EMF: _emit_cloudwatch_emf_metrics,
+    MetricsTarget.NOOP: _emit_noop_metrics,
 }
 
 
+@ray.remote
+class MetricsActor:
+    metrics_config: MetricsConfig = None
+
+    def set_metrics_config(self, config: MetricsConfig) -> None:
+        self.metrics_config = config
+
+    def get_metrics_config(self) -> MetricsConfig:
+        return self.metrics_config
+
+
+def _emit_ignore_exceptions(name: Optional[str], value: Any):
+    try:
+        config_cache: MetricsActor = MetricsActor.options(
+            name=METRICS_CONFIG_ACTOR_NAME, get_if_exists=True
+        ).remote()
+        config = ray.get(config_cache.get_metrics_config.remote())
+        if config:
+            _emit_metrics(metrics_name=name, value=value, metrics_config=config)
+    except BaseException as ex:
+        logger.warning("Emitting metrics failed", ex)
+
+
 def emit_timer_metrics(metrics_name, value, metrics_config, **kwargs):
     _emit_metrics(
         metrics_name=metrics_name,
-        metrics_type=MetricsType.TIMER,
         metrics_config=metrics_config,
         value=value,
         **kwargs,
     )
+
+
+def latency_metric(original_func=None, name: Optional[str] = None):
+    """
+    A decorator that emits latency metrics of a function
+    based on configured metrics config.
+    """
+
+    def _decorate(func):
+        metrics_name = name or f"{func.__name__}_time"
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            start = time.monotonic()
+            try:
+                return func(*args, **kwargs)
+            finally:
+                end = time.monotonic()
+                _emit_ignore_exceptions(name=metrics_name, value=end - start)
+
+        return wrapper
+
+    if original_func:
+        return _decorate(original_func)
+
+    return _decorate
+
+
+def success_metric(original_func=None, name: Optional[str] = None):
+    """
+    A decorator that emits success metrics of a function
+    based on configured metrics config.
+    """
+
+    def _decorate(func):
+        metrics_name = name or f"{func.__name__}_success_count"
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            result = func(*args, **kwargs)
+            _emit_ignore_exceptions(name=metrics_name, value=1)
+            return result
+
+        return wrapper
+
+    if original_func:
+        return _decorate(original_func)
+
+    return _decorate
+
+
+def failure_metric(original_func=None, name: Optional[str] = None):
+    """
+    A decorator that emits failure metrics of a function
+    based on configured metrics config.
+    """
+
+    def _decorate(func):
+        metrics_name = name or f"{func.__name__}_failure_count"
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            try:
+                return func(*args, **kwargs)
+            except BaseException as ex:
+                exception_name = type(ex).__name__
+                # We emit two metrics, one for exception class and
+                # another for just the specified metric name.
+                _emit_ignore_exceptions(
+                    name=f"{metrics_name}.{exception_name}", value=1
+                )
+                _emit_ignore_exceptions(name=metrics_name, value=1)
+                raise ex
+
+        return wrapper
+
+    if original_func:
+        return _decorate(original_func)
+
+    return _decorate
+
+
+def metrics(original_func=None, prefix: Optional[str] = None):
+    """
+    A decorator that emits all metrics for a function.
+    """
+
+    def _decorate(func):
+        name = prefix or func.__name__
+        failure_metrics_name = f"{name}_failure_count"
+        success_metrics_name = f"{name}_success_count"
+        latency_metrics_name = f"{name}_time"
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            start = time.monotonic()
+            try:
+                result = func(*args, **kwargs)
+                _emit_ignore_exceptions(name=success_metrics_name, value=1)
+                return result
+            except BaseException as ex:
+                exception_name = type(ex).__name__
+                _emit_ignore_exceptions(
+                    name=f"{failure_metrics_name}.{exception_name}", value=1
+                )
+                _emit_ignore_exceptions(name=failure_metrics_name, value=1)
+                raise ex
+            finally:
+                end = time.monotonic()
+                _emit_ignore_exceptions(name=latency_metrics_name, value=end - start)
+
+        return wrapper
+
+    if original_func:
+        return _decorate(original_func)
+
+    return _decorate

{deltacat-1.1.1.dist-info → deltacat-1.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deltacat
-Version: 1.1.1
+Version: 1.1.2
 Summary: A scalable, fast, ACID-compliant Data Catalog powered by Ray.
 Home-page: https://github.com/ray-project/deltacat
 Author: Ray Team

{deltacat-1.1.1.dist-info → deltacat-1.1.2.dist-info}/RECORD

@@ -1,11 +1,11 @@
-deltacat/__init__.py,sha256=PeDnE7G_w2Gwkfg1VVp1mGIZm0_-WoyYbu7SlmoCFHs,1777
+deltacat/__init__.py,sha256=1qjk3DyuuYXNfuzWlEqKVNNPDDpBkV8gwsSgJiMCq1s,1777
 deltacat/constants.py,sha256=_6oRI-3yp5c8J1qKGQZrt89I9-ttT_gSSvVsJ0h8Duc,1939
 deltacat/exceptions.py,sha256=xqZf8CwysNYP2d39pf27OnXGStPREgBgIM-e2Tts-TI,199
 deltacat/logs.py,sha256=YT26oj-oKZReyBEhiBQU5jc246aSu_d4B2bZcUVBHmE,6550
 deltacat/aws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/aws/clients.py,sha256=WKgbgaq8CacH81nvvcqrjdshGtYvQicvBeOLg1m7wCA,6501
-deltacat/aws/constants.py,sha256=luXWMO_8eatq8f9NlFjNM7q362j77JwzTM2BEVS_8-8,353
-deltacat/aws/s3u.py,sha256=aK1_pyfipd9Jq1ZiaOC-gszyIIfc1TSbch6YmuZmjt0,23878
+deltacat/aws/clients.py,sha256=VgddlV3AEjlBGIFmhhHxokYzwJ-lXnmHAeprVyADduI,6948
+deltacat/aws/constants.py,sha256=Ti8D92AFY3lY2eoOwYBSI1eqS8gMykX5DHf4w3xPybE,492
+deltacat/aws/s3u.py,sha256=7-ZNz8fui_S5nprxtMO8PGa-G1YOXfidqcguzTTOvL8,24118
 deltacat/aws/redshift/__init__.py,sha256=7SvjG-dqox8zZUhFicTsUvpG5vXYDl_QQ3ohlHOgTKc,342
 deltacat/aws/redshift/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/aws/redshift/model/manifest.py,sha256=ThgpdwzaWz493Zz9e8HSWwuxEheA1nDuypM3pe4vozk,12987
@@ -50,14 +50,14 @@ deltacat/compute/compactor/utils/round_completion_file.py,sha256=DmZfHeAXlQn0DDd
 deltacat/compute/compactor/utils/sort_key.py,sha256=oK6otg-CSsma6zlGPaKg-KNEvcZRG2NqBlCw1X3_FBc,2397
 deltacat/compute/compactor/utils/system_columns.py,sha256=CNIgAGos0xAGEpdaQIH7KfbSRrGZgjRbItXMararqXQ,9399
 deltacat/compute/compactor_v2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/compute/compactor_v2/compaction_session.py,sha256=xAxiTOxHffRvPqkv4ObGM-NWdpxRRMyrS8WWZWrgTFQ,25141
-deltacat/compute/compactor_v2/constants.py,sha256=yZgzFD59wiXbXiTVgYPWRodZGpngiSBNFB2jmoZ4fps,1471
+deltacat/compute/compactor_v2/compaction_session.py,sha256=lXLoOiVjvsG-VEFD9afeKMjcExmOMg9I4-JTrTCVSo4,25576
+deltacat/compute/compactor_v2/constants.py,sha256=R5qvsaX-rDrSmSqUl0yLp6A3hVrAD4whYkV2NBkDR9Y,2199
 deltacat/compute/compactor_v2/deletes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/compute/compactor_v2/deletes/delete_file_envelope.py,sha256=AeuH9JRMwp6mvQf6P2cqL92hUEtResQq6qUTS0kIKac,3111
 deltacat/compute/compactor_v2/deletes/delete_strategy.py,sha256=SMEJOxR-5r92kvKNqtu2w6HmwtmhljcZX1wcNEuS-4w,2833
 deltacat/compute/compactor_v2/deletes/delete_strategy_equality_delete.py,sha256=U4zxVECXSPs1Nj3iPf_tiRRCs12CF8CHmRt4s_GDzq8,6503
 deltacat/compute/compactor_v2/deletes/model.py,sha256=kW7kfRe4jVNMnsWQrl0nyKdDpvB9mbJND-MVzAajbAI,558
-deltacat/compute/compactor_v2/deletes/utils.py,sha256=g63imGECPpPK9eHdde-6qyCg8_RjXCLF2UdfckPk0h4,6468
+deltacat/compute/compactor_v2/deletes/utils.py,sha256=9CchSw1_caWGWtRHa4ycy58t5T422EN6UB9XYa1zpbk,6640
 deltacat/compute/compactor_v2/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/compute/compactor_v2/model/hash_bucket_input.py,sha256=iJy8kLi1dIpFIyfoAjkaAtZvg8Np1z7BsUNGAcWfFm4,3042
 deltacat/compute/compactor_v2/model/hash_bucket_result.py,sha256=EsY9BPPywhmxlcLKn3kGWzAX4s4BTR2vYyPUB-wAEOc,309
@@ -65,14 +65,14 @@ deltacat/compute/compactor_v2/model/merge_file_group.py,sha256=1o86t9lc3K6ZvtViV
 deltacat/compute/compactor_v2/model/merge_input.py,sha256=ITRBR8gMbJpeRkZhRaVzGEEk3F2WqS2LwEkjd5zcaMQ,5416
 deltacat/compute/compactor_v2/model/merge_result.py,sha256=_IZTCStpb4UKiRCJYA3g6EhAqjrw0t9vmoDAN8kIK-Y,436
 deltacat/compute/compactor_v2/steps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deltacat/compute/compactor_v2/steps/hash_bucket.py,sha256=Kuhgh1y12t4V9rP67bdalQF6_sZiobfAK3tvOka8IWA,6324
-deltacat/compute/compactor_v2/steps/merge.py,sha256=dNGE_UtQmptYWj59_XQBoFrB6iNWYE37iup81HqWcAU,21394
+deltacat/compute/compactor_v2/steps/hash_bucket.py,sha256=be61umFucTfzeZ03xii1P_NFqXsGmhl55hm_ULuCFPc,6617
+deltacat/compute/compactor_v2/steps/merge.py,sha256=xjLpv93o9bMjihLXXO1j4XCXhyARc5GQI5eWxQRy0XI,21657
 deltacat/compute/compactor_v2/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/compute/compactor_v2/utils/content_type_params.py,sha256=rNKZisxGrLQOkwX8eHUQiFoTR1V-E66pMqWigtrs618,2156
 deltacat/compute/compactor_v2/utils/dedupe.py,sha256=62tFCY2iRP7I3-45GCIYs6_SJsQl8C5lBEr8gbNfbsw,1932
 deltacat/compute/compactor_v2/utils/delta.py,sha256=8hjkDeIIkSX-gAQ2utQSp2sZcO2tWZHMTxpFusZwBHw,3635
-deltacat/compute/compactor_v2/utils/io.py,sha256=jgIfwrfH2mTFUx1M0TgwZGGfrS4IXjP1PmqwaQmNAJM,5092
-deltacat/compute/compactor_v2/utils/merge.py,sha256=hK4Y7acrtgfvWWTz-fAGznEg6qn6dBYu8blQUQVHhs0,5244
+deltacat/compute/compactor_v2/utils/io.py,sha256=autXlE3uHICdCCuJoS7mfdeJbRRiz2_xlz-3izlccB4,5264
+deltacat/compute/compactor_v2/utils/merge.py,sha256=7p8lEmepxNekFFP5uVxgVLvAQRQnscOmUlSj8kUvW2c,5408
 deltacat/compute/compactor_v2/utils/primary_key_index.py,sha256=MAscmL35WfwN7Is72aFlD_cGhxtZgjRwwR5kS9Yn2uU,11393
 deltacat/compute/compactor_v2/utils/task_options.py,sha256=MCY0Sz5NCgNMaY92W8p87FvvDB91mnPQ4AhL8ix3BiA,13780
 deltacat/compute/merge_on_read/__init__.py,sha256=ckbgngmqPjYBYz_NySsR1vNTOb_hNpeL1sYkZKvBI9M,214
@@ -174,6 +174,7 @@ deltacat/tests/test_utils/utils.py,sha256=a32qEwcSSd1lvRi0aJJ4ZLnc1ZyXmoQF_K95za
 deltacat/tests/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deltacat/tests/utils/test_cloudpickle.py,sha256=J0pnBY3-PxlUh6MamZAN1PuquKQPr2iyzjiJ7-Rcl0o,1506
 deltacat/tests/utils/test_daft.py,sha256=Xal84zR42rXsWQI3lImdDYWOzewomKmhmiUQ59m67V0,6488
+deltacat/tests/utils/test_metrics.py,sha256=kznfueuChhTG3kKnfbVOtxks2uwIWrXlDjY3b2qQaNc,19429
 deltacat/tests/utils/test_pyarrow.py,sha256=eZAuYp9MUf8lmpIilH57JkURuNsTGZ3IAGC4Gm5hdrM,17307
 deltacat/tests/utils/test_record_batch_tables.py,sha256=AkG1WyljQmjnl-AxhbFWyo5LnMIKRyLScfgC2B_ES-s,11321
 deltacat/tests/utils/test_resources.py,sha256=HtpvDrfPZQNtGDXUlsIzc_yd7Vf1cDscZ3YbN0oTvO8,2560
@@ -187,7 +188,7 @@ deltacat/utils/arguments.py,sha256=5y1Xz4HSAD8M8Jt83i6gOEKoYjy_fMQe1V43IhIE4hY,1
 deltacat/utils/cloudpickle.py,sha256=XE7YDmQe56ksfl3NdYZkzOAhbHSuhNcBZGOehQpgZr0,1187
 deltacat/utils/common.py,sha256=RG_-enXNpLKaYrqyx1ne2lL10lxN9vK7F631oJP6SE8,1375
 deltacat/utils/daft.py,sha256=heg6J8NHnTI1UbcjXvsjGBbFKU6f7mvAio-KZuTSuFI,5506
-deltacat/utils/metrics.py,sha256=Ob-RXGoNnfTMRXaNbSHoqW8y-n8KfRA9nLuo9AvsReI,6201
+deltacat/utils/metrics.py,sha256=PZeBV4rhlA_7WjucXDe2DyZj5A8pYCQsYoKDwgyqb7E,9937
 deltacat/utils/numpy.py,sha256=ZiGREobTVT6IZXgPxkSUpLJFN2Hn8KEZcrqybLDXCIA,2027
 deltacat/utils/pandas.py,sha256=GfwjYb8FUSEeoBdXZI1_NJkdjxPMbCCUhlyRfGbDkn8,9562
 deltacat/utils/performance.py,sha256=7ZLaMkS1ehPSIhT5uOQVBHvjC70iKHzoFquFo-KL0PI,645
@@ -202,8 +203,8 @@ deltacat/utils/ray_utils/concurrency.py,sha256=JDVwMiQWrmuSlyCWAoiq9ctoJ0XADEfDD
 deltacat/utils/ray_utils/dataset.py,sha256=SIljK3UkSqQ6Ntit_iSiYt9yYjN_gGrCTX6_72XdQ3w,3244
 deltacat/utils/ray_utils/performance.py,sha256=d7JFM7vTXHzkGx9qNQcZzUWajnqINvYRwaM088_FpsE,464
 deltacat/utils/ray_utils/runtime.py,sha256=5eaBWTDm0IXVoc5Y6aacoVB-f0Mnv-K2ewyTSjHKHwM,5009
-deltacat-1.1.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-deltacat-1.1.1.dist-info/METADATA,sha256=XeXOc863rqN4olrgF3bK3Hm3Cozw7nlshK-hHILg-o4,1780
-deltacat-1.1.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-deltacat-1.1.1.dist-info/top_level.txt,sha256=RWdIcid4Bv2i2ozLVh-70kJpyB61xEKXod9XXGpiono,9
-deltacat-1.1.1.dist-info/RECORD,,
+deltacat-1.1.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+deltacat-1.1.2.dist-info/METADATA,sha256=r16g6Lc01Nlsb0Dr5DPona2hiOsWLIcscEXkQyfpD3o,1780
+deltacat-1.1.2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+deltacat-1.1.2.dist-info/top_level.txt,sha256=RWdIcid4Bv2i2ozLVh-70kJpyB61xEKXod9XXGpiono,9
+deltacat-1.1.2.dist-info/RECORD,,