valkey-glide 2.0.0rc7__cp39-cp39-macosx_11_0_arm64.whl → 2.0.1__cp39-cp39-macosx_11_0_arm64.whl

glide/async_commands/core.py

@@ -61,6 +61,7 @@ from glide.constants import (
     TXInfoStreamFullResponse,
     TXInfoStreamResponse,
 )
+from glide.exceptions import RequestError
 from glide.protobuf.command_request_pb2 import RequestType
 from glide.routes import Route
 
@@ -2535,8 +2536,8 @@ class CoreCommands(Protocol):
         Returns:
             TOK: A simple "OK" response.
 
-            If `start` exceeds the end of the list, or if `start` is greater than `end`, the result will be an empty list
-            (which causes `key` to be removed).
+            If `start` exceeds the end of the list, or if `start` is greater than `end`, the list is emptied
+            and the key is removed.
 
             If `end` exceeds the actual end of the list, it will be treated like the last element of the list.
 
@@ -2554,9 +2555,6 @@ class CoreCommands(Protocol):
     async def lrem(self, key: TEncodable, count: int, element: TEncodable) -> int:
         """
         Removes the first `count` occurrences of elements equal to `element` from the list stored at `key`.
-        If `count` is positive, it removes elements equal to `element` moving from head to tail.
-        If `count` is negative, it removes elements equal to `element` moving from tail to head.
-        If `count` is 0 or greater than the occurrences of elements equal to `element`, it removes all elements
         equal to `element`.
 
         See [valkey.io](https://valkey.io/commands/lrem/) for more details.
@@ -2564,6 +2562,11 @@ class CoreCommands(Protocol):
         Args:
             key (TEncodable): The key of the list.
             count (int): The count of occurrences of elements equal to `element` to remove.
+
+                - If `count` is positive, it removes elements equal to `element` moving from head to tail.
+                - If `count` is negative, it removes elements equal to `element` moving from tail to head.
+                - If `count` is 0 or greater than the occurrences of elements equal to `element`, it removes all elements
+
             element (TEncodable): The element to remove from the list.
 
         Returns:
@@ -6048,19 +6051,19 @@ class CoreCommands(Protocol):
             elements (List[TEncodable]): A list of members to add to the HyperLogLog stored at `key`.
 
         Returns:
-            int: If the HyperLogLog is newly created, or if the HyperLogLog approximated cardinality is
-            altered, then returns 1.
+            bool: If the HyperLogLog is newly created, or if the HyperLogLog approximated cardinality is
+            altered, then returns `True`.
 
-            Otherwise, returns 0.
+            Otherwise, returns `False`.
 
         Examples:
             >>> await client.pfadd("hll_1", ["a", "b", "c" ])
-                1 # A data structure was created or modified
+                True # A data structure was created or modified
             >>> await client.pfadd("hll_2", [])
-                1 # A new empty data structure was created
+                True # A new empty data structure was created
         """
         return cast(
-            int,
+            bool,
             await self._execute_command(RequestType.PfAdd, [key] + elements),
         )
 
@@ -6649,6 +6652,10 @@ class CoreCommands(Protocol):
             args.append("REPLACE")
         if absttl is True:
             args.append("ABSTTL")
+        if idletime is not None and frequency is not None:
+            raise RequestError(
+                "syntax error: IDLETIME and FREQ cannot be set at the same time."
+            )
         if idletime is not None:
             args.extend(["IDLETIME", str(idletime)])
         if frequency is not None:

glide/async_commands/standalone_commands.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from typing import Dict, List, Mapping, Optional, Union, cast
 
 from glide.async_commands.batch import Batch
