deltacat 1.1.0__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.0"
+__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/model/compact_partition_params.py

@@ -20,6 +20,7 @@ from deltacat.compute.compactor_v2.constants import (
     AVERAGE_RECORD_SIZE_BYTES,
     TASK_MAX_PARALLELISM,
     DROP_DUPLICATES,
+    TOTAL_MEMORY_BUFFER_PERCENTAGE,
 )
 from deltacat.constants import PYARROW_INFLATION_MULTIPLIER
 from deltacat.compute.compactor.utils.sort_key import validate_sort_keys
@@ -85,12 +86,17 @@ class CompactPartitionParams(dict):
         result.average_record_size_bytes = params.get(
             "average_record_size_bytes", AVERAGE_RECORD_SIZE_BYTES
         )
+        result.total_memory_buffer_percentage = params.get(
+            "total_memory_buffer_percentage", TOTAL_MEMORY_BUFFER_PERCENTAGE
+        )
         result.hash_group_count = params.get(
             "hash_group_count", result.hash_bucket_count
         )
         result.drop_duplicates = params.get("drop_duplicates", DROP_DUPLICATES)
         result.ray_custom_resources = params.get("ray_custom_resources")
 
+        result.memory_logs_enabled = params.get("memory_logs_enabled", False)
+
         result.metrics_config = params.get("metrics_config")
 
         if not importlib.util.find_spec("memray"):
@@ -190,6 +196,16 @@ class CompactPartitionParams(dict):
     def average_record_size_bytes(self, average_record_size_bytes: float) -> None:
         self["average_record_size_bytes"] = average_record_size_bytes
 
+    @property
+    def total_memory_buffer_percentage(self) -> int:
+        return self["total_memory_buffer_percentage"]
+
+    @total_memory_buffer_percentage.setter
+    def total_memory_buffer_percentage(
+        self, total_memory_buffer_percentage: int
+    ) -> None:
+        self["total_memory_buffer_percentage"] = total_memory_buffer_percentage
+
     @property
     def min_files_in_batch(self) -> float:
         return self["min_files_in_batch"]
@@ -355,6 +371,14 @@ class CompactPartitionParams(dict):
     def sort_keys(self, keys: List[SortKey]) -> None:
         self["sort_keys"] = keys
 
+    @property
+    def memory_logs_enabled(self) -> bool:
+        return self.get("memory_logs_enabled")
+
+    @memory_logs_enabled.setter
+    def memory_logs_enabled(self, value: bool) -> None:
+        self["memory_logs_enabled"] = value
+
     @property
     def metrics_config(self) -> Optional[MetricsConfig]:
         return self.get("metrics_config")

deltacat/compute/compactor/model/compaction_session_audit_info.py

@@ -84,6 +84,13 @@ class CompactionSessionAuditInfo(dict):
         """
         return self.get("recordsDeduped")
 
+    @property
+    def records_deleted(self) -> int:
+        """
+        The total count of deleted records in a compaction session if delete deltas are present.
+        """
+        return self.get("recordsDeleted")
+
     @property
     def input_size_bytes(self) -> float:
         """
@@ -461,6 +468,10 @@ class CompactionSessionAuditInfo(dict):
         self["recordsDeduped"] = records_deduped
         return self
 
+    def set_records_deleted(self, records_deleted: int) -> CompactionSessionAuditInfo:
+        self["recordsDeleted"] = records_deleted
+        return self
+
     def set_input_size_bytes(
         self, input_size_bytes: float
     ) -> CompactionSessionAuditInfo:

deltacat/compute/compactor_v2/compaction_session.py

@@ -62,8 +62,10 @@ from deltacat.utils.resources import (
 from deltacat.compute.compactor_v2.utils.task_options import (
     hash_bucket_resource_options_provider,
     merge_resource_options_provider,
+    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
@@ -117,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
     )
@@ -258,8 +269,10 @@ def _execute_compaction(
         resource_amount_provider=hash_bucket_resource_options_provider,
         previous_inflation=params.previous_inflation,
         average_record_size_bytes=params.average_record_size_bytes,
+        total_memory_buffer_percentage=params.total_memory_buffer_percentage,
         primary_keys=params.primary_keys,
         ray_custom_resources=params.ray_custom_resources,
+        memory_logs_enabled=params.memory_logs_enabled,
     )
 
     total_input_records_count = np.int64(0)
@@ -275,7 +288,29 @@ def _execute_compaction(
             delete_strategy,
             delete_file_envelopes,
         )
-        local_merge_result = ray.get(mg.merge.remote(local_merge_input))
+        estimated_da_bytes = (
+            compaction_audit.estimated_in_memory_size_bytes_during_discovery
+        )
+        estimated_num_records = sum(
+            [
+                entry.meta.record_count
+                for delta in uniform_deltas
+                for entry in delta.manifest.entries
+            ]
+        )
+        local_merge_options = local_merge_resource_options_provider(
+            estimated_da_size=estimated_da_bytes,
+            estimated_num_rows=estimated_num_records,
+            total_memory_buffer_percentage=params.total_memory_buffer_percentage,
+            round_completion_info=round_completion_info,
+            compacted_delta_manifest=previous_compacted_delta_manifest,
+            ray_custom_resources=params.ray_custom_resources,
+            primary_keys=params.primary_keys,
+            memory_logs_enabled=params.memory_logs_enabled,
+        )
+        local_merge_result = ray.get(
+            mg.merge.options(**local_merge_options).remote(local_merge_input)
+        )
         total_input_records_count += local_merge_result.input_record_count
         merge_results = [local_merge_result]
         merge_invoke_end = time.monotonic()
@@ -296,6 +331,7 @@ def _execute_compaction(
                     object_store=params.object_store,
                     deltacat_storage=params.deltacat_storage,
                     deltacat_storage_kwargs=params.deltacat_storage_kwargs,
+                    memory_logs_enabled=params.memory_logs_enabled,
                 )
             }
 
