openmetadata-ingestion 1.3.4.0__py3-none-any.whl → 1.4.0.0rc2__py3-none-any.whl

metadata/ingestion/ometa/mixins/lineage_mixin.py

@@ -14,24 +14,31 @@ Mixin class containing Lineage specific methods
 To be used by OpenMetadata class
 """
 import traceback
-from typing import Any, Dict, Generic, Optional, Type, TypeVar, Union
+from copy import deepcopy
+from typing import Any, Dict, Generic, List, Optional, Type, TypeVar, Union
 
 from pydantic import BaseModel
 
 from metadata.generated.schema.api.lineage.addLineage import AddLineageRequest
 from metadata.generated.schema.entity.services.databaseService import DatabaseService
 from metadata.generated.schema.type.entityLineage import EntitiesEdge
+from metadata.generated.schema.type.entityReference import EntityReference
 from metadata.ingestion.lineage.models import ConnectionTypeDialectMapper
 from metadata.ingestion.lineage.parser import LINEAGE_PARSING_TIMEOUT
+from metadata.ingestion.models.patch_request import build_patch
 from metadata.ingestion.ometa.client import REST, APIError
 from metadata.ingestion.ometa.utils import get_entity_type
 from metadata.utils.logger import ometa_logger
+from metadata.utils.lru_cache import LRU_CACHE_SIZE, LRUCache
 
 logger = ometa_logger()
 
 T = TypeVar("T", bound=BaseModel)
 
 
+search_cache = LRUCache(LRU_CACHE_SIZE)
+
+
 class OMetaLineageMixin(Generic[T]):
     """
     OpenMetadata API methods related to Lineage.
@@ -41,13 +48,91 @@ class OMetaLineageMixin(Generic[T]):
 
     client: REST
 
-    def add_lineage(self, data: AddLineageRequest) -> Dict[str, Any]:
+    def _merge_column_lineage(
+        self, original: List[Dict[str, Any]], updated: List[Dict[str, Any]]
+    ):
+        temp_result = []
+        for column in original or []:
+            temp_result.append((*column.get("fromColumns", []), column.get("toColumn")))
+        for column in updated or []:
+            data = column.dict()
+            temp_result.append((*data.get("fromColumns", []), data.get("toColumn")))
+        return [
+            {"fromColumns": list(col_data[:-1]), "toColumn": col_data[-1]}
+            for col_data in set(temp_result)
+        ]
+
+    def _update_cache(self, request: AddLineageRequest, response: Dict[str, Any]):
+        try:
+            for res in response.get("downstreamEdges", []):
+                if str(request.edge.toEntity.id.__root__) == res.get("toEntity"):
+                    search_cache.put(
+                        (
+                            request.edge.fromEntity.id.__root__,
+                            request.edge.toEntity.id.__root__,
+                        ),
+                        {"edge": res.get("lineageDetails")},
+                    )
+                    return
+        except Exception as e:
+            logger.debug(f"Error while updating cache: {e}")
+
+        # discard the cache if failed to update
+        search_cache.put(
+            (
+                request.edge.fromEntity.id.__root__,
+                request.edge.toEntity.id.__root__,
+            ),
+            None,
+        )
+
+    def add_lineage(
+        self, data: AddLineageRequest, check_patch: bool = False
+    ) -> Dict[str, Any]:
         """
         Add lineage relationship between two entities and returns
         the entity information of the origin node
         """
         try:
-            self.client.put(self.get_suffix(AddLineageRequest), data=data.json())
+            patch_op_success = False
+            if check_patch and data.edge.lineageDetails:
+                from_id = data.edge.fromEntity.id.__root__
+                to_id = data.edge.toEntity.id.__root__
+                edge = self.get_lineage_edge(from_id, to_id)
+                if edge:
+                    original: AddLineageRequest = deepcopy(data)
+                    original.edge.lineageDetails.columnsLineage = edge["edge"].get(
+                        "columnsLineage", []
+                    )
+                    original.edge.lineageDetails.pipeline = (
+                        EntityReference(**edge["edge"].get("pipeline"))
+                        if edge["edge"].get("pipeline")
+                        else None
+                    )
+                    # merge the original and new column level lineage
+                    data.edge.lineageDetails.columnsLineage = (
+                        self._merge_column_lineage(
+                            original.edge.lineageDetails.columnsLineage,
+                            data.edge.lineageDetails.columnsLineage,
+                        )
+                    )
+
+                    # Keep the pipeline information from the original
+                    # lineage if available
+                    if (
+                        original.edge.lineageDetails.pipeline
+                        and not data.edge.lineageDetails.pipeline
+                    ):
+                        data.edge.lineageDetails.pipeline = (
+                            original.edge.lineageDetails.pipeline
+                        )
+                    patch = self.patch_lineage_edge(original=original, updated=data)
+                    if patch is not None:
+                        patch_op_success = True
+
+            if patch_op_success is False:
+                self.client.put(self.get_suffix(AddLineageRequest), data=data.json())
+
         except APIError as err:
             logger.debug(traceback.format_exc())
             logger.error(
@@ -62,8 +147,81 @@ class OMetaLineageMixin(Generic[T]):
             data.edge.fromEntity.type, str(data.edge.fromEntity.id.__root__)
         )
 
