atomicshop 2.19.19__py3-none-any.whl → 2.20.0__py3-none-any.whl

atomicshop/__init__.py

@@ -1,4 +1,4 @@
 """Atomic Basic functions and classes to make developer life easier"""
 
 __author__ = "Den Kras"
-__version__ = '2.19.19'
+__version__ = '2.20.0'

atomicshop/basics/threads.py

@@ -18,6 +18,20 @@ def current_thread_id():
     return thread_id
 
 
+def get_current_thread_name():
+    return threading.current_thread().name
+
+
+def set_current_thread_name(name: str):
+    threading.current_thread().name = name
+
+
+def set_current_thread_name_by_process_name():
+    import multiprocessing
+    current_process_name = multiprocessing.current_process().name
+    threading.current_thread().name = current_process_name
+
+
 def get_number_of_active_threads():
     return threading.active_count()
 

atomicshop/mitm/connection_thread_worker.py

@@ -2,6 +2,7 @@ from datetime import datetime
 import threading
 import queue
 import copy
+import socket
 
 from ..wrappers.socketw import receiver, sender, socket_client, base
 from .. import websocket_parse
@@ -73,12 +74,16 @@ def thread_worker_main(
 
         statistics_writer.write_row(
             thread_id=str(thread_id),
-            host=client_message.server_name,
+            engine=client_message.engine_name,
+            source_host=client_message.client_name,
+            source_ip=client_message.client_ip,
             tls_type=tls_type,
             tls_version=tls_version,
             protocol=client_message.protocol,
             protocol2=client_message.protocol2,
             protocol3=client_message.protocol3,
+            dest_port=client_message.destination_port,
+            host=client_message.server_name,
             path=http_path,
             status_code=http_status_code,
             command=http_command,
@@ -287,12 +292,14 @@ def thread_worker_main(
 
     def client_message_first_start() -> ClientMessage:
         client_message: ClientMessage = ClientMessage()
+        client_message.client_name = client_name
         client_message.client_ip = client_ip
         client_message.source_port = source_port
         client_message.destination_port = destination_port
         client_message.server_name = server_name
         client_message.thread_id = thread_id
         client_message.process_name = process_commandline
+        client_message.engine_name = engine_name
 
         return client_message
 
@@ -530,7 +537,9 @@ def thread_worker_main(
     http_path_queue: queue.Queue = queue.Queue()
 
     try:
+        engine_name: str = recorder.engine_name
         client_ip, source_port = client_socket.getpeername()
+        client_name = socket.gethostbyaddr(client_ip)[0]
         destination_port = client_socket.getsockname()[1]
 
         network_logger.info(f"Thread Created - Client [{client_ip}:{source_port}] | "

atomicshop/mitm/initialize_engines.py

@@ -66,7 +66,7 @@ class ModuleCategory:
         #     logger_name=self.engine_name,
         #     directory_path=logs_path,
         #     add_stream=True,
-        #     add_timedfile=True,
+        #     add_timedfile_with_internal_queue=True,
         #     formatter_streamhandler='DEFAULT',
         #     formatter_filehandler='DEFAULT',
         #     backupCount=config_static.LogRec.store_logs_for_x_days

atomicshop/mitm/message.py

@@ -10,6 +10,7 @@ class ClientMessage:
     def __init__(self):
         # noinspection PyTypeChecker
         self.timestamp: datetime = None
+        self.engine_name: str = str()
         # noinspection PyTypeChecker
         self.request_raw_bytes: bytes = None
         self.request_auto_parsed: Union[http_parse.HTTPRequestParse, any] = None
@@ -22,6 +23,7 @@ class ClientMessage:
         self.response_raw_hex: hex = None
         self.server_name: str = str()
         self.server_ip: str = str()
+        self.client_name: str = str()
         self.client_ip: str = str()
         self.source_port: int = int()
         self.destination_port: int = int()

atomicshop/mitm/mitm_main.py

@@ -2,10 +2,11 @@ import threading
 import multiprocessing
 import time
 import datetime
+import os
 
 import atomicshop   # Importing atomicshop package to get the version of the package.
 
-from .. import filesystem, queues, dns, on_exit, print_api
+from .. import filesystem, dns, on_exit, print_api
 from ..permissions import permissions
 from ..python_functions import get_current_python_version_string, check_python_version_compliance
 from ..wrappers.socketw import socket_wrapper, dns_server, base
@@ -29,6 +30,12 @@ EXCEPTIONS_CSV_LOGGER_HEADER: str = 'time,exception'
 # noinspection PyTypeChecker
 MITM_ERROR_LOGGER: loggingw.ExceptionCsvLogger = None
 
+# Create request domain queue.
+DOMAIN_QUEUE: multiprocessing.Queue = multiprocessing.Queue()
+
+# Create logger's queue.
+NETWORK_LOGGER_QUEUE: multiprocessing.Queue = multiprocessing.Queue()
+
 
 try:
     win_console.disable_quick_edit()
@@ -58,9 +65,20 @@ def exit_cleanup():
         RECS_PROCESS_INSTANCE.terminate()
         RECS_PROCESS_INSTANCE.join()
 
+    # Before terminating multiprocessing child processes, we need to put None to all the QueueListeners' queues,
+    # so they will stop waiting for new logs and will be able to terminate.
+    # Or else we will get a BrokenPipeError exception. This happens for because the QueueListener is waiting for
+    # new logs to come through the ".get()" method, but the main process is already terminated.
+    NETWORK_LOGGER_QUEUE.put(None)
+    # Get all the child processes and terminate them.
+    for process in multiprocessing.active_children():
+        process.terminate()
+        # We need for processes to finish, since there is a logger there that needs to write the last log.
+        process.join()
+
 
 def mitm_server(config_file_path: str, script_version: str):
-    on_exit.register_exit_handler(exit_cleanup, at_exit=False)
+    on_exit.register_exit_handler(exit_cleanup, at_exit=False, kill_signal=False)
 
     # Main function should return integer with error code, 0 is successful.
     # Since listening server is infinite, this will not be reached.
@@ -91,15 +109,21 @@ def mitm_server(config_file_path: str, script_version: str):
             config_static.Certificates.sni_server_certificate_from_server_socket_download_directory)
 
     network_logger_name = config_static.MainConfig.LOGGER_NAME
-    network_logger = loggingw.create_logger(
-        logger_name=network_logger_name,
-        directory_path=config_static.LogRec.logs_path,
+
+    _ = loggingw.create_logger(
+        get_queue_listener=True,
+        log_queue=NETWORK_LOGGER_QUEUE,
+        file_path=f'{config_static.LogRec.logs_path}{os.sep}{network_logger_name}.txt',
         add_stream=True,
         add_timedfile=True,
         formatter_streamhandler='DEFAULT',
         formatter_filehandler='DEFAULT',
-        backupCount=config_static.LogRec.store_logs_for_x_days
-    )
+        backupCount=config_static.LogRec.store_logs_for_x_days)
+
+    network_logger_with_queue_handler = loggingw.create_logger(
+        logger_name=network_logger_name,
+        add_queue_handler=True,
+        log_queue=NETWORK_LOGGER_QUEUE)
 
     # Initiate Listener logger, which is a child of network logger, so he uses the same settings and handlers
     listener_logger = loggingw.get_logger_with_level(f'{network_logger_name}.listener')
@@ -242,44 +266,53 @@ def mitm_server(config_file_path: str, script_version: str):
 
     print_api.print_api("Press [Ctrl]+[C] to stop.", color='blue')
 
-    # Create request domain queue.
-    domain_queue = queues.NonBlockQueue()
-
     # === Initialize DNS module ====================================================================================
     if config_static.DNSServer.enable:
-        try:
-            dns_server_instance = dns_server.DnsServer(
-                listening_interface=config_static.DNSServer.listening_interface,
-                listening_port=config_static.DNSServer.listening_port,
-                log_directory_path=config_static.LogRec.logs_path,
-                backupCount_log_files_x_days=config_static.LogRec.store_logs_for_x_days,
-                forwarding_dns_service_ipv4=config_static.DNSServer.forwarding_dns_service_ipv4,
-                tcp_target_server_ipv4=config_static.DNSServer.target_tcp_server_ipv4,
+        dns_process = multiprocessing.Process(
+            target=dns_server.start_dns_server_multiprocessing_worker,
+            kwargs={
+                'listening_interface': config_static.DNSServer.listening_interface,
+                'listening_port' :config_static.DNSServer.listening_port,
+                'log_directory_path': config_static.LogRec.logs_path,
+                'backupCount_log_files_x_days': config_static.LogRec.store_logs_for_x_days,
+                'forwarding_dns_service_ipv4': config_static.DNSServer.forwarding_dns_service_ipv4,
+                'tcp_target_server_ipv4': config_static.DNSServer.target_tcp_server_ipv4,
                 # Passing the engine domain list to DNS server to work with.
                 # 'list' function re-initializes the current list, or else it will be the same instance object.
-                tcp_resolve_domain_list=list(config_static.Certificates.domains_all_times),
-                offline_mode=config_static.DNSServer.offline_mode,
-                resolve_to_tcp_server_only_tcp_resolve_domains=(
+                'tcp_resolve_domain_list': list(config_static.Certificates.domains_all_times),
+                'offline_mode': config_static.DNSServer.offline_mode,
+                'resolve_to_tcp_server_only_tcp_resolve_domains': (
                     config_static.DNSServer.resolve_to_tcp_server_only_engine_domains),
-                resolve_to_tcp_server_all_domains=config_static.DNSServer.resolve_to_tcp_server_all_domains,
-                resolve_regular=config_static.DNSServer.resolve_regular,
-                cache_timeout_minutes=config_static.DNSServer.cache_timeout_minutes,
-                request_domain_queue=domain_queue,
-                logger=network_logger
-            )
-        except (dns_server.DnsPortInUseError, dns_server.DnsConfigurationValuesError) as e:
-            print_api.print_api(e, error_type=True, color="red", logger=system_logger)
-            # Wait for the message to be printed and saved to file.
+                'resolve_to_tcp_server_all_domains': config_static.DNSServer.resolve_to_tcp_server_all_domains,
+                'resolve_regular': config_static.DNSServer.resolve_regular,
+                'cache_timeout_minutes': config_static.DNSServer.cache_timeout_minutes,
+                'request_domain_queue': DOMAIN_QUEUE,
+                'logging_queue': NETWORK_LOGGER_QUEUE,
+                'logger_name': network_logger_name
+            },
+            name="dns_server")
+        dns_process.daemon = True
+        dns_process.start()
+
+        is_alive: bool = False
+        max_wait_time: int = 5
+        while not is_alive:
+            is_alive = dns_process.is_alive()
             time.sleep(1)
-            return 1
-
-        dns_thread = threading.Thread(target=dns_server_instance.start, name="dns_server")
-        dns_thread.daemon = True
-        dns_thread.start()
+            max_wait_time -= 1
+            if max_wait_time == 0:
+                message = "DNS Server process didn't start."
+                print_api.print_api(message, error_type=True, color="red", logger=system_logger)
+                # Wait for the message to be printed and saved to file.
+                time.sleep(1)
+                return 1
 
     # === EOF Initialize DNS module ================================================================================
     # === Initialize TCP Server ====================================================================================
     if config_static.TCPServer.enable:
+        engines_domains: dict = dict()
+        for engine in engines_list:
+            engines_domains[engine.engine_name] = engine.domain_list
         try:
             socket_wrapper_instance = socket_wrapper.SocketWrapper(
                 listening_interface=config_static.TCPServer.listening_interface,
@@ -319,7 +352,8 @@ def mitm_server(config_file_path: str, script_version: str):
                 forwarding_dns_service_ipv4_list___only_for_localhost=(
                     config_static.TCPServer.forwarding_dns_service_ipv4_list___only_for_localhost),
                 skip_extension_id_list=config_static.SkipExtensions.SKIP_EXTENSION_ID_LIST,
-                request_domain_from_dns_server_queue=domain_queue
+                request_domain_from_dns_server_queue=DOMAIN_QUEUE,
+                engines_domains=engines_domains
             )
         except socket_wrapper.SocketWrapperPortInUseError as e:
             print_api.print_api(e, error_type=True, color="red", logger=system_logger)
@@ -376,7 +410,7 @@ def mitm_server(config_file_path: str, script_version: str):
             target=socket_wrapper_instance.loop_for_incoming_sockets,
             kwargs={
                 'reference_function_name': thread_worker_main,
-                'reference_function_args': (network_logger, statistics_writer, engines_list, reference_module,)
+                'reference_function_args': (network_logger_with_queue_handler, statistics_writer, engines_list, reference_module,)
             },
             name="accepting_loop"
         )

atomicshop/on_exit.py

@@ -133,6 +133,7 @@ def register_exit_handler(
         Same goes for all the exceptions.
     :param console_close: Register the console close handler.
     :param kill_signal: Register the kill signal handler.
+        Same problem as with atexit handler, it will be called right away on [Ctrl+C].
     :param args: The arguments to pass to the cleanup action.
     :param kwargs: The keyword arguments to pass to the cleanup action.
     """

atomicshop/print_api.py

@@ -112,7 +112,7 @@ def print_api(
             elif logger_method == 'critical' and not color:
                 color = 'red'
 
-            if color is not None and logger is None:
+            if color is not None:
                 message = ansi_escape_codes.get_colors_basic_dict(color) + message + ansi_escape_codes.ColorsBasic.END
 
         # If 'online' is set to 'True', we'll output message as oneline.
@@ -126,13 +126,10 @@ def print_api(
         if logger:
             # Emit to logger only if 'print_end' is default, since we can't take responsibility for anything else.
             if print_end == '\n':
-                if stdcolor and color is not None:
-                    # Use logger to output message.
-                    with loggingw.temporary_change_logger_stream_record_color(logger, color):
-                        getattr(logger, logger_method)(message)
-                else:
-                    # Use logger to output message.
-                    getattr(logger, logger_method)(message)
+                # Use logger to output message.
+                getattr(logger, logger_method)(message)
+            else:
+                raise ValueError("Logger can't output messages with 'print_end' other than '\\n'.")
         # If logger wasn't passed.
         else:
             # Use print to output the message.

atomicshop/wrappers/loggingw/handlers.py

@@ -9,6 +9,7 @@ from typing import Literal, Union
 import threading
 from datetime import datetime
 import contextlib
+import multiprocessing
 
 from . import loggers, formatters, filters, consts
 from ... import datetimes, filesystem
@@ -48,17 +49,16 @@ def _process_formatter_attribute(
         return formatter
 
 
-def add_stream_handler(
-        logger: logging.Logger,
+def get_stream_handler_extended(
         logging_level: str = "DEBUG",
         formatter: Union[
             Literal['DEFAULT', 'MESSAGE'],
             str,
             None] = None,
         formatter_use_nanoseconds: bool = False
-):
+) -> logging.StreamHandler:
     """
-    Function to add StreamHandler to logger.
+    Function to get StreamHandler with extended configuration.
     Stream formatter will output messages to the console.
     """
 
@@ -76,11 +76,7 @@ def add_stream_handler(
             formatter=formatter, use_nanoseconds=formatter_use_nanoseconds)
         set_formatter(stream_handler, logging_formatter)
 
-    # Adding the handler to the main logger
-    loggers.add_handler(logger, stream_handler)
-
-    # Disable propagation from the 'root' logger, so we will not see the messages twice.
-    loggers.set_propagation(logger)
+    return stream_handler
 
 
 # Function to start the interval-based rotation check
@@ -140,9 +136,80 @@ def _wrap_do_rollover(handler, header):
     handler.doRollover = new_do_rollover
 
 
+def get_queue_handler_and_start_queue_listener_for_file_handler(file_handler):
+    """
+    Function to create QueueHandler and start QueueListener for the FileHandler.
+    The QueueListener, which will get the logs from the queue and use the FileHandler to write them to the
+    file.
+    The QueueHandler will put the logs to the queue.
+
+    :param file_handler: FileHandler object.
+    :return: QueueHandler object.
+    """
+
+    # Create the Queue between threads. "-1" means that there can infinite number of items that can be
+    # put in the Queue. if integer is bigger than 0, it means that this will be the maximum
+    # number of items.
+    queue_object = queue.Queue(-1)
+
+    # Create QueueListener, which will get the logs from the queue and use the FileHandler to write them to the file.
+    start_queue_listener_for_handlers((file_handler,), queue_object)
+
+    # Get the QueueHandler, which will put the logs to the queue.
+    queue_handler = get_queue_handler(queue_object)
+
+    return queue_handler
+
+
+# BASE FUNCTIONS =======================================================================================================
+
+
+def get_stream_handler() -> logging.StreamHandler:
+    """
+    Function to get a StreamHandler.
+    This handler that will output messages to the console.
+
+    :return: StreamHandler.
+    """
+
+    return logging.StreamHandler()
+
+
 # noinspection PyPep8Naming
-def add_timedfilehandler_with_queuehandler(
-        logger: logging.Logger,
+def get_timed_rotating_file_handler(
+        log_file_path: str,
+        when: str = "midnight",
+        interval: int = 1,
+        backupCount: int = 0,
+        delay: bool = False,
+        encoding=None
+) -> TimedRotatingFileHandler:
+    """
+    Function to get a TimedRotatingFileHandler.
+    This handler will output messages to a file, rotating the log file at certain timed intervals.
+
+    :param log_file_path: Path to the log file.
+    :param when: When to rotate the log file. Possible values:
+        "S" - Seconds
+        "M" - Minutes
+        "H" - Hours
+        "D" - Days
+        "midnight" - Roll over at midnight
+    :param interval: Interval to rotate the log file.
+    :param backupCount: int, Number of backup files to keep. Default is 0.
+        If backupCount is > 0, when rollover is done, no more than backupCount files are kept, the oldest are deleted.
+        If backupCount is == 0, all the backup files will be kept.
+    :param delay: bool, If set to True, the log file will be created only if there's something to write.
+    :param encoding: Encoding to use for the log file. Same as for the TimeRotatingFileHandler, which uses Default None.
+    :return: TimedRotatingFileHandler.
+    """
+
+    return TimedRotatingFileHandler(
+        filename=log_file_path, when=when, interval=interval, backupCount=backupCount, delay=delay, encoding=encoding)
+
+
+# noinspection PyPep8Naming
+def get_timed_rotating_file_handler_extended(
         file_path: str,
         file_type: Literal[
             'txt',
@@ -158,24 +225,47 @@ def add_timedfilehandler_with_queuehandler(
         rotation_date_format: str = None,
         rotation_callback_namer_function: callable = None,
         rotation_use_default_callback_namer_function: bool = True,
+        use_internal_queue_listener: bool = False,
         when: str = 'midnight',
         interval: int = 1,
         delay: bool = True,
         backupCount: int = 0,
         encoding=None,
         header: str = None
-):
-    """
-    Function to add TimedRotatingFileHandler and QueueHandler to logger.
-    TimedRotatingFileHandler will output messages to the file through QueueHandler.
-    This is needed, since TimedRotatingFileHandler is not thread-safe, though official docs say it is.
+) -> Union[TimedRotatingFileHandler, logging.handlers.QueueHandler]:
+    """
+    :param file_path: Path to the log file.
+    :param file_type: Type of the file. Possible values: 'txt', 'csv', 'json'.
+    :param logging_level: Logging level for the handler.
+    :param formatter: Formatter for the handler.
+    :param formatter_use_nanoseconds: If set to True, the formatter will use nanoseconds.
+    :param rotate_at_rollover_time: If set to True, the handler will rotate the log file at the rollover time.
+    :param rotation_date_format: Date format string to set to the handler's suffix.
+    :param rotation_callback_namer_function: Callback function to change the filename on rotation.
+    :param rotation_use_default_callback_namer_function: If set to True, the default callback namer function will be used
+        and the filename will be changed on rotation instead of using the default like this:
+        'file.log.2021-12-24' -> 'file_2021-12-24.log'.
+    :param use_internal_queue_listener: If set to True, the handler will use internal QueueListener to write logs.
+    :param when: When to rotate the log file. Possible values:
+        "S" - Seconds
+        "M" - Minutes
+        "H" - Hours
+        "D" - Days
+        "midnight" - Roll over at midnight
+    :param use_internal_queue_listener: If set to True, the handler will use internal QueueListener to write logs.
+        Function to add TimedRotatingFileHandler and QueueHandler to logger.
+        TimedRotatingFileHandler will output messages to the file through QueueHandler.
+        This is needed, since TimedRotatingFileHandler is not thread-safe, though official docs say it is.
+    :param interval: Interval to rotate the log file.
+    :param delay: If set to True, the log file will be created only if there's something to write.
+    :param backupCount: Number of backup files to keep. Default is 0.
+        If backupCount is > 0, when rollover is done, no more than backupCount files are kept, the oldest are deleted.
+        If backupCount is == 0, all the backup files will be kept.
+    :param encoding: Encoding to use for the log file. Same as for the TimeRotatingFileHandler, which uses Default None.
+    :param header: Header to write to the log file.
+    :return: TimedRotatingFileHandler or QueueHandler (if, use_internal_queue_listener is set to True).
     """
 
-    # Setting the TimedRotatingFileHandler, without adding it to the logger.
-    # It will be added to the QueueListener, which will use the TimedRotatingFileHandler to write logs.
-    # This is needed since there's a bug in TimedRotatingFileHandler, which won't let it be used with
-    # threads the same way it would be used for multiprocess.
-
     # Creating file handler with log filename. At this stage the log file is created and locked by the handler,
     # Unless we use "delay=True" to tell the class to write the file only if there's something to write.
 
@@ -216,95 +306,36 @@ def add_timedfilehandler_with_queuehandler(
     if rotate_at_rollover_time:
         _start_interval_rotation(file_handler)
 
-    queue_handler = start_queue_listener_for_file_handler_and_get_queue_handler(file_handler)
-    loggers.set_logging_level(queue_handler, logging_level)
-
-    # Add the QueueHandler to the logger.
-    loggers.add_handler(logger, queue_handler)
-
-    # Disable propagation from the 'root' logger, so we will not see the messages twice.
-    loggers.set_propagation(logger)
-
-
-def start_queue_listener_for_file_handler_and_get_queue_handler(file_handler):
-    """
-    Function to start QueueListener, which will put the logs from FileHandler to the Queue.
-    QueueHandler will get the logs from the Queue and put them to the file that was set in the FileHandler.
-
-    :param file_handler: FileHandler object.
-    :return: QueueHandler object.
-    """
-
-    # Create the Queue between threads. "-1" means that there can infinite number of items that can be
-    # put in the Queue. if integer is bigger than 0, it means that this will be the maximum
-    # number of items.
-    queue_object = queue.Queue(-1)
-    # Create QueueListener, which will put the logs from FileHandler to the Queue and put the logs to the queue.
-    start_queue_listener_for_file_handler(file_handler, queue_object)
-
-    return get_queue_handler(queue_object)
-
-
-# BASE FUNCTIONS =======================================================================================================
-
-
-def get_stream_handler() -> logging.StreamHandler:
-    """
-    Function to get a StreamHandler.
-    This handler that will output messages to the console.
-
-    :return: StreamHandler.
-    """
-
-    return logging.StreamHandler()
-
-
-# noinspection PyPep8Naming
-def get_timed_rotating_file_handler(
-        log_file_path: str,
-        when: str = "midnight",
-        interval: int = 1,
-        backupCount: int = 0,
-        delay: bool = False,
-        encoding=None
-) -> TimedRotatingFileHandler:
-    """
-    Function to get a TimedRotatingFileHandler.
-    This handler will output messages to a file, rotating the log file at certain timed intervals.
-
-    :param log_file_path: Path to the log file.
-    :param when: When to rotate the log file. Possible values:
-        "S" - Seconds
-        "M" - Minutes
-        "H" - Hours
-        "D" - Days
-        "midnight" - Roll over at midnight
-    :param interval: Interval to rotate the log file.
-    :param backupCount: int, Number of backup files to keep. Default is 0.
-        If backupCount is > 0, when rollover is done, no more than backupCount files are kept, the oldest are deleted.
-        If backupCount is == 0, all the backup files will be kept.
-    :param delay: bool, If set to True, the log file will be created only if there's something to write.
-    :param encoding: Encoding to use for the log file. Same as for the TimeRotatingFileHandler, which uses Default None.
-    :return: TimedRotatingFileHandler.
-    """
+    # Setting the TimedRotatingFileHandler, without adding it to the logger.
+    # It will be added to the QueueListener, which will use the TimedRotatingFileHandler to write logs.
+    # This is needed since there's a bug in TimedRotatingFileHandler, which won't let it be used with
+    # threads the same way it would be used for multiprocess.
 
-    return TimedRotatingFileHandler(
-        filename=log_file_path, when=when, interval=interval, backupCount=backupCount, delay=delay, encoding=encoding)
+    # If internal queue listener is set to True, we'll start the QueueListener for the FileHandler.
+    if use_internal_queue_listener:
+        queue_handler = get_queue_handler_and_start_queue_listener_for_file_handler(file_handler)
+        loggers.set_logging_level(queue_handler, logging_level)
+        return queue_handler
+    else:
+        return file_handler
 
 
-def start_queue_listener_for_file_handler(
-        file_handler: logging.FileHandler, queue_object) -> logging.handlers.QueueListener:
+def start_queue_listener_for_handlers(
+        handlers: tuple[logging.Handler],
+        queue_object: Union[queue.Queue, multiprocessing.Queue]
+) -> logging.handlers.QueueListener:
     """
     Function to get a QueueListener for the FileHandler.
     This handler get the messages from the FileHandler and put them in the Queue.
 
-    :param file_handler: FileHandler to get the messages from.
+    :param handlers: Tuple of handlers to put in the QueueListener.
+        For example, it can be (stream_handler, file_handler).
     :param queue_object: Queue object to put the messages in.
     :return: QueueListener.
     """
 
     # Create the QueueListener based on TimedRotatingFileHandler
-    queue_listener = QueueListener(queue_object, file_handler)
+    queue_listener: logging.handlers.QueueListener = QueueListener(queue_object, *handlers)
     # Start the QueueListener. Each logger will have its own instance of the Queue
     queue_listener.start()
 
@@ -324,6 +355,25 @@ def get_queue_handler(queue_object) -> logging.handlers.QueueHandler:
     return QueueHandler(queue_object)
 
 
+def get_queue_handler_extended(
+        queue_object: Union[
+            queue.Queue,
+            multiprocessing.Queue],
+        logging_level: str = "DEBUG"):
+    """
+    Function to get the QueueHandler.
+    QueueHandler of the logger will pass the logs to the Queue and the opposite QueueListener will write them
+    from the Queue to the file that was set in the FileHandler.
+    """
+
+    # Getting the QueueHandler.
+    queue_handler = get_queue_handler(queue_object)
+    # Setting log level for the handler, that will use the logger while initiated.
+    loggers.set_logging_level(queue_handler, logging_level)
+
+    return queue_handler
+
+
 def set_formatter(handler: logging.Handler, logging_formatter: logging.Formatter):
     """
     Function to set the formatter for the handler.