openmetadata-ingestion 1.9.11.3__py3-none-any.whl → 1.9.13.0__py3-none-any.whl

metadata/ingestion/source/database/snowflake/metadata.py

@@ -20,6 +20,7 @@ import sqlalchemy.types as sqltypes
 import sqlparse
 from snowflake.sqlalchemy.custom_types import VARIANT, StructuredType
 from snowflake.sqlalchemy.snowdialect import SnowflakeDialect, ischema_names
+from sqlalchemy import exc as sa_exc
 from sqlalchemy.engine.reflection import Inspector
 from sqlparse.sql import Function, Identifier, Token
 
@@ -74,8 +75,10 @@ from metadata.ingestion.source.database.incremental_metadata_extraction import (
 from metadata.ingestion.source.database.multi_db_source import MultiDBSource
 from metadata.ingestion.source.database.snowflake.constants import (
     DEFAULT_STREAM_COLUMNS,
+    PROCEDURE_TYPE_URL_MAP,
     SNOWFLAKE_CLASSIFICATION_DESCRIPTION,
     SNOWFLAKE_TAG_DESCRIPTION,
+    TABLE_TYPE_URL_MAP,
 )
 from metadata.ingestion.source.database.snowflake.models import (
     STORED_PROC_LANGUAGE_MAP,
@@ -688,11 +691,11 @@ class SnowflakeSource(
         table_type: Optional[TableType] = None,
     ) -> Optional[str]:
         """
-        Method to get the source url for snowflake
+        Method to get the source url for snowflake tables
         """
         try:
             if self.account and self.org_name:
-                tab_type = "view" if table_type == TableType.View else "table"
+                tab_type = TABLE_TYPE_URL_MAP.get(table_type, "table")
                 url = self._get_source_url_root(
                     database_name=database_name, schema_name=schema_name
                 )
@@ -704,6 +707,41 @@ class SnowflakeSource(
             logger.error(f"Unable to get source url: {exc}")
         return None
 
+    def get_procedure_source_url(
+        self,
+        database_name: Optional[str] = None,
+        schema_name: Optional[str] = None,
+        procedure_name: Optional[str] = None,
+        procedure_signature: Optional[str] = None,
+        procedure_type: Optional[str] = None,
+    ) -> Optional[str]:
+        """
+        Method to get the source url for snowflake stored procedures
+        """
+        try:
+            if self.account and self.org_name:
+                url = self._get_source_url_root(
+                    database_name=database_name, schema_name=schema_name
+                )
+
+                # Convert string procedure type to enum and get URL mapping
+                proc_type_enum = (
+                    StoredProcedureType(procedure_type)
+                    if procedure_type
+                    else StoredProcedureType.StoredProcedure
+                )
+                tab_type = PROCEDURE_TYPE_URL_MAP.get(proc_type_enum, "procedure")
+
+                if procedure_name:
+                    full_name = f"{procedure_name}{procedure_signature or ''}"
+                    url = f"{url}/{tab_type}/{full_name}"
+
+                return url
+        except Exception as exc:
+            logger.debug(traceback.format_exc())
+            logger.error(f"Unable to get procedure source url: {exc}")
+        return None
+
     def _get_view_names_and_types(
         self, schema_name: str, materialized_views: bool = False
     ) -> List[TableNameAndType]:
@@ -844,12 +882,13 @@ class SnowflakeSource(
                     schema_name=self.context.get().database_schema,
                 ),
                 sourceUrl=SourceUrl(
-                    self._get_source_url_root(
+                    self.get_procedure_source_url(
                         database_name=self.context.get().database,
                         schema_name=self.context.get().database_schema,
+                        procedure_name=stored_procedure.name,
+                        procedure_signature=stored_procedure.signature,
+                        procedure_type=stored_procedure.procedure_type,
                     )
-                    + f"/procedure/{stored_procedure.name}"
-                    + f"{stored_procedure.signature if stored_procedure.signature else ''}"
                 ),
             )
             yield Either(right=stored_procedure_request)
@@ -910,17 +949,26 @@ class SnowflakeSource(
                     table_name = result[6].split(".")[-1]
                     # Can't fetch source of stream is source is dropped or no priviledge
                     if table_name == "No privilege or table dropped":
-                        logger.debug(
-                            f"Couldn't fetch columns of stream [{result and result[1]}],"
-                            f" due to error on source: {table_name}. Result: {result}"
+                        logger.warning(
+                            f"Couldn't fetch columns of stream [{result and result[1]}] "
+                            f"(schema: '{schema_name}', db: '{db_name}') due to error on"
+                            f" source: [{table_name}]. Result: {result}"
                         )
                         return []
             except Exception:
                 pass
 
-        columns = inspector.get_columns(
-            table_name, schema_name, table_type=table_type, db_name=db_name
-        )
+        try:
+            columns = inspector.get_columns(
+                table_name, schema_name, table_type=table_type, db_name=db_name
+            )
+        except sa_exc.NoSuchTableError:
+            logger.warning(
+                f"Table [{table_name}] (schema: '{schema_name}', db: '{db_name}') not found."
+                " Unable to fetch columns. Please check if the configured Snowflake user has"
+                " necessary grants on this table."
+            )
+            return []
 
         if table_type == TableType.Stream:
             columns = [*columns, *DEFAULT_STREAM_COLUMNS]

metadata/ingestion/source/database/snowflake/queries.py

@@ -31,7 +31,9 @@ SNOWFLAKE_SQL_STATEMENT = textwrap.dedent(
     AND query_text NOT LIKE '/* {{"app": "dbt", %%}} */%%'
     AND start_time between to_timestamp_ltz('{start_time}') and to_timestamp_ltz('{end_time}')
     {filters}
+    ORDER BY start_time
     LIMIT {result_limit}
+    OFFSET {offset}
     """
 )
 

metadata/ingestion/source/database/snowflake/query_parser.py

@@ -32,6 +32,7 @@ from metadata.utils.logger import ingestion_logger
 
 logger = ingestion_logger()
 SNOWFLAKE_ABORTED_CODE = "1969"
+SNOWFLAKE_QUERY_BATCH_SIZE = 1000
 
 
 class SnowflakeQueryParserSource(QueryParserSource, ABC):
@@ -51,18 +52,27 @@ class SnowflakeQueryParserSource(QueryParserSource, ABC):
             )
         return cls(config, metadata)
 
-    def get_sql_statement(self, start_time: datetime, end_time: datetime) -> str:
+    def get_sql_statement(
+        self,
+        start_time: datetime,
+        end_time: datetime,
+        offset: int = 0,
+        limit: int = None,
+    ) -> str:
         """
         returns sql statement to fetch query logs
         """
+        if limit is None:
+            limit = self.config.sourceConfig.config.resultLimit
         return self.sql_stmt.format(
             start_time=start_time,
             end_time=end_time,
-            result_limit=self.config.sourceConfig.config.resultLimit,
+            result_limit=limit,
             filters=self.get_filters(),
             account_usage=self.service_connection.accountUsageSchema,
             credit_cost=self.service_connection.creditCost
             * self.service_connection.creditCost,
+            offset=offset,
         )
 
     def check_life_cycle_query(

metadata/ingestion/source/database/snowflake/usage.py

@@ -11,11 +11,22 @@
 """
 Snowflake usage module
 """
+import traceback
+from datetime import timedelta
+from typing import Iterable
+
+from metadata.generated.schema.type.basic import DateTime
+from metadata.generated.schema.type.tableQuery import TableQueries, TableQuery
+from metadata.ingestion.lineage.masker import mask_query
 from metadata.ingestion.source.database.snowflake.queries import SNOWFLAKE_SQL_STATEMENT
 from metadata.ingestion.source.database.snowflake.query_parser import (
+    SNOWFLAKE_QUERY_BATCH_SIZE,
     SnowflakeQueryParserSource,
 )
 from metadata.ingestion.source.database.usage_source import UsageSource
+from metadata.utils.logger import ingestion_logger
+
+logger = ingestion_logger()
 
 
 class SnowflakeUsageSource(SnowflakeQueryParserSource, UsageSource):
@@ -41,3 +52,89 @@ class SnowflakeUsageSource(SnowflakeQueryParserSource, UsageSource):
         "INSERT",
         "MERGE",
     ]
+
+    def yield_table_queries(self) -> Iterable[TableQuery]:
+        """
+        Given an Engine, iterate over the day range and
+        query the results with pagination
+        """
+        daydiff = self.end - self.start
+        for days in range(daydiff.days):
+            logger.info(
+                f"Scanning query logs for {(self.start + timedelta(days=days)).date()} - "
+                f"{(self.start + timedelta(days=days + 1)).date()}"
+            )
+            query = None
+            offset = 0
+            total_fetched = 0
+            max_results = self.source_config.resultLimit
+            try:
+                for engine in self.get_engine():
+                    while total_fetched < max_results:
+                        batch_size = min(
+                            SNOWFLAKE_QUERY_BATCH_SIZE, max_results - total_fetched
+                        )
+                        query = self.get_sql_statement(
+                            start_time=self.start + timedelta(days=days),
+                            end_time=self.start + timedelta(days=days + 1),
+                            offset=offset,
+                            limit=batch_size,
+                        )
+                        with engine.connect() as conn:
+                            rows = conn.execute(query)
+                            queries = []
+                            row_count = 0
+                            for row in rows:
+                                row = dict(row)
+                                row_count += 1
+                                try:
+                                    row.update({k.lower(): v for k, v in row.items()})
+                                    logger.debug(f"Processing row: {row}")
+                                    query_type = row.get("query_type")
+                                    query_text = self.format_query(row["query_text"])
+                                    queries.append(
+                                        TableQuery(
+                                            query=query_text,
+                                            query_type=query_type,
+                                            exclude_usage=self.check_life_cycle_query(
+                                                query_type=query_type,
+                                                query_text=query_text,
+                                            ),
+                                            dialect=self.dialect.value,
+                                            userName=row["user_name"],
+                                            startTime=str(row["start_time"]),
+                                            endTime=str(row["end_time"]),
+                                            analysisDate=DateTime(row["start_time"]),
+                                            aborted=self.get_aborted_status(row),
+                                            databaseName=self.get_database_name(row),
+                                            duration=row.get("duration"),
+                                            serviceName=self.config.serviceName,
+                                            databaseSchema=self.get_schema_name(row),
+                                            cost=row.get("cost"),
+                                        )
+                                    )
+                                except Exception as exc:
+                                    logger.debug(traceback.format_exc())
+                                    logger.warning(
+                                        f"Unexpected exception processing row [{row}]: {exc}"
+                                    )
+                        if queries:
+                            yield TableQueries(queries=queries)
+                        total_fetched += row_count
+                        if row_count < batch_size:
+                            break
+                        offset += batch_size
+                        logger.info(
+                            f"Fetching next page with offset {offset} (fetched {total_fetched}/{max_results}) "
+                            f"for {(self.start + timedelta(days=days)).date()}"
+                        )
+            except Exception as exc:
+                if query:
+                    logger.debug(
+                        (
+                            f"###### USAGE QUERY #######\n{mask_query(query, self.dialect.value) or query}"
+                            "\n##########################"
+                        )
+                    )
+                logger.debug(traceback.format_exc())
+                logger.error(f"Source usage processing error: {exc}")

metadata/ingestion/source/database/sql_column_handler.py

@@ -268,9 +268,17 @@ class SqlColumnHandlerMixin:
 
         table_columns = []
 
-        columns = self._get_columns_internal(
-            schema_name, table_name, db_name, inspector, table_type
-        )
+        try:
+            columns = self._get_columns_internal(
+                schema_name, table_name, db_name, inspector, table_type
+            )
+        except Exception as exc:
+            logger.debug(traceback.format_exc())
+            logger.warning(
+                f"Unexpected exception getting columns for table [{table_name}] "
+                f"(schema: '{schema_name}', db: '{db_name}'): {exc}"
+            )
+            columns = []
 
         def process_column(column: dict):
             (

metadata/readers/dataframe/mf4.py

@@ -0,0 +1,75 @@
+#  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.
+
+"""
+MF4 DataFrame reader for processing MF4 (Measurement Data Format) files
+"""
+
+import io
+
+import pandas as pd
+
+from metadata.readers.dataframe.base import DataFrameReader
+from metadata.readers.dataframe.common import dataframe_to_chunks
+from metadata.readers.dataframe.models import DatalakeColumnWrapper
+from metadata.utils.logger import ingestion_logger
+
+logger = ingestion_logger()
+
+
+class MF4DataFrameReader(DataFrameReader):
+    """
+    MF4 file reader implementation for extracting schema and data
+    from MF4 (Measurement Data Format) files.
+    """
+
+    @staticmethod
+    def extract_schema_from_header(mf4_bytes: bytes) -> DatalakeColumnWrapper:
+        """
+        Extract schema from MF4 header common properties.
+        This method uses the MDF header metadata instead of actual data extraction.
+        """
+        from asammdf import MDF
+
+        file_obj = io.BytesIO(mf4_bytes)
+
+        mdf = MDF(file_obj)
+
+        if hasattr(mdf, "header") and hasattr(mdf.header, "_common_properties"):
+            common_props = mdf.header._common_properties
+
+            schema_dict = {}
+
+            for key, value in common_props.items():
+                schema_dict[key] = pd.Series(value)
+
+            if schema_dict:
+                schema_df = pd.DataFrame(schema_dict, index=[0])
+                logger.info(f"Extracted {len(schema_dict)} properties from MF4 header")
+                return DatalakeColumnWrapper(
+                    dataframes=dataframe_to_chunks(schema_df), raw_data=common_props
+                )
+
+        logger.debug("No _common_properties found in header.")
+
+    @staticmethod
+    def read_from_mf4(mf4_bytes: bytes) -> DatalakeColumnWrapper:
+        """
+        Convert MF4 file content to DatalakeColumnWrapper using header schema extraction.
+        """
+        return MF4DataFrameReader.extract_schema_from_header(mf4_bytes)
+
+    def _read(self, *, key: str, bucket_name: str, **__) -> DatalakeColumnWrapper:
+        """
+        Read MF4 file and extract schema information.
+        """
+        file_content = self.reader.read(key, bucket_name=bucket_name)
+        return self.read_from_mf4(file_content)

metadata/readers/dataframe/reader_factory.py

@@ -27,6 +27,7 @@ from metadata.readers.dataframe.dsv import (
     get_dsv_reader_by_separator,
 )
 from metadata.readers.dataframe.json import JSONDataFrameReader
+from metadata.readers.dataframe.mf4 import MF4DataFrameReader
 from metadata.readers.dataframe.parquet import ParquetDataFrameReader
 from metadata.readers.models import ConfigSource
 from metadata.utils.logger import utils_logger
@@ -50,6 +51,7 @@ class SupportedTypes(Enum):
     JSONL = "jsonl"
     JSONLGZ = "jsonl.gz"
     JSONLZIP = "jsonl.zip"
+    MF4 = "MF4"
 
 
 DF_READER_MAP = {
@@ -68,6 +70,7 @@ DF_READER_MAP = {
     SupportedTypes.JSONL.value: JSONDataFrameReader,
     SupportedTypes.JSONLGZ.value: JSONDataFrameReader,
     SupportedTypes.JSONLZIP.value: JSONDataFrameReader,
+    SupportedTypes.MF4.value: MF4DataFrameReader,
 }
 
 

metadata/utils/datalake/datalake_utils.py

@@ -542,8 +542,129 @@ class JsonDataFrameColumnParser(GenericDataFrameColumnParser):
         """
         if self.raw_data:
             try:
+                # First, check if this is an Iceberg/Delta Lake metadata file
+                data = json.loads(self.raw_data)
+                if self._is_iceberg_delta_metadata(data):
+                    return self._parse_iceberg_delta_schema(data)
+                # Otherwise, try to parse as standard JSON Schema
                 return parse_json_schema(schema_text=self.raw_data, cls=Column)
             except Exception as exc:
                 logger.warning(f"Unable to parse the json schema: {exc}")
                 logger.debug(traceback.format_exc())
         return self._get_columns(self.data_frame)
+
+    def _is_iceberg_delta_metadata(self, data: dict) -> bool:
+        """
+        Check if the JSON data is an Iceberg or Delta Lake metadata file.
+        These files have a specific structure with 'schema' containing 'fields'.
+        """
+        return (
+            isinstance(data, dict)
+            and "schema" in data
+            and isinstance(data["schema"], dict)
+            and "fields" in data["schema"]
+            and isinstance(data["schema"]["fields"], list)
+        )
+
+    def _parse_iceberg_delta_schema(self, data: dict) -> List[Column]:
+        """
+        Parse Iceberg/Delta Lake metadata file schema to extract columns.
+        These files have structure: {"schema": {"fields": [{"id": ..., "name": ..., "type": ..., "required": ...}, ...]}}
+        """
+        columns = []
+        schema = data.get("schema", {})
+        fields = schema.get("fields", [])
+
+        for field in fields:
+            try:
+                column_name = field.get("name", "")
+                column_type = field.get("type", "string")
+
+                # Get the type string from dict if needed
+                type_str = column_type
+                if isinstance(column_type, dict):
+                    type_str = column_type.get("type", "string")
+
+                # Use DataType enum directly - it will handle the conversion
+                try:
+                    data_type = (
+                        DataType(type_str.upper())
+                        if isinstance(type_str, str)
+                        else DataType.STRING
+                    )
+                except (ValueError, AttributeError):
+                    # If the type is not recognized, default to STRING
+                    data_type = DataType.STRING
+
+                column = Column(
+                    name=truncate_column_name(column_name),
+                    displayName=column_name,
+                    dataType=data_type,
+                    dataTypeDisplay=column_type
+                    if isinstance(column_type, str)
+                    else str(column_type),
+                )
+
+                # Handle nested struct types
+                if (
+                    isinstance(column_type, dict)
+                    and column_type.get("type") == "struct"
+                ):
+                    column.children = self._parse_struct_fields(
+                        column_type.get("fields", [])
+                    )
+                    column.dataType = DataType.STRUCT
+
+                columns.append(column)
+            except Exception as exc:
+                logger.warning(f"Unable to parse field {field}: {exc}")
+                logger.debug(traceback.format_exc())
+
+        return columns
+
+    def _parse_struct_fields(self, fields: list) -> List[dict]:
+        """
+        Parse nested struct fields in Iceberg/Delta Lake metadata.
+        """
+        children = []
+        for field in fields:
+            try:
+                child_name = field.get("name", "")
+                child_type = field.get("type", "string")
+
+                # Get the type string from dict if needed
+                type_str = child_type
+                if isinstance(child_type, dict):
+                    type_str = child_type.get("type", "string")
+
+                # Use DataType enum directly
+                try:
+                    data_type = (
+                        DataType(type_str.upper())
+                        if isinstance(type_str, str)
+                        else DataType.STRING
+                    )
+                except (ValueError, AttributeError):
+                    data_type = DataType.STRING
+
+                child = {
+                    "name": truncate_column_name(child_name),
+                    "displayName": child_name,
+                    "dataType": data_type.value,
+                    "dataTypeDisplay": child_type
+                    if isinstance(child_type, str)
+                    else str(child_type),
+                }
+
+                # Recursively handle nested structs
+                if isinstance(child_type, dict) and child_type.get("type") == "struct":
+                    child["children"] = self._parse_struct_fields(
+                        child_type.get("fields", [])
+                    )
+
+                children.append(child)
+            except Exception as exc:
+                logger.warning(f"Unable to parse nested field {field}: {exc}")
+                logger.debug(traceback.format_exc())
+
+        return children

metadata/workflow/base.py

@@ -54,6 +54,7 @@ from metadata.utils.execution_time_tracker import ExecutionTimeTracker
 from metadata.utils.helpers import datetime_to_ts
 from metadata.utils.logger import ingestion_logger, set_loggers_level
 from metadata.workflow.workflow_output_handler import WorkflowOutputHandler
+from metadata.workflow.workflow_resource_metrics import WorkflowResourceMetrics
 from metadata.workflow.workflow_status_mixin import WorkflowStatusMixin
 
 logger = ingestion_logger()
@@ -338,6 +339,20 @@ class BaseWorkflow(ABC, WorkflowStatusMixin):
                     f" found {len(step.status.failures)} errors"
                 )
 
+            # Only calculate resource metrics when debug is enabled
+            # for no unnecessary computations
+            if self._is_debug_enabled():
+                metrics = WorkflowResourceMetrics()
+                logger.debug(
+                    f"Workflow Resources - "
+                    f"CPU: {metrics.cpu_usage_percent:.2f}% "
+                    f"({metrics.system_cpu_cores}c/{metrics.system_cpu_threads}t) | "
+                    f"Memory: {metrics.memory_used_mb:.2f}MB/"
+                    f"{metrics.memory_total_mb:.2f}MB "
+                    f"({metrics.memory_usage_percent:.2f}%) | "
+                    f"Processes: {metrics.active_processes}"
+                )
+
         except Exception as exc:
             logger.debug(traceback.format_exc())
             logger.error(f"Wild exception reporting status - {exc}")

metadata/workflow/workflow_resource_metrics.py

@@ -0,0 +1,111 @@
+#  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.
+
+"""
+Module to capture resource metrics for workflow execution monitoring
+"""
+
+import os
+from typing import Optional
+
+import psutil
+
+
+class WorkflowResourceMetrics:
+    """Captures CPU and memory metrics for a workflow process and all its children."""
+
+    def __init__(self, pid: Optional[int] = None):
+        """Initialize metrics for the given process ID (defaults to current process)."""
+        self.pid: int = pid or os.getpid()
+        self._collect_metrics()
+
+    def _collect_metrics(self):
+        """Collect metrics for this process and all its children."""
+        try:
+            process = psutil.Process(self.pid)
+
+            # Get memory and CPU for this process and all its children
+            total_mem_rss = process.memory_info().rss
+            total_cpu = process.cpu_percent(interval=1)
+            process_count = 1
+            total_threads = process.num_threads()  # Get thread count for main process
+
+            # Is process is spawning other child processes via multiprocessing
+            # then, include all child processes. This is needed to get aggregated
+            # view of CPU and memory usage
+            try:
+                children = process.children(recursive=True)
+                process_count += len(children)
+                for child in children:
+                    try:
+                        total_mem_rss += child.memory_info().rss
+                        total_cpu += child.cpu_percent(interval=0.1)
+                        total_threads += (
+                            child.num_threads()
+                        )  # Add thread count for each child
+                    except (psutil.NoSuchProcess, psutil.AccessDenied):
+                        pass
+            except Exception:
+                pass
+
+            # Get actual system memory info
+            system_mem = psutil.virtual_memory()
+
+            # Get CPU core information
+            cpu_cores = psutil.cpu_count(logical=False)  # Physical cores
+            cpu_logical = psutil.cpu_count(
+                logical=True
+            )  # Logical cores (with hyperthreading)
+
+            # Store computed metrics
+            self.cpu_usage_percent: float = total_cpu
+            self.memory_used_rss_bytes: int = total_mem_rss
+            self.memory_used_mb: float = total_mem_rss / (1024 * 1024)
+            self.memory_total_mb: float = system_mem.total / (1024 * 1024)
+            self.memory_usage_percent: float = (total_mem_rss / system_mem.total) * 100
+            self.active_processes: int = process_count
+            self.active_threads: int = total_threads
+            self.system_cpu_cores: int = cpu_cores or 1
+            self.system_cpu_threads: int = cpu_logical or 1
+
+        except (psutil.NoSuchProcess, psutil.AccessDenied, Exception):
+            # Fallback values if process metrics cannot be collected
+            self.cpu_usage_percent = 0.0
+            self.memory_used_rss_bytes = 0
+            self.memory_used_mb = 0.0
+            self.memory_total_mb = 0.0
+            self.memory_usage_percent = 0.0
+            self.active_processes = 0
+            self.active_threads = 0
+            self.system_cpu_cores = 1
+            self.system_cpu_threads = 1
+
+    def to_dict(self):
+        """Return metrics as a dictionary."""
+        return {
+            "cpu_usage_percent": self.cpu_usage_percent,
+            "memory_used_rss_bytes": self.memory_used_rss_bytes,
+            "memory_used_mb": self.memory_used_mb,
+            "memory_total_mb": self.memory_total_mb,
+            "memory_usage_percent": self.memory_usage_percent,
+            "active_processes": self.active_processes,
+            "active_threads": self.active_threads,
+            "system_cpu_cores": self.system_cpu_cores,
+            "system_cpu_threads": self.system_cpu_threads,
+        }
+
+    def __str__(self):
+        """String representation of metrics."""
+        return (
+            f"CPU: {self.cpu_usage_percent:.2f}% ({self.system_cpu_cores}c/{self.system_cpu_threads}t) | "
+            f"Memory: {self.memory_used_mb:.2f}MB/{self.memory_total_mb:.2f}MB ({self.memory_usage_percent:.2f}%) | "
+            f"Processes: {self.active_processes} | Threads: {self.active_threads}"
+        )