+from glide.async_commands.batch_options import BatchOptions
 from glide.async_commands.command_args import ObjectType
 from glide.async_commands.core import (
     CoreCommands,
@@ -76,7 +77,7 @@ class StandaloneCommands(CoreCommands):
         self,
         batch: Batch,
         raise_on_error: bool,
-        timeout: Optional[int] = None,
+        options: Optional[BatchOptions] = None,
     ) -> Optional[List[TResult]]:
         """
         Executes a batch by processing the queued commands.
@@ -96,10 +97,7 @@ class StandaloneCommands(CoreCommands):
                 When set to ``False``, errors will be included as part of the batch response array, allowing
                 the caller to process both successful and failed commands together. In this case, error details
                 will be provided as instances of ``RequestError``.
-            timeout (Optional[int]): The duration in milliseconds that the client should wait for the batch request
-                to complete. This duration encompasses sending the request, awaiting a response from the server, and any
-                required reconnections or retries. If the specified timeout is exceeded for the request,
-                a timeout error will be raised. If not explicitly set, the client's default request timeout will be used.
+            options (Optional[BatchOptions]): A ``BatchOptions`` object containing execution options.
 
         Returns:
             Optional[List[TResult]]: An array of results, where each entry corresponds to a command's execution result.
@@ -125,33 +123,38 @@ class StandaloneCommands(CoreCommands):
             # Expected Output: Pipeline Batch Result: [OK, OK, b'value1', b'value2']
 
         Example (Atomic Batch - Transaction with options):
+            >>> from glide import BatchOptions
             >>> transaction = Batch(is_atomic=True)
             >>> transaction.set("key", "1")
             >>> transaction.incr("key")
             >>> transaction.custom_command(["get", "key"])
+            >>> options = BatchOptions(timeout=1000)  # Set a timeout of 1000 milliseconds
             >>> result = await client.exec(
             ...     transaction,
             ...     raise_on_error=False,  # Do not raise an error on failure
-            ...     timeout=1000  # Set a timeout of 1000 milliseconds
+            ...     options=options
             ... )
             >>> print(f"Transaction Result: {result}")
             # Expected Output: Transaction Result: [OK, 2, b'2']
 
         Example (Non-Atomic Batch - Pipeline with options):
+            >>> from glide import BatchOptions
             >>> pipeline = Batch(is_atomic=False)
             >>> pipeline.custom_command(["set", "key1", "value1"])
             >>> pipeline.custom_command(["set", "key2", "value2"])
             >>> pipeline.custom_command(["get", "key1"])
             >>> pipeline.custom_command(["get", "key2"])
+            >>> options = BatchOptions(timeout=1000)  # Set a timeout of 1000 milliseconds
             >>> result = await client.exec(
             ...     pipeline,
             ...     raise_on_error=False,  # Do not raise an error on failure
-            ...     timeout=1000  # Set a timeout of 1000 milliseconds
+            ...     options=options
             ... )
             >>> print(f"Pipeline Result: {result}")
             # Expected Output: Pipeline Result: [OK, OK, b'value1', b'value2']
         """
         commands = batch.commands[:]
