fdc-shared-kernel 0.0.97__tar.gz → 0.0.99__tar.gz

{fdc_shared_kernel-0.0.97 → fdc_shared_kernel-0.0.99}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fdc_shared_kernel
-Version: 0.0.97
+Version: 0.0.99
 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.97 → fdc_shared_kernel-0.0.99}/fdc_shared_kernel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fdc_shared_kernel
-Version: 0.0.97
+Version: 0.0.99
 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.97 → fdc_shared_kernel-0.0.99}/fdc_shared_kernel.egg-info/SOURCES.txt

@@ -16,6 +16,8 @@ shared_kernel/auth/token_handler.py
 shared_kernel/auth/workbook_permission_handler.py
 shared_kernel/config/__init__.py
 shared_kernel/database/__init__.py
+shared_kernel/dataclasses/__init__.py
+shared_kernel/dataclasses/event_executor.py
 shared_kernel/datatype_mappings/__init__.py
 shared_kernel/datatype_mappings/connectors_to_system/__init__.py
 shared_kernel/datatype_mappings/connectors_to_system/csv.py
@@ -35,6 +37,7 @@ shared_kernel/enums/async_task_executor.py
 shared_kernel/enums/status_tracker.py
 shared_kernel/event_executor/__init__.py
 shared_kernel/event_executor/event_executor.py
+shared_kernel/event_executor/job_executor.py
 shared_kernel/event_executor/utils.py
 shared_kernel/exceptions/__init__.py
 shared_kernel/exceptions/configuration_exceptions.py
@@ -89,8 +92,10 @@ 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/thread_local_util.py
+shared_kernel/utils/thread_debug_utils.py
+shared_kernel/utils/thread_local_storage.py
 tests/__init__.py
+tests/test_job_executor.py
 tests/messaging/__init__.py
 tests/messaging/utils/__init__.py
 tests/messaging/utils/test_aws_utility.py

{fdc_shared_kernel-0.0.97 → fdc_shared_kernel-0.0.99}/pyproject.toml

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

fdc_shared_kernel-0.0.99/shared_kernel/dataclasses/event_executor.py

@@ -0,0 +1,41 @@
+"""
+File: event_executor.py
+Author: Akdham
+Description: Dataclasses for event executor
+Date: 2025-05-07
+"""
+from concurrent.futures import Future
+from dataclasses import dataclass, field
+from typing import Any, Callable, List
+
+from shared_kernel.messaging.utils.event_messages import EventMessage
+
+@dataclass
+class EventStats:
+    """Statistics for an event type"""
+    successful_events: int = 0
+    failed_events: int = 0
+    
+    @property
+    def total_events(self) -> int:
+        return self.successful_events + self.failed_events
+
+
+@dataclass
+class ActiveJob:
+    """Represents a job currently being processed by the executor."""
+
+    execution_future: Future
+    event_msg_object: EventMessage
+
+
+@dataclass
+class EventContext:
+    """Stores metadata and runtime statistics for an event."""
+
+    schema: dict
+    description: str
+    callback: Callable[[Any], None]
+    total_workers: int
+    event_stats: EventStats
+    active_jobs: List[ActiveJob] = field(default_factory=list)

fdc_shared_kernel-0.0.99/shared_kernel/event_executor/event_executor.py