+        self._update_cache(data, from_entity_lineage)
         return from_entity_lineage
 
+    def get_lineage_edge(
+        self,
+        from_id: str,
+        to_id: str,
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Get the lineage edge between two entities.
+
+        Args:
+            from_id (str): The ID of the source entity.
+            to_id (str): The ID of the target entity.
+
+        Returns:
+            Optional[Dict[str, Any]]: The lineage edge if found, None otherwise.
+        """
+        try:
+            if (from_id, to_id) in search_cache:
+                return search_cache.get((from_id, to_id))
+            res = self.client.get(
+                f"{self.get_suffix(AddLineageRequest)}/getLineageEdge/"
+                f"{from_id}/{to_id}"
+            )
+            search_cache.put((from_id, to_id), res)
+            return res
+        except APIError as err:
+            if err.status_code != 404:
+                logger.debug(traceback.format_exc())
+                logger.debug(
+                    f"Error {err.status_code} trying to GET linage edge between "
+                    f"{from_id} and {to_id}: {err}"
+                )
+            return None
+
+    def patch_lineage_edge(
+        self,
+        original: AddLineageRequest,
+        updated: AddLineageRequest,
+    ) -> Optional[str]:
+        """
+        Patches a lineage edge between two entities.
+
+        Args:
+            original (AddLineageRequest): The original lineage request.
+            updated (AddLineageRequest): The updated lineage request.
+
+        Returns:
+            bool: True if the patch operation is successful, False otherwise.
+        """
+        try:
+            allowed_fields = {"columnsLineage": True, "pipeline": True}
+            patch = build_patch(
+                source=original.edge.lineageDetails,
+                destination=updated.edge.lineageDetails,
+                allowed_fields=allowed_fields,
+                remove_change_description=False,
+            )
+            if patch:
+                self.client.patch(
+                    f"{self.get_suffix(AddLineageRequest)}/{original.edge.fromEntity.type}/"
+                    f"{original.edge.fromEntity.id.__root__}/{original.edge.toEntity.type}"
+                    f"/{original.edge.toEntity.id.__root__}",
+                    data=str(patch),
+                )
+                return str(patch)
+        except APIError as err:
+            logger.debug(traceback.format_exc())
+            logger.warning(
+                f"Error Patching Lineage Edge {err.status_code} "
+                f"for {original.edge.fromEntity.fullyQualifiedName}"
+            )
+        return None
+
     def get_lineage_by_id(
         self,
         entity: Union[Type[T], str],
@@ -155,6 +313,7 @@ class OMetaLineageMixin(Generic[T]):
         database_name: str = None,
         schema_name: str = None,
         timeout: int = LINEAGE_PARSING_TIMEOUT,
+        check_patch: bool = False,
     ) -> None:
         """
         Method parses the query and generated the lineage
@@ -178,9 +337,15 @@ class OMetaLineageMixin(Generic[T]):
             )
             for lineage_request in add_lineage_request or []:
                 if lineage_request.right:
-                    resp = self.add_lineage(lineage_request.right)
+                    resp = self.add_lineage(
+                        lineage_request.right, check_patch=check_patch
+                    )
                     entity_name = resp.get("entity", {}).get("name")
                     for node in resp.get("nodes", []):
                         logger.info(
                             f"added lineage between table {node.get('name')} and {entity_name} "
                         )
+                elif lineage_request.left:
+                    logger.error(
+                        f"Error while adding lineage: {lineage_request.left.error}"
+                    )

metadata/ingestion/ometa/mixins/patch_mixin.py