+        timeout = options.timeout if options else None
         return await self._execute_batch(
             commands,
             is_atomic=batch.is_atomic,

glide/config.py

@@ -73,7 +73,7 @@ class BackoffStrategy:
     """
     Represents the strategy used to determine how and when to reconnect, in case of connection failures.
     The time between attempts grows exponentially, to the formula rand(0 .. factor * (exponentBase ^ N)), where N
-    is the number of failed attempts.
+    is the number of failed attempts, and `rand(...)` applies a jitter of up to `jitter_percent`% to introduce randomness and reduce retry storms.
     Once the maximum value is reached, that will remain the time between retry attempts until a reconnect attempt is
     successful.
     The client will attempt to reconnect indefinitely.
@@ -147,25 +147,66 @@ class PeriodicChecksStatus(Enum):
     """
 
 
+class TlsAdvancedConfiguration:
+    """
+    Represents advanced TLS configuration settings.
+
+    Attributes:
+        use_insecure_tls (Optional[bool]): Whether to bypass TLS certificate verification.
+
+            - When set to True, the client skips certificate validation.
+              This is useful when connecting to servers or clusters using self-signed certificates,
+              or when DNS entries (e.g., CNAMEs) don't match certificate hostnames.
+
+            - This setting is typically used in development or testing environments. **It is
+              strongly discouraged in production**, as it introduces security risks such as man-in-the-middle attacks.
+
+            - Only valid if TLS is already enabled in the base client configuration.
+              Enabling it without TLS will result in a `ConfigurationError`.
+
+            - Default: False (verification is enforced).
+    """
+
+    def __init__(self, use_insecure_tls: Optional[bool] = None):
+        self.use_insecure_tls = use_insecure_tls
+
+
 class AdvancedBaseClientConfiguration:
     """
     Represents the advanced configuration settings for a base Glide client.
 
     Attributes:
         connection_timeout (Optional[int]): The duration in milliseconds to wait for a TCP/TLS connection to complete.
-            This applies both during initial client creation and any reconnections that may occur during request processing.
+            This applies both during initial client creation and any reconnection that may occur during request processing.
             **Note**: A high connection timeout may lead to prolonged blocking of the entire command pipeline.
-            If not explicitly set, a default value of 250 milliseconds will be used.
+            If not explicitly set, a default value of 2000 milliseconds will be used.
+        tls_config (Optional[TlsAdvancedConfiguration]): The advanced TLS configuration settings.
+            This allows for more granular control of TLS behavior, such as enabling an insecure mode
+            that bypasses certificate validation.
     """
 
-    def __init__(self, connection_timeout: Optional[int] = None):
+    def __init__(
+        self,
+        connection_timeout: Optional[int] = None,
+        tls_config: Optional[TlsAdvancedConfiguration] = None,
+    ):
         self.connection_timeout = connection_timeout
+        self.tls_config = tls_config
 
     def _create_a_protobuf_conn_request(
         self, request: ConnectionRequest
     ) -> ConnectionRequest:
         if self.connection_timeout:
             request.connection_timeout = self.connection_timeout
+
+        if self.tls_config and self.tls_config.use_insecure_tls:
+            if request.tls_mode == TlsMode.SecureTls:
+                request.tls_mode = TlsMode.InsecureTls
+            elif request.tls_mode == TlsMode.NoTls:
+                raise ConfigurationError(
+                    "use_insecure_tls cannot be enabled when use_tls is disabled."
+                )
+
         return request
 
 
@@ -187,14 +228,15 @@ class BaseClientConfiguration:
                 ].
 
         use_tls (bool): True if communication with the cluster should use Transport Level Security.
-            Should match the TLS configuration of the server/cluster, otherwise the connection attempt will fail
+            Should match the TLS configuration of the server/cluster, otherwise the connection attempt will fail.
+            For advanced tls configuration, please use `AdvancedBaseClientConfiguration`.
         credentials (ServerCredentials): Credentials for authentication process.
             If none are set, the client will not authenticate itself with the server.
         read_from (ReadFrom): If not set, `PRIMARY` will be used.
         request_timeout (Optional[int]): The duration in milliseconds that the client should wait for a request to
             complete.
             This duration encompasses sending the request, awaiting for a response from the server, and any required
-            reconnections or retries.
+            reconnection or retries.
             If the specified timeout is exceeded for a pending request, it will result in a timeout error. If not
             explicitly set, a default value of 250 milliseconds will be used.
         reconnect_strategy (Optional[BackoffStrategy]): Strategy used to determine how and when to reconnect, in case of
@@ -214,6 +256,25 @@ class BaseClientConfiguration:
             If ReadFrom strategy is AZAffinityReplicasAndPrimary, this setting ensures that readonly commands are directed
             to nodes (first replicas then primary) within the specified AZ if they exist.
         advanced_config (Optional[AdvancedBaseClientConfiguration]): Advanced configuration settings for the client.
