atomicshop 2.14.3__py3-none-any.whl → 2.14.5__py3-none-any.whl

atomicshop/wrappers/ctyping/etw_winapi/const.py

@@ -6,8 +6,15 @@ from ctypes.wintypes import ULONG
 # Constants
 EVENT_TRACE_CONTROL_STOP = 1
 WNODE_FLAG_TRACED_GUID = 0x00020000
+EVENT_TRACE_REAL_TIME_MODE = 0x00000100
+EVENT_CONTROL_CODE_ENABLE_PROVIDER = 1
 
 MAXIMUM_LOGGERS = 64
+ULONG64 = ctypes.c_uint64
+
+INVALID_HANDLE_VALUE = ctypes.c_void_p(-1).value
+TRACEHANDLE = ULONG64
+
 
 
 """
@@ -43,7 +50,6 @@ class WNODE_HEADER(ctypes.Structure):
     ]
 
 
-# Define EVENT_TRACE_PROPERTIES structure
 class EVENT_TRACE_PROPERTIES(ctypes.Structure):
     _fields_ = [
         ("Wnode", WNODE_HEADER),
@@ -70,29 +76,32 @@ class EVENT_TRACE_PROPERTIES(ctypes.Structure):
     ]
 
 
-# Define the EVENT_TRACE_LOGFILE structure
-class EVENT_TRACE_LOGFILE(ctypes.Structure):
+class TRACE_LOGFILE_HEADER(ctypes.Structure):
     _fields_ = [
-        ("LogFileName", wintypes.LPWSTR),
-        ("LoggerName", wintypes.LPWSTR),
-        ("CurrentTime", wintypes.LARGE_INTEGER),
-        ("BuffersRead", wintypes.ULONG),
-        ("ProcessTraceMode", wintypes.ULONG),
-        ("EventRecordCallback", wintypes.LPVOID),
         ("BufferSize", wintypes.ULONG),
-        ("Filled", wintypes.ULONG),
-        ("EventsLost", wintypes.ULONG),
-        ("BuffersLost", wintypes.ULONG),
-        ("RealTimeBuffersLost", wintypes.ULONG),
-        ("LogBuffersLost", wintypes.ULONG),
-        ("BuffersWritten", wintypes.ULONG),
+        ("Version", wintypes.ULONG),
+        ("ProviderVersion", wintypes.ULONG),
+        ("NumberOfProcessors", wintypes.ULONG),
+        ("EndTime", wintypes.LARGE_INTEGER),
+        ("TimerResolution", wintypes.ULONG),
+        ("MaximumFileSize", wintypes.ULONG),
         ("LogFileMode", wintypes.ULONG),
-        ("IsKernelTrace", wintypes.ULONG),
-        ("Context", wintypes.ULONG)  # Placeholder for context pointer
+        ("BuffersWritten", wintypes.ULONG),
+        ("StartBuffers", wintypes.ULONG),
+        ("PointerSize", wintypes.ULONG),
+        ("EventsLost", wintypes.ULONG),
+        ("CpuSpeedInMHz", wintypes.ULONG),
+        ("LoggerName", wintypes.WCHAR * 256),
+        ("LogFileName", wintypes.WCHAR * 256),
+        ("TimeZone", wintypes.LPVOID),
+        ("BootTime", wintypes.LARGE_INTEGER),
+        ("PerfFreq", wintypes.LARGE_INTEGER),
+        ("StartTime", wintypes.LARGE_INTEGER),
+        ("ReservedFlags", wintypes.ULONG),
+        ("BuffersLost", wintypes.ULONG)
     ]
 
 
-# Define the EVENT_TRACE_HEADER structure
 class EVENT_TRACE_HEADER(ctypes.Structure):
     _fields_ = [
         ("Size", wintypes.USHORT),
@@ -116,10 +125,67 @@ class EVENT_TRACE_HEADER(ctypes.Structure):
     ]
 
 
-# Define the EVENT_RECORD structure
+class EVENT_TRACE(ctypes.Structure):
+    _fields_ = [
+        ("Header", EVENT_TRACE_HEADER),
+        ("InstanceId", wintypes.DWORD),
+        ("ParentInstanceId", wintypes.DWORD),
+        ("ParentGuid", GUID),
+        ("MofData", ctypes.c_void_p),
+        ("MofLength", wintypes.ULONG),
+        ("ClientContext", wintypes.ULONG)
+    ]
+
+
+class EVENT_TRACE_LOGFILEW(ctypes.Structure):
+    _fields_ = [
+        ("LogFileName", ctypes.c_wchar_p),
+        ("LoggerName", ctypes.c_wchar_p),
+        ("CurrentTime", wintypes.LARGE_INTEGER),
+        ("BuffersRead", wintypes.ULONG),
+        ("ProcessTraceMode", wintypes.ULONG),
+        ("CurrentEvent", EVENT_TRACE),
+        ("LogfileHeader", TRACE_LOGFILE_HEADER),
+        ("BufferCallback", ctypes.c_void_p),  # Placeholder for buffer callback
+        ("BufferSize", wintypes.ULONG),
+        ("Filled", wintypes.ULONG),
+        ("EventsLost", wintypes.ULONG),
+        ("EventCallback", ctypes.CFUNCTYPE(None, ctypes.POINTER(EVENT_TRACE))),
+        ("Context", ULONG64)
+    ]
+
+
+class EVENT_DESCRIPTOR(ctypes.Structure):
+    _fields_ = [
+        ("Id", wintypes.USHORT),
+        ("Version", wintypes.BYTE),
+        ("Channel", wintypes.BYTE),
+        ("Level", wintypes.BYTE),
+        ("Opcode", wintypes.BYTE),
+        ("Task", wintypes.USHORT),
+        ("Keyword", ULONG64),
+    ]
+
+
+class EVENT_HEADER(ctypes.Structure):
+    _fields_ = [
+        ("Size", wintypes.USHORT),
+        ("HeaderType", wintypes.USHORT),
+        ("Flags", wintypes.USHORT),
+        ("EventProperty", wintypes.USHORT),
+        ("ThreadId", wintypes.ULONG),
+        ("ProcessId", wintypes.ULONG),
+        ("TimeStamp", wintypes.LARGE_INTEGER),
+        ("ProviderId", GUID),
+        ("EventDescriptor", EVENT_DESCRIPTOR),
+        ("ProcessorTime", ULONG64),
+        ("ActivityId", GUID),
+        ("RelatedActivityId", GUID),
+    ]
+
 class EVENT_RECORD(ctypes.Structure):
     _fields_ = [
-        ("EventHeader", EVENT_TRACE_HEADER),
+        ("EventHeader", EVENT_HEADER),
         ("BufferContext", wintypes.ULONG),
         ("ExtendedDataCount", wintypes.USHORT),
         ("UserDataLength", wintypes.USHORT),
@@ -129,6 +195,50 @@ class EVENT_RECORD(ctypes.Structure):
     ]
 
 
+# class EVENT_TRACE_LOGFILE(ctypes.Structure):
+#     _fields_ = [
+#         ("LogFileName", wintypes.LPWSTR),
+#         ("LoggerName", wintypes.LPWSTR),
+#         ("CurrentTime", wintypes.LARGE_INTEGER),
+#         ("BuffersRead", wintypes.ULONG),
+#         ("ProcessTraceMode", wintypes.ULONG),
+#         ("EventRecordCallback", wintypes.LPVOID),
+#         ("BufferSize", wintypes.ULONG),
+#         ("Filled", wintypes.ULONG),
+#         ("EventsLost", wintypes.ULONG),
+#         ("BuffersLost", wintypes.ULONG),
+#         ("RealTimeBuffersLost", wintypes.ULONG),
+#         ("LogBuffersLost", wintypes.ULONG),
+#         ("BuffersWritten", wintypes.ULONG),
+#         ("LogFileMode", wintypes.ULONG),
+#         ("IsKernelTrace", wintypes.ULONG),
+#         ("Context", wintypes.ULONG)  # Placeholder for context pointer
+#     ]
+
+
+class EVENT_TRACE_LOGFILE(ctypes.Structure):
+    _fields_ = [
+        ("LogFileName", wintypes.LPWSTR),
+        ("LoggerName", wintypes.LPWSTR),
+        ("CurrentTime", wintypes.LARGE_INTEGER),
+        ("BuffersRead", wintypes.ULONG),
+        ("ProcessTraceMode", wintypes.ULONG),
+        ("CurrentEvent", EVENT_RECORD),
+        ("LogfileHeader", TRACE_LOGFILE_HEADER),
+        ("BufferCallback", wintypes.LPVOID),
+        ("BufferSize", wintypes.ULONG),
+        ("Filled", wintypes.ULONG),
+        ("EventsLost", wintypes.ULONG),
+        ("EventCallback", ctypes.c_void_p),
+        ("IsKernelTrace", wintypes.ULONG),
+        ("Context", wintypes.LPVOID)
+    ]
+
+
+# Define the callback type for processing events
+EVENT_CALLBACK_TYPE = ctypes.WINFUNCTYPE(None, ctypes.POINTER(EVENT_RECORD))
+
+
 class PROVIDER_ENUMERATION_INFO(ctypes.Structure):
     _fields_ = [
         ("NumberOfProviders", ULONG),

atomicshop/wrappers/ctyping/etw_winapi/etw_functions.py

@@ -1,12 +1,137 @@
 import ctypes
+from ctypes import wintypes
 from ctypes.wintypes import ULONG
 import uuid
+from typing import Literal
 
 from . import const
+from ....etws import providers
+
+class ETWSessionExists(Exception):
+    pass
+
+
+# Convert the GUID string to a GUID structure
+def _string_to_guid(guid_string):
+    guid_string = guid_string.strip('{}')  # Remove curly braces
+    parts = guid_string.split('-')
+    return const.GUID(
+        Data1=int(parts[0], 16),
+        Data2=int(parts[1], 16),
+        Data3=int(parts[2], 16),
+        Data4=(ctypes.c_ubyte * 8)(*[
+            int(parts[3][i:i+2], 16) for i in range(0, 4, 2)
+        ] + [
+            int(parts[4][i:i+2], 16) for i in range(0, 12, 2)
+        ])
+    )
+
+
+# Set up the ETW session
+def start_etw_session(
+        session_name: str,
+        provider_guid_list: list = None,
+        provider_name_list: list = None,
+        verbosity_mode: int = 4,
+        maximum_buffers: int = 38
+):
+    """
+    Start an ETW session and enable the specified provider.
+
+    :param session_name: The name of the session to start.
+    :param provider_guid_list: The GUID list of the providers to enable.
+    :param provider_name_list: The name list of the providers to enable.
+    :param verbosity_mode: The verbosity level of the events to capture.
+        0 - Always: Capture all events. This is typically used for critical events that should always be logged.
+        1 - Critical: Capture critical events that indicate a severe problem.
+        2 - Error: Capture error events that indicate a problem but are not critical.
+        3 - Warning: Capture warning events that indicate a potential problem.
+        4 - Information: Capture informational events that are not indicative of problems.
+        5 - Verbose: Capture detailed trace events for diagnostic purposes.
+    :param maximum_buffers: The maximum number of buffers to use.
+        0 or 16: The default value of ETW class. If you put 0, it will be converted to 16 by default by ETW itself.
+        38: The maximum number of buffers that can be used.
+
+        Event Handling Capacity:
+            16 Buffers: With fewer buffers, the session can handle a smaller volume of events before needing to flush
+            the buffers to the log file or before a real-time consumer needs to process them. If the buffers fill up
+            quickly and cannot be processed in time, events might be lost.
+            38 Buffers: With more buffers, the session can handle a higher volume of events. This reduces the
+            likelihood of losing events in high-traffic scenarios because more events can be held in memory before
+            they need to be processed or written to a log file.
+        Performance Considerations:
+            16 Buffers: Requires less memory, but may be prone to event loss under heavy load if the buffers fill up
+            faster than they can be processed.
+            38 Buffers: Requires more memory, but can improve reliability in capturing all events under heavy load by
+            providing more buffer space. However, it can also increase the memory footprint of the application or
+            system running the ETW session.
+    """
+
+    if not provider_guid_list and not provider_name_list:
+        raise ValueError("Either 'provider_guid_list' or 'provider_name_list' must be provided")
+    elif provider_guid_list and provider_name_list:
+        raise ValueError("Only one of 'provider_guid_list' or 'provider_name_list' must be provided")
+
+    if provider_name_list:
+        provider_guid_list = []
+        for provider_name in provider_name_list:
+            provider_guid_list.append(providers.get_provider_guid_by_name(provider_name))
+
+    properties_size = ctypes.sizeof(const.EVENT_TRACE_PROPERTIES) + (2 * wintypes.MAX_PATH)
+    properties = (ctypes.c_byte * properties_size)()
+    properties_ptr = ctypes.cast(properties, ctypes.POINTER(const.EVENT_TRACE_PROPERTIES))
+
+    # Initialize the EVENT_TRACE_PROPERTIES structure
+    properties_ptr.contents.Wnode.BufferSize = properties_size
+    properties_ptr.contents.Wnode.Guid = const.GUID()
+    properties_ptr.contents.Wnode.Flags = const.WNODE_FLAG_TRACED_GUID
+    properties_ptr.contents.Wnode.ClientContext = 1   # QPC clock resolution
+    properties_ptr.contents.BufferSize = 1024
+    properties_ptr.contents.MinimumBuffers = 1
+    properties_ptr.contents.MaximumBuffers = maximum_buffers
+    properties_ptr.contents.MaximumFileSize = 0
+    properties_ptr.contents.LogFileMode = const.EVENT_TRACE_REAL_TIME_MODE
+    properties_ptr.contents.FlushTimer = 1
+    properties_ptr.contents.EnableFlags = 0
+
+    # Start the ETW session
+    session_handle = wintypes.HANDLE()
+    status = ctypes.windll.advapi32.StartTraceW(
+        ctypes.byref(session_handle),
+        ctypes.c_wchar_p(session_name),
+        properties_ptr
+    )
+
+    if status != 0:
+        if status == 183:
+            raise ETWSessionExists(f"ETW session [{session_name}] already exists")
+        else:
+            raise Exception(f"StartTraceW failed with error {status}")
+
+    # Enable each provider
+    for provider_guid in provider_guid_list:
+        provider_guid_struct = _string_to_guid(provider_guid)
+        status = ctypes.windll.advapi32.EnableTraceEx2(
+            session_handle,
+            ctypes.byref(provider_guid_struct),
+            const.EVENT_CONTROL_CODE_ENABLE_PROVIDER,
+            verbosity_mode,
+            0,
+            0,
+            0,
+            None
+        )
+
+        if status != 0:
+            raise Exception(f"EnableTraceEx2 failed for provider {provider_guid} with error {status}")
+
+    print("ETW session started successfully")
+
+    return session_handle
 
 
 # Function to stop and delete ETW session
-def stop_and_delete_etw_session(session_name) -> tuple[bool, int]:
+def stop_and_delete_etw_session(session_name: str) -> tuple[bool, int]:
     """
     Stop and delete ETW session.
 
