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

metadata/ingestion/source/database/incremental_metadata_extraction.py

@@ -0,0 +1,144 @@
+#  Copyright 2021 Collate
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  http://www.apache.org/licenses/LICENSE-2.0
+#  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.
+"""
+Incremental Metadata Extraction related classes
+"""
+import traceback
+from datetime import datetime, timedelta, timezone
+from typing import List, Optional, Tuple
+
+from pydantic import BaseModel
+
+from metadata.generated.schema.entity.services.ingestionPipelines.ingestionPipeline import (
+    PipelineState,
+    PipelineStatus,
+)
+from metadata.generated.schema.metadataIngestion.databaseServiceMetadataPipeline import (
+    Incremental,
+)
+from metadata.ingestion.ometa.ometa_api import OpenMetadata
+from metadata.utils.logger import ingestion_logger
+
+logger = ingestion_logger()
+
+MILLISECONDS_IN_ONE_DAY = 24 * 60 * 60 * 1000
+
+
+class IncrementalConfig(BaseModel):
+    """Holds the Configuration to extract the Metadata incrementally, if enabled."""
+
+    enabled: bool
+    start_timestamp: Optional[int] = None
+
+    @property
+    def start_datetime_utc(self) -> Optional[datetime]:
+        if self.start_timestamp:
+            return datetime.fromtimestamp(self.start_timestamp / 1000, timezone.utc)
+        return None
+
+    @classmethod
+    def create(
+        cls,
+        incremental: Optional[bool],
+        pipeline_name: Optional[str],
+        metadata: OpenMetadata,
+    ) -> "IncrementalConfig":
+        """Returns the IncrementalConfig based on the flow defined on the IncrementalConfigCreator."""
+        return IncrementalConfigCreator(incremental, pipeline_name, metadata).create()
+
+
+class IncrementalConfigCreator:
+    """Helper class to create an IncrementalConfig instance automagically."""
+
+    def __init__(
+        self,
+        incremental: Optional[Incremental],
+        pipeline_name: Optional[str],
+        metadata: OpenMetadata,
+    ):
+        self.incremental = incremental
+        self.pipeline_name = pipeline_name
+        self.metadata = metadata
+
+    def _calculate_pipeline_status_parameters(self) -> Tuple[int, int]:
+        """Calculate the needed 'start' and 'end' parameters based on the 'lookbackDays'."""
+        now = datetime.now()
+
+        # We multiply the value by 1000 because our backend uses epoch_milliseconds instead of epoch_seconds.
+        start = int(
+            (now - timedelta(days=self.incremental.lookbackDays)).timestamp() * 1000
+        )
+        end = int(now.timestamp() * 1000)
+
+        return start, end
+
+    def _get_pipeline_statuses(self) -> Optional[List[PipelineStatus]]:
+        """Retrieve all the pipeline statuses between 'start' and 'end'."""
+        if not self.pipeline_name:
+            return None
+
+        start, end = self._calculate_pipeline_status_parameters()
+
+        return self.metadata.get_pipeline_status_between_ts(
+            self.pipeline_name, start, end
+        )
+
+    def _get_last_success_timestamp(
+        self, pipeline_statuses: List[PipelineStatus]
+    ) -> Optional[int]:
+        """Filter the pipeline statuses to get the last time the pipeline was run succesfully."""
+        return max(  # pylint: disable=R1728
+            [
+                pipeline.startDate.__root__
+                for pipeline in pipeline_statuses
+                if pipeline.pipelineState == PipelineState.success
+                and pipeline.startDate
+            ]
+        )
+
+    def _add_safety_margin(self, last_success_timestamp: int) -> int:
+        """Add some safety margin to the last successful run timestamp based on the 'safetyMarginDays'."""
+        return last_success_timestamp - (
+            self.incremental.safetyMarginDays * MILLISECONDS_IN_ONE_DAY
+        )
+
+    def create(self) -> IncrementalConfig:
+        """Creates a new IncrementalConfig using the historical runs of the pipeline.
+        If no previous successful runs are found within the time period it will disable the incremental ingestion.
+        """
+        try:
+            if (
+                not (self.incremental and self.pipeline_name)
+                or not self.incremental.enabled
+            ):
+                return IncrementalConfig(enabled=False)
+
+            pipeline_statuses = self._get_pipeline_statuses()
+
+            if not pipeline_statuses:
+                return IncrementalConfig(enabled=False)
+
+            last_success_timestamp = self._get_last_success_timestamp(pipeline_statuses)
+
+            if not last_success_timestamp:
+                return IncrementalConfig(enabled=False)
+
+            return IncrementalConfig(
+                enabled=True,
+                start_timestamp=self._add_safety_margin(last_success_timestamp),
+            )
+        except Exception as exc:
+            logger.debug(traceback.format_exc())
+            logger.info(
+                "Couldn't create the IncrementalConfig due to %s. Proceeding Full Extraction.",
+                exc,
+            )
+            return IncrementalConfig(enabled=False)