+
+        lazy_connect (Optional[bool]): Enables lazy connection mode, where physical connections to the server(s)
+            are deferred until the first command is sent. This can reduce startup latency and allow for client
+            creation in disconnected environments.
+
+            When set to `True`, the client will not attempt to connect to the specified nodes during
+            initialization. Instead, connections will be established only when a command is actually executed.
+
+            Note that the first command executed with lazy connections may experience additional latency
+            as it needs to establish the connection first. During this initial connection, the standard
+            request timeout does not apply yet - instead, the connection establishment is governed by
+            `AdvancedBaseClientConfiguration.connection_timeout`. The request timeout (`request_timeout`)
+            only begins counting after the connection has been successfully established. This behavior
+            can effectively increase the total time needed for the first command to complete.
+
+            This setting applies to both standalone and cluster modes. Note that if an operation is
+            attempted and connection fails (e.g., unreachable nodes), errors will surface at that point.
+
+            If not set, connections are established immediately during client creation (equivalent to `False`).
     """
 
     def __init__(
@@ -229,6 +290,7 @@ class BaseClientConfiguration:
         inflight_requests_limit: Optional[int] = None,
         client_az: Optional[str] = None,
         advanced_config: Optional[AdvancedBaseClientConfiguration] = None,
+        lazy_connect: Optional[bool] = None,
     ):
         self.addresses = addresses
         self.use_tls = use_tls
@@ -241,6 +303,7 @@ class BaseClientConfiguration:
         self.inflight_requests_limit = inflight_requests_limit
         self.client_az = client_az
         self.advanced_config = advanced_config
+        self.lazy_connect = lazy_connect
 
         if read_from == ReadFrom.AZ_AFFINITY and not client_az:
             raise ValueError(
@@ -301,6 +364,8 @@ class BaseClientConfiguration:
         if self.advanced_config:
             self.advanced_config._create_a_protobuf_conn_request(request)
 
+        if self.lazy_connect is not None:
+            request.lazy_connect = self.lazy_connect
         return request
 
     def _is_pubsub_configured(self) -> bool:
@@ -317,9 +382,13 @@ class AdvancedGlideClientConfiguration(AdvancedBaseClientConfiguration):
     Represents the advanced configuration settings for a Standalone Glide client.
     """
 
-    def __init__(self, connection_timeout: Optional[int] = None):
+    def __init__(
+        self,
+        connection_timeout: Optional[int] = None,
+        tls_config: Optional[TlsAdvancedConfiguration] = None,
+    ):
 
-        super().__init__(connection_timeout)
+        super().__init__(connection_timeout, tls_config)
 
 
 class GlideClientConfiguration(BaseClientConfiguration):
@@ -337,12 +406,13 @@ class GlideClientConfiguration(BaseClientConfiguration):
                 ]
 
         use_tls (bool): True if communication with the cluster should use Transport Level Security.
+                Please use `AdvancedGlideClusterClientConfiguration`.
         credentials (ServerCredentials): Credentials for authentication process.
                 If none are set, the client will not authenticate itself with the server.
         read_from (ReadFrom): If not set, `PRIMARY` will be used.
         request_timeout (Optional[int]):  The duration in milliseconds that the client should wait for a request to complete.
                 This duration encompasses sending the request, awaiting for a response from the server, and any required
-                reconnections or retries.
+                reconnection or retries.
                 If the specified timeout is exceeded for a pending request, it will result in a timeout error.
                 If not explicitly set, a default value of 250 milliseconds will be used.
         reconnect_strategy (Optional[BackoffStrategy]): Strategy used to determine how and when to reconnect, in case of
@@ -414,6 +484,7 @@ class GlideClientConfiguration(BaseClientConfiguration):
         inflight_requests_limit: Optional[int] = None,
         client_az: Optional[str] = None,
         advanced_config: Optional[AdvancedGlideClientConfiguration] = None,
+        lazy_connect: Optional[bool] = None,
     ):
         super().__init__(
             addresses=addresses,
@@ -427,6 +498,7 @@ class GlideClientConfiguration(BaseClientConfiguration):
             inflight_requests_limit=inflight_requests_limit,
             client_az=client_az,
             advanced_config=advanced_config,
+            lazy_connect=lazy_connect,
         )
         self.database_id = database_id
         self.pubsub_subscriptions = pubsub_subscriptions
@@ -479,8 +551,12 @@ class AdvancedGlideClusterClientConfiguration(AdvancedBaseClientConfiguration):
     Represents the advanced configuration settings for a Glide Cluster client.
     """
 
-    def __init__(self, connection_timeout: Optional[int] = None):
-        super().__init__(connection_timeout)
+    def __init__(
+        self,
+        connection_timeout: Optional[int] = None,
+        tls_config: Optional[TlsAdvancedConfiguration] = None,
+    ):
+        super().__init__(connection_timeout, tls_config)
 
 
 class GlideClusterClientConfiguration(BaseClientConfiguration):
@@ -497,12 +573,13 @@ class GlideClusterClientConfiguration(BaseClientConfiguration):
                 ]
 
         use_tls (bool): True if communication with the cluster should use Transport Level Security.
+                For advanced tls configuration, please use `AdvancedGlideClusterClientConfiguration`.
         credentials (ServerCredentials): Credentials for authentication process.
                 If none are set, the client will not authenticate itself with the server.
         read_from (ReadFrom): If not set, `PRIMARY` will be used.
         request_timeout (Optional[int]):  The duration in milliseconds that the client should wait for a request to complete.
             This duration encompasses sending the request, awaiting for a response from the server, and any required
-            reconnections or retries.
+            reconnection or retries.
             If the specified timeout is exceeded for a pending request, it will result in a timeout error. If not explicitly
             set, a default value of 250 milliseconds will be used.
         reconnect_strategy (Optional[BackoffStrategy]): Strategy used to determine how and when to reconnect, in case of
@@ -586,6 +663,7 @@ class GlideClusterClientConfiguration(BaseClientConfiguration):
         inflight_requests_limit: Optional[int] = None,
         client_az: Optional[str] = None,
         advanced_config: Optional[AdvancedGlideClusterClientConfiguration] = None,
+        lazy_connect: Optional[bool] = None,
     ):
         super().__init__(
             addresses=addresses,
@@ -599,6 +677,7 @@ class GlideClusterClientConfiguration(BaseClientConfiguration):
             inflight_requests_limit=inflight_requests_limit,
             client_az=client_az,
             advanced_config=advanced_config,
+            lazy_connect=lazy_connect,
         )
         self.periodic_checks = periodic_checks
         self.pubsub_subscriptions = pubsub_subscriptions
@@ -637,6 +716,8 @@ class GlideClusterClientConfiguration(BaseClientConfiguration):
                 for channel_pattern in channels_patterns:
                     entry.channels_or_patterns.append(str.encode(channel_pattern))
 
+        if self.lazy_connect is not None:
+            request.lazy_connect = self.lazy_connect
         return request
 
     def _is_pubsub_configured(self) -> bool:

glide/glide.pyi

@@ -27,6 +27,28 @@ class ClusterScanCursor:
     def get_cursor(self) -> str: ...
     def is_finished(self) -> bool: ...
 
+class OpenTelemetryConfig:
+    def __init__(
+        self,
+        traces: Optional[OpenTelemetryTracesConfig] = None,
+        metrics: Optional[OpenTelemetryMetricsConfig] = None,
+        flush_interval_ms: Optional[int] = None,
+    ) -> None: ...
+    def get_traces(self) -> Optional[OpenTelemetryTracesConfig]: ...
+    def set_traces(self, traces: OpenTelemetryTracesConfig) -> None: ...
+    def get_metrics(self) -> Optional[OpenTelemetryMetricsConfig]: ...
+
+class OpenTelemetryTracesConfig:
+    def __init__(
+        self, endpoint: str, sample_percentage: Optional[int] = None
+    ) -> None: ...
+    def get_endpoint(self) -> str: ...
+    def get_sample_percentage(self) -> Optional[int]: ...
+
+class OpenTelemetryMetricsConfig:
+    def __init__(self, endpoint: str) -> None: ...
+    def get_endpoint(self) -> str: ...
+
 def start_socket_listener_external(init_callback: Callable) -> None: ...
 def value_from_pointer(pointer: int) -> TResult: ...
 def create_leaked_value(message: str) -> int: ...
@@ -34,3 +56,6 @@ def create_leaked_bytes_vec(args_vec: List[bytes]) -> int: ...
 def get_statistics() -> dict: ...
 def py_init(level: Optional[Level], file_name: Optional[str]) -> Level: ...
 def py_log(log_level: Level, log_identifier: str, message: str) -> None: ...
+def create_otel_span(name: str) -> int: ...
+def drop_otel_span(span_ptr: int) -> None: ...
+def init_opentelemetry(config: OpenTelemetryConfig) -> None: ...

glide/glide_client.py

@@ -36,6 +36,7 @@ from glide.exceptions import (
 )
 from glide.logger import Level as LogLevel
 from glide.logger import Logger as ClientLogger
+from glide.opentelemetry import OpenTelemetry
 from glide.protobuf.command_request_pb2 import Command, CommandRequest, RequestType
 from glide.protobuf.connection_request_pb2 import ConnectionRequest
 from glide.protobuf.response_pb2 import RequestErrorType, Response
@@ -47,6 +48,8 @@ from .glide import (
     MAX_REQUEST_ARGS_LEN,
     ClusterScanCursor,
     create_leaked_bytes_vec,
+    create_otel_span,
+    drop_otel_span,
     get_statistics,
     start_socket_listener_external,
     value_from_pointer,
@@ -410,6 +413,13 @@ class BaseClient(CoreCommands):
             raise ClosingError(
                 "Unable to execute requests; the client is closed. Please create a new client."
             )
+
+        # Create span if OpenTelemetry is configured and sampling indicates we should trace
+        span = None
+        if OpenTelemetry.should_sample():
+            command_name = RequestType.Name(request_type)
+            span = create_otel_span(command_name)
+
         request = CommandRequest()
         request.callback_idx = self._get_callback_index()
         request.single_command.request_type = request_type
@@ -424,6 +434,11 @@ class BaseClient(CoreCommands):
             request.single_command.args_vec_pointer = create_leaked_bytes_vec(
                 encoded_args
             )
+
+        # Add span pointer to request if span was created
+        if span:
+            request.root_span_ptr = span
+
         set_protobuf_route(request, route)
         return await self._write_request_await_response(request)
 
@@ -441,6 +456,14 @@ class BaseClient(CoreCommands):
             raise ClosingError(
                 "Unable to execute requests; the client is closed. Please create a new client."
             )
+
+        # Create span if OpenTelemetry is configured and sampling indicates we should trace
+        span = None
+
+        if OpenTelemetry.should_sample():
+            # Use "Batch" as span name for batches
+            span = create_otel_span("Batch")
+
         request = CommandRequest()
         request.callback_idx = self._get_callback_index()
         batch_commands = []
@@ -462,6 +485,11 @@ class BaseClient(CoreCommands):
             request.batch.timeout = timeout
         request.batch.retry_server_error = retry_server_error
         request.batch.retry_connection_error = retry_connection_error
+
+        # Add span pointer to request if span was created
+        if span:
+            request.root_span_ptr = span
+
         set_protobuf_route(request, route)
         return await self._write_request_await_response(request)
 
@@ -656,6 +684,10 @@ class BaseClient(CoreCommands):
             else:
                 res_future.set_result(None)
 
+        # Clean up span if it was created
+        if response.HasField("root_span_ptr"):
+            drop_otel_span(response.root_span_ptr)
+
     async def _process_push(self, response: Response) -> None:
         if response.HasField("closing_error") or not response.HasField("resp_pointer"):
             err_msg = (

glide/logger.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import traceback
 from enum import Enum
 from typing import Optional
 
@@ -20,13 +21,12 @@ class Level(Enum):
 
 class Logger:
     """
-    A singleton class that allows logging which is consistent with logs from the internal rust core.
+    A singleton class that allows logging which is consistent with logs from the internal GLIDE core.
     The logger can be set up in 2 ways -
     1. By calling Logger.init, which configures the logger only if it wasn't previously configured.
     2. By calling Logger.set_logger_config, which replaces the existing configuration, and means that new logs will not be
     saved with the logs that were sent before the call.
-    If set_logger_config wasn't called, the first log attempt will initialize a new logger with default configuration decided
-    by the Rust core.
+    If none of these functions are called, the first log attempt will initialize a new logger with default configuration.
     """
 
     _instance = None
@@ -38,48 +38,60 @@ class Logger:
 
     @classmethod
     def init(cls, level: Optional[Level] = None, file_name: Optional[str] = None):
-        """_summary_
+        """
         Initialize a logger if it wasn't initialized before - this method is meant to be used when there is no intention to
         replace an existing logger.
-        The logger will filter all logs with a level lower than the given level,
-        If given a fileName argument, will write the logs to files postfixed with fileName. If fileName isn't provided,
+        The logger will filter all logs with a level lower than the given level.
+        If given a file_name argument, will write the logs to files postfixed with file_name. If file_name isn't provided,
         the logs will be written to the console.
+
         Args:
             level (Optional[Level]): Set the logger level to one of [ERROR, WARN, INFO, DEBUG, TRACE, OFF].
-            If log level isn't provided, the logger will be configured with default configuration decided by the Rust core.
-            file_name (Optional[str]):  If provided the target of the logs will be the file mentioned.
-            Otherwise, logs will be printed to the console.
-            To turn off logging completely, set the level to Level.OFF.
+                If log level isn't provided, the logger will be configured with default configuration.
+                To turn off logging completely, set the level to Level.OFF.
+            file_name (Optional[str]): If provided the target of the logs will be the file mentioned.
+                Otherwise, logs will be printed to the console.
         """
         if cls._instance is None:
             cls._instance = cls(level, file_name)
 
     @classmethod
