fdc-shared-kernel 0.0.63__tar.gz → 0.0.65__tar.gz

{fdc_shared_kernel-0.0.63 → fdc_shared_kernel-0.0.65}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fdc_shared_kernel
-Version: 0.0.63
+Version: 0.0.65
 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.63 → fdc_shared_kernel-0.0.65}/fdc_shared_kernel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fdc_shared_kernel
-Version: 0.0.63
+Version: 0.0.65
 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.63 → fdc_shared_kernel-0.0.65}/pyproject.toml

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

{fdc_shared_kernel-0.0.63 → fdc_shared_kernel-0.0.65}/shared_kernel/enums/status_tracker.py

@@ -2,6 +2,8 @@ from enum import Enum
 
 
 class TaskStatus(Enum):
+    QUEUED = "Queued"
     PROCESSING = "Processing"
     COMPLETED = "Completed"
-    FAILED = "Failed"
+    FAILED = "Failed"
+    SKIPPED = "Skipped"

{fdc_shared_kernel-0.0.63 → fdc_shared_kernel-0.0.65}/shared_kernel/event_executor/event_executor.py

@@ -219,6 +219,8 @@ class EventExecutor:
                 if message:
                     logger.info(f"Received message for event {event_name}: {message}")
                     future = executor.submit(self._callback_wrapper, callback, message)
+                    # adding a callback to the future object to ensure that its removed from
+                    # _active_futures upon its successful completion
                     future.add_done_callback(lambda f: self._active_futures[event_name].discard(f))
                     self._active_futures[event_name].add(future)
             except Exception as e:
@@ -266,7 +268,8 @@ class EventExecutor:
                 },
                 "events": {
                     "successful": event_stats.successful_events,
-                    "failed": event_stats.failed_events
+                    "failed": event_stats.failed_events,
+                    "total": event_stats.total_events
                 }
             }
         

{fdc_shared_kernel-0.0.63 → fdc_shared_kernel-0.0.65}/shared_kernel/messaging/aws_databus.py

@@ -6,6 +6,8 @@ from shared_kernel.interfaces.databus import DataBus
 from shared_kernel.logger import Logger
 from shared_kernel.messaging.utils.aws_utility import AWSMessagingUtility, AWSQueue
 from shared_kernel.messaging.utils.event_messages import AWSEventMessage
+from shared_kernel.status_tracker.status_tracker import StatusTracker
+from shared_kernel.enums import TaskStatus
 
 app_config = Config()
 logger = Logger(app_config.get("APP_NAME"))
@@ -34,6 +36,7 @@ class AWSDataBus(DataBus):
             super().__init__()
             self.aws_utility = AWSMessagingUtility()
             self.event_queue_mapper = {}
+            self.status_tracker = StatusTracker()
             self.initialized = True
 
     def make_connection(self):
@@ -56,7 +59,15 @@ class AWSDataBus(DataBus):
         Returns:
             bool: True if the event was published successfully, False otherwise.
         """
-        return self.aws_utility.publish_event(event_name, event_payload)
+        is_success, validated_event_dict = self.aws_utility.publish_event(event_name, event_payload)
+        if is_success:
+            self.status_tracker.create_task(
+                span_id=validated_event_dict["event_meta"]["span_id"],
+                trace_id=validated_event_dict["event_meta"]["trace_id"],
+                task=validated_event_dict["event_name"],
+                status=TaskStatus.QUEUED.value,
+                task_id=validated_event_dict["event_meta"]["job_id"],
+            )
 
     def subscribe_sync_event(self, event_name: str, callback: Callable[[Any], None]):
         """

{fdc_shared_kernel-0.0.63 → fdc_shared_kernel-0.0.65}/shared_kernel/messaging/utils/aws_utility.py

@@ -1,5 +1,5 @@
 import json
-from typing import Dict
+from typing import Dict, Optional, Union
 
 import boto3
 from botocore.exceptions import ClientError