@@ -88,9 +88,11 @@ def update_column_description(
     """
     Inplace update for the incoming column list
     """
-    col_dict = {col.column_fqn: col.description for col in column_descriptions}
+    col_dict = {col.column_fqn.lower(): col.description for col in column_descriptions}
     for col in columns:
-        desc_column = col_dict.get(col.fullyQualifiedName.__root__)
+        # For dbt the column names in OM and dbt are not always in the same case.
+        # We'll match the column names in case insensitive way
+        desc_column = col_dict.get(col.fullyQualifiedName.__root__.lower())
         if desc_column:
             if col.description and not force:
                 # If the description is already present and force is not passed,
@@ -234,9 +236,10 @@ class OMetaPatchMixin(OMetaPatchMixinBase):
 
     def patch_test_case_definition(
         self,
-        source: TestCase,
+        test_case: TestCase,
         entity_link: str,
         test_case_parameter_values: Optional[List[TestCaseParameterValue]] = None,
+        compute_passed_failed_row_count: Optional[bool] = False,
     ) -> Optional[TestCase]:
         """Given a test case and a test case definition JSON PATCH the test case
 
@@ -245,7 +248,7 @@ class OMetaPatchMixin(OMetaPatchMixinBase):
             test_case_definition: test case definition to add
         """
         source: TestCase = self._fetch_entity_if_exists(
-            entity=TestCase, entity_id=source.id, fields=["testDefinition", "testSuite"]
+            entity=TestCase, entity_id=test_case.id, fields=["testDefinition", "testSuite"]  # type: ignore
         )  # type: ignore
 
         if not source:
@@ -256,6 +259,8 @@ class OMetaPatchMixin(OMetaPatchMixinBase):
         destination.entityLink = EntityLink(__root__=entity_link)
         if test_case_parameter_values:
             destination.parameterValues = test_case_parameter_values
+        if compute_passed_failed_row_count != source.computePassedFailedRowCount:
+            destination.computePassedFailedRowCount = compute_passed_failed_row_count
 
         return self.patch(entity=TestCase, source=source, destination=destination)
 

metadata/ingestion/ometa/mixins/server_mixin.py

@@ -13,8 +13,17 @@ Mixin class containing Server and client specific methods
 
 To be used by OpenMetadata class
 """
-from metadata.__version__ import get_client_version, get_server_version_from_string
+from typing import Optional
+
+from metadata.__version__ import (
+    get_client_version,
+    get_server_version_from_string,
+    match_versions,
+)
+from metadata.generated.schema.settings.settings import Settings, SettingType
+from metadata.ingestion.models.encoders import show_secrets_encoder
 from metadata.ingestion.ometa.client import REST
+from metadata.ingestion.ometa.routes import ROUTES
 from metadata.utils.logger import ometa_logger
 
 logger = ometa_logger()
@@ -67,9 +76,45 @@ class OMetaServerMixin:
             f"OpenMetadata client running with Server version [{server_version}] and Client version [{client_version}]"
         )
 
-        # Server version will be 0.13.2, vs 0.13.2.X from the client.
-        # If the server version is contained in the client version, then we're good to go
-        if server_version not in client_version:
+        if not match_versions(server_version, client_version):
             raise VersionMismatchException(
-                f"Server version is {server_version} vs. Client version {client_version}. Both should match."
+                f"Server version is {server_version} vs. Client version {client_version}."
+                f" Major and minor versions should match."
             )
+
+    def create_or_update_settings(self, settings: Settings) -> Settings:
+        """Create of update setting
+
+        Args:
+            settings (Settings): setting to update or create
+
+        Returns:
+            Settings
+        """
+        data = settings.json(encoder=show_secrets_encoder)
+        response = self.client.put(ROUTES.get(Settings.__name__), data)
+        return Settings.parse_obj(response)
+
+    def get_settings_by_name(self, setting_type: SettingType) -> Optional[Settings]:
+        """Get setting by name
+
+        Returns:
+            Settings
+        """
+        response = self.client.get(
+            f"{ROUTES.get(Settings.__name__)}/{setting_type.value}"
+        )
+        if not response:
+            return None
+        return Settings.parse_obj(response)
+
+    def get_profiler_config_settings(self) -> Optional[Settings]:
+        """Get profiler config setting
+
+        Returns:
+            Settings
+        """
+        response = self.client.get("/system/settings/profilerConfiguration")
+        if not response:
+            return None
+        return Settings.parse_obj(response)

metadata/ingestion/ometa/mixins/tests_mixin.py

@@ -14,6 +14,7 @@ Mixin class containing Tests specific methods
 To be used by OpenMetadata class
 """
 
+import traceback
 from datetime import datetime, timezone
 from typing import List, Optional, Type, Union
 from urllib.parse import quote
@@ -30,7 +31,7 @@ from metadata.generated.schema.api.tests.createTestDefinition import (
     CreateTestDefinitionRequest,
 )
 from metadata.generated.schema.api.tests.createTestSuite import CreateTestSuiteRequest
-from metadata.generated.schema.entity.data.table import Table
+from metadata.generated.schema.entity.data.table import Table, TableData
 from metadata.generated.schema.tests.basic import TestCaseResult
 from metadata.generated.schema.tests.testCase import TestCase, TestCaseParameterValue
 from metadata.generated.schema.tests.testCaseResolutionStatus import (
@@ -323,3 +324,56 @@ class OMetaTestsMixin:
         response = self.client.post(path, data=data.json(encoder=show_secrets_encoder))
 
         return TestCaseResolutionStatus(**response)
+
+    def ingest_failed_rows_sample(
+        self, test_case: TestCase, failed_rows: TableData
+    ) -> Optional[TableData]:
+        """
+        PUT sample failed data for a test case.
+
+        :param test_case: The test case that failed
+        :param failed_rows: Data to add
+        """
+        resp = None
+        try:
+            resp = self.client.put(
+                f"{self.get_suffix(TestCase)}/{test_case.id.__root__}/failedRowsSample",
+                data=failed_rows.json(),
+            )
+        except Exception as exc:
+            logger.debug(traceback.format_exc())
+            logger.warning(
+                f"Error trying to PUT sample data for {test_case.fullyQualifiedName.__root__}: {exc}"
+            )
+
+        if resp:
+            try:
+                return TableData(**resp["failedRowsSample"])
+            except UnicodeError as err:
+                logger.debug(traceback.format_exc())
+                logger.warning(
+                    f"Unicode Error parsing the sample data response from {test_case.fullyQualifiedName.__root__}: "
+                    f"{err}"
+                )
+            except Exception as exc:
+                logger.debug(traceback.format_exc())
+                logger.warning(
+                    f"Error trying to parse sample data results from {test_case.fullyQualifiedName.__root__}: {exc}"
+                )
+
+        return None
+
+    def ingest_inspection_query(
+        self, test_case: TestCase, inspection_query: str
+    ) -> Optional[TestCase]:
+        """
+        PUT inspection query for a test case.
+
+        :param test_case: The test case that failed
+        :param inspection_query: SQL query to inspect the failed rows
+        """
+        resp = self.client.put(
+            f"{self.get_suffix(TestCase)}/{test_case.id.__root__}/inspectionQuery",
+            data=inspection_query,
+        )
+        return TestCase(**resp)

metadata/ingestion/ometa/mixins/user_mixin.py

@@ -78,7 +78,7 @@ class OMetaUserMixin:
             query_string = self.email_search_query_es(entity=entity).format(
                 email=email, from_=from_count, size=size
             )
-            return self._get_entity_from_es(
+            return self.get_entity_from_es(
                 entity=entity, query_string=query_string, fields=fields
             )
 
@@ -105,7 +105,7 @@ class OMetaUserMixin:
             query_string = self.name_search_query_es(entity=entity).format(
                 name=name, from_=from_count, size=size
             )
-            return self._get_entity_from_es(
+            return self.get_entity_from_es(
                 entity=entity, query_string=query_string, fields=fields
             )
 
@@ -127,7 +127,10 @@ class OMetaUserMixin:
         )
         if maybe_user:
             return EntityReference(
-                id=maybe_user.id.__root__, type=ENTITY_REFERENCE_TYPE_MAP[User.__name__]
+                id=maybe_user.id.__root__,
+                type=ENTITY_REFERENCE_TYPE_MAP[User.__name__],
+                name=maybe_user.name.__root__,
+                displayName=maybe_user.displayName,
             )
 
         maybe_team = self._search_by_email(
@@ -135,7 +138,10 @@ class OMetaUserMixin:
         )
         if maybe_team:
             return EntityReference(
-                id=maybe_team.id.__root__, type=ENTITY_REFERENCE_TYPE_MAP[Team.__name__]
+                id=maybe_team.id.__root__,
+                type=ENTITY_REFERENCE_TYPE_MAP[Team.__name__],
+                name=maybe_team.name.__root__,
+                displayName=maybe_team.displayName,
             )
 
         return None
@@ -156,7 +162,10 @@ class OMetaUserMixin:
         )
         if maybe_user:
             return EntityReference(
-                id=maybe_user.id.__root__, type=ENTITY_REFERENCE_TYPE_MAP[User.__name__]
+                id=maybe_user.id.__root__,
+                type=ENTITY_REFERENCE_TYPE_MAP[User.__name__],
+                name=maybe_user.name.__root__,
+                displayName=maybe_user.displayName,
             )
 
         maybe_team = self._search_by_name(
@@ -164,7 +173,10 @@ class OMetaUserMixin:
         )
         if maybe_team:
             return EntityReference(
-                id=maybe_team.id.__root__, type=ENTITY_REFERENCE_TYPE_MAP[Team.__name__]
+                id=maybe_team.id.__root__,
+                type=ENTITY_REFERENCE_TYPE_MAP[Team.__name__],
+                name=maybe_team.name.__root__,
+                displayName=maybe_team.displayName,
             )
 
         return None

metadata/ingestion/ometa/ometa_api.py

@@ -405,7 +405,12 @@ class OpenMetadata(
                 try:
                     entities.append(entity(**elmt))
                 except Exception as exc:
-                    logger.error(f"Error creating entity. Failed with exception {exc}")
+                    logger.error(
+                        f"Error creating entity [{entity.__name__}]. Failed with exception {exc}"
+                    )
+                    logger.debug(
+                        f"Can't create [{entity.__name__}] from [{elmt}]. Skipping."
+                    )
                     continue
         else:
             entities = [entity(**elmt) for elmt in resp["data"]]

metadata/ingestion/ometa/routes.py

@@ -144,6 +144,7 @@ from metadata.generated.schema.entity.services.storageService import StorageServ
 from metadata.generated.schema.entity.teams.role import Role
 from metadata.generated.schema.entity.teams.team import Team
 from metadata.generated.schema.entity.teams.user import AuthenticationMechanism, User
+from metadata.generated.schema.settings.settings import Settings
 from metadata.generated.schema.tests.testCase import TestCase
 from metadata.generated.schema.tests.testDefinition import TestDefinition
 from metadata.generated.schema.tests.testSuite import TestSuite
@@ -247,4 +248,6 @@ ROUTES = {
     CreateAppRequest.__name__: "/apps",
     AppMarketPlaceDefinition.__name__: "/apps/marketplace",
     CreateAppMarketPlaceDefinitionRequest.__name__: "/apps/marketplace",
+    # Settings
+    Settings.__name__: "/system/settings",
 }

metadata/ingestion/ometa/utils.py

@@ -57,6 +57,8 @@ def get_entity_type(
         return class_name.replace("databaseschema", "databaseSchema")
     if "searchindex" in class_name:
         return class_name.replace("searchindex", "searchIndex")
+    if "dashboarddatamodel" in class_name:
+        return class_name.replace("dashboarddatamodel", "dashboardDataModel")
 
     return class_name
 

metadata/ingestion/processor/query_parser.py

@@ -17,9 +17,6 @@ import traceback
 from typing import Optional
 
 from metadata.config.common import ConfigModel
-from metadata.generated.schema.entity.services.ingestionPipelines.status import (
-    StackTraceError,
-)
 from metadata.generated.schema.type.basic import DateTime
 from metadata.generated.schema.type.queryParserData import ParsedData, QueryParserData
 from metadata.generated.schema.type.tableQuery import TableQueries, TableQuery
@@ -92,34 +89,47 @@ class QueryParserProcessor(Processor):
         return "Query Parser"
 
     @classmethod
-    def create(cls, config_dict: dict, metadata: OpenMetadata, **kwargs):
+    def create(
+        cls,
+        config_dict: dict,
+        metadata: OpenMetadata,
+        pipeline_name: Optional[str] = None,
+        **kwargs,
+    ):
         config = ConfigModel.parse_obj(config_dict)
         connection_type = kwargs.pop("connection_type", "")
         return cls(config, metadata, connection_type)
 
     def _run(self, record: TableQueries) -> Optional[Either[QueryParserData]]:
-        if record and record.queries:
-            data = []
-            for table_query in record.queries:
-                try:
-                    parsed_sql = parse_sql_statement(
-                        table_query,
-                        ConnectionTypeDialectMapper.dialect_of(self.connection_type),
-                    )
-                    if parsed_sql:
-                        data.append(parsed_sql)
-                except Exception as exc:
-                    return Either(
-                        left=StackTraceError(
-                            name="Query",
-                            error=f"Error processing query [{table_query.query}]: {exc}",
-                            stackTrace=traceback.format_exc(),
-                        )
-                    )
-
-            return Either(right=QueryParserData(parsedData=data))
-
-        return None
+        if record is None or record.queries is None:
+            return None
+
+        data = []
+        success_cnt = 0
+        failed_cnt = 0
+        total_cnt = len(record.queries)
+
+        for table_query in record.queries:
+            try:
+                parsed_sql = parse_sql_statement(
+                    table_query,
+                    ConnectionTypeDialectMapper.dialect_of(self.connection_type),
+                )
+                if parsed_sql:
+                    data.append(parsed_sql)
+                success_cnt += 1
+            except Exception as exc:
+                failed_cnt += 1
+                logger.debug(traceback.format_exc())
+                logger.warning(f"Error processing query [{table_query.query}]: {exc}")
+            cur_total_cnt = success_cnt + failed_cnt
+            if cur_total_cnt % 1000 == 0 or cur_total_cnt == total_cnt:
+                logger.info(
+                    f"Total query count:{cur_total_cnt} / {total_cnt}."
+                    f" Current success count: {success_cnt}."
+                    f" Current failed count: {failed_cnt}."
+                )
+        return Either(right=QueryParserData(parsedData=data))
 
     def close(self):
         """Nothing to close"""

metadata/ingestion/sink/file.py

@@ -13,6 +13,7 @@ Sink that will store metadata in a file.
 Useful for local testing without having OM up.
 """
 import pathlib
+from typing import Optional
 
 from metadata.config.common import ConfigModel
 from metadata.ingestion.api.common import Entity
@@ -49,7 +50,9 @@ class FileSink(Sink):
         self.wrote_something = False
 
     @classmethod
-    def create(cls, config_dict: dict, _: OpenMetadata):
+    def create(
+        cls, config_dict: dict, _: OpenMetadata, pipeline_name: Optional[str] = None
+    ):
         config = FileSinkConfig.parse_obj(config_dict)
         return cls(config)
 

metadata/ingestion/sink/metadata_rest.py

@@ -117,7 +117,12 @@ class MetadataRestSink(Sink):  # pylint: disable=too-many-public-methods
         self.team_entities = {}
 
     @classmethod
-    def create(cls, config_dict: dict, metadata: OpenMetadata):
+    def create(
+        cls,
+        config_dict: dict,
+        metadata: OpenMetadata,
+        pipeline_name: Optional[str] = None,
+    ):
         config = MetadataRestSinkConfig.parse_obj(config_dict)
         return cls(config, metadata)
 
@@ -241,7 +246,7 @@ class MetadataRestSink(Sink):  # pylint: disable=too-many-public-methods
 
     @_run_dispatch.register
     def write_lineage(self, add_lineage: AddLineageRequest) -> Either[Dict[str, Any]]:
-        created_lineage = self.metadata.add_lineage(add_lineage)
+        created_lineage = self.metadata.add_lineage(add_lineage, check_patch=True)
         return Either(right=created_lineage["entity"]["fullyQualifiedName"])
 
     def _create_role(self, create_role: CreateRoleRequest) -> Optional[Role]:
@@ -499,10 +504,19 @@ class MetadataRestSink(Sink):  # pylint: disable=too-many-public-methods
         """
         Ingest the life cycle data
         """
-        self.metadata.patch_life_cycle(
-            entity=record.entity, life_cycle=record.life_cycle
+
+        entity = self.metadata.get_by_name(entity=record.entity, fqn=record.entity_fqn)
+
+        if entity:
+            self.metadata.patch_life_cycle(entity=entity, life_cycle=record.life_cycle)
+            return Either(right=entity)
+
+        return Either(
+            left=StackTraceError(
+                name=record.entity_fqn,
+                error=f"Entity of type '{record.entity}' with name '{record.entity_fqn}' not found.",
+            )
         )
-        return Either(right=record)
 
     @_run_dispatch.register
     def write_profiler_response(self, record: ProfilerResponse) -> Either[Table]: