feat: implement logger (#80)

* feat: implement logger

Signed-off-by: dosi <dosi.kolev@limechain.tech>

* feat: add logger to the client

Signed-off-by: dosi <dosi.kolev@limechain.tech>

* feat: add logging in executable

Signed-off-by: dosi <dosi.kolev@limechain.tech>

* test: add logger in unit/integration tests

Signed-off-by: dosi <dosi.kolev@limechain.tech>

* refactor: log more information when switching nodes, change the default log level to be ERROR

Signed-off-by: dosi <dosi.kolev@limechain.tech>

* test: add unit tests for logger

Signed-off-by: dosi <dosi.kolev@limechain.tech>

* refactor: log requestId when maximum attempts are exceeded in executable

Signed-off-by: dosi <dosi.kolev@limechain.tech>

* feat: add example for logging workflow

Signed-off-by: dosi <dosi.kolev@limechain.tech>

* chore: remove empty lines

Signed-off-by: dosi <dosi.kolev@limechain.tech>

* refactor: use set_silent instead of set_level in logging_example.py

Signed-off-by: dosi <dosi.kolev@limechain.tech>

---------

Signed-off-by: dosi <dosi.kolev@limechain.tech>

Author: Dosik13

examples/logging_example.py

@@ -0,0 +1,86 @@
+import os
+import sys
+from dotenv import load_dotenv
+
+from hiero_sdk_python import (
+    Client,
+    AccountId,
+    PrivateKey,
+    AccountCreateTransaction,
+    Network,
+)
+from hiero_sdk_python.logger.logger import Logger
+from hiero_sdk_python.logger.log_level import LogLevel
+
+load_dotenv()
+
+def show_logging_workflow():
+    """Function to demonstrate logging functionality in the Hiero SDK."""
+
+    # Retrieving network type from environment variable HEDERA_NETWORK
+    network_name = os.getenv('HEDERA_NETWORK', 'testnet')
+    
+    # Network setup
+    network = Network(network_name)
+    client = Client(network)
+    
+    # The client comes with default logger.
+    # We can create logger and replace the default logger of this client.
+    # Create a custom logger with DEBUG level
+    logger = Logger(level=LogLevel.DEBUG, name="hiero_sdk_python")
+    # Replace the default logger
+    client.logger = logger
+    
+    # Set the logging level for this client's logger
+    client.logger.set_level(LogLevel.TRACE)
+    
+    # Retrieving operator ID from environment variable OPERATOR_ID
+    operator_id = AccountId.from_string(os.getenv('OPERATOR_ID'))
+    
+    # Retrieving operator key from environment variable OPERATOR_KEY
+    operator_key = PrivateKey.from_string(os.getenv('OPERATOR_KEY'))
+    
+    # Setting the client operator ID and key
+    client.set_operator(operator_id, operator_key)
+    
+    # Generate new key to use with new account
+    new_key = PrivateKey.generate()
+    
+    print(f"Private key: {new_key.to_string()}")
+    print(f"Public key: {new_key.public_key().to_string()}")
+    
+    # Transaction used to show trace level logging functionality from client
+    transaction = (
+        AccountCreateTransaction()
+        .set_key(new_key.public_key())
+        .set_initial_balance(100000000)  # 1 HBAR in tinybars
+        .freeze_with(client)
+        .sign(operator_key)
+    )
+    
+    try:
+        receipt = transaction.execute(client)
+        print(f"Account creation with client trace level logging successful. Account ID: {receipt.accountId}")
+    except Exception as e:
+        print(f"Account creation failed: {str(e)}")
+    
+    # Logger can be disabled
+    client.logger.set_silent(True)
+    
+    # Create account transaction used with disabled logger
+    transaction = (
+        AccountCreateTransaction()
+        .set_key(new_key.public_key())
+        .set_initial_balance(100000000)  # 1 HBAR in tinybars
+        .freeze_with(client)
+        .sign(operator_key)
+    )
+    
+    try:
+        receipt = transaction.execute(client)
+        print(f"Account creation with disabled logging successful. Account ID: {receipt.accountId}")
+    except Exception as e:
+        print(f"Account creation failed: {str(e)}")
+
+if __name__ == "__main__":
+    show_logging_workflow()

src/hiero_sdk_python/client/client.py

@@ -1,3 +1,4 @@
+from hiero_sdk_python.logger.logger import Logger, LogLevel
 import grpc
 from collections import namedtuple
 
@@ -38,6 +39,8 @@ def __init__(self, network=None):
         self._switch_node(initial_node_id)
 
         self._init_mirror_stub()
+        
+        self.logger = Logger(LogLevel.from_env(), "hiero_sdk_python")
 
     def _init_mirror_stub(self):
         """

src/hiero_sdk_python/executable.py

@@ -1,3 +1,4 @@
+from os import error
 import time
 import typing
 import grpc
@@ -6,7 +7,6 @@
 
 from hiero_sdk_python.channels import _Channel
 from hiero_sdk_python.exceptions import MaxAttemptsError
-
 if typing.TYPE_CHECKING:
     from hiero_sdk_python.client.client import Client
 
@@ -138,6 +138,12 @@ def _map_response(self, response, node_id, proto_request):
             The appropriate response object for the operation
         """
         raise NotImplementedError("_map_response must be implemented by subclasses")
+    
+    def _get_request_id(self):
+        """
+        Format the request ID for the logger.
+        """
+        return f"{self.__class__.__name__}:{time.time_ns()}"
 
     def _execute(self, client: "Client"):
         """
@@ -160,17 +166,23 @@ def _execute(self, client: "Client"):
         max_attempts = client.max_attempts
         current_backoff = self._min_backoff
         err_persistant = None
-
+        
+        tx_id = self.transaction_id if hasattr(self, "transaction_id") else None
+        
+        logger = client.logger
+        
         for attempt in range(max_attempts):
             # Exponential backoff for retries
             if attempt > 0 and current_backoff < self._max_backoff:
                 current_backoff *= 2
-
+            
             # Create a channel wrapper from the client's channel
             channel = _Channel(client.channel)
 
             # Set the node account id to the client's node account id
             self.node_account_id = client.node_account_id
+            
+            logger.trace("Executing", "requestId", self._get_request_id(), "nodeAccountID", self.node_account_id, "attempt", attempt + 1, "maxAttempts", max_attempts)
 
             # Get the appropriate gRPC method to call
             method = self._get_method(channel)
@@ -179,6 +191,8 @@ def _execute(self, client: "Client"):
             proto_request = self._make_request()
 
             try:
+                logger.trace("Executing gRPC call", "requestId", self._get_request_id())
+                
                 # Execute the transaction method with the protobuf request
                 response = _execute_method(method, proto_request)
 
@@ -188,19 +202,22 @@ def _execute(self, client: "Client"):
                 # Determine if we should retry based on the response
                 execution_state = self._should_retry(response)
 
+                logger.trace(f"{self.__class__.__name__} status received", "nodeAccountID", self.node_account_id, "network", client.network.network, "state", execution_state.name, "txID", tx_id)
+                
                 # Handle the execution state
                 match execution_state:
                     case _ExecutionState.RETRY:
                         # If we should retry, wait for the backoff period and try again
                         err_persistant = status_error
-                        _delay_for_attempt(current_backoff)
+                        _delay_for_attempt(self._get_request_id(), current_backoff, attempt, logger, err_persistant)
                         continue
                     case _ExecutionState.EXPIRED:
                         raise status_error
                     case _ExecutionState.ERROR:
                         raise status_error
                     case _ExecutionState.FINISHED:
                         # If the transaction completed successfully, map the response and return it
+                        logger.trace(f"{self.__class__.__name__} finished execution")
                         return self._map_response(response, client.node_account_id, proto_request)
             except grpc.RpcError as e:
                 # Save the error
@@ -210,19 +227,23 @@ def _execute(self, client: "Client"):
                 node_index = (attempt + 1) % len(node_account_ids)
                 current_node_account_id = node_account_ids[node_index]
                 client._switch_node(current_node_account_id)
+                logger.trace("Switched to a different node for the next attempt", "error", err_persistant, "from node", self.node_account_id, "to node", current_node_account_id)
                 continue
+            
+        logger.error("Exceeded maximum attempts for request", "requestId", self._get_request_id(), "last exception being", err_persistant)
 
         raise MaxAttemptsError("Exceeded maximum attempts for request", client.node_account_id, err_persistant)
 
 
-def _delay_for_attempt(current_backoff: int):
+def _delay_for_attempt(request_id: str, current_backoff: int, attempt: int, logger, error):
     """
     Delay for the specified backoff period before retrying.
 
     Args:
         attempt (int): The current attempt number (0-based)
         current_backoff (int): The current backoff period in milliseconds
     """
+    logger.trace(f"Retrying request attempt", "requestId", request_id, "delay", current_backoff, "attempt", attempt, "error", error)
     time.sleep(current_backoff * 0.001)
 
 def _execute_method(method, proto_request):

src/hiero_sdk_python/logger/log_level.py

@@ -0,0 +1,57 @@
+"""
+Log level module for the Hiero SDK.
+
+This module defines the log levels used throughout the SDK.
+"""
+
+import os
+from enum import IntEnum
+
+class LogLevel(IntEnum):
+    """
+    Enumeration of log levels
+    """
+    TRACE = 5
+    DEBUG = 10
+    INFO = 20
+    WARN = 30
+    ERROR = 40
+    CRITICAL = 50
+    DISABLED = 60
+    
+    def to_python_level(self):
+        """Convert to Python's logging level
+        
+        Returns:
+            int: The Python logging level
+        """
+        return self.value
+
+    @classmethod
+    def from_string(cls, level_str) -> 'LogLevel':
+        """Convert a string to a LogLevel
+        
+        Args:
+            level_str: The string to convert
+        
+        Returns:
+            LogLevel: The LogLevel enum value
+        """
+        if level_str is None:
+            return cls.ERROR
+
+        try:
+            return cls[level_str.upper()]
+        except KeyError:
+            raise ValueError(f"Invalid log level: {level_str}")
+        
+    @classmethod
+    def from_env(cls):
+        """
+        Get log level from environment variable
+        
+        Returns:
+            LogLevel: The LogLevel enum value
+        """
+        level_str = os.getenv('LOG_LEVEL')
+        return cls.from_string(level_str)