fdc-shared-kernel 0.0.71__tar.gz → 0.0.72__tar.gz

{fdc_shared_kernel-0.0.71 → fdc_shared_kernel-0.0.72}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fdc_shared_kernel
-Version: 0.0.71
+Version: 0.0.72
 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.71 → fdc_shared_kernel-0.0.72}/fdc_shared_kernel.egg-info/SOURCES.txt

@@ -73,4 +73,5 @@ shared_kernel/utils/__init__.py
 shared_kernel/utils/data_validators_utils.py
 shared_kernel/utils/date_format_utils.py
 shared_kernel/utils/string_utils.py
-shared_kernel/utils/template_renderer.py
+shared_kernel/utils/template_renderer.py
+shared_kernel/utils/thread_local_util.py

{fdc_shared_kernel-0.0.71 → fdc_shared_kernel-0.0.72}/pyproject.toml

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

{fdc_shared_kernel-0.0.71 → fdc_shared_kernel-0.0.72}/shared_kernel/event_executor/event_executor.py

@@ -11,10 +11,14 @@ from shared_kernel.logger import Logger
 from shared_kernel.messaging.utils.event_messages import AWSEventMessage, EventMessage
 from shared_kernel.status_tracker import StatusTracker
 from shared_kernel.enums import TaskStatus
+from shared_kernel.utils.thread_local_util import ThreadLocalStorage
+
 
 app_config = Config()
 logger = Logger(app_config.get("APP_NAME"))
 
+thread_local_storage = ThreadLocalStorage()
+
 class EventExecutor:
 
     _instance = None
@@ -143,6 +147,8 @@ class EventExecutor:
             logger.error(
                 f"Error processing event {event_msg.event_name} trace-id: {event_msg.event_meta.trace_id}. span-id: {event_msg.event_meta.trace_id} : {str(e)}"
             )
+            logger.info("Error processing event",type="distributed_trace",is_success="False",failure_reason=str(e))
+
             # adding the failure reason to the event meta
             event_msg.event_meta.failure_reason = str(e)
 
@@ -203,16 +209,28 @@ class EventExecutor:
             logger.info(f"Initiating callback for message: {message}")
             event_msg = AWSEventMessage(message)
             event_name = event_msg.event_name
+
+            # Set thread-local context
+            thread_local_storage.set_all({
+                "trace_id": event_msg.event_meta.trace_id,
+                "span_id": event_msg.event_meta.span_id,
+                "org_id": event_msg.event_meta.org_id if hasattr(event_msg.event_meta, 'org_id') else None,
+                "event_name": event_msg.event_name,
+                "event_payload": json.dumps(event_msg.event_payload)
+            })
+            logger.info("Event recieved",type="distributed_trace")
+            # Process the message
             success = self._process_message(event_msg, callback)
-        finally:
 
-            # update the event stats whether its successful or failure
+        finally:
+            # Update the event stats whether it succeeded or failed
             if event_name:
                 self._update_event_stats(event_name, success)
 
             if success:
                 logger.info(
-                    f"Event {event_msg.event_name} completed successfully. trace-id: {event_msg.event_meta.trace_id}. span-id: {event_msg.event_meta.span_id}."
+                    f"Event {event_msg.event_name} completed successfully. "
+                    f"trace-id: {event_msg.event_meta.trace_id}. span-id: {event_msg.event_meta.span_id}."
                 )
                 self.status_tracker.update_task(
                     span_id=event_msg.event_meta.span_id,
@@ -221,10 +239,17 @@ class EventExecutor:
                     status=TaskStatus.COMPLETED.value,
                     task_id=event_msg.event_meta.job_id,
                 )
+                logger.info("Event processed successfully",type="distributed_trace",is_success="True",time_in_seconds= event_msg.event_meta.time_taken)
             else:
                 logger.warning(
-                    f"Event {event_msg.event_name} failed during processing. trace-id: {event_msg.event_meta.trace_id}. span-id: {event_msg.event_meta.span_id}."
+                    f"Event {event_msg.event_name} failed during processing. "
+                    f"trace-id: {event_msg.event_meta.trace_id}. span-id: {event_msg.event_meta.span_id}."
                 )
+
+            # Clean up thread-local storage
+            thread_local_storage.clear()
+
+            # Delete the message from the queue
             self.databus.delete_message(event_msg)
 
     def _task_done_callback(self, future: Future, event_name: str, event_semaphore: Semaphore) -> None:

{fdc_shared_kernel-0.0.71 → fdc_shared_kernel-0.0.72}/shared_kernel/logger/__init__.py

@@ -2,6 +2,7 @@ import logging
 import os
 import json
 from shared_kernel.config import Config
