@rishibhushan/jenkins-mcp-server 1.0.7 → 1.1.0

package/src/jenkins_mcp_server/config.py

@@ -5,6 +5,8 @@ Handles loading Jenkins connection settings from multiple sources:
 1. VS Code settings.json (highest priority)
 2. Environment variables / .env file
 3. Direct instantiation with parameters
+
+Enhanced with timeout configuration support.
 """
 
 import json
@@ -50,6 +52,50 @@ class JenkinsSettings(BaseSettings):
         description="Jenkins API token (preferred over password)"
     )
 
+    # Timeout settings (High Priority Issue #4)
+    timeout: int = Field(
+        default=30,
+        description="Default timeout for Jenkins API calls in seconds",
+        ge=5,
+        le=300
+    )
+
+    connect_timeout: int = Field(
+        default=10,
+        description="Connection timeout in seconds",
+        ge=2,
+        le=60
+    )
+
+    read_timeout: int = Field(
+        default=30,
+        description="Read timeout for API responses in seconds",
+        ge=5,
+        le=300
+    )
+
+    # Retry settings
+    max_retries: int = Field(
+        default=3,
+        description="Maximum number of retry attempts for failed requests",
+        ge=0,
+        le=10
+    )
+
+    # Console output settings (High Priority Issue #5)
+    console_max_lines: int = Field(
+        default=1000,
+        description="Default maximum lines to return from console output",
+        ge=10,
+        le=50000
+    )
+
+    # SSL verification
+    verify_ssl: bool = Field(
+        default=True,
+        description="Whether to verify SSL certificates"
+    )
+
     model_config = SettingsConfigDict(
         env_prefix="JENKINS_",
         env_file_encoding="utf-8",
@@ -92,6 +138,12 @@ class JenkinsSettings(BaseSettings):
         logger.info("Jenkins Configuration:")
         logger.info(f"  URL: {self.url or 'Not configured'}")
         logger.info(f"  Username: {self.username or 'Not configured'}")
+        logger.info(f"  Timeout: {self.timeout}s")
+        logger.info(f"  Connect Timeout: {self.connect_timeout}s")
+        logger.info(f"  Read Timeout: {self.read_timeout}s")
+        logger.info(f"  Max Retries: {self.max_retries}")
+        logger.info(f"  Console Max Lines: {self.console_max_lines}")
+        logger.info(f"  Verify SSL: {self.verify_ssl}")
 
         if hide_sensitive:
             logger.info(f"  Authentication: {self.auth_method}")
@@ -244,7 +296,8 @@ def load_settings(
         print(f"=== VS Code settings loaded: {vscode_settings is not None} ===", file=sys.stderr, flush=True)
         if vscode_settings:
             # Merge VS Code settings into our settings object
-            for key in ['url', 'username', 'password', 'token']:
+            for key in ['url', 'username', 'password', 'token', 'timeout', 'connect_timeout',
+                        'read_timeout', 'max_retries', 'console_max_lines', 'verify_ssl']:
                 vscode_value = vscode_settings.get(key)
                 if vscode_value is not None:
                     setattr(settings, key, vscode_value)

package/src/jenkins_mcp_server/jenkins_client.py

@@ -3,6 +3,8 @@ Jenkins MCP Server Client Module
 
 Provides a clean interface to Jenkins API operations with automatic fallback
 between python-jenkins library and direct REST API calls.
+
+Enhanced with configurable timeout support.
 """
 
 import logging
@@ -34,7 +36,8 @@ class JenkinsClient:
     Client for interacting with Jenkins API.
 
     Supports both python-jenkins library and direct REST API calls