-    def log(cls, log_level: Level, log_identifier: str, message: str):
-        """Logs the provided message if the provided log level is lower then the logger level.
+    def log(
+        cls,
+        log_level: Level,
+        log_identifier: str,
+        message: str,
+        err: Optional[Exception] = None,
+    ):
+        """
+        Logs the provided message if the provided log level is lower then the logger level.
 
         Args:
-            log_level (Level): The log level of the provided message
+            log_level (Level): The log level of the provided message.
             log_identifier (str): The log identifier should give the log a context.
             message (str): The message to log.
+            err (Optional[Exception]): The exception or error to log.
         """
         if not cls._instance:
             cls._instance = cls(None)
         if not log_level.value.is_lower(Logger.logger_level):
             return
+        if err:
+            message = f"{message}: {traceback.format_exception(err)}"
         py_log(log_level.value, log_identifier, message)
 
     @classmethod
     def set_logger_config(
         cls, level: Optional[Level] = None, file_name: Optional[str] = None
     ):
-        """Creates a new logger instance and configure it with the provided log level and file name.
+        """
+        Creates a new logger instance and configure it with the provided log level and file name.
 
         Args:
             level (Optional[Level]): Set the logger level to one of [ERROR, WARN, INFO, DEBUG, TRACE, OFF].
-            If log level isn't provided, the logger will be configured with default configuration decided by the Rust core.
-            file_name (Optional[str]):  If provided the target of the logs will be the file mentioned.
-            Otherwise, logs will be printed to the console.
-            To turn off logging completely, set the level to OFF.
+                If log level isn't provided, the logger will be configured with default configuration.
+                To turn off logging completely, set the level to OFF.
+            file_name (Optional[str]): If provided the target of the logs will be the file mentioned.
+                Otherwise, logs will be printed to the console.
         """
         Logger._instance = Logger(level, file_name)