mcp-proxy-adapter 6.9.17__py3-none-any.whl → 6.9.19__py3-none-any.whl

mcp_proxy_adapter/core/crl_utils.py

@@ -70,7 +70,7 @@ class CRLManager:
         # Setup HTTP session with retry strategy
         self._setup_http_session()
 
-        logger.info(
+        get_global_logger().info(
             f"CRL Manager initialized - enabled: {self.crl_enabled}, certificates_enabled: {certificates_enabled}"
         )
 
@@ -105,7 +105,7 @@ class CRLManager:
             requests.RequestException: If CRL download fails
         """
         if not self.crl_enabled:
-            logger.debug("CRL is disabled, skipping CRL check")
+            get_global_logger().debug("CRL is disabled, skipping CRL check")
             return None
 
         # Check if CRL URL is configured
@@ -136,7 +136,7 @@ class CRLManager:
             ValueError: If downloaded data is not valid CRL
         """
         try:
-            logger.info(f"Downloading CRL from URL: {self.crl_url}")
+            get_global_logger().info(f"Downloading CRL from URL: {self.crl_url}")
 
             # Download CRL
             response = self.session.get(self.crl_url)
@@ -148,7 +148,7 @@ class CRLManager:
                 "application/pkix-crl" not in content_type
                 and "application/x-pkcs7-crl" not in content_type
             ):