@@ -0,0 +1,251 @@
+import threading
+from concurrent.futures import Future
+from typing import Any, Callable, Dict, Optional
+
+from shared_kernel.config import Config
+from shared_kernel.dataclasses.event_executor import ActiveJob, EventContext, EventStats
+from shared_kernel.event_executor.job_executor import JobExecutor
+from shared_kernel.event_executor.utils import EventConcurrencyManager
+from shared_kernel.interfaces import DataBus
+from shared_kernel.logger import Logger
+from shared_kernel.status_tracker import StatusTracker
+from shared_kernel.utils.thread_local_storage import ThreadLocalStorage
+from shared_kernel.messaging.utils.event_messages import EventMessage
+
+
+app_config = Config()
+logger = Logger(app_config.get("APP_NAME"))
+
+thread_local_storage = ThreadLocalStorage()
+
+
+class EventExecutor:
+    _singleton_instance = None
+    _singleton_lock = threading.Lock()
+
+    def __new__(self, *args, **kwargs):
+        with self._singleton_lock:
+            if self._singleton_instance is None:
+                instance = super().__new__(self)
+                instance._is_initialized = False
+                self._singleton_instance = instance
+            return self._singleton_instance
+
+    def __init__(
+        self,
+        databus: Optional[DataBus] = None,
+        status_tracker: Optional[StatusTracker] = None,
+    ):
+        """Initialize the EventExecutor singleton.
+
+        Args:
+            databus (Optional[DataBus]): The DataBus instance to use for publishing messages.
+            status_tracker (Optional[StatusTracker]): The StatusTracker instance to use for tracking status.
+        """
+        with self._singleton_lock:
+            if self._is_initialized:
+                return
+
+            # checked only during initial initialization - that is during app startup
+            if databus is None or status_tracker is None:
+                raise ValueError(
+                    "DataBus and StatusTracker must be provided for initial initialization"
+                )
+
+            # initialize core components
+            self.databus = databus
+            self.status_tracker = status_tracker
+            self.job_executor = JobExecutor(status_tracker, databus)
+            self._event_listener_threads: Dict[str, threading.Thread] = {}
+            self._event_concurrency_manager = EventConcurrencyManager()
+            self._shutdown_flag = threading.Event()
+            self._event_catalog: Dict[str, EventContext] = {}
+
+            self._is_initialized = True
+            logger.info("EventExecutor singleton initialized.")
+
+    def get_stats(self, event_name: str) -> EventStats:
+        """Return statistics for a specific event."""
+        if event_name in self._event_catalog:
+            return self._event_catalog[event_name].event_stats
+        return EventStats()
+
+    def _on_job_execution_complete(
+        self,
+        execution_future: Future,
+        event_name: str,
+        event_semaphore: threading.Semaphore,
+        active_job: ActiveJob,
+    ) -> None:
+        """
+        Callback executed after a job completes. Updates counters and releases semaphore.
+
+        Args:
+            execution_future (Future): the completed future
+            event_name (str): name of the event
+            event_semaphore (Semaphore): semaphore controlling concurrency
+            active_job (ActiveJob): the job object containing the future and payload
+        """
+        try:
+            if active_job in self._event_catalog[event_name].active_jobs:
+                self._event_catalog[event_name].active_jobs.remove(active_job)
+
+            try:
+                execution_future.result()  # will raise if the job failed
+                self._event_catalog[event_name].event_stats.successful_events += 1
+            except Exception:
+                self._event_catalog[event_name].event_stats.failed_events += 1
+        finally:
+            # always release the semaphore, even if there's an exception
+            event_semaphore.release()
+
+    def _listen_events(self, event_name: str) -> None:
+        """Listen to the async event source and dispatch jobs."""
+        logger.info(f"Starting event listener for [{event_name}].")
+
+        event_semaphore = self._event_concurrency_manager.get_event_semaphore(
+            event_name=event_name
+        )
+        event_threadpool_executor = (
+            self._event_concurrency_manager.get_event_threadpool_executor(
+                event_name=event_name
+            )
+        )
+        event_context = self._event_catalog[event_name]
+
+        while not self._shutdown_flag.is_set():
+            is_semaphore_acquired = False
+            try:
+                is_semaphore_acquired = event_semaphore.acquire(timeout=0.5)
+                if is_semaphore_acquired:
+                    # get message from the databus
+                    event_msg_object: EventMessage = self.databus.get_message(event_name)
+                    if event_msg_object:
+                        logger.info(
+                            f"Received message for event {event_name}: {event_msg_object.raw_message}"
+                        )
+
+                        # submit job to executor
+                        execution_future = event_threadpool_executor.submit(
+                            self.job_executor.submit_job,
+                            event_context.callback,
+                            event_msg_object,
+                        )
+
+                        # track active job
+                        active_job = ActiveJob(
+                            execution_future=execution_future, event_msg_object=event_msg_object
+                        )
+                        self._event_catalog[event_name].active_jobs.append(active_job)
+
+                        # assign callback to future
+                        execution_future.add_done_callback(
+                            lambda fut, event_name=event_name, event_semaphore=event_semaphore, active_job=active_job: self._on_job_execution_complete(
+                                fut, event_name, event_semaphore, active_job
+                            )
+                        )
+
+                        # we don't release the semaphore here because it will be released in _task_done_callback
+                        is_semaphore_acquired = False
+                    else:
+                        # no message, release semaphore to permit
+                        event_semaphore.release()
+                        is_semaphore_acquired = False
+                else:
+                    # if we couldn't acquire the semaphore, wait for 0.1 seconds
+                    self._shutdown_flag.wait(0.1)
+            except Exception as e:
+                logger.error(f"Error in event listener for {event_name}: {str(e)}")
+                # TODO: implement retry logic or circuit breaker pattern here - needs to do some research on this
+            finally:
+                # make sure semaphore is released if we encountered an exception after acquiring it
+                if is_semaphore_acquired:
+                    event_semaphore.release()
+
+        logger.info(f"Event listener for {event_name} has been stopped.")
+
+    def get_event_catalog(self) -> dict:
+        """Return the event catalog."""
+        return self._event_catalog
+
+    def get_databus_instance(self) -> DataBus:
+        """Return the databus instance"""
+        return self.databus
+
+    def register_event(
+        self,
+        event_name: str,
+        event_schema: dict,
+        event_description: str,
+        callback: Callable[[Any], None],
+        max_concurrency: int,
+    ) -> dict:
+        """Register an event and start listening for messages."""
+        with self._singleton_lock:  # protect against concurrent register_event calls
+            if event_name in self._event_listener_threads:
+                raise ValueError(f"Event {event_name} is already registered")
+
+            # register with async bus and set up concurrency controls
+            self.databus.subscribe_async_event(event_name, None)
+            self._event_concurrency_manager.set_event_concurrency(
+                event_name=event_name, max_concurrency=max_concurrency
+            )
+
+            # initialize with default EventStats
+            self._event_catalog[event_name] = EventContext(
+                schema=event_schema,
+                description=event_description,
+                callback=callback,
+                total_workers=max_concurrency,
+                event_stats=EventStats(),
+            )
+
+            # launch listener thread
+            long_running_event_listener_thread = threading.Thread(
+                target=self._listen_events,
+                args=(event_name,),
+                name=f"EventListener-{event_name}",
+                daemon=True,
+            )
+            self._event_listener_threads[event_name] = long_running_event_listener_thread
+            long_running_event_listener_thread.start()
+            logger.info(f"Event {event_name} registered and listener started.")
+
+            return True
+
+    def shutdown(self) -> None:
+        """Shut down all running threads and cleanup resources."""
+        self._shutdown_flag.set()
+
+        for event_name, thread in self._event_listener_threads.items():
+            logger.info(f"Shutting down thread for event {event_name}")
+            thread.join(timeout=30)  # Don't wait forever
+
+            if thread.is_alive():
+                logger.warning(
+                    f"Thread for event {event_name} did not terminate gracefully"
+                )
+
+        # wait for all running jobs to finish with timeout
+        for event_name, catalog in self._event_catalog.items():
+            for job in catalog.active_jobs:
+                try:
+                    # Set a timeout to avoid hanging
+                    job.execution_future.result(timeout=10)
+                except Exception as e:
+                    logger.error(
+                        f"Error during shutdown of task for event {event_name}: {str(e)}"
+                    )
+
+        # shut down executors
+        for (
+            event_name,
+            executor,
+        ) in self._event_concurrency_manager.event_threadpool_executors.items():
+            logger.info(f"Shutting down executor for event {event_name}")
+            executor.shutdown(wait=True)
+
+        self._event_listener_threads.clear()
+        self._event_concurrency_manager.event_threadpool_executors.clear()
+        self._event_concurrency_manager.event_semaphores.clear()
+        logger.info("EventExecutor shutdown complete.")

