holmesgpt 0.11.5__py3-none-any.whl

holmes/plugins/toolsets/azure_sql/tools/analyze_database_health_status.py

@@ -0,0 +1,205 @@
+import logging
+from typing import Dict
+from datetime import datetime, timezone
+
+from holmes.core.tools import StructuredToolResult, ToolResultStatus
+from holmes.plugins.toolsets.azure_sql.azure_base_toolset import (
+    BaseAzureSQLTool,
+    BaseAzureSQLToolset,
+    AzureSQLDatabaseConfig,
+)
+from holmes.plugins.toolsets.azure_sql.apis.azure_sql_api import AzureSQLAPIClient
+from typing import Tuple
+
+
+class AnalyzeDatabaseHealthStatus(BaseAzureSQLTool):
+    def __init__(self, toolset: "BaseAzureSQLToolset"):
+        super().__init__(
+            name="analyze_database_health_status",
+            description="Analyzes the overall health status of an Azure SQL database including active operations, resource usage alerts, and system status. Use this first to get a high-level view of database health.",
+            parameters={},
+            toolset=toolset,
+        )
+
+    def _gather_health_data(
+        self, db_config: AzureSQLDatabaseConfig, client: AzureSQLAPIClient
+    ) -> Dict:
+        """Gather health-related data from Azure SQL API."""
+        health_data = {
+            "database_info": {
+                "name": db_config.database_name,
+                "server": db_config.server_name,
+                "resource_group": db_config.resource_group,
+                "subscription_id": db_config.subscription_id,
+            },
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+        }
+
+        try:
+            operations = client.get_database_operations(
+                db_config.subscription_id,
+                db_config.resource_group,
+                db_config.server_name,
+                db_config.database_name,
+            )
+            health_data["operations"] = operations.get("value", [])
+        except Exception as e:
+            health_data["operations_error"] = str(e)
+
+        try:
+            usages = client.get_database_usages(
+                db_config.subscription_id,
+                db_config.resource_group,
+                db_config.server_name,
+                db_config.database_name,
+            )
+            health_data["resource_usage"] = usages.get("value", [])
+        except Exception as e:
+            health_data["usage_error"] = str(e)
+
+        return health_data
+
+    def _build_health_report(
+        self, health_data: Dict, db_config: AzureSQLDatabaseConfig
+    ) -> str:
+        """Build the formatted health report from gathered data."""
+        report_sections = []
+
+        # Database Overview Section
+        report_sections.append("# Azure SQL Database Health Report")
+        report_sections.append(f"**Database:** {db_config.database_name}")
+        report_sections.append(f"**Server:** {db_config.server_name}")
+        report_sections.append(f"**Generated:** {health_data['timestamp']}")
+        report_sections.append("")
+
+        # Operations Status Section
+        report_sections.append("## Operations Status")
+        if "operations_error" in health_data:
+            report_sections.append(
+                f"⚠️ **Error retrieving operations:** {health_data['operations_error']}"
+            )
+        else:
+            operations = health_data.get("operations", [])
+            if operations:
+                report_sections.append(f"**Active Operations:** {len(operations)}")
+                for op in operations[:5]:  # Show first 5 operations
+                    status = op.get("properties", {}).get("state", "Unknown")
+                    op_type = op.get("properties", {}).get("operation", "Unknown")
+                    start_time = op.get("properties", {}).get("startTime", "Unknown")
+                    report_sections.append(
+                        f"- **{op_type}**: {status} (Started: {start_time})"
+                    )
+            else:
+                report_sections.append("✅ **No active operations**")
+        report_sections.append("")
+
+        # Resource Usage Section
+        report_sections.append("## Resource Usage")
+        if "usage_error" in health_data:
+            report_sections.append(
+                f"⚠️ **Error retrieving usage data:** {health_data['usage_error']}"
+            )
+        else:
+            usages = health_data.get("resource_usage", [])
+            if usages:
+                for usage in usages:
+                    name = usage.get(
+                        "display_name", usage.get("displayName", "Unknown Metric")
+                    )
+                    current = usage.get("current_value", usage.get("currentValue", 0))
+                    limit = usage.get("limit", 0)
+                    unit = usage.get("unit", "")
+
+                    if limit > 0:
+                        percentage = (current / limit) * 100
+                        status_icon = (
+                            "🔴"
+                            if percentage > 90
+                            else "🟡"
+                            if percentage > 70
+                            else "🟢"
+                        )
+                        report_sections.append(
+                            f"- **{name}**: {status_icon} {current:,} / {limit:,} {unit} ({percentage:.1f}%)"
+                        )
+                    else:
+                        report_sections.append(f"- **{name}**: {current:,} {unit}")
+            else:
+                report_sections.append("No usage data available")
+
+        return "\n".join(report_sections)
+
+    def _invoke(self, params: Dict) -> StructuredToolResult:
+        try:
+            db_config = self.toolset.database_config()
+            client = self.toolset.api_client()
+
+            # Gather health-related data
+            health_data = self._gather_health_data(db_config, client)
+
+            # Build the formatted report
+            report_text = self._build_health_report(health_data, db_config)
+
+            return StructuredToolResult(
+                status=ToolResultStatus.SUCCESS,
+                data=report_text,
+                params=params,
+            )
+        except Exception as e:
+            error_msg = f"Failed to generate health report: {str(e)}"
+            logging.error(error_msg)
+            return StructuredToolResult(
+                status=ToolResultStatus.ERROR,
+                error=error_msg,
+                params=params,
+            )
+
+    def get_parameterized_one_liner(self, params: Dict) -> str:
+        db_config = self.toolset.database_config()
+        return f"Analyze health status for database {db_config.server_name}/{db_config.database_name}"
+
+    @staticmethod
+    def validate_config(
+        api_client: AzureSQLAPIClient, database_config: AzureSQLDatabaseConfig
+    ) -> Tuple[bool, str]:
+        errors = []
+
+        try:
+            # Test database operations API access
+            api_client.get_database_operations(
+                database_config.subscription_id,
+                database_config.resource_group,
+                database_config.server_name,
+                database_config.database_name,
+            )
+        except Exception as e:
+            error_msg = str(e)
+            if (
+                "authorization" in error_msg.lower()
+                or "permission" in error_msg.lower()
+            ):
+                errors.append(f"Database operations access denied: {error_msg}")
+            else:
+                errors.append(f"Database operations connection failed: {error_msg}")
+
+        try:
+            # Test database usages API access
+            api_client.get_database_usages(
+                database_config.subscription_id,
+                database_config.resource_group,
+                database_config.server_name,
+                database_config.database_name,
+            )
+        except Exception as e:
+            error_msg = str(e)
+            if (
+                "authorization" in error_msg.lower()
+                or "permission" in error_msg.lower()
+            ):
+                errors.append(f"Database usage metrics access denied: {error_msg}")
+            else:
+                errors.append(f"Database usage metrics connection failed: {error_msg}")
+
+        if errors:
+            return False, "\n".join(errors)
+        return True, ""

