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

mcp_proxy_adapter/examples/proxy_registration_example.py

@@ -19,7 +19,7 @@ sys.path.insert(0, str(project_root))
 import aiohttp
 from aiohttp import ClientTimeout, TCPConnector
 import ssl
-from mcp_proxy_adapter.core.logging import logger
+from mcp_proxy_adapter.core.logging import get_global_logger
 
 
 class ProxyRegistrationExample:
@@ -112,15 +112,15 @@ class ProxyRegistrationExample:
                 "method": "proxy_registration",
                 "params": {"operation": "register", **server_data},
             }
-            logger.info(f"Testing registration for server: {server_data['server_id']}")
-            logger.debug(f"Request data: {json.dumps(request_data, indent=2)}")
+            get_global_logger().info(f"Testing registration for server: {server_data['server_id']}")
+            get_global_logger().debug(f"Request data: {json.dumps(request_data, indent=2)}")
             # Make request
             async with self.session.post(
                 f"{self.server_url}/cmd", json=request_data, headers=self._get_headers()
             ) as response:
                 result = await response.json()
-                logger.info(f"Response status: {response.status}")
-                logger.debug(f"Response: {json.dumps(result, indent=2)}")
+                get_global_logger().info(f"Response status: {response.status}")
+                get_global_logger().debug(f"Response: {json.dumps(result, indent=2)}")
                 return {
                     "success": response.status == 200,
                     "status_code": response.status,
@@ -128,7 +128,7 @@ class ProxyRegistrationExample:
                     "server_id": server_data["server_id"],
                 }
         except Exception as e:
-            logger.error(f"Registration test failed: {e}")
+            get_global_logger().error(f"Registration test failed: {e}")
             return {
                 "success": False,
                 "error": str(e),
@@ -149,21 +149,21 @@ class ProxyRegistrationExample:
                 "method": "proxy_registration",
                 "params": {"operation": "discover"},
             }
-            logger.info("Testing discovery operation")
+            get_global_logger().info("Testing discovery operation")
             # Make request
             async with self.session.post(
                 f"{self.server_url}/cmd", json=request_data, headers=self._get_headers()
             ) as response:
                 result = await response.json()
-                logger.info(f"Response status: {response.status}")
-                logger.debug(f"Response: {json.dumps(result, indent=2)}")
+                get_global_logger().info(f"Response status: {response.status}")
+                get_global_logger().debug(f"Response: {json.dumps(result, indent=2)}")
                 return {
                     "success": response.status == 200,
                     "status_code": response.status,
                     "result": result,
                 }
         except Exception as e:
-            logger.error(f"Discovery test failed: {e}")
+            get_global_logger().error(f"Discovery test failed: {e}")
             return {"success": False, "error": str(e)}
 
     async def test_heartbeat(self, server_key: str) -> Dict[str, Any]:
@@ -187,14 +187,14 @@ class ProxyRegistrationExample:
                     "status": "healthy",
                 },
             }
-            logger.info(f"Testing heartbeat for server: {server_key}")
+            get_global_logger().info(f"Testing heartbeat for server: {server_key}")
             # Make request
             async with self.session.post(
                 f"{self.server_url}/cmd", json=request_data, headers=self._get_headers()
             ) as response:
                 result = await response.json()
-                logger.info(f"Response status: {response.status}")
-                logger.debug(f"Response: {json.dumps(result, indent=2)}")
+                get_global_logger().info(f"Response status: {response.status}")
+                get_global_logger().debug(f"Response: {json.dumps(result, indent=2)}")
                 return {
                     "success": response.status == 200,
                     "status_code": response.status,
@@ -202,13 +202,13 @@ class ProxyRegistrationExample:
                     "server_key": server_key,
                 }
         except Exception as e:
-            logger.error(f"Heartbeat test failed: {e}")
+            get_global_logger().error(f"Heartbeat test failed: {e}")
             return {"success": False, "error": str(e), "server_key": server_key}
 
 
 async def run_proxy_registration_example():
     """Run proxy registration example."""