@@ -40,13 +165,19 @@ def stop_and_delete_etw_session(session_name) -> tuple[bool, int]:
         return True, status
 
 
-def get_all_providers() -> list[tuple[any, uuid.UUID]]:
+def get_all_providers(key_as: Literal['name', 'guid'] = 'name') -> dict:
     """
     Get all ETW providers available on the system.
 
-    :return: A list of tuples containing the provider name and GUID.
+    :param key_as: The key to use in the dictionary, either 'name' or 'guid'.
+        'name': The provider name is used as the key, the guid as the value.
+        'guid': The provider guid is used as the key, the name as the value.
+    :return: dict containing the provider name and GUID.
     """
 
+    if key_as not in ['name', 'guid']:
+        raise ValueError("key_as must be either 'name' or 'guid'")
+
     providers_info_size = ULONG(0)
     status = const.tdh.TdhEnumerateProviders(None, ctypes.byref(providers_info_size))
 
@@ -71,7 +202,7 @@ def get_all_providers() -> list[tuple[any, uuid.UUID]]:
         ctypes.addressof(providers_info.contents) + ctypes.sizeof(const.PROVIDER_ENUMERATION_INFO),
         ctypes.POINTER(const.PROVIDER_INFORMATION * provider_count))
 
-    providers = []
+    providers: dict = {}
     for i in range(provider_count):
         provider = provider_array.contents[i]
         provider_name_offset = provider.ProviderNameOffset
