openmetadata-ingestion 1.8.0.0__py3-none-any.whl → 1.8.2.0__py3-none-any.whl

metadata/ingestion/source/database/unitycatalog/metadata.py

@@ -559,17 +559,18 @@ class UnitycatalogSource(
             ).connect() as connection:
                 for query, tag_fqn_builder in query_tag_fqn_builder_mapping:
                     for tag in connection.execute(query):
-                        yield from get_ometa_tag_and_classification(
-                            tag_fqn=FullyQualifiedEntityName(
-                                fqn._build(*tag_fqn_builder(tag))
-                            ),  # pylint: disable=protected-access
-                            tags=[tag.tag_value],
-                            classification_name=tag.tag_name,
-                            tag_description=UNITY_CATALOG_TAG,
-                            classification_description=UNITY_CATALOG_TAG_CLASSIFICATION,
-                            metadata=self.metadata,
-                            system_tags=True,
-                        )
+                        if tag.tag_value:
+                            yield from get_ometa_tag_and_classification(
+                                tag_fqn=FullyQualifiedEntityName(
+                                    fqn._build(*tag_fqn_builder(tag))
+                                ),  # pylint: disable=protected-access
+                                tags=[tag.tag_value],
+                                classification_name=tag.tag_name,
+                                tag_description=UNITY_CATALOG_TAG,
+                                classification_description=UNITY_CATALOG_TAG_CLASSIFICATION,
+                                metadata=self.metadata,
+                                system_tags=True,
+                            )
         except Exception as exc:
             logger.debug(traceback.format_exc())
             logger.warning(
@@ -612,17 +613,18 @@ class UnitycatalogSource(
             ).connect() as connection:
                 for query, tag_fqn_builder in query_tag_fqn_builder_mapping:
                     for tag in connection.execute(query):
-                        yield from get_ometa_tag_and_classification(
-                            tag_fqn=FullyQualifiedEntityName(
-                                fqn._build(*tag_fqn_builder(tag))
-                            ),  # pylint: disable=protected-access
-                            tags=[tag.tag_value],
-                            classification_name=tag.tag_name,
-                            tag_description=UNITY_CATALOG_TAG,
-                            classification_description=UNITY_CATALOG_TAG_CLASSIFICATION,
-                            metadata=self.metadata,
-                            system_tags=True,
-                        )
+                        if tag.tag_value:
+                            yield from get_ometa_tag_and_classification(
+                                tag_fqn=FullyQualifiedEntityName(
+                                    fqn._build(*tag_fqn_builder(tag))
+                                ),  # pylint: disable=protected-access
+                                tags=[tag.tag_value],
+                                classification_name=tag.tag_name,
+                                tag_description=UNITY_CATALOG_TAG,
+                                classification_description=UNITY_CATALOG_TAG_CLASSIFICATION,
+                                metadata=self.metadata,
+                                system_tags=True,
+                            )
         except Exception as exc:
             logger.debug(traceback.format_exc())
             logger.warning(f"Error getting tags for schema {schema_name}: {exc}")

metadata/ingestion/source/metadata/amundsen/metadata.py

@@ -147,18 +147,18 @@ class AmundsenSource(Source):
     def _iter(self, *_, **__) -> Iterable[Either[Entity]]:
         table_entities = self.client.execute_query(NEO4J_AMUNDSEN_TABLE_QUERY)
         for table in table_entities:
-            yield from Either(right=self.create_table_entity(table))
+            yield from self.create_table_entity(table)
 
         user_entities = self.client.execute_query(NEO4J_AMUNDSEN_USER_QUERY)
         for user in user_entities:
-            yield from Either(right=self.create_user_entity(user))
-            yield from Either(right=self.add_owner_to_entity(user))
+            yield from self.create_user_entity(user)
+            yield from self.add_owner_to_entity(user)
 
         dashboard_entities = self.client.execute_query(NEO4J_AMUNDSEN_DASHBOARD_QUERY)
         for dashboard in dashboard_entities:
-            yield from Either(right=self.create_dashboard_service(dashboard))
-            yield from Either(right=self.create_chart_entity(dashboard))
-            yield from Either(right=self.create_dashboard_entity(dashboard))
+            yield from self.create_dashboard_service(dashboard)
+            yield from self.create_chart_entity(dashboard)
+            yield from self.create_dashboard_entity(dashboard)
 
     def create_user_entity(self, user) -> Iterable[Either[OMetaUserProfile]]:
         try:

metadata/ingestion/source/pipeline/databrickspipeline/connection.py

@@ -24,17 +24,38 @@ from metadata.generated.schema.entity.services.connections.pipeline.databricksPi
 from metadata.generated.schema.entity.services.connections.testConnectionResult import (
     TestConnectionResult,
 )
+from metadata.ingestion.connections.builders import (
+    create_generic_db_connection,
+    get_connection_args_common,
+    init_empty_connection_arguments,
+)
 from metadata.ingestion.connections.test_connections import test_connection_steps
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.source.database.databricks.client import DatabricksClient
 from metadata.utils.constants import THREE_MIN
 
 
+def get_connection_url(connection: DatabricksPipelineConnection) -> str:
+    url = f"databricks+connector://token:{connection.token.get_secret_value()}@{connection.hostPort}"
+    return url
+
+
 def get_connection(connection: DatabricksPipelineConnection) -> DatabricksClient:
     """
     Create connection
     """
-    return DatabricksClient(connection)
+
+    if connection.httpPath:
+        if not connection.connectionArguments:
+            connection.connectionArguments = init_empty_connection_arguments()
+        connection.connectionArguments.root["http_path"] = connection.httpPath
+
+    engine = create_generic_db_connection(
+        connection=connection,
+        get_connection_url_fn=get_connection_url,
+        get_connection_args_fn=get_connection_args_common,
+    )
+    return DatabricksClient(connection, engine)
 
 
 def test_connection(
@@ -49,7 +70,10 @@ def test_connection(
     of a metadata workflow or during an Automation Workflow
     """
 
-    test_fn = {"GetPipelines": client.list_jobs_test_connection}
+    test_fn = {
+        "GetPipelines": client.list_jobs_test_connection,
+        "GetLineage": client.test_lineage_query,
+    }
 
     return test_connection_steps(
         metadata=metadata,

metadata/ingestion/source/pipeline/databrickspipeline/metadata.py

@@ -14,7 +14,7 @@ Databricks pipeline source to extract metadata
 """
 
 import traceback
-from typing import Iterable, List, Optional
+from typing import Iterable, List, Optional, Tuple
 
 from pydantic import ValidationError
 
@@ -27,6 +27,7 @@ from metadata.generated.schema.entity.data.pipeline import (
     Task,
     TaskStatus,
 )
+from metadata.generated.schema.entity.data.table import Table
 from metadata.generated.schema.entity.services.connections.pipeline.databricksPipelineConnection import (
     DatabricksPipelineConnection,
 )
@@ -43,8 +44,16 @@ from metadata.generated.schema.type.basic import (
     SourceUrl,
     Timestamp,
 )
+from metadata.generated.schema.type.entityLineage import (
+    ColumnLineage,
+    EntitiesEdge,
+    LineageDetails,
+)
+from metadata.generated.schema.type.entityLineage import Source as LineageSource
+from metadata.generated.schema.type.entityReference import EntityReference
 from metadata.ingestion.api.models import Either
 from metadata.ingestion.api.steps import InvalidSourceException
+from metadata.ingestion.lineage.sql_lineage import get_column_fqn
 from metadata.ingestion.models.pipeline_status import OMetaPipelineStatus
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.source.pipeline.databrickspipeline.models import (
@@ -54,7 +63,6 @@ from metadata.ingestion.source.pipeline.databrickspipeline.models import (
 from metadata.ingestion.source.pipeline.pipeline_service import PipelineServiceSource
 from metadata.utils import fqn
 from metadata.utils.logger import ingestion_logger
-from metadata.utils.time_utils import convert_timestamp_to_milliseconds
 
 logger = ingestion_logger()
 
@@ -200,21 +208,15 @@ class DatabrickspipelineSource(PipelineServiceSource):
                         executionStatus=STATUS_MAP.get(
                             run.state.result_state, StatusType.Failed
                         ),
-                        startTime=Timestamp(
-                            convert_timestamp_to_milliseconds(run.start_time)
-                        ),
-                        endTime=Timestamp(
-                            convert_timestamp_to_milliseconds(run.end_time)
-                        ),
+                        startTime=Timestamp(run.start_time),
+                        endTime=Timestamp(run.end_time) if run.end_time else None,
                         logLink=run.run_page_url,
                     )
                     for task in run.tasks or []
                 ]
                 pipeline_status = PipelineStatus(
                     taskStatus=task_status,
-                    timestamp=Timestamp(
-                        convert_timestamp_to_milliseconds(run.start_time)
-                    ),
+                    timestamp=Timestamp(run.start_time),
                     executionStatus=STATUS_MAP.get(
                         run.state.result_state,
                         StatusType.Failed,
@@ -235,13 +237,173 @@ class DatabrickspipelineSource(PipelineServiceSource):
         except Exception as exc:
             yield Either(
                 left=StackTraceError(
-                    name=pipeline_fqn,
+                    name=pipeline_details.job_id,
                     error=f"Failed to yield pipeline status: {exc}",
                     stackTrace=traceback.format_exc(),
                 )
             )
 
+    def _process_and_validate_column_lineage(
+        self,
+        column_lineage: List[Tuple[str, str]],
+        from_entity: Table,
+        to_entity: Table,
+    ) -> List[ColumnLineage]:
+        """
+        Process and validate column lineage
+        """
+        processed_column_lineage = []
+        if column_lineage:
+            for column_tuple in column_lineage or []:
+                try:
+                    if len(column_tuple) < 2:
+                        logger.debug(f"Skipping invalid column tuple: {column_tuple}")
+                        continue
+
+                    source_col = column_tuple[0]
+                    target_col = column_tuple[-1]
+
+                    if not source_col or not target_col:
+                        logger.debug(
+                            f"Skipping column tuple with empty values: source={source_col}, "
+                            f"target={target_col}, to_entity={to_entity.name}"
+                        )
+                        continue
+
+                    from_column = get_column_fqn(
+                        table_entity=from_entity, column=str(source_col)
+                    )
+                    to_column = get_column_fqn(
+                        table_entity=to_entity,
+                        column=str(target_col),
+                    )
+                    if from_column and to_column:
+                        processed_column_lineage.append(
+                            ColumnLineage(
+                                fromColumns=[from_column],
+                                toColumn=to_column,
+                            )
+                        )
+                except Exception as err:
+                    logger.warning(
+                        f"Error processing column lineage {column_tuple}: {err}"
+                    )
+                    logger.debug(traceback.format_exc())
+                    continue
+        if not processed_column_lineage:
+            logger.warning(
+                f"No column lineage found for {from_entity.name} to {to_entity.name}"
+            )
+        return processed_column_lineage or []
+
     def yield_pipeline_lineage_details(
         self, pipeline_details: DataBrickPipelineDetails
     ) -> Iterable[Either[AddLineageRequest]]:
-        """Get lineage between pipeline and data sources. Not Implemented."""
+        try:
+            pipeline_fqn = fqn.build(
+                metadata=self.metadata,
+                entity_type=Pipeline,
+                service_name=self.context.get().pipeline_service,
+                pipeline_name=self.context.get().pipeline,
+            )
+
+            pipeline_entity = self.metadata.get_by_name(
+                entity=Pipeline, fqn=pipeline_fqn
+            )
+
+            table_lineage_list = self.client.get_table_lineage(
+                job_id=pipeline_details.job_id
+            )
+            if table_lineage_list:
+                for table_lineage in table_lineage_list:
+                    source_table_full_name = table_lineage.get("source_table_full_name")
+                    target_table_full_name = table_lineage.get("target_table_full_name")
+                    if source_table_full_name and target_table_full_name:
+                        source = fqn.split_table_name(source_table_full_name)
+                        target = fqn.split_table_name(target_table_full_name)
+                        for dbservicename in self.get_db_service_names() or ["*"]:
+
+                            from_entity = self.metadata.get_by_name(
+                                entity=Table,
+                                fqn=fqn.build(
+                                    metadata=self.metadata,
+                                    entity_type=Table,
+                                    table_name=source.get("table"),
+                                    database_name=source.get("database"),
+                                    schema_name=source.get("database_schema"),
+                                    service_name=dbservicename,
+                                ),
+                            )
+
+                            if from_entity is None:
+                                continue
+
+                            to_entity = self.metadata.get_by_name(
+                                entity=Table,
+                                fqn=fqn.build(
+                                    metadata=self.metadata,
+                                    entity_type=Table,
+                                    table_name=target.get("table"),
+                                    database_name=target.get("database"),
+                                    schema_name=target.get("database_schema"),
+                                    service_name=dbservicename,
+                                ),
+                            )
+
+                            if to_entity is None:
+                                continue
+
+                            processed_column_lineage = (
+                                self._process_and_validate_column_lineage(
+                                    column_lineage=self.client.get_column_lineage(
+                                        job_id=pipeline_details.job_id,
+                                        TableKey=(
+                                            source_table_full_name,
+                                            target_table_full_name,
+                                        ),
+                                    ),
+                                    from_entity=from_entity,
+                                    to_entity=to_entity,
+                                )
+                            )
+
+                            lineage_details = LineageDetails(
+                                pipeline=EntityReference(
+                                    id=pipeline_entity.id.root, type="pipeline"
+                                ),
+                                source=LineageSource.PipelineLineage,
+                                columnsLineage=processed_column_lineage,
+                            )
+
+                            yield Either(
+                                right=AddLineageRequest(
+                                    edge=EntitiesEdge(
+                                        fromEntity=EntityReference(
+                                            id=from_entity.id,
+                                            type="table",
+                                        ),
+                                        toEntity=EntityReference(
+                                            id=to_entity.id,
+                                            type="table",
+                                        ),
+                                        lineageDetails=lineage_details,
+                                    )
+                                )
+                            )
+
+                else:
+                    logger.debug(
+                        f"No source or target table full name found for job {pipeline_details.job_id}"
+                    )
+            else:
+                logger.debug(
+                    f"No table lineage found for job {pipeline_details.job_id}"
+                )
+        except Exception as exc:
+            yield Either(
+                left=StackTraceError(
+                    name=pipeline_details.job_id,
+                    error=f"Wild error ingesting pipeline lineage {pipeline_details} - {exc}",
+                    stackTrace=traceback.format_exc(),
+                )
+            )

metadata/pii/algorithms/classifiers.py

@@ -103,7 +103,6 @@ class HeuristicPIIClassifier(ColumnClassifier[PIITag]):
         column_name: Optional[str] = None,
         column_data_type: Optional[DataType] = None,
     ) -> Mapping[PIITag, float]:
-
         if column_data_type is not None and is_non_pii_datatype(column_data_type):
             return {}
 

metadata/pii/algorithms/presidio_patches.py

@@ -16,6 +16,10 @@ from typing import List, Protocol, Sequence
 from dateutil.parser import parse
 from presidio_analyzer import RecognizerResult
 
+from metadata.utils.logger import pii_logger
+
+logger = pii_logger()
+
 
 class PresidioRecognizerResultPatcher(Protocol):
     """
@@ -76,8 +80,11 @@ def date_time_patcher(
             # try to parse using dateutils, if it fails, skip the result
             try:
                 _ = parse(text[result.start : result.end])
-            except ValueError:
+            except (ValueError, OverflowError):
                 # if parsing fails, skip the result
                 continue
+            except Exception as e:
+                logger.info("Unexpected error while parsing date time: %s", e)
+                continue
         patched_result.append(result)
     return patched_result

metadata/profiler/interface/sqlalchemy/bigquery/profiler_interface.py

@@ -13,16 +13,45 @@
 Interfaces with database for all database engine
 supporting sqlalchemy abstraction layer
 """
+from typing import List, Type, cast
+
 from sqlalchemy import Column, inspect
 
+from metadata.generated.schema.entity.data.table import SystemProfile
 from metadata.profiler.interface.sqlalchemy.profiler_interface import (
     SQAProfilerInterface,
 )
+from metadata.profiler.metrics.system.bigquery.system import (
+    BigQuerySystemMetricsComputer,
+)
+from metadata.profiler.metrics.system.system import System
+from metadata.profiler.processor.runner import QueryRunner
+from metadata.utils.logger import profiler_interface_registry_logger
+
+logger = profiler_interface_registry_logger()
 
 
 class BigQueryProfilerInterface(SQAProfilerInterface):
     """BigQuery profiler interface"""
 
+    def _compute_system_metrics(
+        self,
+        metrics: Type[System],
+        runner: QueryRunner,
+        *args,
+        **kwargs,
+    ) -> List[SystemProfile]:
+        logger.debug(f"Computing {metrics.name()} metric for {runner.table_name}")
+        self.system_metrics_class = cast(
+            Type[BigQuerySystemMetricsComputer], self.system_metrics_class
+        )
+        instance = self.system_metrics_class(
+            session=self.session,
+            runner=runner,
+            usage_location=self.service_connection_config.usageLocation,
+        )
+        return instance.get_system_metrics()
+
     def _get_struct_columns(self, columns: dict, parent: str):
         """"""
         # pylint: disable=import-outside-toplevel

metadata/profiler/interface/sqlalchemy/databricks/profiler_interface.py

@@ -13,25 +13,55 @@
 Interfaces with database for all database engine
 supporting sqlalchemy abstraction layer
 """
-from typing import List
+from typing import List, Type, cast
 
 from pyhive.sqlalchemy_hive import HiveCompiler
 from sqlalchemy import Column
 
 from metadata.generated.schema.entity.data.table import Column as OMColumn
-from metadata.generated.schema.entity.data.table import ColumnName, DataType
+from metadata.generated.schema.entity.data.table import (
+    ColumnName,
+    DataType,
+    SystemProfile,
+)
 from metadata.generated.schema.entity.services.databaseService import (
     DatabaseServiceType,
 )
 from metadata.profiler.interface.sqlalchemy.profiler_interface import (
     SQAProfilerInterface,
 )
+from metadata.profiler.metrics.system.databricks.system import (
+    DatabricksSystemMetricsComputer,
+)
+from metadata.profiler.metrics.system.system import System
 from metadata.profiler.orm.converter.base import build_orm_col
+from metadata.profiler.processor.runner import QueryRunner
+from metadata.utils.logger import profiler_interface_registry_logger
+
+logger = profiler_interface_registry_logger()
 
 
 class DatabricksProfilerInterface(SQAProfilerInterface):
     """Databricks profiler interface"""
 
+    def _compute_system_metrics(
+        self,
+        metrics: Type[System],
+        runner: QueryRunner,
+        *args,
+        **kwargs,
+    ) -> List[SystemProfile]:
+        logger.debug(f"Computing {metrics.name()} metric for {runner.table_name}")
+        self.system_metrics_class = cast(
+            Type[DatabricksSystemMetricsComputer], self.system_metrics_class
+        )
+        instance = self.system_metrics_class(
+            session=self.session,
+            runner=runner,
+            catalog=self.service_connection_config.catalog,
+        )
+        return instance.get_system_metrics()
+
     def visit_column(self, *args, **kwargs):
         result = super(  # pylint: disable=bad-super-call
             HiveCompiler, self

metadata/profiler/interface/sqlalchemy/profiler_interface.py

@@ -26,7 +26,7 @@ from typing import Any, Dict, List, Optional, Type, Union
 
 from sqlalchemy import Column, inspect, text
 from sqlalchemy.exc import DBAPIError, ProgrammingError, ResourceClosedError
-from sqlalchemy.orm import scoped_session
+from sqlalchemy.orm import Session, scoped_session
 
 from metadata.generated.schema.entity.data.table import (
     CustomMetricProfile,
@@ -51,7 +51,7 @@ from metadata.profiler.metrics.registry import Metrics
 from metadata.profiler.metrics.static.mean import Mean
 from metadata.profiler.metrics.static.stddev import StdDev
 from metadata.profiler.metrics.static.sum import Sum
-from metadata.profiler.metrics.system.system import System, SystemMetricsComputer
+from metadata.profiler.metrics.system.system import System, SystemMetricsRegistry
 from metadata.profiler.orm.functions.table_metric_computer import TableMetricComputer
 from metadata.profiler.orm.registry import Dialects
 from metadata.profiler.processor.metric_filter import MetricFilter
@@ -111,13 +111,9 @@ class SQAProfilerInterface(ProfilerInterface, SQAInterfaceMixin):
 
         self._table = self.sampler.raw_dataset
         self.create_session()
-        self.system_metrics_computer = self.initialize_system_metrics_computer()
-
-    def initialize_system_metrics_computer(self) -> SystemMetricsComputer:
-        """Initialize system metrics computer. Override this if you want to use a metric source with
-        state or other dependencies.
-        """
-        return SystemMetricsComputer()
+        self.system_metrics_class = SystemMetricsRegistry.get(
+            self.session.get_bind().dialect
+        )
 
     def create_session(self):
         self.session_factory = self._session_factory()
@@ -362,7 +358,8 @@ class SQAProfilerInterface(ProfilerInterface, SQAInterfaceMixin):
         *args,
         **kwargs,
     ) -> List[SystemProfile]:
-        """Get system metric for tables
+        """Get system metric for tables. Override this in the interface if you want to use a metric source with
+        for other sources.
 
         Args:
             metric_type: type of metric
@@ -372,8 +369,10 @@ class SQAProfilerInterface(ProfilerInterface, SQAInterfaceMixin):
         Returns:
             dictionnary of results
         """
-        logger.debug(f"Computing system metrics for {runner.table_name}")
-        return self.system_metrics_computer.get_system_metrics(runner=runner)
+        logger.debug(
+            f"No implementation found for {self.session.get_bind().dialect.name} for {metrics.name()} metric"
+        )
+        return []
 
     def _create_thread_safe_runner(self, session, column=None):
         """Create thread safe runner"""

metadata/profiler/interface/sqlalchemy/redshift/profiler_interface.py

@@ -0,0 +1,50 @@
+#  Copyright 2025 Collate
+#  Licensed under the Collate Community License, Version 1.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  https://github.com/open-metadata/OpenMetadata/blob/main/ingestion/LICENSE
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""
+Interfaces with database for all database engine
+supporting sqlalchemy abstraction layer
+"""
+from typing import List, Type, cast
+
+from metadata.generated.schema.entity.data.table import SystemProfile
+from metadata.profiler.interface.sqlalchemy.profiler_interface import (
+    SQAProfilerInterface,
+)
+from metadata.profiler.metrics.system.redshift.system import (
+    RedshiftSystemMetricsComputer,
+)
+from metadata.profiler.metrics.system.system import System
+from metadata.profiler.processor.runner import QueryRunner
+from metadata.utils.logger import profiler_interface_registry_logger
+
+logger = profiler_interface_registry_logger()
+
+
+class RedshiftProfilerInterface(SQAProfilerInterface):
+    """Redshift profiler interface"""
+
+    def _compute_system_metrics(
+        self,
+        metrics: Type[System],
+        runner: QueryRunner,
+        *args,
+        **kwargs,
+    ) -> List[SystemProfile]:
+        logger.debug(f"Computing {metrics.name()} metric for {runner.table_name}")
+        self.system_metrics_class = cast(
+            Type[RedshiftSystemMetricsComputer], self.system_metrics_class
+        )
+        instance = self.system_metrics_class(
+            session=self.session,
+            runner=runner,
+        )
+        return instance.get_system_metrics()

metadata/profiler/interface/sqlalchemy/snowflake/profiler_interface.py

@@ -14,10 +14,18 @@ Interfaces with database for all database engine
 supporting sqlalchemy abstraction layer
 """
 
+from typing import List, Type, cast
+
+from metadata.generated.schema.entity.data.table import SystemProfile
 from metadata.profiler.interface.sqlalchemy.profiler_interface import (
     OVERFLOW_ERROR_CODES,
     SQAProfilerInterface,
 )
+from metadata.profiler.metrics.system.snowflake.system import (
+    SnowflakeSystemMetricsComputer,
+)
+from metadata.profiler.metrics.system.system import System
+from metadata.profiler.processor.runner import QueryRunner
 from metadata.utils.logger import profiler_interface_registry_logger
 
 logger = profiler_interface_registry_logger()
@@ -36,6 +44,18 @@ class SnowflakeProfilerInterface(SQAProfilerInterface):
         super().create_session()
         self.set_session_tag(self.session)
 
+    def _compute_system_metrics(
+        self, metrics: Type[System], runner: QueryRunner, *args, **kwargs
+    ) -> List[SystemProfile]:
+        self.system_metrics_class = cast(
+            Type[SnowflakeSystemMetricsComputer], self.system_metrics_class
+        )
+        instance = self.system_metrics_class(
+            session=self.session,
+            runner=runner,
+        )
+        return instance.get_system_metrics()
+
     def _programming_error_static_metric(self, runner, column, exc, session, metrics):
         if exc.orig and exc.orig.errno in OVERFLOW_ERROR_CODES.get(
             session.bind.dialect.name