fdc-shared-kernel 0.0.44__tar.gz → 0.0.46__tar.gz

{fdc_shared_kernel-0.0.44 → fdc_shared_kernel-0.0.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fdc_shared_kernel
-Version: 0.0.44
+Version: 0.0.46
 Summary: Shared library for microservice
 Author-email: Shikhil S <shikhil.s@dbizsolution.com>, Ahammed Akdham N <ahammedakdham.n@dbizsolution.com>
 Classifier: Programming Language :: Python :: 3

{fdc_shared_kernel-0.0.44 → fdc_shared_kernel-0.0.46}/fdc_shared_kernel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fdc_shared_kernel
-Version: 0.0.44
+Version: 0.0.46
 Summary: Shared library for microservice
 Author-email: Shikhil S <shikhil.s@dbizsolution.com>, Ahammed Akdham N <ahammedakdham.n@dbizsolution.com>
 Classifier: Programming Language :: Python :: 3

{fdc_shared_kernel-0.0.44 → fdc_shared_kernel-0.0.46}/fdc_shared_kernel.egg-info/SOURCES.txt

@@ -40,10 +40,14 @@ shared_kernel/messaging/nats_databus.py
 shared_kernel/metrics/__init__.py
 shared_kernel/metrics/status_tracker.py
 shared_kernel/models/__init__.py
+shared_kernel/registries/__init__.py
+shared_kernel/registries/service_event_registry.py
 shared_kernel/security/__init__.py
 shared_kernel/security/key_vault/__init__.py
 shared_kernel/security/key_vault/aws_secret_manager.py
 shared_kernel/security/key_vault/azure_keyvault.py
+shared_kernel/status_tracker/__init__.py
+shared_kernel/status_tracker/status_tracker.py
 shared_kernel/tests/__init__.py
 shared_kernel/tests/config/__init__.py
 shared_kernel/tests/config/test_config.py

{fdc_shared_kernel-0.0.44 → fdc_shared_kernel-0.0.46}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fdc_shared_kernel"
-version = "0.0.44"
+version = "0.0.46"
 requires-python = ">=3.7"
 readme = "README_pypi.md"
 description = "Shared library for microservice"

{fdc_shared_kernel-0.0.44 → fdc_shared_kernel-0.0.46}/shared_kernel/exceptions/custom_exceptions.py

@@ -12,3 +12,9 @@ class UnsupportedProfiling(BaseCustomException):
     """Raised when an unsupported data profiling method is requested."""
     def __init__(self, message: str = "The profiling method is not supported.", details: str = "") -> None:
         super().__init__(message=message, details=details)
+
+
+class StatusTrackerException(BaseCustomException):
+    """Raised when an error occurs during status tracker operations."""
+    def __init__(self, message: str = "An error occurred during status tracking.") -> None:
+        super().__init__(message=message)

{fdc_shared_kernel-0.0.44 → fdc_shared_kernel-0.0.46}/shared_kernel/logger/__init__.py

@@ -45,6 +45,7 @@ class Logger:
 
         self.logger = logging.getLogger(name if name else __name__)
         self.logger.setLevel(logging.DEBUG)
+        self.logger.propagate = False
         self.formatter = logging.Formatter(
             "%(asctime)s - %(name)s - %(filename)s - %(module)s - %(levelname)s - %(message)s"
         )

{fdc_shared_kernel-0.0.44 → fdc_shared_kernel-0.0.46}/shared_kernel/messaging/nats_databus.py

@@ -23,13 +23,6 @@ class NATSDataBus(DataBus):
     A NATS interface class to handle both standard NATS and JetStream operations.
     """
 
-    _instance = None
-
-    def __new__(cls, *args, **kwargs):
-        if cls._instance is None:
-            cls._instance = super(NATSDataBus, cls).__new__(cls)
-        return cls._instance
-
     def __init__(self, config: Dict = None):
         """
         Initialize the NATSDataBus.
@@ -37,16 +30,14 @@ class NATSDataBus(DataBus):
         Args:
             config (Dict): A dictionary containing the NATS configuration.
         """
-        if not hasattr(self, "initialized"):  # Prevent reinitialization
-            super().__init__()
-            self.nats_client = NATS()
-            self.servers = config.get("servers")
-            self.user = config.get("user")
-            self.password = config.get("password")
-            self.connected = False
-            self.nats_jet_stream_context = None  # JetStream context
-            self.initialized = True
-            self.max_delivery_count = app_config.get("MAX_DELIVERY_COUNT")
+        super().__init__()
+        self.nats_client = NATS()
+        self.servers = config.get("servers")
+        self.user = config.get("user")
+        self.password = config.get("password")
+        self.connected = False
+        self.nats_jet_stream_context = None  # JetStream context
+        self.max_delivery_count = app_config.get("MAX_DELIVERY_COUNT")
 
     async def _connection_error_callback(self, e: Exception) -> None:
         """
@@ -74,6 +65,7 @@ class NATSDataBus(DataBus):
                         ack_policy=AckPolicy.EXPLICIT,
                         deliver_policy=DeliverPolicy.ALL,
                         filter_subject=subject,
+                        ack_wait=3600,
                         max_ack_pending=5,
                     )
                     await self.nats_jet_stream_context.add_consumer(
@@ -200,7 +192,7 @@ class NATSDataBus(DataBus):
         """
         Connect to the NATS server.
         """
-        if not self.connected:
+        if not self.nats_client.is_connected:
             await self.nats_client.connect(
                 servers=self.servers,
                 user=self.user,
@@ -296,19 +288,20 @@ class NATSDataBus(DataBus):
                 event_data: dict = json.loads(message_object.data.decode())
                 has_job_failed = False
                 try:
-                    callback(event_data)
+                    await callback(event_data)
+                    # acknowledge the message after processing and finishing the job
+                    await message_object.ack()
+                    logger.info(f"Acknowledged job: {event_data}")
                 except Exception as e:
                     logger.error(
                         f"Invoking callback during execution of [{event_name}] failed due to {str(e)}"
                     )
                     has_job_failed = True
 
-                if not has_job_failed:
-                    # acknowledge the message after processing and finishing the job successfully
-                    await message_object.ack()
-                    logger.info(f"Acknowledged job: {event_data}")
-                elif message_object.metadata.num_delivered == self.max_delivery_count:
-                    # move to DLQ if max retries have been reached
+                if (
+                    has_job_failed
+                    and message_object.metadata.num_delivered == self.max_delivery_count
+                ):
                     logger.warning("Moving event to the dead letter topic after max retries")
                     await self._create_dlq_stream()
                     await self._move_to_dlq(event_name, event_data)

fdc_shared_kernel-0.0.46/shared_kernel/registries/__init__.py

@@ -0,0 +1 @@
+from shared_kernel.registries.service_event_registry import ServiceEventRegistry # noqa

fdc_shared_kernel-0.0.46/shared_kernel/registries/service_event_registry.py

@@ -0,0 +1,21 @@
+from shared_kernel.config import Config
+
+config = Config()
+
+
+class ServiceEventRegistry:
+    # Sync events to master service to create/update status tracker
+    CREATE_TASK = (
+        config.get("MASTER_SERVICE_BASE_ENDPOINT")
+        + "/event/subscribe-sync-event/CREATE_TASK/"
+    )
+
+    UPDATE_TASK = (
+        config.get("MASTER_SERVICE_BASE_ENDPOINT")
+        + "/event/subscribe-sync-event/UPDATE_TASK/"
+    )
+
+    MARK_TASK_AS_FAILURE = (
+        config.get("MASTER_SERVICE_BASE_ENDPOINT")
+        + "/event/subscribe-sync-event/MARK_TASK_AS_FAILURE/"
+    )

fdc_shared_kernel-0.0.46/shared_kernel/status_tracker/__init__.py

@@ -0,0 +1 @@
+from shared_kernel.status_tracker.status_tracker import StatusTracker # noqa

fdc_shared_kernel-0.0.46/shared_kernel/status_tracker/status_tracker.py

@@ -0,0 +1,89 @@
+from shared_kernel.exceptions.custom_exceptions import StatusTrackerException
+from shared_kernel.interfaces.databus import DataBus
+from shared_kernel.messaging import DataBusFactory
+from shared_kernel.registries.service_event_registry import ServiceEventRegistry
+
+service_event_registry = ServiceEventRegistry()
+
+
+class StatusTracker:
+    """
+    A singleton StatusTracker class that ensures only one StatusTracker instance is created.
+
+    Attributes:
+        _instance (Optional[StatusTracker]): The single instance of the StatusTracker.
+    """
+
+    _instance = None
+
+    def __new__(cls, name=None):
+        """
+        override __new__ to ensure singleton pattern.
+        """
+        if cls._instance is None:
+            cls._instance = super(StatusTracker, cls).__new__(cls)
+            cls._instance._initialize(name=name)
+        return cls._instance
+
+
+    def _initialize(self):
+        self.databus: DataBus = DataBusFactory.create_data_bus(
+            bus_type="HTTP", config={}
+        )
+
+
+    def create_task(self, span_id, trace_id, entity_id, task, status):
+        """Publishes a synchronous event to create a task"""
+        try:
+            payload = {
+                "span_id": span_id,
+                "trace_id": trace_id,
+                "entity_id": entity_id,
+                "task": task,
+                "status": status,
+            }
+            response = self.databus.request_event(
+                getattr(service_event_registry, "CREATE_TASK"), payload
+            )
+            return response
+
+        except Exception as e:
+            raise StatusTrackerException(e)
+
+
+    def update_task(self, span_id, trace_id, entity_id, task, status):
+        """Publishes a synchronous event to update a task"""
+        try:
+            payload = {
+                "span_id": span_id,
+                "trace_id": trace_id,
+                "entity_id": entity_id,
+                "task": task,
+                "status": status,
+            }
+            response = self.databus.request_event(
+                getattr(service_event_registry, "UPDATE_TASK"), payload
+            )
+            return response
+
+        except Exception as e:
+            raise StatusTrackerException(e)
+
+
+    def mark_task_as_failure(self, span_id, trace_id, entity_id, task, failure_reason):
+        """Publishes a synchronous event to mark a task as failure"""
+        try:
+            payload = {
+                "span_id": span_id,
+                "trace_id": trace_id,
+                "entity_id": entity_id,
+                "task": task,
+                "failure_reason": failure_reason,
+            }
+            response = self.databus.request_event(
+                getattr(service_event_registry, "MARK_TASK_AS_FAILURE"), payload
+            )
+            return response
+
+        except Exception as e:
+            raise StatusTrackerException(e)