@@ -79,7 +210,12 @@ def get_all_providers() -> list[tuple[any, uuid.UUID]]:
             ctypes.addressof(providers_info.contents) + provider_name_offset, ctypes.c_wchar_p)
         provider_name = provider_name_ptr.value
         provider_guid = uuid.UUID(bytes_le=bytes(provider.ProviderId))
-        providers.append((provider_name, provider_guid))
+        provider_guid_string = str(provider_guid)
+
+        if key_as == 'name':
+            providers[provider_name] = provider_guid_string
+        elif key_as == 'guid':
+            providers[provider_guid_string] = provider_name
 
     return providers
 

atomicshop/wrappers/loggingw/formatters.py

@@ -1,4 +1,5 @@
 import logging
+import time
 
 
 # Log formatter, means how the log will look inside the file
@@ -8,32 +9,9 @@ import logging
 
 # ".40" truncating the string to only 40 characters. Example: %(message).250s
 
-# Adding '%(asctime)s.%(msecs)06f' will print milliseconds as well as nanoseconds:
-# 2022-02-17 15:15:51,913.335562
-# If you don't use custom 'datefmt' in your 'setFormatter' function,
-# it will print duplicate milliseconds:
-# 2022-02-17 15:15:51,913.913.335562
-# The setting should be like:
-# file_handler.setFormatter(logging.Formatter(log_formatter_file, datefmt='%Y-%m-%d,%H:%M:%S'))
-# 's' stands for string. 'd' stands for digits, a.k.a. 'int'. 'f' stands for float.
-
-# Old tryouts:
-#   log_formatter_file: str = f"%(asctime)s.%(msecs)06f | " \
-#   log_formatter_file: str = f"%(asctime)s.%(msecs) | " \
-#                           f"%(levelname)-{len(log_header_level)}s | " \
-#                           f"%(name)-{len(log_header_logger)}s | " \
-#                           f"%(filename)-{len(log_header_script)}s : " \
-#                           f"%(lineno)-{len(log_header_line)}d | " \
-#                           "%(threadName)s: %(message)s"
-#   log_formatter_file: str = "{asctime}.{msecs:0<3.0f} | " \
-#   log_formatter_file: str = "{asctime}.{msecs:0>3.0f}.{msecs:0>.6f} | " \
-
-# Old tryouts for reference:
-#   file_formatter = logging.Formatter(log_formatter_file, style='{')
-#   file_formatter.default_time_format = '%Y-%m-%d %H:%M:%S'
-#   file_formatter.default_msec_format = '%s,%03d'
-#   file_formatter.default_msec_format = '%s,%03f'
 