-                logger.warning(f"Unexpected content type for CRL: {content_type}")
+                get_global_logger().warning(f"Unexpected content type for CRL: {content_type}")
 
             # Save to temporary file
             with tempfile.NamedTemporaryFile(
@@ -161,14 +161,14 @@ class CRLManager:
             if SECURITY_FRAMEWORK_AVAILABLE:
                 try:
                     is_crl_valid(temp_file_path)
-                    logger.info(
+                    get_global_logger().info(
                         f"CRL downloaded and validated successfully from {self.crl_url}"
                     )
                 except Exception as e:
                     os.unlink(temp_file_path)
                     raise ValueError(f"Downloaded CRL is not valid: {e}")
             else:
-                logger.warning(
+                get_global_logger().warning(
                     "mcp_security_framework not available, skipping CRL validation"
                 )
 
@@ -178,10 +178,10 @@ class CRLManager:
             return temp_file_path
 
         except requests.RequestException as e:
-            logger.error(f"Failed to download CRL from {self.crl_url}: {e}")
+            get_global_logger().error(f"Failed to download CRL from {self.crl_url}: {e}")
             raise
         except Exception as e:
-            logger.error(f"CRL download failed: {e}")
+            get_global_logger().error(f"CRL download failed: {e}")
             raise
 
     def _get_crl_from_file(self) -> str:
@@ -202,11 +202,11 @@ class CRLManager:
         if SECURITY_FRAMEWORK_AVAILABLE:
             try:
                 is_crl_valid(self.crl_path)
-                logger.info(f"CRL file validated successfully: {self.crl_path}")
+                get_global_logger().info(f"CRL file validated successfully: {self.crl_path}")
             except Exception as e:
                 raise ValueError(f"CRL file is not valid: {e}")
         else:
-            logger.warning(
+            get_global_logger().warning(
                 "mcp_security_framework not available, skipping CRL validation"
             )
 
@@ -230,28 +230,28 @@ class CRLManager:
             return False
 
         if not SECURITY_FRAMEWORK_AVAILABLE:
-            logger.warning("mcp_security_framework not available, skipping CRL check")
+            get_global_logger().warning("mcp_security_framework not available, skipping CRL check")
             return False
 
         try:
             crl_data = self.get_crl_data()
             if not crl_data:
-                logger.warning("CRL is enabled but no CRL data is available")
+                get_global_logger().warning("CRL is enabled but no CRL data is available")
                 return False
 
             is_revoked = is_certificate_revoked(cert_path, crl_data)
 
             if is_revoked:
-                logger.warning(f"Certificate is revoked according to CRL: {cert_path}")
+                get_global_logger().warning(f"Certificate is revoked according to CRL: {cert_path}")
             else:
-                logger.debug(
+                get_global_logger().debug(
                     f"Certificate is not revoked according to CRL: {cert_path}"
                 )
 
             return is_revoked
 
         except Exception as e:
-            logger.error(f"CRL check failed for certificate {cert_path}: {e}")
+            get_global_logger().error(f"CRL check failed for certificate {cert_path}: {e}")
             # For security, consider certificate invalid if CRL check fails
             return True
 
@@ -278,7 +278,7 @@ class CRLManager:
             }
 
         if not SECURITY_FRAMEWORK_AVAILABLE:
-            logger.warning(
+            get_global_logger().warning(
                 "mcp_security_framework not available, skipping CRL validation"
             )
             return {
@@ -291,7 +291,7 @@ class CRLManager:
         try:
             crl_data = self.get_crl_data()
             if not crl_data:
-                logger.warning("CRL is enabled but no CRL data is available")
+                get_global_logger().warning("CRL is enabled but no CRL data is available")
                 return {
                     "is_revoked": True,  # For security, consider invalid if CRL unavailable
                     "crl_checked": False,
@@ -311,7 +311,7 @@ class CRLManager:
             return result
 
         except Exception as e:
-            logger.error(f"CRL validation failed for certificate {cert_path}: {e}")
+            get_global_logger().error(f"CRL validation failed for certificate {cert_path}: {e}")
             # For security, consider certificate invalid if CRL validation fails
             return {
                 "is_revoked": True,
@@ -331,7 +331,7 @@ class CRLManager:
             return None
 
         if not SECURITY_FRAMEWORK_AVAILABLE:
-            logger.warning("mcp_security_framework not available, cannot get CRL info")
+            get_global_logger().warning("mcp_security_framework not available, cannot get CRL info")
             return None
 
         try:
@@ -342,7 +342,7 @@ class CRLManager:
             return get_crl_info(crl_data)
 
         except Exception as e:
-            logger.error(f"Failed to get CRL info: {e}")
+            get_global_logger().error(f"Failed to get CRL info: {e}")
             return None
 
     def cleanup_cache(self):
@@ -351,9 +351,9 @@ class CRLManager:
             try:
                 if os.path.exists(temp_path):
                     os.unlink(temp_path)
-                    logger.debug(f"Cleaned up temporary CRL file: {temp_path}")
+                    get_global_logger().debug(f"Cleaned up temporary CRL file: {temp_path}")
             except Exception as e:
-                logger.warning(f"Failed to cleanup temporary CRL file {temp_path}: {e}")
+                get_global_logger().warning(f"Failed to cleanup temporary CRL file {temp_path}: {e}")
 
         self._crl_cache.clear()
 

mcp_proxy_adapter/core/logging.py

@@ -60,7 +60,7 @@ class RequestLogger:
 
     def __init__(self, logger_name: str, request_id: Optional[str] = None):
         """
-        Initialize request logger.
+        Initialize request get_global_logger().
 
         Args:
             logger_name: Logger name.
@@ -69,31 +69,31 @@ class RequestLogger:
         self.logger = logging.getLogger(logger_name)
         self.request_id = request_id or str(uuid.uuid4())
         self.filter = RequestContextFilter(self.request_id)
-        self.logger.addFilter(self.filter)
+        get_global_logger().addFilter(self.filter)
 
     def debug(self, msg: str, *args, **kwargs):
         """Log message with DEBUG level."""
-        self.logger.debug(f"[{self.request_id}] {msg}", *args, **kwargs)
+        get_global_logger().debug(f"[{self.request_id}] {msg}", *args, **kwargs)
 
     def info(self, msg: str, *args, **kwargs):
         """Log message with INFO level."""
-        self.logger.info(f"[{self.request_id}] {msg}", *args, **kwargs)
+        get_global_logger().info(f"[{self.request_id}] {msg}", *args, **kwargs)
 
     def warning(self, msg: str, *args, **kwargs):
         """Log message with WARNING level."""
-        self.logger.warning(f"[{self.request_id}] {msg}", *args, **kwargs)
+        get_global_logger().warning(f"[{self.request_id}] {msg}", *args, **kwargs)
 
     def error(self, msg: str, *args, **kwargs):
         """Log message with ERROR level."""
-        self.logger.error(f"[{self.request_id}] {msg}", *args, **kwargs)
+        get_global_logger().error(f"[{self.request_id}] {msg}", *args, **kwargs)
 
     def exception(self, msg: str, *args, **kwargs):
         """Log exception with traceback."""
-        self.logger.exception(f"[{self.request_id}] {msg}", *args, **kwargs)
+        get_global_logger().exception(f"[{self.request_id}] {msg}", *args, **kwargs)
 
     def critical(self, msg: str, *args, **kwargs):
         """Log message with CRITICAL level."""
-        self.logger.critical(f"[{self.request_id}] {msg}", *args, **kwargs)
+        get_global_logger().critical(f"[{self.request_id}] {msg}", *args, **kwargs)
 
 
 def setup_logging(
@@ -118,7 +118,7 @@ def setup_logging(
         rotation_interval: Interval for rotation. By default, taken from configuration.
 
     Returns:
-        Configured logger.
+        Configured get_global_logger().
     """
     # Use provided parameters or defaults
     level = level or "INFO"
@@ -247,16 +247,24 @@ def _parse_file_size(size_str) -> int:
 
 def get_logger(name: str) -> logging.Logger:
     """
-    Get a logger with the specified name.
+    Get a get_global_logger() with the specified name.
 
     Args:
         name: Logger name.
 
     Returns:
-        Configured logger instance.
+        Configured get_global_logger() instance.
     """
     return logging.getLogger(name)
 
 
-# Global logger for use throughout the application
-logger = setup_logging()
+# Global get_global_logger() for use throughout the application
+# Initialize lazily to avoid import-time errors
+logger = None
+
+def get_global_logger():
+    """Get the global logger, initializing it if necessary."""
+    global logger
+    if logger is None:
+        logger = setup_logging()
+    return logger

mcp_proxy_adapter/core/mtls_asgi.py

@@ -37,7 +37,7 @@ class MTLSASGIApp:
         self.verify_client = ssl_config.get("verify_client", False)
         self.client_cert_required = ssl_config.get("client_cert_required", False)
 
-        logger.info(
+        get_global_logger().info(
             f"MTLS ASGI app initialized: verify_client={self.verify_client}, "
             f"client_cert_required={self.client_cert_required}"
         )
@@ -58,11 +58,11 @@ class MTLSASGIApp:
                 if client_cert:
                     # Store certificate in scope for middleware access
                     scope["client_certificate"] = client_cert
-                    logger.debug(
+                    get_global_logger().debug(
                         f"Client certificate extracted: {client_cert.get('subject', {})}"
                     )
                 elif self.client_cert_required:
-                    logger.warning("Client certificate required but not provided")
+                    get_global_logger().warning("Client certificate required but not provided")
                     # Return 401 Unauthorized
                     await self._send_unauthorized_response(send)
                     return
@@ -71,7 +71,7 @@ class MTLSASGIApp:
             await self.app(scope, receive, send)
 
         except Exception as e:
-            logger.error(f"Error in MTLS ASGI app: {e}")
+            get_global_logger().error(f"Error in MTLS ASGI app: {e}")
             await self._send_error_response(send, str(e))
 
     def _extract_client_certificate(self, scope: Scope) -> Optional[Dict[str, Any]]:
@@ -97,7 +97,7 @@ class MTLSASGIApp:
             return None
 
         except Exception as e:
-            logger.error(f"Failed to extract client certificate: {e}")
+            get_global_logger().error(f"Failed to extract client certificate: {e}")
             return None
 
     async def _send_unauthorized_response(self, send: Send) -> None:
@@ -153,8 +153,8 @@ def create_mtls_asgi_app(app: ASGIApp, ssl_config: Dict[str, Any]) -> ASGIApp:
         MTLS-enabled ASGI application
     """
     if ssl_config.get("mode") == "mtls" or ssl_config.get("verify_client", False):
-        logger.info("Creating MTLS-enabled ASGI application")
+        get_global_logger().info("Creating MTLS-enabled ASGI application")
         return MTLSASGIApp(app, ssl_config)
     else:
-        logger.info("Creating standard ASGI application (no mTLS)")
+        get_global_logger().info("Creating standard ASGI application (no mTLS)")
         return app

mcp_proxy_adapter/core/mtls_asgi_app.py

@@ -37,7 +37,7 @@ class MTLSASGIApp:
         self.ssl_config = ssl_config
         self.client_cert_required = ssl_config.get("client_cert_required", True)
 
-        logger.info(
+        get_global_logger().info(
             f"MTLS ASGI app initialized: client_cert_required={self.client_cert_required}"
         )
 
@@ -57,11 +57,11 @@ class MTLSASGIApp:
                 if client_cert:
                     # Store certificate in scope for middleware access
                     scope["client_certificate"] = client_cert
-                    logger.debug(
+                    get_global_logger().debug(
                         f"Client certificate extracted: {client_cert.get('subject', {})}"
                     )
                 elif self.client_cert_required:
-                    logger.warning("Client certificate required but not provided")
+                    get_global_logger().warning("Client certificate required but not provided")
                     # Return 401 Unauthorized
                     await self._send_unauthorized_response(send)
                     return
@@ -70,7 +70,7 @@ class MTLSASGIApp:
             await self.app(scope, receive, send)
 
         except Exception as e:
-            logger.error(f"Error in MTLS ASGI app: {e}")
+            get_global_logger().error(f"Error in MTLS ASGI app: {e}")
             await self._send_error_response(send, str(e))
 
     def _extract_client_certificate(
@@ -88,7 +88,7 @@ class MTLSASGIApp:
         try:
             ssl_context = scope.get("ssl")
             if not ssl_context:
-                logger.debug("No SSL context found in scope")
+                get_global_logger().debug("No SSL context found in scope")
                 return None
 
             # Try to get peer certificate
@@ -99,14 +99,14 @@ class MTLSASGIApp:
                     cert = x509.load_der_x509_certificate(cert_data)
                     return self._cert_to_dict(cert)
                 else:
-                    logger.debug("No certificate data in SSL context")
+                    get_global_logger().debug("No certificate data in SSL context")
                     return None
             else:
-                logger.debug("SSL context has no getpeercert method")
+                get_global_logger().debug("SSL context has no getpeercert method")
                 return None
 
         except Exception as e:
-            logger.error(f"Failed to extract client certificate: {e}")
+            get_global_logger().error(f"Failed to extract client certificate: {e}")
             return None
 
     def _cert_to_dict(self, cert: x509.Certificate) -> Dict[str, Any]:
@@ -152,7 +152,7 @@ class MTLSASGIApp:
                 },
             }
         except Exception as e:
-            logger.error(f"Failed to convert certificate to dict: {e}")
+            get_global_logger().error(f"Failed to convert certificate to dict: {e}")
             return {"error": str(e)}
 
     async def _send_unauthorized_response(self, send):

mcp_proxy_adapter/core/mtls_proxy.py

@@ -72,11 +72,11 @@ class MTLSProxy:
                 ssl=ssl_context
             )
             
-            logger.info(f"🔐 mTLS Proxy started on {self.external_host}:{self.external_port}")
-            logger.info(f"🌐 Proxying to {self.internal_host}:{self.internal_port}")
+            get_global_logger().info(f"🔐 mTLS Proxy started on {self.external_host}:{self.external_port}")
+            get_global_logger().info(f"🌐 Proxying to {self.internal_host}:{self.internal_port}")
             
         except Exception as e:
-            logger.error(f"❌ Failed to start mTLS proxy: {e}")
+            get_global_logger().error(f"❌ Failed to start mTLS proxy: {e}")
             raise
             
     async def stop(self):
@@ -84,14 +84,14 @@ class MTLSProxy:
         if self.server:
             self.server.close()
             await self.server.wait_closed()
-            logger.info("🔐 mTLS Proxy stopped")
+            get_global_logger().info("🔐 mTLS Proxy stopped")
             
     async def _handle_client(self, reader, writer):
         """Handle client connection."""
         try:
             # Get client address
             client_addr = writer.get_extra_info('peername')
-            logger.info(f"🔐 mTLS connection from {client_addr}")
+            get_global_logger().info(f"🔐 mTLS connection from {client_addr}")
             
             # Connect to internal server
             internal_reader, internal_writer = await asyncio.open_connection(
@@ -105,7 +105,7 @@ class MTLSProxy:
             )
             
         except Exception as e:
-            logger.error(f"❌ Error handling client connection: {e}")
+            get_global_logger().error(f"❌ Error handling client connection: {e}")
         finally:
             try:
                 writer.close()
@@ -123,7 +123,7 @@ class MTLSProxy:
                 writer.write(data)
                 await writer.drain()
         except Exception as e:
-            logger.debug(f"Proxy connection closed ({direction}): {e}")
+            get_global_logger().debug(f"Proxy connection closed ({direction}): {e}")
         finally:
             try:
                 writer.close()
@@ -148,7 +148,7 @@ async def start_mtls_proxy(config: Dict[str, Any]) -> Optional[MTLSProxy]:
     
     # Only start mTLS proxy if mTLS is explicitly enabled
     if protocol != "mtls" and not verify_client:
-        logger.info("🌐 Regular mode: no mTLS proxy needed")
+        get_global_logger().info("🌐 Regular mode: no mTLS proxy needed")
         return None
         
     # Get configuration
@@ -164,7 +164,7 @@ async def start_mtls_proxy(config: Dict[str, Any]) -> Optional[MTLSProxy]:
     ca_cert = transport_config.get("ca_cert")
     
     if not cert_file or not key_file:
-        logger.warning("⚠️  mTLS enabled but certificates not configured")
+        get_global_logger().warning("⚠️  mTLS enabled but certificates not configured")
         return None
         
     # Create and start proxy

mcp_proxy_adapter/core/mtls_server.py

@@ -25,8 +25,8 @@ class mTLSHandler(BaseHTTPRequestHandler):
         super().__init__(*args, **kwargs)
 
     def log_message(self, format, *args):
-        """Override to use our logger."""
-        logger.info(f"mTLS Server: {format % args}")
+        """Override to use our get_global_logger()."""
+        get_global_logger().info(f"mTLS Server: {format % args}")
 
     def do_GET(self):
         """Handle GET requests."""
@@ -58,7 +58,7 @@ class mTLSHandler(BaseHTTPRequestHandler):
             self.wfile.write(json.dumps(response_data).encode())
 
         except Exception as e:
-            logger.error(f"Error in mTLS GET handler: {e}")
+            get_global_logger().error(f"Error in mTLS GET handler: {e}")
             self.send_error(500, str(e))
 
     def do_POST(self):
@@ -100,7 +100,7 @@ class mTLSHandler(BaseHTTPRequestHandler):
             self.wfile.write(json.dumps(response_data).encode())
 
         except Exception as e:
-            logger.error(f"Error in mTLS POST handler: {e}")
+            get_global_logger().error(f"Error in mTLS POST handler: {e}")
             self.send_error(500, str(e))
 
     def _forward_to_main_app(
@@ -124,7 +124,7 @@ class mTLSHandler(BaseHTTPRequestHandler):
                 "forwarded": True,
             }
         except Exception as e:
-            logger.error(f"Error forwarding to main app: {e}")
+            get_global_logger().error(f"Error forwarding to main app: {e}")
             return {
                 "status": "error",
                 "message": f"Forwarding failed: {e}",
@@ -167,7 +167,7 @@ class mTLSServer:
         self.server_thread: Optional[threading.Thread] = None
         self.running = False
 
-        logger.info(f"mTLS Server initialized: {host}:{port}")
+        get_global_logger().info(f"mTLS Server initialized: {host}:{port}")
 
     def _create_handler(self):
         """Create handler with main app reference."""
@@ -182,15 +182,15 @@ class mTLSServer:
         try:
             # Check if certificate files exist
             if not os.path.exists(self.cert_file):
-                logger.error(f"Certificate file not found: {self.cert_file}")
+                get_global_logger().error(f"Certificate file not found: {self.cert_file}")
                 return False
 
             if not os.path.exists(self.key_file):
-                logger.error(f"Key file not found: {self.key_file}")
+                get_global_logger().error(f"Key file not found: {self.key_file}")
                 return False
 
             if not os.path.exists(self.ca_cert_file):
-                logger.error(
+                get_global_logger().error(
                     f"CA certificate file not found: {self.ca_cert_file}"
                 )
                 return False
@@ -217,24 +217,24 @@ class mTLSServer:
             self.server_thread.start()
 
             self.running = True
-            logger.info(
+            get_global_logger().info(
                 f"✅ mTLS Server started on https://{self.host}:{self.port}"
             )
             return True
 
         except Exception as e:
-            logger.error(f"Failed to start mTLS server: {e}")
+            get_global_logger().error(f"Failed to start mTLS server: {e}")
             return False
 
     def _run_server(self):
         """Run the server (blocking)."""
         try:
-            logger.info(
+            get_global_logger().info(
                 f"mTLS Server listening on https://{self.host}:{self.port}"
             )
             self.server.serve_forever()
         except Exception as e:
-            logger.error(f"mTLS Server error: {e}")
+            get_global_logger().error(f"mTLS Server error: {e}")
         finally:
             self.running = False
 
@@ -245,9 +245,9 @@ class mTLSServer:
                 self.server.shutdown()
                 self.server.server_close()
                 self.running = False
-                logger.info("✅ mTLS Server stopped")
+                get_global_logger().info("✅ mTLS Server stopped")
             except Exception as e:
-                logger.error(f"Error stopping mTLS server: {e}")
+                get_global_logger().error(f"Error stopping mTLS server: {e}")
 
     def is_running(self) -> bool:
         """Check if server is running."""
@@ -278,7 +278,7 @@ def start_mtls_server_thread(
         # Check if mTLS is enabled
         verify_client = ssl_config.get("verify_client", False)
         if not verify_client:
-            logger.info(
+            get_global_logger().info(
                 "mTLS not enabled (verify_client=False), skipping mTLS server"
             )
             return None
@@ -316,9 +316,9 @@ def start_mtls_server_thread(
         if mtls_server.start():
             return mtls_server
         else:
-            logger.error("Failed to start mTLS server")
+            get_global_logger().error("Failed to start mTLS server")
             return None
 
     except Exception as e:
-        logger.error(f"Error starting mTLS server thread: {e}")
+        get_global_logger().error(f"Error starting mTLS server thread: {e}")
         return None