wormhole-proxy 3.2.0__tar.gz → 3.2.2__tar.gz

{wormhole_proxy-3.2.0 → wormhole_proxy-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: wormhole-proxy
-Version: 3.2.0
+Version: 3.2.2
 Summary: Asynchronous I/O HTTP and HTTPS Proxy on Python >= 3.11
 License: MIT
 Keywords: wormhole,asynchronous,web,proxy

{wormhole_proxy-3.2.0 → wormhole_proxy-3.2.2}/pyproject.toml

@@ -1,7 +1,7 @@
 # Main project metadata (PEP 621 standard)
 [project]
 name = "wormhole-proxy"
-version = "3.2.0"
+version = "3.2.2"
 description = "Asynchronous I/O HTTP and HTTPS Proxy on Python >= 3.11"
 readme = "README.md"
 authors = [

{wormhole_proxy-3.2.0 → wormhole_proxy-3.2.2}/wormhole/auth_manager.py

@@ -28,7 +28,7 @@ def _secure_create_file(path: Path) -> bool:
     if sys.platform == "win32":
         # On Windows, we rely on default user permissions and warn if the filesystem is not NTFS.
         try:
-            import win32api
+            import win32api  # noqa
 
             fs_type = win32api.GetVolumeInformation(
                 str(path.resolve().drive) + "\\"

{wormhole_proxy-3.2.0 → wormhole_proxy-3.2.2}/wormhole/handler.py

@@ -1,4 +1,4 @@
-from .logger import logger
+from .logger import logger, format_log_message as flm
 from .safeguards import has_public_ipv6, is_ad_domain, is_private_ip
 from .tools import get_content_length, get_host_and_port
 import asyncio
@@ -19,6 +19,7 @@ async def relay_stream(
     writer: asyncio.StreamWriter,
     ident: dict[str, str],
     return_first_line: bool = False,
+    verbose: int = 0,
 ) -> bytes | None:
     """
     Relays data between a reader and a writer stream until EOF.
@@ -46,13 +47,13 @@ async def relay_stream(
             writer.write(data)
             await writer.drain()
     except (ConnectionResetError, BrokenPipeError) as e:
-        logger.debug(
-            f"[{ident['id']}][{ident['client']}]: Relay network error: {e}"
-        )
+        logger.debug(flm(f"Relay network error: {e}", ident, verbose))
     except Exception as e:
-        logger.exception(
-            f"[{ident['id']}][{ident['client']}]: Unexpected relay error: {e}",
-        )
+        msg = flm(f"Unexpected relay error: {e}", ident, verbose)
+        if verbose > 2:  # Show full traceback only for -vv
+            logger.exception(msg)
+        else:
+            logger.error(msg)
     finally:
         if not writer.is_closing():
             writer.close()
@@ -61,7 +62,7 @@ async def relay_stream(
 
 
 async def _resolve_and_validate_host(
-    host: str, allow_private: bool
+    host: str, ident: dict[str, str], allow_private: bool, verbose: int = 0
 ) -> list[str]:
     """
     Resolves a hostname to a list of IPs, validates them, and caches the list.
@@ -72,14 +73,18 @@ async def _resolve_and_validate_host(
     """
     # Ad-block check
     if is_ad_domain(host):
-        raise PermissionError(f"Blocked ad domain: {host}")
+        raise PermissionError(f"Blocked ad domain")
 
     # Check cache first
     if host in DNS_CACHE:
         ip_list, timestamp = DNS_CACHE[host]
         if time.time() - timestamp < DNS_CACHE_TTL:
             logger.debug(
-                f"DNS cache hit for '{host}'. ({len(DNS_CACHE)} hosts cached)"
+                flm(
+                    f"DNS cache hit for '{host}'. ({len(DNS_CACHE)} hosts cached)",
+                    ident,
+                    verbose,
+                )
             )
             return ip_list
 
@@ -109,7 +114,11 @@ async def _resolve_and_validate_host(
     final_ip_list = []
     if has_public_ipv6() and valid_ipv6s:
         logger.debug(
-            f"Host has public IPv6. Prioritizing {len(valid_ipv6s)} IPv6 addresses."
+            flm(
+                f"Host has public IPv6. Prioritizing {len(valid_ipv6s)} IPv6 addresses.",
+                ident,
+                verbose,
+            )
         )
         random.shuffle(valid_ipv6s)
         final_ip_list.extend(valid_ipv6s)
@@ -131,19 +140,30 @@ async def _resolve_and_validate_host(
     # Update cache
     DNS_CACHE[host] = (final_ip_list, time.time())
     logger.debug(
-        f"DNS cache miss for '{host}'. Resolved to {final_ip_list}. Caching. ({len(DNS_CACHE)} hosts cached)"
+        flm(
+            (
+                f"DNS cache miss for '{host}'. "
+                f"Resolved to {final_ip_list}. Caching. "
+                f"({len(DNS_CACHE)} hosts cached)"
+            ),
+            ident,
+            verbose,
+        )
     )
     return final_ip_list
 
 
 async def _create_connection_with_retries(
-    ip_list: list[str], port: int, ident: dict[str, str]
+    ip_list: list[str],
+    port: int,
+    ident: dict[str, str],
+    max_attempts: int = 3,
+    timeout: int = 5,
+    verbose: int = 0,
 ) -> tuple[asyncio.StreamReader, asyncio.StreamWriter]:
     """
     Tries to connect to a list of IPs with a fast timeout and retry mechanism.
     """
-    max_attempts = 3
-    timeout = 5  # seconds
     last_error = None
 
     # Create a list of connection targets to try, ensuring we don't exceed max_attempts
@@ -154,7 +174,11 @@ async def _create_connection_with_retries(
     for i, ip in enumerate(targets_to_try):
         attempt = i + 1
         logger.debug(
-            f"Connection attempt {attempt}/{max_attempts} to {ip}:{port}"
+            flm(
+                f"Connection attempt {attempt}/{max_attempts} to {ip}:{port}",
+                ident,
+                verbose,
+            )
         )
         try:
             # Use a short timeout for each connection attempt
@@ -162,13 +186,21 @@ async def _create_connection_with_retries(
                 asyncio.open_connection(ip, port), timeout=timeout
             )
             logger.debug(
-                f"Successfully connected to {ip}:{port} on attempt {attempt}"
+                flm(
+                    f"Successfully connected to {ip}:{port} on attempt {attempt}",
+                    ident,
+                    verbose,
+                )
             )
             return reader, writer
         except (OSError, asyncio.TimeoutError) as e:
             last_error = e
             logger.warning(
-                f"Connection to {ip}:{port} failed on attempt {attempt}: {e}"
+                flm(
+                    f"Connection to {ip}:{port} failed on attempt {attempt}: {e}",
+                    ident,
+                    verbose,
+                )
             )
 
     raise OSError(
@@ -186,6 +218,7 @@ async def process_https_tunnel(
     uri: str,
     ident: dict[str, str],
     allow_private: bool,
+    verbose: int = 0,
 ) -> None:
     """Establishes an HTTPS tunnel and relays data between client and server."""
     host, port = get_host_and_port(uri)
@@ -194,11 +227,13 @@ async def process_https_tunnel(
 
     try:
         # Resolve and validate the host to get a list of potential IPs.
-        ip_list = await _resolve_and_validate_host(host, allow_private)
+        ip_list = await _resolve_and_validate_host(
+            host, ident, allow_private, verbose
+        )
 
         # Attempt to connect to one of the IPs with retry logic.
         server_reader, server_writer = await _create_connection_with_retries(
-            ip_list, port, ident
+            ip_list, port, ident, verbose=verbose
         )
 
         # Signal the client that the tunnel is established.
@@ -207,21 +242,30 @@ async def process_https_tunnel(
 
         # Use a TaskGroup for structured concurrency to relay data in both directions.
         async with asyncio.TaskGroup() as tg:
-            tg.create_task(relay_stream(client_reader, server_writer, ident))
-            tg.create_task(relay_stream(server_reader, client_writer, ident))
+            tg.create_task(
+                relay_stream(
+                    client_reader, server_writer, ident, verbose=verbose
+                )
+            )
+            tg.create_task(
+                relay_stream(
+                    server_reader, client_writer, ident, verbose=verbose
+                )
+            )
 
-        logger.info(f"[{ident['id']}][{ident['client']}]: {method} 200 {uri}")
+        logger.info(flm(f"{method} 200 {uri}", ident, verbose))
 
     except PermissionError as e:
-        logger.warning(
-            f"[{ident['id']}][{ident['client']}]: {method} 403 {uri} ({e})"
-        )
+        logger.warning(flm(f"{method} 403 {uri} ({e})", ident, verbose))
         client_writer.write(b"HTTP/1.1 403 Forbidden\r\n\r\n")
         await client_writer.drain()
     except Exception as e:
-        logger.exception(
-            f"[{ident['id']}][{ident['client']}]: {method} 502 {uri} ({e})"
-        )
+        msg = flm(f"{method} 502 {uri} ({e})", ident, verbose)
+        if verbose > 2:  # Show full traceback only for -vv
+            logger.exception(msg)
+        else:
+            logger.error(msg)
+
     finally:
         # Ensure server streams are closed if they were opened.
         if server_writer and not server_writer.is_closing():
@@ -238,6 +282,8 @@ async def _send_http_request(
     headers: list[str],
     payload: bytes,
     ident: dict[str, str],
+    max_attempts: int = 3,
+    verbose: int = 0,
 ) -> tuple[asyncio.StreamReader, asyncio.StreamWriter]:
     """Helper function to connect and send an HTTP request."""
     request_line = f"{method} {path or '/'} {version}".encode()
@@ -245,7 +291,7 @@ async def _send_http_request(
 
     # Attempt to connect to one of the IPs with retry logic.
     server_reader, server_writer = await _create_connection_with_retries(
-        ip_list, port, ident
+        ip_list, port, ident, max_attempts, verbose=verbose
     )
 
     server_writer.write(request_line + b"\r\n" + headers_bytes + b"\r\n\r\n")
@@ -265,6 +311,8 @@ async def process_http_request(
     payload: bytes,
     ident: dict[str, str],
     allow_private: bool,
+    max_attempts: int = 3,
+    verbose: int = 0,
 ) -> None:
     """Processes a standard HTTP request by forwarding it to the target server."""
     server_reader = None
@@ -300,12 +348,18 @@ async def process_http_request(
             return
 
         # Resolve and validate the host to get a list of potential IPs.
-        ip_list = await _resolve_and_validate_host(host, allow_private)
+        ip_list = await _resolve_and_validate_host(
+            host, ident, allow_private, verbose
+        )
 
         # --- Attempt to upgrade to HTTP/1.1 if needed ---
         if version == "HTTP/1.0":
             logger.debug(
-                f"[{ident['id']}][{ident['client']}]: Attempting to upgrade HTTP/1.0 request for {host_header} to HTTP/1.1"
+                flm(
+                    f"Attempting to upgrade HTTP/1.0 request for {host_header} to HTTP/1.1",
+                    ident,
+                    verbose,
+                )
             )
 
             # Prepare headers for HTTP/1.1
@@ -332,10 +386,16 @@ async def process_http_request(
                     headers_v1_1,
                     payload,
                     ident,
+                    max_attempts,
+                    verbose,
                 )
             except Exception as e:
                 logger.warning(
-                    f"[{ident['id']}][{ident['client']}]: HTTP/1.1 upgrade failed ({e}). Falling back to HTTP/1.0."
+                    flm(
+                        f"HTTP/1.1 upgrade failed ({e}). Falling back to HTTP/1.0.",
+                        ident,
+                        verbose,
+                    )
                 )
                 if server_writer and not server_writer.is_closing():
                     server_writer.close()
@@ -361,6 +421,8 @@ async def process_http_request(
                     original_headers,
                     payload,
                     ident,
+                    max_attempts,
+                    verbose,
                 )
         else:
             # Original request was already HTTP/1.1 or newer
@@ -385,11 +447,17 @@ async def process_http_request(
                 final_headers,
                 payload,
                 ident,
+                max_attempts,
+                verbose,
             )
 
         # Relay the server's response back to the client.
         response_status_line = await relay_stream(
-            server_reader, client_writer, ident, return_first_line=True
+            server_reader,
+            client_writer,
+            ident,
+            return_first_line=True,
+            verbose=verbose,
         )
 
         # Log the outcome.
@@ -398,26 +466,24 @@ async def process_http_request(
             if response_status_line
             else 502
         )
-        logger.info(
-            f"[{ident['id']}][{ident['client']}]: {method} {response_code} {uri}"
-        )
+        logger.info(flm(f"{method} {response_code} {uri}", ident, verbose))
 
     except PermissionError as e:
-        logger.warning(
-            f"[{ident['id']}][{ident['client']}]: {method} 403 {uri} ({e})"
-        )
+        logger.warning(flm(f"{method} 403 {uri} ({e})", ident, verbose))
         client_writer.write(b"HTTP/1.1 403 Forbidden\r\n\r\n")
         await client_writer.drain()
     except Exception as e:
-        logger.exception(
-            f"[{ident['id']}][{ident['client']}]: {method} 502 {uri} ({e})"
-        )
+        msg = flm(f"{method} 502 {uri} ({e})", ident, verbose)
+        if verbose > 2:  # Show full traceback only for -vv
+            logger.exception(msg)
+        else:
+            logger.error(msg)
         if not client_writer.is_closing():
             try:
                 client_writer.write(b"HTTP/1.1 502 Bad Gateway\r\n\r\n")
                 await client_writer.drain()
             except ConnectionError:
-                pass
+                pass  # Ignore if client is already closed
     finally:
         if server_writer and not server_writer.is_closing():
             server_writer.close()
@@ -425,7 +491,7 @@ async def process_http_request(
 
 
 async def parse_request(
-    client_reader: asyncio.StreamReader, max_retry: int, ident: dict[str, str]
+    client_reader: asyncio.StreamReader, ident: dict[str, str], verbose: int = 0
 ) -> tuple[str, list[str], bytes] | tuple[None, None, None]:
     """
     Parses the initial request from the client.
@@ -443,7 +509,7 @@ async def parse_request(
         )
     except (asyncio.IncompleteReadError, asyncio.TimeoutError) as e:
         logger.debug(
-            f"[{ident['id']}][{ident['client']}]: Failed to read initial request: {e}"
+            flm(f"Failed to read initial request: {e}", ident, verbose)
         )
         return None, None, None
 
@@ -459,9 +525,7 @@ async def parse_request(
         try:
             payload = await client_reader.readexactly(content_length)
         except asyncio.IncompleteReadError:
-            logger.debug(
-                f"[{ident['id']}][{ident['client']}]: Incomplete payload read."
-            )
+            logger.debug(flm(f"Incomplete payload read.", ident, verbose))
             return None, None, None
 
     return request_line, headers, payload

wormhole_proxy-3.2.2/wormhole/logger.py

@@ -0,0 +1,136 @@
+from loguru import logger
+import asyncio
+import logging.handlers
+import os
+import sys
+
+
+class LogThrottler:
+    """A class to throttle and summarize repeated log messages."""
+
+    def __init__(self, logger, level: str, delay: float = 5.0):
+        """Initializes the log throttler with a level name and delay."""
+        self.logger = logger
+        self.level = level.upper()  # Store the level name, e.g., "ERROR"
+        self.delay = delay
+        self.last_message: str | None = None
+        self.repeat_count: int = 0
+        self.timer: asyncio.TimerHandle | None = None
+
+    def _flush_summary(self, **kwargs):
+        """Prints the summary of how many times the last message was repeated."""
+        if self.repeat_count > 2:
+            self.logger.opt(depth=2).log(
+                self.level,
+                f"{self.last_message} (and {self.repeat_count -1} more in the last {self.delay} seconds.)",
+                **kwargs,
+            )
+        elif self.repeat_count == 2:
+            # If the message was repeated only once, we log it directly.
+            self.logger.opt(depth=2).log(
+                self.level, self.last_message, **kwargs
+            )
+
+        # Reset the state
+        self.timer = None
+        self.last_message = None
+        self.repeat_count = 0
+
+    def process(self, message: str, **kwargs):
+        """Processes a log message, either logging it or incrementing a repeat counter."""
+        if self.last_message and message != self.last_message:
+            if self.timer:
+                self.timer.cancel()
+            self._flush_summary()
+
+        if message == self.last_message:
+            self.repeat_count += 1
+        else:
+            # It's a new message. Log it immediately, but look 1 frame up the stack.
+            # This ensures the log record shows the original caller (e.g., wormhole.handler).
+            self.logger.opt(depth=1).log(self.level, message, **kwargs)
+            self.last_message = message
+            self.repeat_count = 1
+
+        if self.timer:
+            self.timer.cancel()
+
+        loop = asyncio.get_running_loop()
+        self.timer = loop.call_later(self.delay, self._flush_summary)
+
+
+# In loguru, the logger is imported and ready to be configured.
+# We just need to ensure other modules import this configured instance.
+def setup_logger(
+    syslog_host: str | None = None, syslog_port: int = 514, verbose: int = 0
+) -> None:
+    """
+    Configures the global loguru logger instance. This should only be called once.
+    """
+    # Remove the default handler to have full control over sinks.
+    logger.remove()
+
+    # Set logging level based on verbosity.
+    if verbose >= 2:
+        level = "DEBUG"
+    elif verbose >= 1:
+        level = "DEBUG"
+    else:
+        level = "INFO"
+
+    # --- Console Sink ---
+    # Loguru automatically adds contextual data. The format is simpler.
+    console_format = (
+        "<green>{time:MMM D HH:mm:ss}</green> "
+        "<cyan>{name}</cyan>[<cyan>{process}</cyan>]: "
+        "<level>{message}</level>"
+    )
+    logger.add(sys.stderr, level=level, format=console_format)
+
+    # --- Syslog Sink ---
+    if syslog_host and syslog_host != "DISABLED":
+        # Create a standard library syslog handler instance.
+        # Loguru can sink to handler objects directly.
+        if syslog_host.startswith("/") and os.path.exists(syslog_host):
+            handler = logging.handlers.SysLogHandler(address=syslog_host)
+            syslog_format = "{time:MMM D HH:mm:ss} {name}[{process}]: {message}"
+        else:
+            handler = logging.handlers.SysLogHandler(
+                address=(syslog_host, syslog_port)
+            )
+            # For network syslog, the hostname is typically added by the syslog server,
+            # but we can include it if needed.
+            syslog_format = "{time:MMM D HH:mm:ss} {extra[hostname]} {name}[{process}]: {message}"
+            # Add hostname to all log records.
+            logger.configure(extra={"hostname": os.uname().nodename})
+
+        logger.add(handler, level="INFO", format=syslog_format)
+
+    # Suppress overly verbose asyncio logger messages unless in high verbosity.
+    logging.getLogger("asyncio").setLevel(
+        logging.DEBUG if verbose >= 2 else logging.CRITICAL
+    )
+    if verbose < 2:
+        logger.info = LogThrottler(logger, "info").process
+        logger.warning = LogThrottler(logger, "warning").process
+        logger.error = LogThrottler(logger, "error").process
+
+
+def format_log_message(
+    message: str, ident: dict[str, str], verbose: int
+) -> str:
+    """
+    Formats a log message with the given identifier.
+
+    Args:
+        message: The log message to format.
+        ident: A dictionary containing identifiers like 'id' and 'client'.
+        verbose: The verbosity level of the logger.
+
+    Returns:
+        A formatted log message string.
+    """
+    if verbose > 1:
+        return f"[{ident['id']}][{ident['client']}]: {message}"
+    else:
+        return f"[{ident['client']}]: {message}"

{wormhole_proxy-3.2.0 → wormhole_proxy-3.2.2}/wormhole/proxy.py

@@ -9,7 +9,7 @@ if sys.version_info < (3, 11):
 
 from .ad_blocker import update_database
 from .auth_manager import add_user, modify_user, delete_user
-from .logger import logger, setup_logger
+from .logger import logger, setup_logger, format_log_message as flm
 from .safeguards import load_ad_block_db, load_allowlist
 from .server import start_wormhole_server
 from .version import VERSION
@@ -32,22 +32,42 @@ except ImportError:
 async def main_async(args) -> None:
     """The main asynchronous function to run the server."""
     if uvloop:
-        logger.info(f"Using high-performance event loop: {uvloop.__name__}")
+        logger.info(
+            flm(
+                f"Using high-performance event loop: {uvloop.__name__}",
+                ident={"id": "000000", "client": args.host},
+                verbose=args.verbose,
+            )
+        )
     else:
-        logger.info("Using standard asyncio event loop.")
+        logger.info(
+            flm(
+                "Using standard asyncio event loop.",
+                ident={"id": "000000", "client": args.host},
+                verbose=args.verbose,
+            )
+        )
 
     if args.allowlist:
-        num_allowed = load_allowlist(args.allowlist)
+        num_allowed = load_allowlist(args.allowlist, args.host)
         if num_allowed > 0:
             logger.info(
-                f"Loaded custom allowlist. Total allowlist size: {num_allowed} domains."
+                flm(
+                    f"Loaded custom allowlist. Total allowlist size: {num_allowed} domains.",
+                    ident={"id": "000000", "client": args.host},
+                    verbose=args.verbose,
+                )
             )
 
     if args.ad_block_db:
-        num_blocked = await load_ad_block_db(args.ad_block_db)
+        num_blocked = await load_ad_block_db(args.ad_block_db, args.host)
         if num_blocked > 0:
             logger.info(
-                f"Ad-blocker enabled with {num_blocked} domains from database."
+                flm(
+                    f"Ad-blocker enabled with {num_blocked} domains from database.",
+                    ident={"id": "000000", "client": args.host},
+                    verbose=args.verbose,
+                )
             )
 
     shutdown_event = asyncio.Event()
@@ -65,16 +85,34 @@ async def main_async(args) -> None:
         args.allow_private,
     )
 
-    logger.info("Server startup complete. Waiting for connections...")
+    logger.info(
+        flm(
+            "Server startup complete. Waiting for connections...",
+            ident={"id": "000000", "client": args.host},
+            verbose=args.verbose,
+        )
+    )
 
     # Wait for the shutdown signal.
     await shutdown_event.wait()
 
     # Gracefully shut down the server.
-    logger.info("Shutdown signal received, closing server...")
+    logger.info(
+        flm(
+            f"Shutdown signal received, closing server...",
+            ident={"id": "000000", "client": args.host},
+            verbose=args.verbose,
+        )
+    )
     server.close()
     await server.wait_closed()
-    logger.info("Server has been shut down gracefully.")
+    logger.info(
+        flm(
+            f"Server has been shut down gracefully.",
+            ident={"id": "000000", "client": args.host},
+            verbose=args.verbose,
+        )
+    )
 
 
 def main() -> int:

{wormhole_proxy-3.2.0 → wormhole_proxy-3.2.2}/wormhole/safeguards.py

@@ -83,13 +83,14 @@ def is_private_ip(ip_str: str) -> bool:
         return True
 
 
-async def load_ad_block_db(path: str) -> int:
+async def load_ad_block_db(path: str, host: str) -> int:
     """
     Loads a list of domains to block from a SQLite database into a global set
     for fast in-memory access.
 
     Args:
         path: The path to the SQLite database file.
+        host: The host IP of the server, used for logging.
 
     Returns:
         The number of unique domains loaded into the blocklist.
@@ -103,7 +104,7 @@ async def load_ad_block_db(path: str) -> int:
                     AD_BLOCK_SET.add(row[0])
     except Exception as e:
         logger.error(
-            f"Could not load ad-block database from '{path}': {e}",
+            f"[000000][{host}]: Could not load ad-block database from '{path}': {e}",
         )
 
     if AD_BLOCK_SET:
@@ -112,13 +113,13 @@ async def load_ad_block_db(path: str) -> int:
         content_size = sum(sys.getsizeof(s) for s in AD_BLOCK_SET)
         total_size_mb = (set_size + content_size) / (1024 * 1024)
         logger.debug(
-            f"Ad-block set memory usage: ~{total_size_mb:.2f} MB for {len(AD_BLOCK_SET)} domains"
+            f"[000000][{host}]: Ad-block set memory usage: ~{total_size_mb:.2f} MB for {len(AD_BLOCK_SET)} domains"
         )
 
     return len(AD_BLOCK_SET)
 
 
-def load_allowlist(path: str) -> int:
+def load_allowlist(path: str, host: str) -> int:
     """
     Loads domains from a user-provided file and adds them to the global allowlist set.
     """
@@ -128,7 +129,7 @@ def load_allowlist(path: str) -> int:
                 if line.strip() and not line.startswith("#"):
                     ALLOW_LIST_SET.add(line.strip().lower())
     except FileNotFoundError:
-        logger.error(f"Allowlist file not found at '{path}'")
+        logger.error(f"[000000][{host}]: Allowlist file not found at '{path}'")
     return len(ALLOW_LIST_SET)
 
 

{wormhole_proxy-3.2.0 → wormhole_proxy-3.2.2}/wormhole/server.py

@@ -1,6 +1,6 @@
 from .authentication import get_ident, verify_credentials
 from .handler import process_http_request, process_https_tunnel, parse_request
-from .logger import logger
+from .logger import logger, format_log_message as flm
 from time import time
 import asyncio
 import functools
@@ -45,22 +45,22 @@ async def handle_connection(
     CURRENT_TASKS += 1
     if verbose > 0:
         logger.debug(
-            f"[{ident['id']}][{ident['client']}]: {CURRENT_TASKS}/{MAX_TASKS} Tasks active"
+            flm(f"{CURRENT_TASKS}/{MAX_TASKS} Tasks active", ident, verbose)
         )
     else:
-        logger.debug(f"[{ident['id']}][{ident['client']}]: Connection started.")
+        logger.debug(flm("Connection started.", ident, verbose))
 
     try:
         # Parse the initial request from the client.
         request_line, headers, payload = await parse_request(
-            client_reader, MAX_RETRY, ident
+            client_reader, ident, verbose
         )
         # If parse_request fails, it returns (None, None, None). We check all three
         # to explicitly narrow the types for mypy, which can't infer that if one
         # is None, they all are.
         if not request_line or headers is None or payload is None:
             logger.debug(
-                f"[{ident['id']}][{ident['client']}]: Empty request, closing connection."
+                flm("Empty request, closing connection.", ident, verbose)
             )
             return
 
@@ -69,7 +69,11 @@ async def handle_connection(
             method, uri, version = request_line.split(" ", 2)
         except ValueError:
             logger.debug(
-                f"[{ident['id']}][{ident['client']}]: Malformed request line '{request_line}', closing."
+                flm(
+                    f"Malformed request line '{request_line}', closing.",
+                    ident,
+                    verbose,
+                )
             )
             return
 
@@ -86,14 +90,24 @@ async def handle_connection(
             )
             if user_ident is None:
                 logger.info(
-                    f"[{ident['id']}][{ident['client']}]: {method} 407 {uri} (Authentication Failed)"
+                    flm(
+                        f"{method} 407 {uri} (Authentication Failed)",
+                        ident,
+                        verbose,
+                    )
                 )
                 return
             ident = user_ident  # Update ident with authenticated user info.
         # --- Request Dispatching ---
         if method.upper() == "CONNECT":
             await process_https_tunnel(
-                client_reader, client_writer, method, uri, ident, allow_private
+                client_reader,
+                client_writer,
+                method,
+                uri,
+                ident,
+                allow_private,
+                verbose,
             )
         else:
             # The check above ensures `headers` is `list[str]` and `payload` is `bytes`.
@@ -106,11 +120,12 @@ async def handle_connection(
                 payload,
                 ident,
                 allow_private,
+                verbose,
             )
 
     except Exception as e:
         logger.error(
-            f"[{ident['id']}][{ident['client']}]: Unhandled error in connection handler: {e}",
+            flm(f"Unhandled error in connection handler: {e}", ident, verbose),
             exc_info=True,
         )
     finally:
@@ -120,7 +135,7 @@ async def handle_connection(
             await client_writer.wait_closed()
         duration = time() - start_time
         logger.debug(
-            f"[{ident['id']}][{ident['client']}]: Connection closed ({duration:.5f} seconds)."
+            flm(f"Connection closed ({duration:.5f} seconds).", ident, verbose)
         )
 
 
@@ -154,13 +169,21 @@ async def start_wormhole_server(
         for s in server.sockets:
             addr = s.getsockname()
             logger.info(
-                f"[000000][{host}]: Wormhole proxy bound and listening at {addr[0]}:{addr[1]}"
+                flm(
+                    f"Wormhole proxy bound and listening at {addr[0]}:{addr[1]}",
+                    ident={"id": "000000", "client": host},
+                    verbose=verbose,
+                )
             )
 
         return server
 
     except OSError as e:
         logger.critical(
-            f"[000000][{host}]: Failed to bind server at {host}:{port}: {e}"
+            flm(
+                f"Failed to bind server at {host}:{port}: {e}",
+                ident={"id": "000000", "client": host},
+                verbose=verbose,
+            )
         )
         raise

wormhole_proxy-3.2.0/wormhole/logger.py

@@ -1,58 +0,0 @@
-from loguru import logger
-import logging.handlers
-import os
-import sys
-
-# In loguru, the logger is imported and ready to be configured.
-# We just need to ensure other modules import this configured instance.
-
-
-def setup_logger(
-    syslog_host: str | None = None, syslog_port: int = 514, verbose: int = 0
-) -> None:
-    """
-    Configures the global loguru logger instance. This should only be called once.
-    """
-    # Remove the default handler to have full control over sinks.
-    logger.remove()
-
-    # Set logging level based on verbosity.
-    if verbose >= 2:
-        level = "DEBUG"
-    elif verbose >= 1:
-        level = "DEBUG"
-    else:
-        level = "INFO"
-
-    # --- Console Sink ---
-    # Loguru automatically adds contextual data. The format is simpler.
-    console_format = (
-        "<green>{time:MMM D HH:mm:ss}</green> "
-        "<cyan>{name}</cyan>[<cyan>{process}</cyan>]: "
-        "<level>{message}</level>"
-    )
-    logger.add(sys.stderr, level=level, format=console_format)
-
-    # --- Syslog Sink ---
-    if syslog_host and syslog_host != "DISABLED":
-        # Create a standard library syslog handler instance.
-        # Loguru can sink to handler objects directly.
-        if syslog_host.startswith("/") and os.path.exists(syslog_host):
-            handler = logging.handlers.SysLogHandler(address=syslog_host)
-            syslog_format = "{time:MMM D HH:mm:ss} {name}[{process}]: {message}"
-        else:
-            handler = logging.handlers.SysLogHandler(
-                address=(syslog_host, syslog_port)
-            )
-            # For network syslog, the hostname is typically added by the syslog server,
-            # but we can include it if needed.
-            syslog_format = "{time:MMM D HH:mm:ss} {extra[hostname]} {name}[{process}]: {message}"
-            # Add hostname to all log records.
-            logger.configure(extra={"hostname": os.uname().nodename})
-
-        logger.add(handler, level="INFO", format=syslog_format)
-
-    # Suppress overly verbose asyncio logger messages unless in high verbosity.
-    logging.getLogger("asyncio").setLevel(
-        logging.DEBUG if verbose >= 2 else logging.CRITICAL
-    )