+DEFAULT_STREAM_FORMATTER: str = "%(levelname)s | %(threadName)s | %(name)s | %(message)s"
+DEFAULT_MESSAGE_FORMATTER: str = "%(message)s"
 
 FORMAT_ELEMENT_TO_HEADER: dict = {
     'asctime': 'Event Time [Y-M-D H:M:S]',
@@ -56,7 +34,7 @@ FORMAT_ELEMENT_TO_HEADER: dict = {
 }
 
 DEFAULT_FORMATTER_TXT_FILE: str = \
-    "{asctime},{msecs:013.9f} | " \
+    "{asctime} | " \
     "{levelname:<" + f"{len(FORMAT_ELEMENT_TO_HEADER['levelname'])}" + "s} | " \
     "{name:<" + f"{len(FORMAT_ELEMENT_TO_HEADER['name'])}" + "s} | " \
     "{filename:<" + f"{len(FORMAT_ELEMENT_TO_HEADER['filename'])}" + "s} : " \
@@ -64,7 +42,53 @@ DEFAULT_FORMATTER_TXT_FILE: str = \
     "{threadName} | {message}"
 
 DEFAULT_FORMATTER_CSV_FILE: str = \
-    '\"{asctime}.{msecs:010.6f}\",{levelname},{name},{filename},{lineno},{threadName},\"{message}\"'
+    '\"{asctime}\",{levelname},{name},{filename},{lineno},{threadName},\"{message}\"'
+
+
+class NanosecondsFormatter(logging.Formatter):
+    def __init__(self, fmt=None, datefmt=None, style='%', use_nanoseconds=False):
+        super().__init__(fmt, datefmt, style)
+        self.use_nanoseconds = use_nanoseconds
+
+    def formatTime(self, record, datefmt=None):
+        ct = self.converter(record.created)
+
+        if datefmt:
+            # Remove unsupported %f from datefmt if present
+            if '%f' in datefmt:
+                datefmt = datefmt.replace('%f', '')
+                self.use_nanoseconds = True
+        else:
+            # Default time format if datefmt is not provided
+            datefmt = '%Y-%m-%d %H:%M:%S'
+
+        s = time.strftime(datefmt, ct)
+
+        if self.use_nanoseconds:
+            # Calculate nanoseconds from the fractional part of the timestamp
+            nanoseconds = f'{record.created:.9f}'.split('.')[1]
+            # Return the formatted string with nanoseconds appended
+            return f'{s}.{nanoseconds}'
+        else:
+            return s
+
+
+
+
+
+        # if datefmt is None:
+        #     # Use the default behavior if no datefmt is provided
+        #     return super().formatTime(record, datefmt)
+        # elif '%f' in datefmt:
+        #     # Format the time up to seconds
+        #     base_time = time.strftime(datefmt.replace('%f', ''), ct)
+        #     # Calculate nanoseconds from the fractional part of the timestamp
+        #     nanoseconds = f'{record.created:.9f}'.split('.')[1]
+        #     # Return the formatted string with nanoseconds appended
+        #     return base_time + nanoseconds
+        # else:
+        #     # Use the provided datefmt if it doesn't include %f
+        #     return time.strftime(datefmt, ct)
 
 
 class FormatterProcessor:
@@ -150,7 +174,11 @@ class FormatterProcessor:
 
 
 def get_logging_formatter_from_string(
-        formatter: str, style=None, datefmt=None, disable_duplicate_ms: bool = False) -> logging.Formatter:
+        formatter: str,
+        style=None,
+        datefmt=None,
+        use_nanoseconds: bool = False
+) -> logging.Formatter:
     """
     Function to get the logging formatter from the string.
 
@@ -160,12 +188,12 @@ def get_logging_formatter_from_string(
         '%': will use the '%' style.
         '{': will use the '{' style.
     :param datefmt: string, date format of 'asctime' element. Default is None.
-    :param disable_duplicate_ms: bool, if True, will disable the duplicate milliseconds in the 'asctime' element.
-        Example: If we're using '%(asctime)s.%(msecs)06f' msecs value in our time stamp, we need to use custom
-            'datefmt' to get rid of the additional duplicate milliseconds:
-            Instead of '2022-02-17 15:15:51,913.913.335562' print '2022-02-17 15:15:51,913.335562'
-            The problem with this method is that milliseconds aren't adjusted to 3 digits with zeroes (like 1 = 001).
-            We can use the regular strftime format: datefmt='%Y-%m-%d,%H:%M:%S:%f'
+        We use custom formatter that can process the date format with nanoseconds:
+        '%Y-%m-%d %H:%M:%S.%f' -> '2021-01-01 00:00:00.000000000'
+    :param use_nanoseconds: bool, if set to True, the formatter will use nanoseconds instead of milliseconds.
+        This will print 'asctime' in the following format: '2021-01-01 00:00:00.000000000', instead of
+        '2021-01-01 00:00:00.000'.
+
     :return: logging.Formatter, formatter.
     """
 