metadata/ingestion/source/database/life_cycle_query_mixin.py

@@ -15,7 +15,7 @@ import traceback
 from collections import defaultdict
 from datetime import datetime
 from functools import lru_cache
-from typing import Dict, Iterable, List, Optional
+from typing import Dict, Iterable, List, Optional, Type
 
 from pydantic import BaseModel, Field
 from sqlalchemy.engine import Engine
@@ -31,7 +31,7 @@ from metadata.generated.schema.type.lifeCycle import AccessDetails, LifeCycle
 from metadata.ingestion.api.models import Either, Entity
 from metadata.ingestion.api.status import Status
 from metadata.ingestion.models.life_cycle import OMetaLifeCycleData
-from metadata.ingestion.models.topology import TopologyContext
+from metadata.ingestion.models.topology import TopologyContextManager
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.utils import fqn
 from metadata.utils.logger import ingestion_logger
@@ -57,7 +57,7 @@ class LifeCycleQueryMixin:
     Module stores the methods to query the sources and get life cycle information
     """
 
-    context: TopologyContext
+    context: TopologyContextManager
     status: Status
     source_config: DatabaseServiceMetadataPipeline
     engine: Engine
@@ -92,34 +92,35 @@ class LifeCycleQueryMixin:
 
         return queries_dict
 
-    def get_life_cycle_data(self, entity: Entity, query: str):
+    def get_life_cycle_data(
+        self, entity: Type[Entity], entity_name: str, entity_fqn: str, query: str
+    ):
         """
         Get the life cycle data
         """
-        if entity:
-            try:
-                life_cycle_data = self.life_cycle_query_dict(query=query).get(
-                    entity.name.__root__
-                )
-                if life_cycle_data:
-                    life_cycle = LifeCycle(
-                        created=AccessDetails(
-                            timestamp=convert_timestamp_to_milliseconds(
-                                life_cycle_data.created_at.timestamp()
-                            )
+        try:
+            life_cycle_data = self.life_cycle_query_dict(query=query).get(entity_name)
+            if life_cycle_data:
+                life_cycle = LifeCycle(
+                    created=AccessDetails(
+                        timestamp=convert_timestamp_to_milliseconds(
+                            life_cycle_data.created_at.timestamp()
                         )
                     )
-                    yield Either(
-                        right=OMetaLifeCycleData(entity=entity, life_cycle=life_cycle)
-                    )
-            except Exception as exc:
+                )
                 yield Either(
-                    left=StackTraceError(
-                        name=entity.name.__root__,
-                        error=f"Unable to get the table life cycle data for table {entity.name.__root__}: {exc}",
-                        stackTrace=traceback.format_exc(),
+                    right=OMetaLifeCycleData(
+                        entity=entity, entity_fqn=entity_fqn, life_cycle=life_cycle
                     )
                 )
+        except Exception as exc:
+            yield Either(
+                left=StackTraceError(
+                    name=entity_name,
+                    error=f"Unable to get the table life cycle data for table {entity_name}: {exc}",
+                    stackTrace=traceback.format_exc(),
+                )
+            )
 
     def yield_life_cycle_data(self, _) -> Iterable[Either[OMetaLifeCycleData]]:
         """
@@ -129,21 +130,23 @@ class LifeCycleQueryMixin:
             table_fqn = fqn.build(
                 self.metadata,
                 entity_type=Table,
-                service_name=self.context.database_service,
-                database_name=self.context.database,
-                schema_name=self.context.database_schema,
-                table_name=self.context.table,
+                service_name=self.context.get().database_service,
+                database_name=self.context.get().database,
+                schema_name=self.context.get().database_schema,
+                table_name=self.context.get().table,
                 skip_es_search=True,
             )