@@ -216,7 +216,7 @@ class AWSMessagingUtility:
             f"Message deleted from queue with receipt handle '{receipt_handle}'."
         )
 
-    def publish_event(self, event_name: str, event_payload: dict):
+    def publish_event(self, event_name: str, event_payload: dict) -> Union[bool, Optional[dict]]:
         """
         Publish an event to EventBridge.
         Args:
@@ -243,13 +243,16 @@ class AWSMessagingUtility:
                 logger.error(
                     f"Failed to publish event '{event_name}': {response['Entries'][0].get('ErrorMessage', 'Unknown error while publishing event')}"
                 )
-                return False
+                return False, None
             else:
                 event_id = response["Entries"][0].get("EventId")
                 logger.info(
                     f"Successfully published event '{event_name}' with EventId: {event_id}"
                 )
-                return True
+                return True, publish_message.event_dict
         except ClientError as e:
             logger.error(f"Failed to publish event: {e}")
-            return False
+            return False, None
+        except Exception as e:
+            logger.error(f"Failed to publish event: {e}")
+            return False, None

{fdc_shared_kernel-0.0.63 → fdc_shared_kernel-0.0.65}/shared_kernel/messaging/utils/event_messages.py

@@ -13,12 +13,15 @@ class EventMeta:
         span_id (str): Unique identifier for this specific operation within the trace.
         job_id (str): Identifier for the job associated with this event.
     """
+    ALLOWED_TRIGGER_BY_VALUES = {"SCHEDULER", "PROVISION", "MANUAL", "EVENT"}
+
     def __init__(self, meta_data: Dict):
         self.trace_id: str = meta_data.get("trace_id")
         self.job_id: str = meta_data.get("job_id")
+        self.trigger = meta_data.get("trigger")
 
-        # entity_name is specific to entity related events
-        self.entity_name = meta_data.get("entity_name")
+        if self.trigger and self.trigger not in self.ALLOWED_TRIGGER_BY_VALUES:
+            raise ValueError(f"Invalid trigger value: {self.trigger}. Must be one of {self.ALLOWED_TRIGGER_BY_VALUES}.")
 
         # time taken for the entire execution of the event
         self.start_time: str = None
@@ -28,8 +31,10 @@ class EventMeta:
         # failure reason if any
         self.failure_reason: str = None
 
-        # generate a new span_id for each event
-        self.span_id: str = str(uuid.uuid4())
+        # generate a new span_id for each event if not present already
+        self.span_id: str = meta_data.get("span_id", str(uuid.uuid4()))
+
+        self.additional_fields: Dict[str, Any] = {k: v for k, v in meta_data.items() if k not in {"trace_id", "job_id"}}
 
     def start_event(self):
         """Sets the start time of the event."""
@@ -62,15 +67,16 @@ class EventMeta:
 
     def to_dict(self) -> Dict:
         """Returns a dictionary representation of the event metadata."""
-        return {
+        base_dict = {
             "trace_id": self.trace_id,
             "span_id": self.span_id,
             "job_id": self.job_id,
             "start_time": self.start_time or "",
             "end_time": self.end_time or "",
             "time_taken": self.time_taken if self.time_taken else "",
-            "entity_name": self.entity_name if self.entity_name else ""
         }
+        # merge core fields with additional fields
+        return {**base_dict, **self.additional_fields}
 
 
 class PublishEventMessage:
@@ -114,8 +120,9 @@ class PublishEventMessage:
         if "event_meta" not in self.event_dict or not self.event_dict["event_meta"]["trace_id"]:
             raise Exception("Message metdata or trace_id not found.")
 
-        # always generate a new job_id
+        # always generate a new job id and span id
         self.event_dict["event_meta"]["job_id"] = str(uuid.uuid4())
+        self.event_dict["event_meta"]["span_id"] = str(uuid.uuid4())
 
     def to_dict(self) -> dict:
         """Convert the event to a dictionary format"""