fdc_shared_kernel-0.0.99/shared_kernel/event_executor/job_executor.py

@@ -0,0 +1,306 @@
+"""
+Filename: job_executor.py
+Author: Akdham
+Description: Handles the execution of individual jobs/tasks triggered by events.
+Date: 2025-05-07
+"""
+import json
+from typing import Any, Callable, Dict, Optional
+
+from shared_kernel.config import Config
+from shared_kernel.enums import TaskStatus
+from shared_kernel.interfaces import DataBus
+from shared_kernel.logger import Logger
+from shared_kernel.status_tracker import StatusTracker
+from shared_kernel.messaging.utils.event_messages import AWSEventMessage, EventMessage
+from shared_kernel.utils.thread_local_storage import ThreadLocalStorage
+
+app_config = Config()
+logger = Logger(app_config.get("APP_NAME"))
+
+thread_local_storage = ThreadLocalStorage()
+
+
+class JobExecutor:
+    """
+    Handles the execution of individual jobs/tasks triggered by events.
+    Responsible for the actual business logic execution and status tracking as well as error handling.
+    """
+
+    def __init__(self, status_tracker: StatusTracker, databus: DataBus):
+        """
+        Initialize the job executor.
+
+        Args:
+            status_tracker: Status tracker to track status of events' jobs
+            databus: DataBus
+        """
+        self.status_tracker = status_tracker
+        self.databus = databus
+
+    def _setup_thread_context(self, event_msg: EventMessage) -> None:
+        """
+        Set up thread-local storage with event metadata.
+        
+        Args:
+            event_msg: Event message containing metadata
+        """
+        context = {
+            "trace_id": event_msg.event_meta.trace_id,
+            "span_id": event_msg.event_meta.span_id,
+            "event_name": event_msg.event_name,
+            "event_payload": json.dumps(event_msg.event_payload),
+            "event_meta": json.dumps(event_msg.event_meta.to_dict()),
+        }
+        
+        # add optional fields if they exist
+        if hasattr(event_msg.event_meta, "org_id"):
+            context["org_id"] = event_msg.event_meta.org_id
+            
+        if hasattr(event_msg.event_meta, "trigger"):
+            context["trigger"] = event_msg.event_meta.trigger
+            
+        if hasattr(event_msg.event_meta, "parent_span_id"):
+            context["parent_span_id"] = event_msg.event_meta.parent_span_id
+        
+        thread_local_storage.set_all(context)
+        logger.info("Event received", type="distributed_trace")
+
+    def _get_task_tracking_id(self, task_details: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """
+        Extract tracking id from task details if available.
+        
+        Args:
+            task_details: Task details dictionary
+            
+        Returns:
+            tracking id or None
+        """
+        task = task_details.get("task_details") if task_details else None
+        if task and task.get("tracking_id"):
+            return json.loads(task["tracking_id"])
+        return None
+    
+    def _is_duplicate_task(self, task_details: Optional[dict]) -> bool:
+        return bool(task_details and task_details.get("is_duplicate", False))
+    
+    def _handle_new_task(self, event_msg: EventMessage):
+        """
+        Create a new task and set event meta and message receipt handle.
+        
+        Args:
+            event_msg: Event message
+        """
+        logger.info(
+            f"[JobExecutor] Creating new task:\n"
+            f"  event_name: {event_msg.event_name}\n"
+            f"  trace_id: {event_msg.event_meta.trace_id}\n"
+            f"  span_id: {event_msg.event_meta.span_id}"
+        )
+        self.status_tracker.create_task(event_msg=event_msg, status=TaskStatus.PROCESSING.value)
+        self.status_tracker.set_event_meta_and_message_receipt_handle(event_msg)
+
+    def _update_queued_task(self, event_msg: EventMessage):
+        """
+        Update a queued task and set event meta and message receipt handle.
+        
+        Args:
+            event_msg: Event message
+        """
+        logger.info(
+            f"[JobExecutor] Updating queued task:\n"
+            f"  event_name: {event_msg.event_name}\n"
+            f"  trace_id: {event_msg.event_meta.trace_id}\n"
+            f"  span_id: {event_msg.event_meta.span_id}"
+        )
+        self.status_tracker.set_event_meta_and_message_receipt_handle(event_msg)
+        self.status_tracker.update_task(event_msg=event_msg, status=TaskStatus.PROCESSING.value)
+
+    def _handle_dlq(self, event_msg: EventMessage):
+        """
+        Publish event to DLQ.
+        
+        Args:
+            event_msg: Event message
+        """
+        logger.warning(
+            f"[JobExecutor] Publishing event to DLQ:\n"
+            f"  event_name: {event_msg.event_name}\n"
+            f"  trace_id: {event_msg.event_meta.trace_id}\n"
+            f"  span_id: {event_msg.event_meta.span_id}"
+        )
+        self.databus.publish_event("DLQ", {
+            "event_name": event_msg.event_name,
+            "event_payload": event_msg.event_payload,
+            "event_meta": event_msg.event_meta.to_dict(),
+        })
+    
+    def _check_and_update_task_status(self, event_msg: AWSEventMessage) -> tuple[bool, Optional[Dict[str, Any]]]:
+        """
+        Determines task state, returns whether it's a duplicate and tracking ID if needed.
+
+        Args:
+            event_msg: Event message
+
+        Returns:
+            tuple: (is_duplicate, tracking_id)
+        """
+        is_duplicate_task = False
+        tracking_id = None
+
+        logger.info(
+            f"[JobExecutor] Checking task status:\n"
+            f"  event_name: {event_msg.event_name}\n"
+            f"  trace_id: {event_msg.event_meta.trace_id}\n"
+            f"  span_id: {event_msg.event_meta.span_id}"
+        )
+
+        task_details: dict = self.status_tracker.get_task(task_details=event_msg)
+
+        # check if the task is marked as a duplicate
+        if self._is_duplicate_task(task_details):
+            logger.info(
+                f"[JobExecutor] Duplicate task already in progress:\n"
+                f"  event_name: {event_msg.event_name}\n"
+                f"  trace_id: {event_msg.event_meta.trace_id}\n"
+                f"  span_id: {event_msg.event_meta.span_id}"
+            )
+            is_duplicate_task = True
+
+        task = task_details.get("task_details") if task_details else None
+
+        # task does not exist -> this is a new/fresh task
+        if not task:
+            logger.info(
+                f"[JobExecutor] No existing task found, treating as new:\n"
+                f"  event_name: {event_msg.event_name}\n"
+                f"  trace_id: {event_msg.event_meta.trace_id}\n"
+                f"  span_id: {event_msg.event_meta.span_id}"
+            )
+            self._handle_new_task(event_msg)
+
+        # task exists and is in QUEUED state 
+        # -> first execution attempt, possibly re-queued from restart mechanism
+        # update in to PROCESSING state and get tracking id
+        elif task["status"] == TaskStatus.QUEUED.value:
+            logger.info(
+                f"[JobExecutor] Task is queued, updating to processing:\n"
+                f"  event_name: {event_msg.event_name}\n"
+                f"  trace_id: {event_msg.event_meta.trace_id}\n"
+                f"  span_id: {event_msg.event_meta.span_id}"
+            )
+            self._update_queued_task(event_msg)
+            tracking_id = self._get_task_tracking_id(task_details)
+
+        # task exists and is in PROCESSING state -> execution started earlier but was interrupted
+        # so just get the tracking id
+        elif task["status"] == TaskStatus.PROCESSING.value:
+            logger.info(
+                f"[JobExecutor] Task is already in processing:\n"
+                f"  event_name: {event_msg.event_name}\n"
+                f"  trace_id: {event_msg.event_meta.trace_id}\n"
+                f"  span_id: {event_msg.event_meta.span_id}"
+            )
+            tracking_id = self._get_task_tracking_id(task_details)
+
+        return is_duplicate_task, tracking_id
+    
+    def _handle_failure(self, event_msg: EventMessage, exception: Exception):
+        """
+        Handles failure reporting, tracking, and DLQ publishing.
+
+        Args:
+            event_msg: The event being processed
+            exception: The exception that occurred
+        """
+        logger.error(
+            f"[JobExecutor] Error processing event:\n"
+            f"  event_name: {event_msg.event_name}\n"
+            f"  trace_id: {event_msg.event_meta.trace_id}\n"
+            f"  span_id: {event_msg.event_meta.span_id}\n"
+            f"  error: {str(exception)}"
+        )
+        event_msg.event_meta.failure_reason = str(exception)
+
+        self.status_tracker.mark_task_as_failure(
+            span_id=event_msg.event_meta.span_id,
+            trace_id=event_msg.event_meta.trace_id,
+            task=event_msg.event_name,
+            failure_reason=str(exception),
+            task_id=event_msg.event_meta.job_id,
+        )
+        
+        # NOTE: for dead letter queue we are simply publishing the
+        # failed event to the databus as a DLQ event.
+        self._handle_dlq(event_msg)
+
+    def submit_job(self, callback: Callable, event_msg: AWSEventMessage) -> None:
+        """
+        Combined method to process message and handle status updates and cleanup.
+
+        Args:
+            callback: Callback function to invoke
+            event_msg: Event message to process
+        """
+        is_success = False
+        try:
+            logger.info(
+                f"[JobExecutor] Initiating event handling:\n"
+                f"  event_name: {event_msg.event_name}\n"
+                f"  event_payload: {event_msg.raw_message}\n"
+                f"  trace_id: {event_msg.event_meta.trace_id}\n"
+                f"  span_id: {event_msg.event_meta.span_id}"
+            )
+
+            # start event timing
+            event_msg.event_meta.start_event_timer()
+            logger.info(
+                f"[JobExecutor] Event timer started:\n"
+                f"  event_name: {event_msg.event_name}\n"
+                f"  trace_id: {event_msg.event_meta.trace_id}\n"
+                f"  span_id: {event_msg.event_meta.span_id}"
+            )
+
+            # thread-local storage
+            self._setup_thread_context(event_msg)
+
+            is_duplicate_task, tracking_id = self._check_and_update_task_status(event_msg=event_msg)
+
+            if is_duplicate_task:
+                logger.info(
+                    f"[JobExecutor] Skipping execution for duplicate task:\n"
+                    f"  event_name: {event_msg.event_name}\n"
+                    f"  trace_id: {event_msg.event_meta.trace_id}\n"
+                    f"  span_id: {event_msg.event_meta.span_id}"
+                )
+                return
+
+            # pass the actual message to the callback rather than the event message object
+            callback(event_msg.raw_message, tracking_id)
+            is_success = True
+
+        except Exception as e:
+            self._handle_failure(event_msg, e)
+
+        finally:
+            event_msg.event_meta.end_event_timer()
+            self.status_tracker.set_event_meta_and_message_receipt_handle(event_msg)
+
+            if is_success:
+                logger.info(
+                    f"[JobExecutor] Event processed successfully:\n"
+                    f"  event_name: {event_msg.event_name}\n"
+                    f"  trace_id: {event_msg.event_meta.trace_id}\n"
+                    f"  span_id: {event_msg.event_meta.span_id}"
+                )
+                self.status_tracker.update_task(event_msg=event_msg, status=TaskStatus.COMPLETED.value)
+            else:
+                logger.error(
+                    f"[JobExecutor] Event processing failed:\n"
+                    f"  event_name: {event_msg.event_name}\n"
+                    f"  trace_id: {event_msg.event_meta.trace_id}\n"
+                    f"  span_id: {event_msg.event_meta.span_id}"
+                )
+
+            thread_local_storage.clear()
+            self.databus.delete_message(event_msg)

{fdc_shared_kernel-0.0.97 → fdc_shared_kernel-0.0.99}/shared_kernel/event_executor/utils.py

@@ -25,14 +25,4 @@ class EventConcurrencyManager:
 
     def get_event_semaphore(self, event_name: str):
         semaphore = self.event_semaphores.get(event_name)
-        return semaphore
-
-@dataclass
-class EventStats:
-    """Statistics for an event type"""
-    successful_events: int = 0
-    failed_events: int = 0
-    
-    @property
-    def total_events(self) -> int:
-        return self.successful_events + self.failed_events
+        return semaphore

{fdc_shared_kernel-0.0.97 → fdc_shared_kernel-0.0.99}/shared_kernel/logger/__init__.py

@@ -2,7 +2,7 @@ import logging
 import os
 import json
 from shared_kernel.config import Config
-from shared_kernel.utils.thread_local_util import ThreadLocalStorage
+from shared_kernel.utils.thread_local_storage import ThreadLocalStorage
 class JSONFormatter(logging.Formatter):
     """
     Custom JSON formatter to structure log records as JSON.