-    with automatic fallback for reliability.
+    with automatic fallback for reliability. Enhanced with configurable
+    timeout support.
     """
 
     def __init__(self, settings: Optional[JenkinsSettings] = None):
@@ -60,6 +63,12 @@ class JenkinsClient:
         username, auth_value = self.settings.get_credentials()
         self.auth = HTTPBasicAuth(username, auth_value)
 
+        # Store timeout settings (High Priority Issue #4)
+        self.timeout = self.settings.timeout
+        self.connect_timeout = self.settings.connect_timeout
+        self.read_timeout = self.settings.read_timeout
+        self.verify_ssl = self.settings.verify_ssl
+
         # Cache for python-jenkins server instance
         self._server: Optional[jenkins.Jenkins] = None
 
@@ -67,14 +76,14 @@ class JenkinsClient:
         self._test_connection()
 
     def _test_connection(self) -> None:
-        """Test connection to Jenkins server (with quick timeout for MCP)"""
+        """Test connection to Jenkins server (with configurable timeout)"""
         try:
-            # Quick connection test with short timeout for MCP compatibility
+            # Quick connection test with configured timeout for MCP compatibility
             response = requests.get(
                 f"{self.base_url}/api/json",
                 auth=self.auth,
-                verify=False,
-                timeout=3  # Short timeout for responsiveness
+                verify=self.verify_ssl if self.verify_ssl else False,
+                timeout=self.connect_timeout  # Use configured connect timeout
             )
             response.raise_for_status()
 
@@ -83,7 +92,7 @@ class JenkinsClient:
             logger.debug(f"Jenkins version: {data.get('_class', 'unknown')}")
 
         except requests.Timeout:
-            logger.warning(f"Connection to Jenkins timed out (server may be slow)")
+            logger.warning(f"Connection to Jenkins timed out after {self.connect_timeout}s (server may be slow)")
             # Don't fail - let actual operations fail if there's a real problem
         except requests.RequestException as e:
             logger.warning(f"Could not verify Jenkins connection: {e}")
@@ -91,19 +100,20 @@ class JenkinsClient:
 
     @property
     def server(self) -> jenkins.Jenkins:
-        """Get or create python-jenkins server instance (lazy initialization)"""
+        """Get or create python-jenkins server instance (lazy initialization with timeout)"""
         if self._server is None:
             username, password = self.settings.get_credentials()
             self._server = jenkins.Jenkins(
                 self.base_url,
                 username=username,
-                password=password
+                password=password,
+                timeout=self.timeout  # Use configured timeout
             )
         return self._server
 
     def _api_call(self, method: str, endpoint: str, **kwargs) -> requests.Response:
         """
-        Make a direct REST API call to Jenkins.
+        Make a direct REST API call to Jenkins with configured timeout.
 
         Args:
             method: HTTP method (GET, POST, etc.)
@@ -115,8 +125,11 @@ class JenkinsClient:
         """
         url = f"{self.base_url}{endpoint}"
         kwargs.setdefault('auth', self.auth)
-        kwargs.setdefault('verify', False)
-        kwargs.setdefault('timeout', 30)
+        kwargs.setdefault('verify', self.verify_ssl if self.verify_ssl else False)
+
+        # Use configured timeout (can be overridden per call)
+        if 'timeout' not in kwargs:
+            kwargs['timeout'] = (self.connect_timeout, self.read_timeout)
 
         response = requests.request(method, url, **kwargs)
         response.raise_for_status()
@@ -220,82 +233,46 @@ class JenkinsClient:
         Returns:
             Dict with 'queue_id' and 'build_number' (if wait_for_start=True)
         """
-        try:
-            # Trigger build using python-jenkins
-            queue_id = self.server.build_job(job_name, parameters or {})
-            queue_id = int(queue_id) if queue_id else None
-
-            build_number = None
-            if wait_for_start and queue_id:
-                build_number = self._wait_for_build_start(
-                    queue_id, timeout, poll_interval
-                )
-
-            return {"queue_id": queue_id, "build_number": build_number}
+        # Get the last build number before triggering
+        last_build_num = self.get_last_build_number(job_name) or 0
 