holmes/plugins/toolsets/azure_sql/tools/analyze_database_performance.py

@@ -0,0 +1,249 @@
+import logging
+from typing import Any, Dict, List, Tuple, cast
+from datetime import datetime, timezone
+
+from holmes.core.tools import StructuredToolResult, ToolResultStatus
+from holmes.plugins.toolsets.azure_sql.azure_base_toolset import (
+    BaseAzureSQLTool,
+    BaseAzureSQLToolset,
+    AzureSQLDatabaseConfig,
+)
+from holmes.plugins.toolsets.azure_sql.apis.azure_sql_api import AzureSQLAPIClient
+
+
+class AnalyzeDatabasePerformance(BaseAzureSQLTool):
+    def __init__(self, toolset: "BaseAzureSQLToolset"):
+        super().__init__(
+            name="analyze_database_performance",
+            description="Analyzes database performance including automatic tuning status, performance advisors, and active recommendations. Essential for identifying performance optimization opportunities.",
+            parameters={},
+            toolset=toolset,
+        )
+
+    def _gather_performance_data(
+        self, db_config: AzureSQLDatabaseConfig, client: AzureSQLAPIClient
+    ) -> Dict:
+        """Gather performance-related data from Azure SQL API."""
+        performance_data = {
+            "database_info": {
+                "name": db_config.database_name,
+                "server": db_config.server_name,
+                "resource_group": db_config.resource_group,
+            },
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+        }
+
+        try:
+            advisors = client.get_database_advisors(
+                db_config.subscription_id,
+                db_config.resource_group,
+                db_config.server_name,
+                db_config.database_name,
+            )
+            performance_data["advisors"] = advisors.get("value", [])
+        except Exception as e:
+            performance_data["advisors_error"] = str(e)
+
+        try:
+            auto_tuning = client.get_database_automatic_tuning(
+                db_config.subscription_id,
+                db_config.resource_group,
+                db_config.server_name,
+                db_config.database_name,
+            )
+            performance_data["automatic_tuning"] = auto_tuning
+        except Exception as e:
+            performance_data["auto_tuning_error"] = str(e)
+
+        # Get recommendations for each advisor
+        recommendations_list: List[Dict[str, Any]] = []
+        performance_data["recommendations"] = cast(Any, recommendations_list)
+        if "advisors" in performance_data:
+            for advisor in performance_data["advisors"]:
+                if isinstance(advisor, dict):
+                    advisor_name = advisor.get("name", "")
+                else:
+                    advisor_name = str(advisor)
+                try:
+                    recommendations = client.get_database_recommended_actions(
+                        db_config.subscription_id,
+                        db_config.resource_group,
+                        db_config.server_name,
+                        db_config.database_name,
+                        advisor_name,
+                    )
+                    recommendations_list.extend(recommendations.get("value", []))
+                except Exception as e:
+                    logging.warning(
+                        f"Failed to get recommendations for advisor {advisor_name}: {e}"
+                    )
+
+        return performance_data
+
+    def _build_performance_report(
+        self, performance_data: Dict, db_config: AzureSQLDatabaseConfig
+    ) -> str:
+        """Build the formatted performance report from gathered data."""
+        report_sections = []
+
+        # Performance Report Header
+        report_sections.append("# Azure SQL Database Performance Report")
+        report_sections.append(f"**Database:** {db_config.database_name}")
+        report_sections.append(f"**Server:** {db_config.server_name}")
+        report_sections.append(f"**Generated:** {performance_data['timestamp']}")
+        report_sections.append("")
+
+        # Automatic Tuning Section
+        report_sections.append("## Automatic Tuning Status")
+        if "auto_tuning_error" in performance_data:
+            report_sections.append(
+                f"⚠️ **Error retrieving auto-tuning data:** {performance_data['auto_tuning_error']}"
+            )
+        else:
+            auto_tuning = performance_data.get("automatic_tuning", {})
+            # Handle both camelCase and snake_case field names
+            desired_state = auto_tuning.get(
+                "desired_state", auto_tuning.get("desiredState", "Unknown")
+            )
+            actual_state = auto_tuning.get(
+                "actual_state", auto_tuning.get("actualState", "Unknown")
+            )
+
+            status_icon = "✅" if desired_state == actual_state else "⚠️"
+            report_sections.append(f"- **Desired State**: {desired_state}")
+            report_sections.append(f"- **Actual State**: {actual_state} {status_icon}")
+
+            options = auto_tuning.get("options", {})
+            for option_name, option_data in options.items():
+                desired = option_data.get(
+                    "desired_state", option_data.get("desiredState", "Unknown")
+                )
+                actual = option_data.get(
+                    "actual_state", option_data.get("actualState", "Unknown")
+                )
+                option_icon = "✅" if desired == actual else "⚠️"
+                report_sections.append(f"  - **{option_name}**: {actual} {option_icon}")
+        report_sections.append("")
+
+        # Performance Advisors Section
+        report_sections.append("## Performance Advisors")
+        if "advisors_error" in performance_data:
+            report_sections.append(
+                f"⚠️ **Error retrieving advisors:** {performance_data['advisors_error']}"
+            )
+        else:
+            advisors = performance_data.get("advisors", [])
+            if advisors:
+                for advisor in advisors:
+                    name = advisor.get("name", "Unknown")
+                    # Handle both camelCase and snake_case field names
+                    auto_execute = advisor.get(
+                        "auto_execute_status",
+                        advisor.get("autoExecuteStatus", "Unknown"),
+                    )
+                    last_checked = advisor.get(
+                        "last_checked", advisor.get("lastChecked", "Never")
+                    )
+
+                    report_sections.append(f"### {name}")
+                    report_sections.append(f"- **Auto Execute**: {auto_execute}")
+                    report_sections.append(f"- **Last Checked**: {last_checked}")
+            else:
+                report_sections.append("No performance advisors available")
+        report_sections.append("")
+
+        # Recommendations Section
+        report_sections.append("## Performance Recommendations")
+        all_recommendations = performance_data.get("recommendations", [])
+        if all_recommendations:
+            active_recommendations = [
+                r
+                for r in all_recommendations
+                if r.get("properties", {}).get("state", {}).get("currentValue")
+                in ["Active", "Pending"]
+            ]
+
+            if active_recommendations:
+                report_sections.append(
+                    f"🚨 **{len(active_recommendations)} Active Recommendations Found**"
+                )
+                for rec in active_recommendations[:5]:  # Show first 5 recommendations
+                    properties = rec.get("properties", {})
+                    details = properties.get("details", {})
+
+                    rec_type = details.get("indexType", "Performance")
+                    impact = details.get("impactDetails", [{}])[0].get(
+                        "name", "Unknown"
+                    )
+                    state = properties.get("state", {}).get("currentValue", "Unknown")
+
+                    report_sections.append(
+                        f"- **{rec_type} Recommendation**: {impact} impact ({state})"
+                    )
+
+                    if "indexColumns" in details:
+                        columns = ", ".join(details["indexColumns"])
+                        report_sections.append(f"  - **Columns**: {columns}")
+            else:
+                report_sections.append("✅ **No active performance recommendations**")
+        else:
+            report_sections.append("No performance recommendations available")
+
+        return "\n".join(report_sections)
+
+    def _invoke(self, params: Dict) -> StructuredToolResult:
+        try:
+            db_config = self.toolset.database_config()
+            client = self.toolset.api_client()
+
+            # Gather performance-related data
+            performance_data = self._gather_performance_data(db_config, client)
+
+            # Build the formatted report
+            report_text = self._build_performance_report(performance_data, db_config)
+
+            return StructuredToolResult(
+                status=ToolResultStatus.SUCCESS,
+                data=report_text,
+                params=params,
+            )
+        except Exception as e:
+            error_msg = f"Failed to generate performance report: {str(e)}"
+            logging.error(error_msg)
+            return StructuredToolResult(
+                status=ToolResultStatus.ERROR,
+                error=error_msg,
+                params=params,
+            )
+
+    def get_parameterized_one_liner(self, params: Dict) -> str:
+        db_config = self.toolset.database_config()
+        return f"Analyze performance for database {db_config.server_name}/{db_config.database_name}"
+
+    @staticmethod
+    def validate_config(
+        api_client: AzureSQLAPIClient, database_config: AzureSQLDatabaseConfig
+    ) -> Tuple[bool, str]:
+        errors = []
+
+        try:
+            # Test database advisors API access
+            api_client.get_database_advisors(
+                database_config.subscription_id,
+                database_config.resource_group,
+                database_config.server_name,
+                database_config.database_name,
+            )
+        except Exception as e:
+            error_msg = str(e)
+            if (
+                "authorization" in error_msg.lower()
+                or "permission" in error_msg.lower()
+            ):
+                errors.append(f"Database management API access denied: {error_msg}")
+            else:
+                errors.append(f"Database management API connection failed: {error_msg}")
+
+        if errors:
+            return False, "\n".join(errors)
+        return True, ""