+from shared_kernel.utils.thread_local_util import ThreadLocalStorage
 class JSONFormatter(logging.Formatter):
     """
     Custom JSON formatter to structure log records as JSON.
@@ -16,8 +17,21 @@ class JSONFormatter(logging.Formatter):
             "level": record.levelname,
             "message": record.getMessage(),
         }
-        if hasattr(record, 'extra_data'):
-            log_record.update(record.extra_data)
+        # Get meta_data if present
+        meta_data = getattr(record, 'meta_data', {})
+
+        # Check if 'type' is in meta_data and is 'distributed_trace'
+        if meta_data.get("type") == "distributed_trace":
+            thread_context = ThreadLocalStorage.get_all()
+            # Add each data from thread local storage
+            log_record["trace_id"] = thread_context.get("trace_id")
+            log_record["span_id"] = thread_context.get("span_id")
+            log_record["org_id"] = thread_context.get("org_id")
+            log_record["event_name"] = thread_context.get("event_name")
+            log_record["event_payload"] = thread_context.get("event_payload")
+            log_record.update(meta_data)
+        if hasattr(record, 'meta_data'):
+            log_record.update(record.meta_data)
         if record.exc_info:
             log_record["exception"] = self.formatException(record.exc_info)
         return json.dumps(log_record)
@@ -100,17 +114,17 @@ class Logger:
         self.logger.addHandler(json_file_handler)
 
     def info(self, message, *args, **kwargs):
-        extra_data = {"extra_data": kwargs}
-        self.logger.info(message, *args, extra=extra_data, stacklevel=2)
+        meta_data = {"meta_data": kwargs}
+        self.logger.info(message, *args, extra=meta_data, stacklevel=2)
 
     def error(self, message, *args, **kwargs):
-        extra_data = {"extra_data": kwargs}
-        self.logger.error(message, exc_info=True, *args, extra=extra_data, stacklevel=2)
+        meta_data = {"meta_data": kwargs}
+        self.logger.error(message, exc_info=True, *args, extra=meta_data, stacklevel=2)
 
     def debug(self, message, *args, **kwargs):
-        extra_data = {"extra_data": kwargs}
-        self.logger.debug(message, *args, extra=extra_data, stacklevel=2)
+        meta_data = {"meta_data": kwargs}
+        self.logger.debug(message, *args, extra=meta_data, stacklevel=2)
 
     def warning(self, message, *args, **kwargs):
-        extra_data = {"extra_data": kwargs}
-        self.logger.warning(message, *args, extra=extra_data, stacklevel=2)
+        meta_data = {"meta_data": kwargs}
+        self.logger.warning(message, *args, extra=meta_data, stacklevel=2)

fdc_shared_kernel-0.0.72/shared_kernel/utils/thread_local_util.py

@@ -0,0 +1,63 @@
+import threading
+
+
+class ThreadLocalStorage:
+    """
+    Utility class for managing thread-local storage with class-level methods and variables.
+    """
+
+    # Class-level thread-local storage
+    _storage = threading.local()
+
+    @classmethod
+    def set(cls, key: str, value: any) -> None:
+        """
+        Sets a value in the thread-local storage.
+
+        :param key: The key for the value.
+        :param value: The value to be stored.
+        """
+        if not hasattr(cls._storage, "data"):
+            cls._storage.data = {}
+        cls._storage.data[key] = value
+
+    @classmethod
+    def set_all(cls, values: dict) -> None:
+        """
+        Sets multiple key-value pairs in the thread-local storage.
+
+        :param values: A dictionary of key-value pairs to store.
+        """
+        if not hasattr(cls._storage, "data"):
+            cls._storage.data = {}
+        cls._storage.data.update(values)
+
+    @classmethod
+    def get(cls, key: str, default=None) -> any:
+        """
+        Retrieves a value from the thread-local storage.
+
+        :param key: The key for the value.
+        :param default: The default value to return if the key is not found.
+        :return: The value associated with the key, or the default value.
+        """
+        if hasattr(cls._storage, "data") and key in cls._storage.data:
+            return cls._storage.data[key]
+        return default
+
+    @classmethod
+    def get_all(cls) -> dict:
+        """
+        Retrieves all key-value pairs from the thread-local storage.
+
+        :return: A dictionary of all thread-local data.
+        """
+        return getattr(cls._storage, "data", {}).copy() if hasattr(cls._storage, "data") else {}
+
+    @classmethod
+    def clear(cls) -> None:
+        """
+        Clears all values from the thread-local storage.
+        """
+        if hasattr(cls._storage, "data"):
+            cls._storage.data.clear()