-            table = self.metadata.get_by_name(entity=Table, fqn=table_fqn)
-            if table:
-                yield from self.get_life_cycle_data(
-                    entity=table,
-                    query=self.life_cycle_query.format(
-                        database_name=table.database.name,
-                        schema_name=table.databaseSchema.name,
-                    ),
-                )
+            # table = self.metadata.get_by_name(entity=Table, fqn=table_fqn)
+            # if table:
+            yield from self.get_life_cycle_data(
+                entity=Table,
+                entity_name=self.context.get().table,
+                entity_fqn=table_fqn,
+                query=self.life_cycle_query.format(
+                    database_name=self.context.get().database,
+                    schema_name=self.context.get().database_schema,
+                ),
+            )
         except Exception as exc:
             yield Either(
                 left=StackTraceError(

metadata/ingestion/source/database/mariadb/metadata.py

@@ -11,6 +11,8 @@
 """
 MariaDB source module
 """
+from typing import Optional
+
 from sqlalchemy.dialects.mysql.base import ischema_names
 from sqlalchemy.dialects.mysql.reflection import MySQLTableDefinitionParser
 
@@ -40,7 +42,9 @@ class MariadbSource(CommonDbSourceService):
     """
 
     @classmethod
-    def create(cls, config_dict, metadata: OpenMetadata):
+    def create(
+        cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
+    ):
         config: WorkflowSource = WorkflowSource.parse_obj(config_dict)
         connection: MariaDBConnection = config.serviceConnection.__root__.config
         if not isinstance(connection, MariaDBConnection):

metadata/ingestion/source/database/mongodb/metadata.py

@@ -13,7 +13,7 @@ MongoDB source methods.
 """
 
 import traceback
-from typing import Dict, List, Union
+from typing import Dict, List, Optional, Union
 
 from pymongo.errors import OperationFailure
 
@@ -45,7 +45,9 @@ class MongodbSource(CommonNoSQLSource):
         self.mongodb = self.connection_obj
 
     @classmethod
-    def create(cls, config_dict, metadata: OpenMetadata):
+    def create(
+        cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
+    ):
         config: WorkflowSource = WorkflowSource.parse_obj(config_dict)
         connection: MongoDBConnection = config.serviceConnection.__root__.config
         if not isinstance(connection, MongoDBConnection):

metadata/ingestion/source/database/mssql/metadata.py

@@ -13,6 +13,7 @@ import traceback
 from typing import Dict, Iterable, List, Optional
 
 from sqlalchemy.dialects.mssql.base import MSDialect, ischema_names
+from sqlalchemy.engine.reflection import Inspector
 
 from metadata.generated.schema.api.data.createStoredProcedure import (
     CreateStoredProcedureRequest,
@@ -65,7 +66,9 @@ from metadata.utils.logger import ingestion_logger
 from metadata.utils.sqa_utils import update_mssql_ischema_names
 from metadata.utils.sqlalchemy_utils import (
     get_all_table_comments,
+    get_all_table_ddls,
     get_all_view_definitions,
+    get_table_ddl,
 )
 
 logger = ingestion_logger()
@@ -87,6 +90,9 @@ MSDialect.get_foreign_keys = get_foreign_keys
 MSDialect.get_table_names = get_table_names
 MSDialect.get_view_names = get_view_names
 
+Inspector.get_all_table_ddls = get_all_table_ddls
+Inspector.get_table_ddl = get_table_ddl
+
 
 class MssqlSource(StoredProcedureMixin, CommonDbSourceService, MultiDBSource):
     """
@@ -95,7 +101,9 @@ class MssqlSource(StoredProcedureMixin, CommonDbSourceService, MultiDBSource):
     """
 
     @classmethod
-    def create(cls, config_dict, metadata: OpenMetadata):
+    def create(
+        cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
+    ):
         """Create class instance"""
         config: WorkflowSource = WorkflowSource.parse_obj(config_dict)
         connection: MssqlConnection = config.serviceConnection.__root__.config
@@ -123,7 +131,7 @@ class MssqlSource(StoredProcedureMixin, CommonDbSourceService, MultiDBSource):
                 database_fqn = fqn.build(
                     self.metadata,
                     entity_type=Database,
-                    service_name=self.context.database_service,
+                    service_name=self.context.get().database_service,
                     database_name=new_database,
                 )
 
@@ -150,8 +158,8 @@ class MssqlSource(StoredProcedureMixin, CommonDbSourceService, MultiDBSource):
         if self.source_config.includeStoredProcedures:
             results = self.engine.execute(
                 MSSQL_GET_STORED_PROCEDURES.format(
-                    database_name=self.context.database,
-                    schema_name=self.context.database_schema,
+                    database_name=self.context.get().database,
+                    schema_name=self.context.get().database_schema,
                 )
             ).all()
             for row in results:
@@ -184,9 +192,9 @@ class MssqlSource(StoredProcedureMixin, CommonDbSourceService, MultiDBSource):
                 databaseSchema=fqn.build(
                     metadata=self.metadata,
                     entity_type=DatabaseSchema,
-                    service_name=self.context.database_service,
-                    database_name=self.context.database,
-                    schema_name=self.context.database_schema,
+                    service_name=self.context.get().database_service,
+                    database_name=self.context.get().database,
+                    schema_name=self.context.get().database_schema,
                 ),
             )
             yield Either(right=stored_procedure_request)

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

@@ -46,27 +46,27 @@ MSSQL_GET_TABLE_COMMENTS = textwrap.dedent(
 SELECT obj.name AS table_name,
         ep.value AS table_comment,
         s.name AS "schema"
-FROM sys.tables AS obj
+FROM sys.objects AS obj
 LEFT JOIN sys.extended_properties AS ep
-    ON obj.object_id = ep.major_id AND ep.minor_id = 0
+    ON obj.object_id = ep.major_id AND ep.minor_id = 0 AND ep.name = 'MS_Description'
 JOIN sys.schemas AS s
     ON obj.schema_id = s.schema_id
-WHERE ep.name = 'MS_Description'
+WHERE
+    obj.type IN ('U', 'V') /* User tables and views */
 """
 )
 
 MSSQL_ALL_VIEW_DEFINITIONS = textwrap.dedent(
     """
-select
-	definition view_def,
-	views.name view_name,
-	sch.name "schema"
-from sys.sql_modules as mod,
-sys.views as views,
-sys.schemas as sch
- where
-mod.object_id=views.object_id and
-views.schema_id=sch.schema_id
+SELECT
+    definition view_def,
+    views.name view_name,
+    sch.name "schema"
+FROM sys.sql_modules as mod
+INNER JOIN sys.views as views
+    ON mod.object_id = views.object_id
+INNER JOIN sys.schemas as sch
+    ON views.schema_id = sch.schema_id
 """
 )
 
@@ -191,10 +191,12 @@ MSSQL_GET_STORED_PROCEDURES = textwrap.dedent(
     """
 SELECT
   ROUTINE_NAME AS name,
-  NULL AS owner,
+  NULL AS owner,            
   ROUTINE_BODY AS language,
-  ROUTINE_DEFINITION AS definition
-FROM INFORMATION_SCHEMA.ROUTINES
+  l.definition AS definition
+FROM INFORMATION_SCHEMA.ROUTINES r
+JOIN sys.procedures p ON p.name = r.ROUTINE_NAME 
+JOIN sys.sql_modules l on l.object_id = p.object_id
  WHERE ROUTINE_TYPE = 'PROCEDURE'
    AND ROUTINE_CATALOG = '{database_name}'
    AND ROUTINE_SCHEMA = '{schema_name}' 

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

@@ -12,6 +12,7 @@
 MSSQL usage module
 """
 from abc import ABC
+from typing import Optional
 
 from metadata.generated.schema.entity.services.connections.database.mssqlConnection import (
     MssqlConnection,
@@ -32,7 +33,9 @@ class MssqlQueryParserSource(QueryParserSource, ABC):
     filters: str
 
     @classmethod
-    def create(cls, config_dict, metadata: OpenMetadata):
+    def create(
+        cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
+    ):
         """Create class instance"""
         config: WorkflowSource = WorkflowSource.parse_obj(config_dict)
         connection: MssqlConnection = config.serviceConnection.__root__.config

metadata/ingestion/source/database/mssql/utils.py

@@ -124,6 +124,7 @@ def get_columns(
         Column("minor_id", Integer, primary_key=True),
         Column("name", String, primary_key=True),
         Column("value", String),
+        Column("class_desc", String),
         schema="sys",
     )
     sys_columns = alias(
@@ -181,6 +182,8 @@ def get_columns(
             onclause=sql.and_(
                 extended_properties.c.major_id == sys_columns.c.object_id,
                 extended_properties.c.minor_id == sys_columns.c.column_id,
+                extended_properties.c.class_desc == "OBJECT_OR_COLUMN",
+                extended_properties.c.name == "MS_Description",
             ),
             isouter=True,
         )

metadata/ingestion/source/database/mysql/connection.py

@@ -30,7 +30,6 @@ from metadata.ingestion.connections.builders import (
     create_generic_db_connection,
     get_connection_args_common,
     get_connection_url_common,
-    init_empty_connection_options,
 )
 from metadata.ingestion.connections.test_connections import (
     test_connection_db_schema_sources,
@@ -52,16 +51,6 @@ def get_connection(connection: MysqlConnection) -> Engine:
             *connection.authType.azureConfig.scopes.split(",")
         )
         connection.authType = BasicAuth(password=access_token_obj.token)
-    if connection.sslCA or connection.sslCert or connection.sslKey:
-        if not connection.connectionOptions:
-            connection.connectionOptions = init_empty_connection_options()
-        if connection.sslCA:
-            connection.connectionOptions.__root__["ssl_ca"] = connection.sslCA
-        if connection.sslCert:
-            connection.connectionOptions.__root__["ssl_cert"] = connection.sslCert
-        if connection.sslKey:
-            connection.connectionOptions.__root__["ssl_key"] = connection.sslKey
-
     return create_generic_db_connection(
         connection=connection,
         get_connection_url_fn=get_connection_url_common,

metadata/ingestion/source/database/mysql/metadata.py

@@ -9,10 +9,11 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 """Mysql source module"""
-from typing import cast
+from typing import Optional, cast
 
 from sqlalchemy.dialects.mysql.base import ischema_names
 from sqlalchemy.dialects.mysql.reflection import MySQLTableDefinitionParser
+from sqlalchemy.engine.reflection import Inspector
 
 from metadata.generated.schema.entity.services.connections.database.mysqlConnection import (
     MysqlConnection,
@@ -24,6 +25,7 @@ from metadata.ingestion.api.steps import InvalidSourceException
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
 from metadata.ingestion.source.database.common_db_source import CommonDbSourceService
 from metadata.ingestion.source.database.mysql.utils import col_type_map, parse_column
+from metadata.utils.sqlalchemy_utils import get_all_table_ddls, get_table_ddl
 
 ischema_names.update(col_type_map)
 
@@ -32,6 +34,9 @@ MySQLTableDefinitionParser._parse_column = (  # pylint: disable=protected-access
     parse_column
 )
 
+Inspector.get_all_table_ddls = get_all_table_ddls
+Inspector.get_table_ddl = get_table_ddl
+
 
 class MysqlSource(CommonDbSourceService):
     """
@@ -40,7 +45,9 @@ class MysqlSource(CommonDbSourceService):
     """
 
     @classmethod
-    def create(cls, config_dict, metadata: OpenMetadata):
+    def create(
+        cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
+    ):
         config: WorkflowSource = WorkflowSource.parse_obj(config_dict)
         connection = cast(MysqlConnection, config.serviceConnection.__root__.config)
         if not isinstance(connection, MysqlConnection):

metadata/ingestion/source/database/oracle/connection.py

@@ -38,7 +38,7 @@ from metadata.ingestion.connections.builders import (
 )
 from metadata.ingestion.connections.test_connections import test_connection_db_common
 from metadata.ingestion.ometa.ometa_api import OpenMetadata
-from metadata.ingestion.source.database.oracle.queries import CHECK_ACCESS_TO_DBA
+from metadata.ingestion.source.database.oracle.queries import CHECK_ACCESS_TO_ALL
 from metadata.utils.logger import ingestion_logger
 
 CX_ORACLE_LIB_VERSION = "8.3.0"
@@ -138,7 +138,7 @@ def test_connection(
     of a metadata workflow or during an Automation Workflow
     """
 
-    test_conn_queries = {"CheckAccess": CHECK_ACCESS_TO_DBA}
+    test_conn_queries = {"CheckAccess": CHECK_ACCESS_TO_ALL}
 
     test_connection_db_common(
         metadata=metadata,

metadata/ingestion/source/database/oracle/metadata.py

@@ -71,7 +71,9 @@ from metadata.utils.helpers import get_start_and_end
 from metadata.utils.logger import ingestion_logger
 from metadata.utils.sqlalchemy_utils import (
     get_all_table_comments,
+    get_all_table_ddls,
     get_all_view_definitions,
+    get_table_ddl,
 )
 
 logger = ingestion_logger()
@@ -96,6 +98,9 @@ Inspector.get_mview_names = get_mview_names
 Inspector.get_mview_definition = get_mview_definition
 OracleDialect.get_mview_names = get_mview_names_dialect
 
+Inspector.get_all_table_ddls = get_all_table_ddls
+Inspector.get_table_ddl = get_table_ddl
+
 
 class OracleSource(StoredProcedureMixin, CommonDbSourceService):
     """
@@ -104,7 +109,9 @@ class OracleSource(StoredProcedureMixin, CommonDbSourceService):
     """
 
     @classmethod
-    def create(cls, config_dict, metadata: OpenMetadata):
+    def create(
+        cls, config_dict, metadata: OpenMetadata, pipeline_name: Optional[str] = None
+    ):
         config = WorkflowSource.parse_obj(config_dict)
         connection: OracleConnection = config.serviceConnection.__root__.config
         if not isinstance(connection, OracleConnection):
@@ -136,27 +143,38 @@ class OracleSource(StoredProcedureMixin, CommonDbSourceService):
 
         return regular_tables + material_tables
 
-    def get_view_definition(
+    def get_schema_definition(
         self, table_type: str, table_name: str, schema_name: str, inspector: Inspector
     ) -> Optional[str]:
-        if table_type not in {TableType.View, TableType.MaterializedView}:
-            return None
+        """
+        Get the DDL statement or View Definition for a table
+        """
+        try:
+            if table_type not in {TableType.View, TableType.MaterializedView}:
+                schema_definition = inspector.get_table_ddl(
+                    self.connection, table_name, schema_name
+                )
 
-        definition_fn = inspector.get_view_definition
-        if table_type == TableType.MaterializedView:
-            definition_fn = inspector.get_mview_definition
+            else:
+                definition_fn = inspector.get_view_definition
+                if table_type == TableType.MaterializedView:
+                    definition_fn = inspector.get_mview_definition
 
-        try:
-            view_definition = definition_fn(table_name, schema_name)
-            view_definition = "" if view_definition is None else str(view_definition)
-            return view_definition
+                schema_definition = definition_fn(table_name, schema_name)
+
+            schema_definition = (
+                str(schema_definition.strip())
+                if schema_definition is not None
+                else None
+            )
+            return schema_definition
 
         except NotImplementedError:
-            logger.warning("View definition not implemented")
+            logger.warning("Schema definition not implemented")
 
         except Exception as exc:
             logger.debug(traceback.format_exc())
-            logger.warning(f"Failed to fetch view definition for {table_name}: {exc}")
+            logger.warning(f"Failed to fetch Schema definition for {table_name}: {exc}")
         return None
 
     def process_result(self, data: FetchProcedureList):
@@ -179,7 +197,7 @@ class OracleSource(StoredProcedureMixin, CommonDbSourceService):
         if self.source_config.includeStoredProcedures:
             results: FetchProcedureList = self.engine.execute(
                 ORACLE_GET_STORED_PROCEDURES.format(
-                    schema=self.context.database_schema.upper()
+                    schema=self.context.get().database_schema.upper()
                 )
             ).all()
             results = self.process_result(data=results)
@@ -207,9 +225,9 @@ class OracleSource(StoredProcedureMixin, CommonDbSourceService):
                 databaseSchema=fqn.build(
                     metadata=self.metadata,
                     entity_type=DatabaseSchema,
-                    service_name=self.context.database_service,
-                    database_name=self.context.database,
-                    schema_name=self.context.database_schema,
+                    service_name=self.context.get().database_service,
+                    database_name=self.context.get().database,
+                    schema_name=self.context.get().database_schema,
                 ),
             )
             yield Either(right=stored_procedure_request)