-    logger.info("🚀 Starting proxy registration example")
+    get_global_logger().info("🚀 Starting proxy registration example")
     # Test configurations
     test_configs = [
         {
@@ -229,9 +229,9 @@ async def run_proxy_registration_example():
     ]
     results = []
     for config in test_configs:
-        logger.info(f"\n📋 Testing: {config['name']}")
-        logger.info(f"Server URL: {config['server_url']}")
-        logger.info(f"Auth Token: {config['auth_token']}")
+        get_global_logger().info(f"\n📋 Testing: {config['name']}")
+        get_global_logger().info(f"Server URL: {config['server_url']}")
+        get_global_logger().info(f"Auth Token: {config['auth_token']}")
         async with ProxyRegistrationExample(
             config["server_url"], config["auth_token"]
         ) as client:
@@ -263,7 +263,7 @@ async def run_proxy_registration_example():
                 {"test": f"{config['name']} - Discovery", **discovery_result}
             )
     # Test without authentication
-    logger.info(f"\n📋 Testing: No Authentication")
+    get_global_logger().info(f"\n📋 Testing: No Authentication")
     async with ProxyRegistrationExample("http://localhost:8002") as client:
         for server_data in client.test_servers:
             result = await client.test_registration(server_data)
@@ -275,40 +275,40 @@ async def run_proxy_registration_example():
                 }
             )
     # Print results
-    logger.info("\n" + "=" * 80)
-    logger.info("📊 EXAMPLE RESULTS")
-    logger.info("=" * 80)
+    get_global_logger().info("\n" + "=" * 80)
+    get_global_logger().info("📊 EXAMPLE RESULTS")
+    get_global_logger().info("=" * 80)
     passed = 0
     failed = 0
     for result in results:
         status = "✅ PASS" if result["success"] else "❌ FAIL"
-        logger.info(f"{status} {result['test']}")
+        get_global_logger().info(f"{status} {result['test']}")
         if result["success"]:
             passed += 1
         else:
             failed += 1
         if "error" in result:
-            logger.error(f"   Error: {result['error']}")
+            get_global_logger().error(f"   Error: {result['error']}")
         elif "result" in result:
             result_data = result["result"]
             if "error" in result_data:
-                logger.error(f"   API Error: {result_data['error']}")
+                get_global_logger().error(f"   API Error: {result_data['error']}")
             elif "result" in result_data:
                 api_result = result_data["result"]
                 if "server_key" in api_result:
-                    logger.info(f"   Server Key: {api_result['server_key']}")
+                    get_global_logger().info(f"   Server Key: {api_result['server_key']}")
                 if "message" in api_result:
-                    logger.info(f"   Message: {api_result['message']}")
-    logger.info("\n" + "=" * 80)
-    logger.info(f"📈 SUMMARY: {passed} passed, {failed} failed")
-    logger.info("=" * 80)
+                    get_global_logger().info(f"   Message: {api_result['message']}")
+    get_global_logger().info("\n" + "=" * 80)
+    get_global_logger().info(f"📈 SUMMARY: {passed} passed, {failed} failed")
+    get_global_logger().info("=" * 80)
     return passed, failed
 
 
 def main():
     """Main function for the example."""
-    logger.info("🔧 MCP Proxy Adapter - Proxy Registration Example")
-    logger.info("=" * 60)
+    get_global_logger().info("🔧 MCP Proxy Adapter - Proxy Registration Example")
+    get_global_logger().info("=" * 60)
     # Check if server is running
     import socket
 
@@ -316,15 +316,15 @@ def main():
     result = sock.connect_ex(("localhost", 8002))
     sock.close()
     if result != 0:
-        logger.error("❌ Server is not running on localhost:8002")
-        logger.info("💡 Please start the server first:")
-        logger.info("   cd mcp_proxy_adapter/examples")
-        logger.info(
+        get_global_logger().error("❌ Server is not running on localhost:8002")
+        get_global_logger().info("💡 Please start the server first:")
+        get_global_logger().info("   cd mcp_proxy_adapter/examples")
+        get_global_logger().info(
             "   python -m mcp_proxy_adapter.main --config server_configs/config_proxy_registration.json"
         )
         sys.exit(1)
-    logger.info("✅ Server is running on localhost:8002")
-    logger.info("🚀 Starting proxy registration example...")
+    get_global_logger().info("✅ Server is running on localhost:8002")
+    get_global_logger().info("🚀 Starting proxy registration example...")
     # Run example
     passed, failed = asyncio.run(run_proxy_registration_example())
     # Exit with appropriate code

mcp_proxy_adapter/examples/test_framework_complete.py

@@ -32,8 +32,8 @@ class FrameworkTester:
         
     async def test_all_protocols(self):
         """Test all protocols with real MCP server registration."""
-        logger.info("🧪 Starting Complete Framework Testing")
-        logger.info("=" * 60)
+        get_global_logger().info("🧪 Starting Complete Framework Testing")
+        get_global_logger().info("=" * 60)
         
         # Test configurations
         test_configs = [
@@ -43,8 +43,8 @@ class FrameworkTester:
         ]
         
         for config_file, protocol, port in test_configs:
-            logger.info(f"\n🔧 Testing {protocol} (port {port})")
-            logger.info("-" * 40)
+            get_global_logger().info(f"\n🔧 Testing {protocol} (port {port})")
+            get_global_logger().info("-" * 40)
             
             try:
                 # Start proxy adapter server
@@ -68,10 +68,10 @@ class FrameworkTester:
                 proxy_process.terminate()
                 await asyncio.sleep(1)
                 
-                logger.info(f"✅ {protocol} testing completed successfully")
+                get_global_logger().info(f"✅ {protocol} testing completed successfully")
                 
             except Exception as e:
-                logger.error(f"❌ {protocol} testing failed: {e}")
+                get_global_logger().error(f"❌ {protocol} testing failed: {e}")
                 self.test_results.append({
                     "protocol": protocol,
                     "status": "failed",
@@ -86,10 +86,10 @@ class FrameworkTester:
         config_path = self.configs_dir / config_file
         
         if not config_path.exists():
-            logger.error(f"❌ Config file not found: {config_path}")
+            get_global_logger().error(f"❌ Config file not found: {config_path}")
             return None
         
-        logger.info(f"🚀 Starting proxy server with {config_file}")
+        get_global_logger().info(f"🚀 Starting proxy server with {config_file}")
         
         try:
             # Start server in background
@@ -102,12 +102,12 @@ class FrameworkTester:
             return process
             
         except Exception as e:
-            logger.error(f"❌ Failed to start server: {e}")
+            get_global_logger().error(f"❌ Failed to start server: {e}")
             return None
     
     async def _test_server_registration(self, protocol: str, port: int):
         """Test MCP server registration."""
-        logger.info(f"📝 Testing server registration for {protocol}")
+        get_global_logger().info(f"📝 Testing server registration for {protocol}")
         
         base_url = f"http://localhost:{port}" if protocol == "HTTP" else f"https://localhost:{port}"
         
@@ -135,17 +135,17 @@ class FrameworkTester:
             )
             
             if response.status_code == 200:
-                logger.info("✅ Server registration successful")
+                get_global_logger().info("✅ Server registration successful")
             else:
-                logger.warning(f"⚠️ Registration returned status {response.status_code}")
+                get_global_logger().warning(f"⚠️ Registration returned status {response.status_code}")
                 
         except Exception as e:
-            logger.error(f"❌ Registration failed: {e}")
+            get_global_logger().error(f"❌ Registration failed: {e}")
             raise
     
     async def _test_mcp_communication(self, protocol: str, port: int):
         """Test MCP communication through proxy."""
-        logger.info(f"🔗 Testing MCP communication for {protocol}")
+        get_global_logger().info(f"🔗 Testing MCP communication for {protocol}")
         
         base_url = f"http://localhost:{port}" if protocol == "HTTP" else f"https://localhost:{port}"
         
@@ -175,19 +175,19 @@ class FrameworkTester:
             if response.status_code == 200:
                 result = response.json()
                 if "result" in result:
-                    logger.info("✅ MCP communication successful")
+                    get_global_logger().info("✅ MCP communication successful")
                 else:
-                    logger.warning(f"⚠️ MCP response: {result}")
+                    get_global_logger().warning(f"⚠️ MCP response: {result}")
             else:
-                logger.warning(f"⚠️ MCP call returned status {response.status_code}")
+                get_global_logger().warning(f"⚠️ MCP call returned status {response.status_code}")
                 
         except Exception as e:
-            logger.error(f"❌ MCP communication failed: {e}")
+            get_global_logger().error(f"❌ MCP communication failed: {e}")
             raise
     
     async def _test_security_features(self, protocol: str, port: int):
         """Test security features."""
-        logger.info(f"🔒 Testing security features for {protocol}")
+        get_global_logger().info(f"🔒 Testing security features for {protocol}")
         
         base_url = f"http://localhost:{port}" if protocol == "HTTP" else f"https://localhost:{port}"
         
@@ -206,43 +206,43 @@ class FrameworkTester:
             )
             
             if response.status_code == 200:
-                logger.info("✅ Health check successful")
+                get_global_logger().info("✅ Health check successful")
             else:
-                logger.warning(f"⚠️ Health check returned status {response.status_code}")
+                get_global_logger().warning(f"⚠️ Health check returned status {response.status_code}")
                 
         except Exception as e:
-            logger.error(f"❌ Security test failed: {e}")
+            get_global_logger().error(f"❌ Security test failed: {e}")
             raise
     
     def _print_summary(self):
         """Print test summary."""
-        logger.info("\n" + "=" * 60)
-        logger.info("📊 FRAMEWORK TESTING SUMMARY")
-        logger.info("=" * 60)
+        get_global_logger().info("\n" + "=" * 60)
+        get_global_logger().info("📊 FRAMEWORK TESTING SUMMARY")
+        get_global_logger().info("=" * 60)
         
         total_tests = len(self.test_results)
         successful_tests = len([r for r in self.test_results if r["status"] == "success"])
         
-        logger.info(f"Total tests: {total_tests}")
-        logger.info(f"Successful: {successful_tests}")
-        logger.info(f"Failed: {total_tests - successful_tests}")
+        get_global_logger().info(f"Total tests: {total_tests}")
+        get_global_logger().info(f"Successful: {successful_tests}")
+        get_global_logger().info(f"Failed: {total_tests - successful_tests}")
         
         if total_tests > 0:
             success_rate = (successful_tests / total_tests) * 100
-            logger.info(f"Success rate: {success_rate:.1f}%")
+            get_global_logger().info(f"Success rate: {success_rate:.1f}%")
             
             if success_rate == 100:
-                logger.info("🎉 All tests passed! Framework is working correctly.")
+                get_global_logger().info("🎉 All tests passed! Framework is working correctly.")
             elif success_rate >= 80:
-                logger.info("✅ Most tests passed. Framework is mostly functional.")
+                get_global_logger().info("✅ Most tests passed. Framework is mostly functional.")
             else:
-                logger.info("⚠️ Many tests failed. Framework needs attention.")
+                get_global_logger().info("⚠️ Many tests failed. Framework needs attention.")
         
-        logger.info("=" * 60)
+        get_global_logger().info("=" * 60)
     
     async def cleanup(self):
         """Cleanup server processes."""
-        logger.info("🧹 Cleaning up server processes...")
+        get_global_logger().info("🧹 Cleaning up server processes...")
         
         for process in self.server_processes:
             try:
@@ -252,7 +252,7 @@ class FrameworkTester:
             except subprocess.TimeoutExpired:
                 process.kill()
             except Exception as e:
-                logger.warning(f"Warning: Failed to cleanup process: {e}")
+                get_global_logger().warning(f"Warning: Failed to cleanup process: {e}")
         
         self.server_processes.clear()
 

mcp_proxy_adapter/examples/test_mcp_server.py

@@ -77,7 +77,7 @@ class TestMCPServer:
         @self.server.call_tool()
         async def call_tool(name: str, arguments: Dict[str, Any]) -> List[types.TextContent]:
             """Handle tool calls."""
-            logger.info(f"Tool called: {name} with args: {arguments}")
+            get_global_logger().info(f"Tool called: {name} with args: {arguments}")
             
             if name == "echo":
                 message = arguments.get("message", "")
@@ -173,7 +173,7 @@ class TestMCPServer:
 
 async def main():
     """Main server function."""
-    logger.info("Starting Test MCP Server...")
+    get_global_logger().info("Starting Test MCP Server...")
     
     server_instance = TestMCPServer()