@@ -382,12 +418,14 @@ def _execute_compaction(
             num_hash_groups=params.hash_group_count,
             hash_group_size_bytes=all_hash_group_idx_to_size_bytes,
             hash_group_num_rows=all_hash_group_idx_to_num_rows,
+            total_memory_buffer_percentage=params.total_memory_buffer_percentage,
             round_completion_info=round_completion_info,
             compacted_delta_manifest=previous_compacted_delta_manifest,
             primary_keys=params.primary_keys,
             deltacat_storage=params.deltacat_storage,
             deltacat_storage_kwargs=params.deltacat_storage_kwargs,
             ray_custom_resources=params.ray_custom_resources,
+            memory_logs_enabled=params.memory_logs_enabled,
         )
 
         def merge_input_provider(index, item):
@@ -417,6 +455,7 @@ def _execute_compaction(
                     deltacat_storage_kwargs=params.deltacat_storage_kwargs,
                     delete_strategy=delete_strategy,
                     delete_file_envelopes=delete_file_envelopes,
+                    memory_logs_enabled=params.memory_logs_enabled,
                 )
             }
 
@@ -438,11 +477,11 @@ def _execute_compaction(
     merge_end = time.monotonic()
 
     total_dd_record_count = sum([ddr.deduped_record_count for ddr in merge_results])
-    total_dropped_record_count = sum(
+    total_deleted_record_count = sum(
         [ddr.deleted_record_count for ddr in merge_results]
     )
     logger.info(
-        f"Deduped {total_dd_record_count} records and dropped {total_dropped_record_count} records..."
+        f"Deduped {total_dd_record_count} records and deleted {total_deleted_record_count} records..."
     )
 
     compaction_audit.set_input_records(total_input_records_count.item())
@@ -456,7 +495,7 @@ def _execute_compaction(
     )
 
     compaction_audit.set_records_deduped(total_dd_record_count.item())
-
+    compaction_audit.set_records_deleted(total_deleted_record_count.item())
     mat_results = []
     for merge_result in merge_results:
         mat_results.extend(merge_result.materialize_results)
@@ -503,7 +542,7 @@ def _execute_compaction(
     record_info_msg = (
         f"Hash bucket records: {total_hb_record_count},"
         f" Deduped records: {total_dd_record_count}, "
-        f" Dropped records: {total_dropped_record_count}, "
+        f" Deleted records: {total_deleted_record_count}, "
         f" Materialized records: {merged_delta.meta.record_count}"
     )
     logger.info(record_info_msg)
@@ -603,7 +642,6 @@ def _execute_compaction(
         f"partition-{params.source_partition_locator.partition_values},"
         f"compacted at: {params.last_stream_position_to_compact},"
     )
-
     return (
         compacted_partition,
         new_round_completion_info,

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/model/hash_bucket_input.py

@@ -22,6 +22,7 @@ class HashBucketInput(Dict):
         object_store: Optional[IObjectStore] = None,
         deltacat_storage=unimplemented_deltacat_storage,
         deltacat_storage_kwargs: Optional[Dict[str, Any]] = None,
+        memory_logs_enabled: Optional[bool] = None,
     ) -> HashBucketInput:
 
         result = HashBucketInput()
@@ -36,6 +37,7 @@ class HashBucketInput(Dict):
         result["object_store"] = object_store
         result["deltacat_storage"] = deltacat_storage
         result["deltacat_storage_kwargs"] = deltacat_storage_kwargs or {}
+        result["memory_logs_enabled"] = memory_logs_enabled
 
         return result
 
@@ -82,3 +84,7 @@ class HashBucketInput(Dict):
     @property
     def deltacat_storage_kwargs(self) -> Optional[Dict[str, Any]]:
         return self.get("deltacat_storage_kwargs")
+
+    @property
+    def memory_logs_enabled(self) -> Optional[bool]:
+        return self.get("memory_logs_enabled")

deltacat/compute/compactor_v2/model/merge_input.py

@@ -46,6 +46,7 @@ class MergeInput(Dict):
         delete_file_envelopes: Optional[List] = None,
         deltacat_storage=unimplemented_deltacat_storage,
         deltacat_storage_kwargs: Optional[Dict[str, Any]] = None,
+        memory_logs_enabled: Optional[bool] = None,
     ) -> MergeInput:
 
         result = MergeInput()
@@ -67,6 +68,7 @@ class MergeInput(Dict):
         result["delete_strategy"] = delete_strategy
         result["deltacat_storage"] = deltacat_storage
         result["deltacat_storage_kwargs"] = deltacat_storage_kwargs or {}
+        result["memory_logs_enabled"] = memory_logs_enabled
         return result
 
     @property
@@ -133,6 +135,10 @@ class MergeInput(Dict):
     def deltacat_storage_kwargs(self) -> Optional[Dict[str, Any]]:
         return self.get("deltacat_storage_kwargs")
 
+    @property
+    def memory_logs_enabled(self) -> Optional[bool]:
+        return self.get("memory_logs_enabled")
+
     @property
     def delete_file_envelopes(
         self,

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()
@@ -142,7 +149,8 @@ def hash_bucket(input: HashBucketInput) -> HashBucketResult:
                 f"({process_util.max_memory/BYTES_PER_GIBIBYTE} GB)"
             )
 
-        process_util.schedule_callback(log_peak_memory, 10)
+        if input.memory_logs_enabled:
+            process_util.schedule_callback(log_peak_memory, 10)
 
         hash_bucket_result, duration = timed_invocation(
             func=_timed_hash_bucket, input=input
@@ -152,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

@@ -12,6 +12,7 @@ from uuid import uuid4
 from deltacat import logs
 from typing import Callable, Iterator, List, Optional, Tuple
 from deltacat.compute.compactor_v2.model.merge_result import MergeResult
+from deltacat.compute.compactor_v2.model.merge_file_group import MergeFileGroup
 from deltacat.compute.compactor.model.materialize_result import MaterializeResult
 from deltacat.compute.compactor.model.pyarrow_write_result import PyArrowWriteResult
 from deltacat.compute.compactor import RoundCompletionInfo, DeltaFileEnvelope
@@ -23,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,
@@ -41,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"):
@@ -269,6 +275,24 @@ def _has_previous_compacted_table(input: MergeInput, hb_idx: int) -> bool:
     )
 
 
+def _can_copy_by_reference(
+    has_delete: bool, merge_file_group: MergeFileGroup, input: MergeInput
+) -> bool:
+    """
+    Can copy by reference only if there are no deletes to merge in
+    and previous compacted stream id matches that of new stream
+    """
+    return (
+        not has_delete
+        and not merge_file_group.dfe_groups
+        and input.round_completion_info is not None
+        and (
+            input.write_to_partition.stream_id
+            == input.round_completion_info.compacted_delta_locator.stream_id
+        )
+    )
+
+
 def _flatten_dfe_list(
     df_envelopes_list: List[List[DeltaFileEnvelope]],
 ) -> List[DeltaFileEnvelope]:
@@ -349,7 +373,7 @@ def _compact_tables(
             1. The compacted PyArrow table.
             2. The total number of records in the incremental data.
             3. The total number of deduplicated records.
-            4. The total number of dropped records due to DELETE operations.
+            4. The total number of deleted records due to DELETE operations.
     """
     df_envelopes: List[DeltaFileEnvelope] = _flatten_dfe_list(dfe_list)
     delete_file_envelopes = input.delete_file_envelopes or []
@@ -460,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()
@@ -479,10 +505,12 @@ def _timed_merge(input: MergeInput) -> MergeResult:
                 assert (
                     input.delete_strategy is not None
                 ), "Merge input missing delete_strategy"
-            if not has_delete and not merge_file_group.dfe_groups:
-                # Can copy by reference only if there are no deletes to merge in
+            if _can_copy_by_reference(
+                has_delete=has_delete, merge_file_group=merge_file_group, input=input
+            ):
                 hb_index_copy_by_ref_ids.append(merge_file_group.hb_index)
                 continue
+
             if _has_previous_compacted_table(input, merge_file_group.hb_index):
                 compacted_table = _download_compacted_table(
                     hb_index=merge_file_group.hb_index,
@@ -548,7 +576,8 @@ def merge(input: MergeInput) -> MergeResult:
                 f"({process_util.max_memory/BYTES_PER_GIBIBYTE} GB)"
             )
 
-        process_util.schedule_callback(log_peak_memory, 10)
+        if input.memory_logs_enabled:
+            process_util.schedule_callback(log_peak_memory, 10)
 
         merge_result, duration = timed_invocation(func=_timed_merge, input=input)
 
@@ -556,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,