@@ -173,10 +201,8 @@ def get_logging_formatter_from_string(
     if not style:
         style = FormatterProcessor(formatter).get_style()['style']
 
-    # The regular 'datefmt' is '%Y-%m-%d,%H:%M:%S:%f'. If we want to use it with milliseconds 'msecs' element,
-    # we need to disable the duplicate milliseconds.
-    if disable_duplicate_ms:
-        datefmt = '%Y-%m-%d,%H:%M:%S'
-
     # Create the logging formatter.
-    return logging.Formatter(formatter, style=style, datefmt=datefmt)
+    if use_nanoseconds or '%f' in datefmt:
+        return NanosecondsFormatter(formatter, style=style, datefmt=datefmt, use_nanoseconds=use_nanoseconds)
+    else:
+        return logging.Formatter(formatter, style=style, datefmt=datefmt)

atomicshop/wrappers/loggingw/handlers.py

@@ -2,6 +2,11 @@ import logging
 from logging.handlers import TimedRotatingFileHandler, QueueListener, QueueHandler
 import re
 import os
+from pathlib import Path
+
+
+DEFAULT_DATE_STRING_FORMAT: str = "%Y_%m_%d"
+DEFAULT_DATE_REGEX_PATTERN: str = r"^\d{4}_\d{2}_\d{2}$"
 
 
 class TimedRotatingFileHandlerWithHeader(TimedRotatingFileHandler):
@@ -150,7 +155,20 @@ def get_handler_name(handler: logging.Handler) -> str:
     return handler.get_name()
 
 
-def change_rotated_filename(file_handler: logging.Handler, file_extension: str):
+def change_rotated_filename(
+        file_handler: logging.Handler,
+        date_format_string: str = None,
+        date_regex_pattern: str = None
+):
+    """
+    Function to change the way TimedRotatingFileHandler managing the rotating filename.
+
+    :param file_handler: FileHandler to change the rotating filename for.
+    :param date_format_string: Date format string to use for the rotated log filename.
+        If None, the default 'DEFAULT_DATE_STRING_FORMAT' will be used.
+    :param date_regex_pattern: Regex pattern to match the rotated log filenames.
+        If None, the default 'DEFAULT_DATE_REGEX_PATTERN' will be used.
+    """
     # Changing the way TimedRotatingFileHandler managing the rotating filename
     # Default file suffix is only "Year_Month_Day" with addition of the dot (".") character to the
     # "file name + extension" that you provide it. Example: log file name:
@@ -170,18 +188,40 @@ def change_rotated_filename(file_handler: logging.Handler, file_extension: str):
     # file_handler.extMatch = re.compile(r"^\d{4}_\d{2}_\d{2}" + re.escape(log_file_extension) + r"$")
     # file_handler.extMatch = re.compile(r"^\d{4}_\d{2}_\d{2}.txt$")
 
-    # Set variables that are responsible for setting TimedRotatingFileHandler filename on rotation.
-    # Log files time format, need only date
-    format_date_log_filename: str = "%Y_%m_%d"
-    # Log file suffix.
-    logfile_suffix: str = "_" + format_date_log_filename + file_extension
-    # Regex object to match the TimedRotatingFileHandler file name suffix.
-    # "re.escape" is used to "escape" strings in regex and use them as is.
-    logfile_regex_suffix = re.compile(r"^\d{4}_\d{2}_\d{2}" + re.escape(file_extension) + r"$")
+    # Update the namer function to format the rotated filename correctly
+    def namer(name):
+        # Currently the 'name' is full file path + '.' + logfile_suffix.
+        # Example: 'C:\\path\\to\\file.log._2021_12_24'
+        # Get the parent directory of the file: C:\path\to
+        parent_dir: str = str(Path(name).parent)
+        # Get the base filename without the extension: file.log
+        filename: str = Path(name).stem
+        # Get the date part of the filename: _2021_12_24
+        date_part: str = str(Path(name).suffix).replace(".", "")
+        # Get the file extension: log
+        file_extension: str = Path(filename).suffix
+        # Get the file name without the extension: file
+        file_stem: str = Path(filename).stem
+
+        return f"{parent_dir}{os.sep}{file_stem}{date_part}{file_extension}"
+
+    # Construct the new suffix without the file extension
+    if date_format_string is None:
+        logfile_suffix = f"_{DEFAULT_DATE_STRING_FORMAT}"
+    else:
+        logfile_suffix = f"_{date_format_string}"
+
+    # Regex pattern to match the rotated log filenames
+    if date_regex_pattern is None:
+        logfile_regex_suffix = re.compile(DEFAULT_DATE_REGEX_PATTERN)
+    else:
+        logfile_regex_suffix = re.compile(date_regex_pattern)
 
-    # Changing the setting that we set above
+    # Update the handler's suffix to include the date format
     file_handler.suffix = logfile_suffix
-    file_handler.namer = lambda name: name.replace(file_extension + ".", "") + file_extension
+
+    file_handler.namer = namer
+    # Update the handler's extMatch regex to match the new filename format
     file_handler.extMatch = logfile_regex_suffix