-        except Exception as e:
-            logger.debug(f"python-jenkins failed, using REST API: {e}")
-            return self._build_job_rest(
-                job_name, parameters, wait_for_start, timeout, poll_interval
+        # Trigger the build
+        if parameters:
+            self._api_call(
+                'POST',
+                f'/job/{job_name}/buildWithParameters',
+                params=parameters
             )
+        else:
+            self._api_call('POST', f'/job/{job_name}/build')
 
-    def _build_job_rest(
-            self,
-            job_name: str,
-            parameters: Optional[Dict[str, Any]],
-            wait_for_start: bool,
-            timeout: int,
-            poll_interval: float
-    ) -> Dict[str, Optional[int]]:
-        """Build job using REST API (fallback method)"""
-        endpoint = f'/job/{job_name}/buildWithParameters' if parameters else f'/job/{job_name}/build'
-
-        response = self._api_call('POST', endpoint, params=parameters)
+        # Get queue ID from response
+        queue_id = self._extract_queue_id_from_location(
+            f'/job/{job_name}/build'
+        )
 
-        # Extract queue ID from Location header
-        location = response.headers.get('Location', '')
-        queue_id = self._extract_queue_id(location)
+        result = {
+            'queue_id': queue_id,
+            'build_number': None
+        }
 
-        build_number = None
-        if wait_for_start and queue_id:
-            build_number = self._wait_for_build_start(queue_id, timeout, poll_interval)
+        # Optionally wait for build to start
+        if wait_for_start:
+            start_time = time.time()
+            while time.time() - start_time < timeout:
+                time.sleep(poll_interval)
 
-        return {"queue_id": queue_id, "build_number": build_number}
+                # Check if a new build has started
+                current_build_num = self.get_last_build_number(job_name)
+                if current_build_num and current_build_num > last_build_num:
+                    result['build_number'] = current_build_num
+                    logger.info(f"Build {job_name} #{current_build_num} started")
+                    break
 
-    def _wait_for_build_start(
-            self,
-            queue_id: int,
-            timeout: int,
-            poll_interval: float
-    ) -> Optional[int]:
-        """Wait for a queued build to start and return its build number"""
-        elapsed = 0.0
-
-        while elapsed < timeout:
-            try:
-                # Try python-jenkins first
-                item = self.server.get_queue_item(queue_id)
-                if item and item.get('executable'):
-                    return int(item['executable']['number'])
-            except Exception:
-                # Fall back to REST API
-                try:
-                    response = self._api_call('GET', f'/queue/item/{queue_id}/api/json')
-                    item = response.json()
-                    if item.get('executable'):
-                        return int(item['executable']['number'])
-                except Exception:
-                    pass
-
-            time.sleep(poll_interval)
-            elapsed += poll_interval
-
-        logger.warning(f"Timeout waiting for build {queue_id} to start")
-        return None
+        return result
 
-    @staticmethod
-    def _extract_queue_id(location: str) -> Optional[int]:
-        """Extract queue ID from Jenkins Location header"""
+    def _extract_queue_id_from_location(self, location: str) -> Optional[int]:
+        """Extract queue ID from Location header"""
         if not location:
             return None
 
@@ -480,6 +457,18 @@ class JenkinsClient:
         response = self._api_call('GET', f'/computer/{node_name}/api/json')
         return response.json()
 
+    # ==================== Additional Helper Methods ====================
+
+    def get_whoami(self) -> Dict[str, Any]:
+        """Get information about the current authenticated user"""
+        response = self._api_call('GET', '/me/api/json')
+        return response.json()
+
+    def get_version(self) -> str:
+        """Get Jenkins version"""
+        response = self._api_call('GET', '/api/json')
+        return response.headers.get('X-Jenkins', 'Unknown')
+
 
 # ==================== Client Factory ====================
 
@@ -515,4 +504,4 @@ def get_jenkins_client(settings: Optional[JenkinsSettings] = None) -> JenkinsCli
 def reset_default_client() -> None:
     """Reset the default client (useful for testing or reconfiguration)"""
     global _default_client
-    _default_client = None
+    _default_client = None

package/src/jenkins_mcp_server/metrics.py

@@ -0,0 +1,358 @@
+"""
+Metrics and Telemetry Module for Jenkins MCP Server
+
+Tracks tool usage, performance, and errors for monitoring
+and optimization purposes.
+"""
+
+import asyncio
+import logging
+import time
+from collections import defaultdict
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ToolMetric:
+    """Single tool execution metric"""
+    tool_name: str
+    execution_time_ms: float
+    success: bool
+    error_message: Optional[str] = None
+    timestamp: datetime = field(default_factory=datetime.now)
+    args: Optional[Dict[str, Any]] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary"""
+        return {
+            "tool_name": self.tool_name,
+            "execution_time_ms": round(self.execution_time_ms, 2),
+            "success": self.success,
+            "error_message": self.error_message,
+            "timestamp": self.timestamp.isoformat(),
+            "args": self.args
+        }
+
+
+@dataclass
+class ToolStats:
+    """Aggregated statistics for a tool"""
+    total_calls: int = 0
+    successful_calls: int = 0
+    failed_calls: int = 0
+    total_time_ms: float = 0.0
+    min_time_ms: float = float('inf')
+    max_time_ms: float = 0.0
+    
+    @property
+    def avg_time_ms(self) -> float:
+        """Calculate average execution time"""
+        if self.total_calls == 0:
+            return 0.0
+        return self.total_time_ms / self.total_calls
+    
+    @property
+    def success_rate(self) -> float:
+        """Calculate success rate percentage"""
+        if self.total_calls == 0:
+            return 0.0
+        return (self.successful_calls / self.total_calls) * 100
+    
+    def add_metric(self, metric: ToolMetric) -> None:
+        """Add a metric to the statistics"""
+        self.total_calls += 1
+        self.total_time_ms += metric.execution_time_ms
+        
+        if metric.success:
+            self.successful_calls += 1
+        else:
+            self.failed_calls += 1
+        
+        self.min_time_ms = min(self.min_time_ms, metric.execution_time_ms)
+        self.max_time_ms = max(self.max_time_ms, metric.execution_time_ms)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary"""
+        return {
+            "total_calls": self.total_calls,
+            "successful_calls": self.successful_calls,
+            "failed_calls": self.failed_calls,
+            "success_rate_percent": round(self.success_rate, 2),
+            "avg_time_ms": round(self.avg_time_ms, 2),
+            "min_time_ms": round(self.min_time_ms, 2) if self.min_time_ms != float('inf') else 0,
+            "max_time_ms": round(self.max_time_ms, 2),
+            "total_time_ms": round(self.total_time_ms, 2)
+        }
+
+
+class MetricsCollector:
+    """
+    Collects and aggregates metrics for tool executions.
+    
+    Features:
+    - Per-tool statistics
+    - Recent execution history
+    - Error tracking
+    - Performance monitoring
+    """
+    
+    def __init__(self, max_history: int = 1000):
+        """
+        Initialize metrics collector.
+        
+        Args:
+            max_history: Maximum number of recent metrics to keep
+        """
+        self.max_history = max_history
+        self._metrics: List[ToolMetric] = []
+        self._tool_stats: Dict[str, ToolStats] = defaultdict(ToolStats)
+        self._lock = asyncio.Lock()
+        self._start_time = datetime.now()
+        
+        logger.info(f"Metrics collector initialized (max_history={max_history})")
+    
+    async def record_execution(
+        self,
+        tool_name: str,
+        execution_time_ms: float,
+        success: bool,
+        error_message: Optional[str] = None,
+        args: Optional[Dict[str, Any]] = None
+    ) -> None:
+        """
+        Record a tool execution.
+        
+        Args:
+            tool_name: Name of the tool
+            execution_time_ms: Execution time in milliseconds
+            success: Whether execution was successful
+            error_message: Error message if failed
+            args: Tool arguments (optional, for debugging)
+        """
+        metric = ToolMetric(
+            tool_name=tool_name,
+            execution_time_ms=execution_time_ms,
+            success=success,
+            error_message=error_message,
+            args=args
+        )
+        
+        async with self._lock:
+            # Add to history
+            self._metrics.append(metric)
+            
+            # Trim history if needed
+            if len(self._metrics) > self.max_history:
+                self._metrics = self._metrics[-self.max_history:]
+            
+            # Update aggregated stats
+            self._tool_stats[tool_name].add_metric(metric)
+        
+        # Log based on result
+        if success:
+            logger.debug(f"Metric recorded: {tool_name} completed in {execution_time_ms:.2f}ms")
+        else:
+            logger.warning(f"Metric recorded: {tool_name} failed after {execution_time_ms:.2f}ms - {error_message}")
+    
+    async def get_tool_stats(self, tool_name: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Get statistics for a specific tool or all tools.
+        
+        Args:
+            tool_name: Specific tool name, or None for all tools
+            
+        Returns:
+            Dictionary with tool statistics
+        """
+        async with self._lock:
+            if tool_name:
+                if tool_name not in self._tool_stats:
+                    return {
+                        "tool_name": tool_name,
+                        "stats": ToolStats().to_dict()
+                    }
+                
+                return {
+                    "tool_name": tool_name,
+                    "stats": self._tool_stats[tool_name].to_dict()
+                }
+            
+            # Return all tools
+            return {
+                tool_name: stats.to_dict()
+                for tool_name, stats in self._tool_stats.items()
+            }
+    
+    async def get_recent_metrics(self, limit: int = 100) -> List[Dict[str, Any]]:
+        """
+        Get recent metrics.
+        
+        Args:
+            limit: Maximum number of metrics to return
+            
+        Returns:
+            List of recent metrics
+        """
+        async with self._lock:
+            recent = self._metrics[-limit:]
+            return [m.to_dict() for m in recent]
+    
+    async def get_failed_executions(self, limit: int = 50) -> List[Dict[str, Any]]:
+        """
+        Get recent failed executions.
+        
+        Args:
+            limit: Maximum number of failures to return
+            
+        Returns:
+            List of failed execution metrics
+        """
+        async with self._lock:
+            failures = [m for m in self._metrics if not m.success]
+            recent_failures = failures[-limit:]
+            return [m.to_dict() for m in recent_failures]
+    
+    async def get_slow_executions(
+        self,
+        threshold_ms: float = 1000,
+        limit: int = 50
+    ) -> List[Dict[str, Any]]:
+        """
+        Get executions that exceeded a time threshold.
+        
+        Args:
+            threshold_ms: Threshold in milliseconds
+            limit: Maximum number of results
+            
+        Returns:
+            List of slow execution metrics
+        """
+        async with self._lock:
+            slow = [
+                m for m in self._metrics
+                if m.execution_time_ms > threshold_ms
+            ]
+            recent_slow = slow[-limit:]
+            return [m.to_dict() for m in recent_slow]
+    
+    async def get_summary(self) -> Dict[str, Any]:
+        """
+        Get overall metrics summary.
+        
+        Returns:
+            Dictionary with summary statistics
+        """
+        async with self._lock:
+            total_executions = len(self._metrics)
+            successful = sum(1 for m in self._metrics if m.success)
+            failed = total_executions - successful
+            
+            if total_executions > 0:
+                avg_time = sum(m.execution_time_ms for m in self._metrics) / total_executions
+                success_rate = (successful / total_executions) * 100
+            else:
+                avg_time = 0.0
+                success_rate = 0.0
+            
+            uptime = datetime.now() - self._start_time
+            
+            return {
+                "uptime_seconds": uptime.total_seconds(),
+                "uptime_human": str(uptime).split('.')[0],  # Remove microseconds
+                "total_executions": total_executions,
+                "successful_executions": successful,
+                "failed_executions": failed,
+                "success_rate_percent": round(success_rate, 2),
+                "avg_execution_time_ms": round(avg_time, 2),
+                "unique_tools_used": len(self._tool_stats),
+                "most_used_tool": self._get_most_used_tool(),
+                "slowest_tool": self._get_slowest_tool()
+            }
+    
+    def _get_most_used_tool(self) -> Optional[str]:
+        """Get the most frequently used tool"""
+        if not self._tool_stats:
+            return None
+        
+        return max(
+            self._tool_stats.items(),
+            key=lambda x: x[1].total_calls
+        )[0]
+    
+    def _get_slowest_tool(self) -> Optional[str]:
+        """Get the tool with highest average execution time"""
+        if not self._tool_stats:
+            return None
+        
+        return max(
+            self._tool_stats.items(),
+            key=lambda x: x[1].avg_time_ms
+        )[0]
+    
+    async def reset(self) -> None:
+        """Reset all metrics"""
+        async with self._lock:
+            self._metrics.clear()
+            self._tool_stats.clear()
+            self._start_time = datetime.now()
+            logger.info("Metrics reset")
+    
+    async def export_metrics(self) -> Dict[str, Any]:
+        """
+        Export all metrics data.
+        
+        Returns:
+            Complete metrics export
+        """
+        async with self._lock:
+            return {
+                "summary": await self.get_summary(),
+                "tool_stats": await self.get_tool_stats(),
+                "recent_metrics": await self.get_recent_metrics(limit=100),
+                "failed_executions": await self.get_failed_executions(limit=50),
+                "slow_executions": await self.get_slow_executions(threshold_ms=1000, limit=50)
+            }
+
+
+# Global metrics collector instance
+_metrics_collector: Optional[MetricsCollector] = None
+
+
+def get_metrics_collector() -> MetricsCollector:
+    """Get or create the global metrics collector instance"""
+    global _metrics_collector
+    if _metrics_collector is None:
+        _metrics_collector = MetricsCollector()
+    return _metrics_collector
+
+
+# Convenience functions
+async def record_tool_execution(
+    tool_name: str,
+    execution_time_ms: float,
+    success: bool,
+    error_message: Optional[str] = None,
+    args: Optional[Dict[str, Any]] = None
+) -> None:
+    """Record a tool execution"""
+    await get_metrics_collector().record_execution(
+        tool_name,
+        execution_time_ms,
+        success,
+        error_message,
+        args
+    )
+
+
+async def get_metrics_summary() -> Dict[str, Any]:
+    """Get metrics summary"""
+    return await get_metrics_collector().get_summary()
+
+
+async def get_tool_metrics(tool_name: Optional[str] = None) -> Dict[str, Any]:
+    """Get tool-specific metrics"""
+    return await get_metrics_collector().get_tool_stats(tool_name)