danielutils 1.0.52__tar.gz → 1.1.1__tar.gz

{danielutils-1.0.52/danielutils.egg-info → danielutils-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: danielutils
-Version: 1.0.52
+Version: 1.1.1
 Summary: A python utils library for things I find useful
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License

{danielutils-1.0.52 → danielutils-1.1.1}/danielutils/__init__.py

@@ -40,7 +40,6 @@ from .generators import *
 from .university import *
 from .mock_ import *
 from .context_managers import *
-from .file_specifications import *
 from .testing import *
 from .retry_executor import *
 from .java import *

{danielutils-1.0.52 → danielutils-1.1.1}/danielutils/abstractions/db/database.py

@@ -1,8 +1,11 @@
 import functools
+import logging
 from abc import ABC, abstractmethod
 from typing import Dict, Any, List, Callable, TypeVar, cast, Optional, Set
 from .database_exceptions import DBException
 from .database_definitions import TableSchema, SelectQuery, UpdateQuery, DeleteQuery
+from ...logging_.utils import get_logger
+logger = get_logger(__name__)
 
 # Type variable for the decorator
 F = TypeVar('F', bound=Callable[..., Any])
@@ -20,11 +23,17 @@ class Database(ABC):
 
         @functools.wraps(db_method)
         async def wrapper(self: 'Database', *args: Any, **kwargs: Any) -> Any:
+            method_name = db_method.__name__
+            logger.debug("Executing database method: %s", method_name)
             try:
-                return await db_method(self, *args, **kwargs)
-            except DBException:
+                result = await db_method(self, *args, **kwargs)
+                logger.debug("Database method '%s' completed successfully", method_name)
+                return result
+            except DBException as e:
+                logger.error("Database method '%s' failed with DBException: %s", method_name, e)
                 raise
             except Exception as e:
+                logger.error("Database method '%s' failed with %s: %s", method_name, type(e).__name__, e)
                 raise cls._default_class_exception_conversion(e)
 
         return cast(F, wrapper)
@@ -45,6 +54,8 @@ class Database(ABC):
     @classmethod
     def __init_subclass__(cls) -> None:
         """Initialize subclass by wrapping all public methods with exception handling"""
+        logger.debug("Initializing Database subclass: %s", cls.__name__)
+        wrapped_methods = []
         for name, method in cls.__dict__.items():
             if (
                     callable(method) and
@@ -53,6 +64,8 @@ class Database(ABC):
                     and name in cls._get_functions_with_auto_converted_exceptions()
             ):
                 setattr(cls, name, cls._wrap_db_exceptions(method))
+                wrapped_methods.append(name)
+        logger.debug("Database subclass '%s' initialized with %s wrapped methods: %s", cls.__name__, len(wrapped_methods), wrapped_methods)
 
     @classmethod
     def _default_class_exception_conversion(cls, e: Exception) -> Exception:
@@ -66,6 +79,7 @@ class Database(ABC):
         Returns:
             Exception: The converted exception
         """
+        logger.warning("Converting exception %s to DBException: %s", type(e).__name__, e)
         return DBException(f"Database error: {str(e)}")
 
     async def __aenter__(self) -> 'Database':
@@ -75,7 +89,9 @@ class Database(ABC):
         Returns:
             Database: The database instance for use in the context
         """
+        logger.debug("Entering database context for %s", self.__class__.__name__)
         await self.connect()
+        logger.debug("Database context entered successfully for %s", self.__class__.__name__)
         return self
 
     async def __aexit__(self, exc_type: Optional[type], exc_val: Optional[Exception], exc_tb: Optional[Any]) -> None:
@@ -87,24 +103,35 @@ class Database(ABC):
             exc_val: The exception instance that was raised, if any
             exc_tb: The traceback for the exception, if any
         """
+        logger.debug("Exiting database context for %s", self.__class__.__name__)
+        if exc_type is not None:
+            logger.warning("Database context exited with exception: %s: %s", exc_type.__name__, exc_val)
         await self.disconnect()
+        logger.debug("Database context exited successfully for %s", self.__class__.__name__)
 
     @abstractmethod
     async def connect(self) -> None:
-        """Establish connection to the database"""
+        """Establish connection to the database
+        Note: Implementations should log connection attempts and results
+        """
 
     @abstractmethod
     async def disconnect(self) -> None:
-        """Close the database connection"""
+        """Close the database connection
+        Note: Implementations should log disconnection attempts and results
+        """
 
     @abstractmethod
     def is_connected(self) -> bool:
-        """Check if the database connection is open"""
+        """Check if the database connection is open
+        Note: Implementations should log connection status checks
+        """
 
     @abstractmethod
     async def get_schemas(self) -> Dict[str, TableSchema]:
         """
         Get the complete database schema
+        Note: Implementations should log schema retrieval operations
 
         Returns:
             Dict[str, TableSchema]: Dictionary mapping table names to their schemas
@@ -114,6 +141,7 @@ class Database(ABC):
     async def create_table(self, schema: TableSchema) -> None:
         """
         Create a new table in the database
+        Note: Implementations should log table creation operations
 
         Args:
             schema (TableSchema): Schema definition for the table
@@ -123,6 +151,7 @@ class Database(ABC):
     async def insert(self, table: str, data: Dict[str, Any]) -> Any:
         """
         Insert a record into the specified table
+        Note: Implementations should log insert operations with table name and data size
 
         Args:
             table (str): Name of the table to insert into
@@ -136,6 +165,7 @@ class Database(ABC):
     async def get(self, query: SelectQuery) -> List[Dict[str, Any]]:
         """
         Get records from the database
+        Note: Implementations should log query operations with table name and result count
 
         Args:
             query (SelectQuery): Query definition containing table name, conditions, ordering, etc.
@@ -148,6 +178,7 @@ class Database(ABC):
     async def update(self, query: UpdateQuery) -> int:
         """
         Update records in the database
+        Note: Implementations should log update operations with table name and affected row count
 
         Args:
             query (UpdateQuery): Query definition containing table name, conditions, and data to update
@@ -160,6 +191,7 @@ class Database(ABC):
     async def delete(self, query: DeleteQuery) -> int:
         """
         Delete records from the database
+        Note: Implementations should log delete operations with table name and affected row count
 
         Args:
             query (DeleteQuery): Query definition containing table name and conditions

{danielutils-1.0.52 → danielutils-1.1.1}/danielutils/abstractions/db/database_factory.py

@@ -1,7 +1,10 @@
 from abc import ABC, abstractmethod
+import logging
 from typing import Literal, Dict, Any, Optional, Tuple
 from .database import Database
 from .implementations import InMemoryDatabase, SQLiteDatabase, PersistentInMemoryDatabase, RedisDatabase
+from ...logging_.utils import get_logger
+logger = get_logger(__name__)
 
 MAPPING = {
     "sqlite": SQLiteDatabase,
@@ -34,14 +37,23 @@ class DatabaseFactory(ABC):
         Returns:
             Database: Database instance
         """
+        logger.debug("Requesting database instance: type=%s, args_count=%s, kwargs_count=%s", db_type, len(db_args) if db_args else 0, len(db_kwargs) if db_kwargs else 0)
+        
         if db_type not in cls._instances:
+            logger.info("Creating new database instance: %s", db_type)
             if db_type not in MAPPING:
+                logger.error("Unsupported database type requested: %s", db_type)
                 raise ValueError(f"Unsupported database type: '{db_type}'")
 
             # Convert None to empty tuple/dict for database initialization
             args = db_args or ()
             kwargs = db_kwargs or {}
+            logger.debug("Initializing %s database with args=%s, kwargs=%s", db_type, args, kwargs)
             cls._instances[db_type] = MAPPING[db_type](*args, **kwargs)
+            logger.info("Database instance created successfully: %s", db_type)
+        else:
+            logger.debug("Returning existing database instance: %s", db_type)
+        
         return cls._instances[db_type]
 
     @classmethod

{danielutils-1.0.52 → danielutils-1.1.1}/danielutils/abstractions/db/database_initializer.py

@@ -1,6 +1,7 @@
 import logging
 from abc import ABC, abstractmethod
 from typing import Dict, Optional, Type, Any, Sequence
+from ...logging_.utils import get_logger
 
 try:
     from sqlalchemy import inspect, Column
@@ -14,8 +15,7 @@ except ImportError:
 
 from .database import Database
 from .database_definitions import ColumnType, TableSchema, TableColumn as ColumnSchema, TableIndex as IndexSchema
-
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 TYPE_MAPPING = {
     'INTEGER': ColumnType.INTEGER,
@@ -52,7 +52,7 @@ async def validate_schema(db: Database, table_name: str, expected_schema: TableS
         # Get existing schema
         existing_schemas = await db.get_schemas()
         if table_name not in existing_schemas:
-            logger.warning(f"Table '{table_name}' does not exist")
+            logger.warning("Table '%s' does not exist", table_name)
             return False
 
         existing_schema = existing_schemas[table_name]
@@ -60,9 +60,12 @@ async def validate_schema(db: Database, table_name: str, expected_schema: TableS
         # Compare columns
         if len(existing_schema.columns) != len(expected_schema.columns):
             logger.warning(
-                f"Column count mismatch in '{table_name}': "
-                f"expected {len(expected_schema.columns)}, "
-                f"got {len(existing_schema.columns)}"
+                "Column count mismatch in '%s': "
+                "expected %d, "
+                "got %d",
+                table_name,
+                len(expected_schema.columns),
+                len(existing_schema.columns)
             )
             return False
 
@@ -77,15 +80,18 @@ async def validate_schema(db: Database, table_name: str, expected_schema: TableS
                     expected_col.unique != existing_col.unique or
                     expected_col.foreign_key != existing_col.foreign_key
             ):
-                logger.warning(f"Column mismatch in '{table_name}': expected {expected_col}, got {existing_col}")
+                logger.warning("Column mismatch in '%s': expected %s, got %s", table_name, expected_col, existing_col)
                 return False
 
         # Compare indexes
         if len(existing_schema.indexes) != len(expected_schema.indexes):
             logger.warning(
-                f"Index count mismatch in '{table_name}': "
-                f"expected {len(expected_schema.indexes)}, "
-                f"got {len(existing_schema.indexes)}"
+                "Index count mismatch in '%s': "
+                "expected %d, "
+                "got %d",
+                table_name,
+                len(expected_schema.indexes),
+                len(existing_schema.indexes)
             )
             return False
 
@@ -97,13 +103,13 @@ async def validate_schema(db: Database, table_name: str, expected_schema: TableS
                     expected_idx.columns != existing_idx.columns or
                     expected_idx.unique != existing_idx.unique
             ):
-                logger.warning(f"Index mismatch in '{table_name}': expected {expected_idx}, got {existing_idx}")
+                logger.warning("Index mismatch in '%s': expected %s, got %s", table_name, expected_idx, existing_idx)
                 return False
 
         return True
 
     except Exception as e:
-        logger.error(f"Error validating schema for '{table_name}': {str(e)}")
+        logger.error("Error validating schema for '%s': %s", table_name, str(e))
         return False
 
 
@@ -233,10 +239,10 @@ class DatabaseInitializer(ABC):
             # Create or validate each table
             for table_name, expected_schema in table_schemas.items():
                 if table_name not in existing_schemas:
-                    logger.info(f"Creating table '{table_name}'")
+                    logger.info("Creating table '%s'", table_name)
                     await db.create_table(expected_schema)
                 else:
-                    logger.info(f"Validating table '{table_name}'")
+                    logger.info("Validating table '%s'", table_name)
                     if not await validate_schema(db, table_name, expected_schema):
                         raise ValueError(
                             f"Schema validation failed for table '{table_name}'. "
@@ -246,7 +252,7 @@ class DatabaseInitializer(ABC):
             logger.info("Database initialization completed successfully")
 
         except Exception as e:
-            logger.error(f"Error initializing database: {str(e)}")
+            logger.error("Error initializing database: %s", str(e))
             raise
 
 

{danielutils-1.0.52 → danielutils-1.1.1}/danielutils/abstractions/db/implementations/in_memory_database.py

@@ -1,6 +1,7 @@
 import logging
 from typing import Dict, Any, List, Type, Union, Sequence
 from datetime import datetime
+from ....logging_.utils import get_logger
 
 try:
     from starlette import status
@@ -14,7 +15,6 @@ from ..database_definitions import Operator, WhereClause, Condition, SelectQuery
     TableColumn
 from ..database_exceptions import DBValidationError, DBQueryError, DBConnectionError, DBException
 
-
 class InMemoryDatabase(Database):
     """In-memory database implementation using dictionaries"""
 
@@ -43,7 +43,7 @@ class InMemoryDatabase(Database):
         # table_name -> {column_name -> last_used_id}
         self.auto_increment_counters: Dict[str, Dict[str, int]] = {}
         self._connected = False
-        self.logger = logging.getLogger(__name__)
+        self.logger = get_logger(__name__)
 
     async def connect(self) -> None:
         """Connect to the database (no-op for in-memory)"""
@@ -75,7 +75,7 @@ class InMemoryDatabase(Database):
             if column.type == ColumnType.AUTOINCREMENT:
                 self.auto_increment_counters[schema.name][column.name] = 0
 
-        self.logger.info(f"Created table '{schema.name}'")
+        self.logger.info("Created table '%s'", schema.name)
 
     def _get_next_auto_increment_id(self, table: str, column: str) -> int:
         """Get the next available ID for an auto-increment column"""
@@ -161,7 +161,7 @@ class InMemoryDatabase(Database):
         # Add row
         self.tables[table][row_data['id']] = row_data
         self.logger.info(
-            f"Inserted row into '{table}' with ID '{row_data['id']}'")
+            "Inserted row into '%s' with ID '%s'", table, row_data['id'])
         return row_data['id']
 
     async def get(self, query: SelectQuery) -> List[Dict[str, Any]]:
@@ -232,7 +232,7 @@ class InMemoryDatabase(Database):
                 row.update(query.data)
                 updated_count += 1
 
-        self.logger.info(f"Updated '{updated_count}' rows in '{query.table}'")
+        self.logger.info("Updated '%s' rows in '%s'", updated_count, query.table)
         return updated_count
 
     async def delete(self, query: DeleteQuery) -> int:
@@ -254,7 +254,7 @@ class InMemoryDatabase(Database):
             del self.tables[query.table][row_id]
 
         self.logger.info(
-            f"Deleted {len(rows_to_delete)} rows from '{query.table}'")
+            "Deleted %d rows from '%s'", len(rows_to_delete), query.table)
         return len(rows_to_delete)
 
     def _validate_column_type(self, column: TableColumn, value: Any) -> bool:

{danielutils-1.0.52 → danielutils-1.1.1}/danielutils/abstractions/db/implementations/persistent_in_memory_database.py

@@ -90,7 +90,7 @@ class PersistentInMemoryDatabase(InMemoryDatabase):
                 json.dump(state, f, indent=2, cls=DateTimeEncoder)
             self.logger.info("Database state saved successfully")
         except Exception as e:
-            self.logger.error(f"Error saving database state: {e}")
+            self.logger.error("Error saving database state: %s", e)
             raise DBException(f"Failed to save database state: {str(e)}")
 
     def _load_state(self) -> None:
@@ -127,7 +127,7 @@ class PersistentInMemoryDatabase(InMemoryDatabase):
 
                 self.logger.info("Database state loaded successfully")
             except Exception as e:
-                self.logger.error(f"Error loading database state: {e}")
+                self.logger.error("Error loading database state: %s", e)
                 raise DBException(f"Failed to load database state: {str(e)}")
 
     def _maybe_save_state(self) -> None:

{danielutils-1.0.52 → danielutils-1.1.1}/danielutils/abstractions/db/implementations/redis_database.py

@@ -2,6 +2,7 @@ import json
 import logging
 from typing import List, Dict, Any, Optional, Type, Union, Sequence
 from datetime import datetime
+from ....logging_.utils import get_logger
 
 try:
     import redis.asyncio as redis
@@ -17,7 +18,6 @@ from ..database_definitions import (
 )
 from ..database_exceptions import DBException, DBValidationError, DBQueryError, DBConnectionError
 
-
 class RedisDatabase(Database):
     """Redis implementation of the Database abstract class"""
 
@@ -54,7 +54,7 @@ class RedisDatabase(Database):
         self.decode_responses = decode_responses
         self._db: redis.Redis = None  # type:ignore
         self._connected = False
-        self.logger = logging.getLogger(__name__)
+        self.logger = get_logger(__name__)
 
         # Redis key prefixes
         self.SCHEMA_PREFIX = "schema:"
@@ -77,10 +77,9 @@ class RedisDatabase(Database):
             # Test connection
             await self._db.ping()
             self._connected = True
-            self.logger.info(
-                f"Connected to Redis database at {self.host}:{self.port}")
+            self.logger.info("Connected to Redis database at %s:%s", self.host, self.port)
         except Exception as e:
-            self.logger.error(f"Error connecting to Redis database: {e}")
+            self.logger.error("Error connecting to Redis database: %s", e)
             raise
 
     async def disconnect(self) -> None:
@@ -130,7 +129,7 @@ class RedisDatabase(Database):
                 counter_key = f"{self.COUNTER_PREFIX}{schema.name}:{column.name}"
                 await self._db.set(counter_key, 0)
 
-        self.logger.info(f"Created table '{schema.name}'")
+        self.logger.info("Created table '%s'", schema.name)
 
     async def _get_next_auto_increment_id(self, table: str, column: str) -> int:
         """Get the next available ID for an auto-increment column"""
@@ -215,7 +214,7 @@ class RedisDatabase(Database):
 
         await self._db.hset(table_key, row_key, json.dumps(hash_data))  # type: ignore
 
-        self.logger.info(f"Inserted row {row_id} into table '{table}'")
+        self.logger.info("Inserted row %s into table '%s'", row_id, table)
         return row_id
 
     def _evaluate_condition(self, row: Dict[str, Any], condition: Condition) -> bool:
@@ -367,7 +366,7 @@ class RedisDatabase(Database):
                 await self._db.hset(table_key, row_id, json.dumps(row_data))  # type: ignore
                 updated_count += 1
 
-        self.logger.info(f"Updated {updated_count} rows in '{query.table}'")
+        self.logger.info("Updated %s rows in '%s'", updated_count, query.table)
         return updated_count
 
     async def delete(self, query: DeleteQuery) -> int:
@@ -395,7 +394,7 @@ class RedisDatabase(Database):
         for row_id in rows_to_delete:
             await self._db.hdel(table_key, row_id)  # type: ignore
 
-        self.logger.info(f"Deleted {len(rows_to_delete)} rows from '{query.table}'")
+        self.logger.info("Deleted %s rows from '%s'", len(rows_to_delete), query.table)
         return len(rows_to_delete)
 
 

{danielutils-1.0.52 → danielutils-1.1.1}/danielutils/abstractions/db/implementations/sqlite_database.py

@@ -44,7 +44,7 @@ class SQLiteDatabase(Database):
     """SQLite implementation of the Database abstract class using SQLAlchemy"""
 
     def is_connected(self) -> bool:
-        pass
+        return self._connected
 
     @classmethod
     def _default_class_exception_conversion(cls, e: Exception) -> Exception:
@@ -95,15 +95,12 @@ class SQLiteDatabase(Database):
             self.session_local = sessionmaker(autocommit=False, autoflush=False, bind=self.engine)
             self.metadata.reflect(bind=self.engine)
             self._connected = True
-            logging.info(f"Connected to SQLite database at '{self.url}'")
+            logging.info("Connected to SQLite database at '%s'", self.url)
         except Exception as e:
             logging.error(
-                f"Error connecting to SQLite database at '{self.url}': {e}")
+                "Error connecting to SQLite database at '%s': %s", self.url, e)
             raise
 
-    def is_connected(self) -> bool:
-        return self._connected
-
     async def disconnect(self) -> None:
         """Close the SQLite database connection"""
         if self.engine:
@@ -179,7 +176,7 @@ class SQLiteDatabase(Database):
                     column_type = self._get_column_type(col.type)
                 except ValueError as e:
                     logging.warning(
-                        f"Could not map type for column {col['name']} in table {table_name}: {e}")
+                        "Could not map type for column %s in table %s: %s", col['name'], table_name, e)
                     continue
 
                 # Handle default values
@@ -284,9 +281,9 @@ class SQLiteDatabase(Database):
             # Create table with all columns
             table = Table(schema.name, self.metadata, *columns)
             table.create(self.engine)  # type: ignore
-            logging.info(f"Created table: '{schema.name}'")
+            logging.info("Created table: '%s'", schema.name)
         except Exception as e:
-            logging.error(f"Error creating table '{schema.name}': {e}")
+            logging.error("Error creating table '%s': %s", schema.name, e)
             raise
 
     def _get_session(self) -> Session:
@@ -312,7 +309,7 @@ class SQLiteDatabase(Database):
                 session.commit()
                 return result.inserted_primary_key[0]
         except Exception as e:
-            logging.error(f"Error inserting into '{table}': {e}")
+            logging.error("Error inserting into '%s': %s", table, e)
             raise
 
     async def get(self, query: SelectQuery) -> List[Dict[str, Any]]:
@@ -417,7 +414,7 @@ class SQLiteDatabase(Database):
                 # Convert result rows to dictionaries
                 return [dict(zip(result.keys(), row)) for row in result]
         except Exception as e:
-            logging.error(f"Error selecting from '{query.table}': {e}")
+            logging.error("Error selecting from '%s': %s", query.table, e)
             raise
 
     async def update(self, query: UpdateQuery) -> int:
@@ -451,7 +448,7 @@ class SQLiteDatabase(Database):
                 session.commit()
                 return result.rowcount
         except Exception as e:
-            logging.error(f"Error updating '{query.table}': {e}")
+            logging.error("Error updating '%s': %s", query.table, e)
             raise
 
     async def delete(self, query: DeleteQuery) -> int:
@@ -485,7 +482,7 @@ class SQLiteDatabase(Database):
                 session.commit()
                 return result.rowcount
         except Exception as e:
-            logging.error(f"Error deleting from '{query.table}': {e}")
+            logging.error("Error deleting from '%s': %s", query.table, e)
             raise
 
 

{danielutils-1.0.52 → danielutils-1.1.1}/danielutils/abstractions/multiprogramming/worker.py

@@ -1,13 +1,16 @@
 from threading import Thread
 from abc import ABC, abstractmethod
 from typing import Optional, Any, Tuple as Tuple
-from logging import error
+import logging
 import danielutils  # this is explicitly this way to prevent circular import
 from ...reflection import get_python_version
+from ...logging_.utils import get_logger
 
 if get_python_version() >= (3, 9):
     from builtins import tuple as Tuple  # type:ignore
 
+logger = get_logger(__name__)
+
 
 class Worker(ABC):
     """A Worker Interface
@@ -15,9 +18,11 @@ class Worker(ABC):
 
     def __init__(self, id: int,
                  pool: "danielutils.abstractions.multiprogramming.worker_pool.WorkerPool") -> None:  # pylint: disable=redefined-builtin #noqa
+        logger.debug("Initializing Worker with id=%s", id)
         self.id = id
         self.pool = pool
         self.thread: Thread = Thread(target=self._loop)
+        logger.debug("Worker %s initialized successfully", id)
 
     @abstractmethod
     def _work(self, obj: Any) -> None:
@@ -27,38 +32,55 @@ class Worker(ABC):
     def _loop(self) -> None:
         """main loop of the worker
         """
+        logger.debug("Worker %s main loop started", self.id)
         while True:
             try:
                 obj = self.acquire()
                 if obj is not None:
+                    logger.debug("Worker %s acquired job: %s", self.id, type(obj[0]).__name__)
                     self.work(obj[0])
                 else:
+                    logger.debug("Worker %s received None job, exiting loop", self.id)
                     break
             except Exception as e:  # pylint: disable=broad-exception-caught
-                error(f"worker thread encountered an error: {e}")
+                logger.error("Worker %s thread encountered an error: %s: %s", self.id, type(e).__name__, e)
+                break
+        logger.debug("Worker %s main loop ended", self.id)
 
     def run(self) -> None:
         """will start self._run() as a new thread with the argument given in __init__
         """
+        logger.debug("Starting worker %s thread", self.id)
         self.thread.start()
+        logger.debug("Worker %s thread started successfully", self.id)
 
     def is_alive(self) -> bool:
         """returns whether the worker is alive or not
         """
-        return self.thread.is_alive()
+        is_alive = self.thread.is_alive()
+        logger.debug("Worker %s is_alive: %s", self.id, is_alive)
+        return is_alive
 
     def work(self, obj: Any) -> None:
         """performed the actual work that needs to happen
         execution of a single job
         """
-        self._work(obj)
-        self._notify()
+        logger.debug("Worker %s starting work on job: %s", self.id, type(obj).__name__)
+        try:
+            self._work(obj)
+            logger.debug("Worker %s completed work on job: %s", self.id, type(obj).__name__)
+        except Exception as e:
+            logger.error("Worker %s failed to process job %s: %s: %s", self.id, type(obj).__name__, type(e).__name__, e)
+            raise
+        finally:
+            self._notify()
 
     def _notify(self) -> None:
         """utility method to be called on the end of each iteration of work 
         to signal actions if needed
         will call 'notification_function'
         """
+        logger.debug("Worker %s notifying pool of job completion", self.id)
         # TODO
         self.pool._notify_subscribers()  # type:ignore  # pylint: disable=protected-access
 
@@ -68,7 +90,13 @@ class Worker(ABC):
         Returns:
             Optional[tuple[Any]]: tuple of job object or None
         """
-        return self.pool._acquire()  # pylint: disable=protected-access
+        logger.debug("Worker %s attempting to acquire job from pool", self.id)
+        job = self.pool._acquire()  # pylint: disable=protected-access
+        if job is not None:
+            logger.debug("Worker %s acquired job: %s", self.id, type(job[0]).__name__)
+        else:
+            logger.debug("Worker %s no jobs available in pool", self.id)
+        return job
 
 
 __all__ = [