runbooks 1.0.3__py3-none-any.whl → 1.1.0__py3-none-any.whl

runbooks/__init__.py

@@ -61,7 +61,7 @@ s3_ops = S3Operations()
 
 # Centralized Version Management - Single Source of Truth
 # All modules MUST import __version__ from this location
-__version__ = "1.0.3"
+__version__ = "1.0.1"
 
 # Fallback for legacy importlib.metadata usage during transition
 try:
@@ -115,7 +115,13 @@ except ImportError as e:
     _enterprise_exports = []
 
 # FinOps exports
-from runbooks.finops import get_cost_data, get_trend, run_dashboard
+# PERFORMANCE FIX: Lazy load finops to avoid MCP initialization
+# from runbooks.finops import get_cost_data, get_trend, run_dashboard
+
+def get_finops_functions():
+    """Lazy load finops functions only when needed."""
+    from runbooks.finops import get_cost_data, get_trend, run_dashboard
+    return get_cost_data, get_trend, run_dashboard
 
 # Consolidated exports for enterprise CloudOps platform
 __all__ = [
@@ -128,7 +134,6 @@ __all__ = [
     "ensure_directory",
     "validate_aws_profile",
     # FinOps capabilities
-    "run_dashboard",
-    "get_cost_data",
-    "get_trend",
+    # Lazy loaded finops functions via get_finops_functions()
+    "get_finops_functions",
 ] + _enterprise_exports

runbooks/__init__.py.backup

@@ -0,0 +1,134 @@
+"""
+CloudOps Runbooks - Enterprise AWS Automation & Cloud Foundations Toolkit
+
+A comprehensive enterprise-grade automation platform for AWS cloud operations,
+designed for CloudOps, DevOps, and SRE teams managing multi-account environments.
+
+## Core Capabilities
+
+### 🔍 Discovery & Assessment
+- **Cloud Foundations Assessment Tool (CFAT)**: Automated AWS environment discovery
+  and best practices assessment with actionable remediation guidance
+- **Multi-Account Inventory**: Comprehensive resource discovery across AWS Organizations
+- **Security Baseline Assessment**: Automated security posture evaluation
+- **Cost & Financial Operations**: Resource utilization and cost optimization analysis
+
+### ⚙️ Operations & Automation
+- **AWS Resource Operations**: Enterprise-grade EC2, S3, DynamoDB management
+- **Organization Management**: AWS Organizations structure and account automation
+- **Identity & Access Management**: Cross-account IAM role and policy management
+- **Infrastructure Automation**: CloudFormation, networking, and compliance operations
+
+### 🏛️ Enterprise Features
+- **Multi-Deployment Support**: CLI, Docker, AWS Lambda, Kubernetes ready
+- **Environment Configuration**: Comprehensive environment variable support
+- **Monitoring & Notifications**: SNS integration and operational awareness
+- **KISS Architecture**: Simple, maintainable, no-legacy-complexity design
+
+## Documentation
+
+For comprehensive documentation, examples, and best practices:
+https://cloudops.oceansoft.io/cloud-foundation/cfat-assessment-tool.html
+
+## Quick Start
+
+```python
+# Assessment and Discovery
+from runbooks.cfat import AssessmentRunner
+from runbooks.inventory import InventoryCollector
+from runbooks.security import SecurityBaselineTester
+
+# Operations and Automation
+from runbooks.operate import EC2Operations, S3Operations, DynamoDBOperations
+
+# Assessment
+runner = AssessmentRunner()
+results = runner.run_assessment()
+
+# Resource Operations
+ec2_ops = EC2Operations()
+s3_ops = S3Operations()
+```
+
+## Target Audience
+
+- **CloudOps Engineers**: Multi-account AWS environment management
+- **DevOps Teams**: Infrastructure automation and CI/CD integration
+- **Site Reliability Engineers (SRE)**: Operational excellence and monitoring
+- **Security Engineers**: Compliance assessment and remediation
+- **FinOps Practitioners**: Cost optimization and resource governance
+"""
+
+# Centralized Version Management - Single Source of Truth
+# All modules MUST import __version__ from this location
+__version__ = "1.0.0"
+
+# Fallback for legacy importlib.metadata usage during transition
+try:
+    from importlib.metadata import version as _pkg_version
+    _metadata_version = _pkg_version("runbooks")
+    if _metadata_version != __version__:
+        import warnings
+        warnings.warn(
+            f"Version mismatch detected: pyproject.toml has {_metadata_version}, "
+            f"but centralized version is {__version__}. Please sync pyproject.toml.",
+            UserWarning
+        )
+except Exception:
+    # Expected during development or when package metadata is unavailable
+    pass
+
+# Core module exports
+from runbooks.config import RunbooksConfig, load_config, save_config
+from runbooks.utils import ensure_directory, setup_logging, validate_aws_profile
+
+# Enterprise module exports with graceful degradation
+try:
+    # Assessment and Discovery
+    from runbooks.cfat.runner import AssessmentRunner
+    from runbooks.inventory.collectors.aws_management import OrganizationsManager
+    from runbooks.inventory.core.collector import InventoryCollector
+    from runbooks.operate.cloudformation_operations import CloudFormationOperations
+    from runbooks.operate.cloudwatch_operations import CloudWatchOperations
+    from runbooks.operate.dynamodb_operations import DynamoDBOperations
+
+    # Operations and Automation
+    from runbooks.operate.ec2_operations import EC2Operations
+    from runbooks.operate.iam_operations import IAMOperations
+    from runbooks.operate.s3_operations import S3Operations
+    from runbooks.security.security_baseline_tester import SecurityBaselineTester
+
+    _enterprise_exports = [
+        "AssessmentRunner",
+        "InventoryCollector",
+        "OrganizationsManager",
+        "SecurityBaselineTester",
+        "EC2Operations",
+        "S3Operations",
+        "DynamoDBOperations",
+        "CloudFormationOperations",
+        "IAMOperations",
+        "CloudWatchOperations",
+    ]
+except ImportError as e:
+    # Graceful degradation if enterprise dependencies aren't available
+    _enterprise_exports = []
+
+# FinOps exports
+from runbooks.finops import get_cost_data, get_trend, run_dashboard
+
+# Consolidated exports for enterprise CloudOps platform
+__all__ = [
+    # Core utilities
+    "__version__",
+    "setup_logging",
+    "load_config",
+    "save_config",
+    "RunbooksConfig",
+    "ensure_directory",
+    "validate_aws_profile",
+    # FinOps capabilities
+    "run_dashboard",
+    "get_cost_data",
+    "get_trend",
+] + _enterprise_exports

runbooks/__init___optimized.py

@@ -0,0 +1,110 @@
+"""
+CloudOps Runbooks - Enterprise AWS Automation & Cloud Foundations Toolkit (OPTIMIZED)
+
+PERFORMANCE OPTIMIZATIONS:
+- Removed automatic finops import (line 118) which triggered MCP loading
+- Lazy loading for enterprise components
+- Version-only import for basic CLI operations
+
+This should reduce startup time from 5.6s to <0.5s for basic operations.
+"""
+
+# Centralized Version Management - Single Source of Truth
+__version__ = "1.0.0"
+
+# Fallback for legacy importlib.metadata usage during transition
+try:
+    from importlib.metadata import version as _pkg_version
+    _metadata_version = _pkg_version("runbooks")
+    if _metadata_version != __version__:
+        import warnings
+        warnings.warn(
+            f"Version mismatch detected: pyproject.toml has {_metadata_version}, "
+            f"but centralized version is {__version__}. Please sync pyproject.toml.",
+            UserWarning
+        )
+except Exception:
+    # Expected during development or when package metadata is unavailable
+    pass
+
+# Core module exports (lazy loading)
+def _lazy_config():
+    """Lazy load config modules."""
+    from runbooks.config import RunbooksConfig, load_config, save_config
+    return RunbooksConfig, load_config, save_config
+
+def _lazy_utils():
+    """Lazy load utility modules.""" 
+    from runbooks.utils import ensure_directory, setup_logging, validate_aws_profile
+    return ensure_directory, setup_logging, validate_aws_profile
+
+# Enterprise module exports with graceful degradation (lazy loading)
+def _lazy_enterprise():
+    """Lazy load enterprise components only when needed."""
+    try:
+        # Assessment and Discovery
+        from runbooks.cfat.runner import AssessmentRunner
+        from runbooks.inventory.collectors.aws_management import OrganizationsManager
+        from runbooks.inventory.core.collector import InventoryCollector
+        from runbooks.operate.cloudformation_operations import CloudFormationOperations
+        from runbooks.operate.cloudwatch_operations import CloudWatchOperations
+        from runbooks.operate.dynamodb_operations import DynamoDBOperations
+
+        # Operations and Automation
+        from runbooks.operate.ec2_operations import EC2Operations
+        from runbooks.operate.iam_operations import IAMOperations
+        from runbooks.operate.s3_operations import S3Operations
+        from runbooks.security.security_baseline_tester import SecurityBaselineTester
+
+        return {
+            "AssessmentRunner": AssessmentRunner,
+            "InventoryCollector": InventoryCollector,
+            "OrganizationsManager": OrganizationsManager,
+            "SecurityBaselineTester": SecurityBaselineTester,
+            "EC2Operations": EC2Operations,
+            "S3Operations": S3Operations,
+            "DynamoDBOperations": DynamoDBOperations,
+            "CloudFormationOperations": CloudFormationOperations,
+            "IAMOperations": IAMOperations,
+            "CloudWatchOperations": CloudWatchOperations,
+        }
+    except ImportError:
+        return {}
+
+# FinOps exports (LAZY LOADING TO FIX STARTUP PERFORMANCE)
+def _lazy_finops():
+    """Lazy load FinOps modules only when needed."""
+    try:
+        from runbooks.finops import get_cost_data, get_trend, run_dashboard
+        return get_cost_data, get_trend, run_dashboard
+    except ImportError:
+        return None, None, None
+
+# Expose lazy loaders for core functionality
+def get_config():
+    """Get config utilities (lazy loaded)."""
+    return _lazy_config()
+
+def get_utils():
+    """Get utility functions (lazy loaded)."""
+    return _lazy_utils()
+
+def get_enterprise():
+    """Get enterprise components (lazy loaded)."""
+    return _lazy_enterprise()
+
+def get_finops():
+    """Get FinOps functions (lazy loaded)."""
+    return _lazy_finops()
+
+# Minimal exports for fast startup
+__all__ = [
+    "__version__",
+    "get_config",
+    "get_utils", 
+    "get_enterprise",
+    "get_finops",
+]
+
+# Only expose the lazy loaders by default
+# The actual functions are loaded on-demand

runbooks/cloudops/base.py

@@ -353,11 +353,64 @@ class CloudOpsBase:
             roi_percentage=roi_percentage,
             payback_period_months=payback_period,
             overall_risk_level=overall_risk,
-            operational_efficiency_gain=80.0 if total_savings > 1000 else 50.0,  # Estimate based on savings
-            manual_effort_reduction=90.0,  # High automation benefit
+            operational_efficiency_gain=self._calculate_operational_efficiency_gain(total_savings),
+            manual_effort_reduction=self._calculate_manual_effort_reduction(),
             business_continuity_impact="minimal"
         )
-    
+
+    def _calculate_operational_efficiency_gain(self, total_savings: float) -> float:
+        """
+        Calculate operational efficiency gain based on actual performance deltas.
+
+        Args:
+            total_savings: Monthly cost savings achieved
+
+        Returns:
+            Operational efficiency gain percentage
+        """
+        # Calculate efficiency based on actual operation benchmarks
+        if hasattr(self, 'benchmarks') and self.benchmarks:
+            # Calculate average improvement from successful operations
+            successful_ops = [b for b in self.benchmarks if b.success]
+            if successful_ops:
+                avg_duration = sum(b.duration for b in successful_ops) / len(successful_ops)
+                # Convert duration to efficiency metric (faster = more efficient)
+                # Base efficiency on savings magnitude and operation speed
+                if total_savings > 5000:
+                    return min(90.0, 60.0 + (10 / max(avg_duration, 1.0)))
+                elif total_savings > 1000:
+                    return min(80.0, 50.0 + (10 / max(avg_duration, 1.0)))
+                else:
+                    return min(60.0, 40.0 + (10 / max(avg_duration, 1.0)))
+
+        # Fallback based on savings magnitude only
+        if total_savings > 5000:
+            return 85.0
+        elif total_savings > 1000:
+            return 70.0
+        else:
+            return 50.0
+
+    def _calculate_manual_effort_reduction(self) -> float:
+        """
+        Calculate manual effort reduction based on operation automation.
+
+        Returns:
+            Manual effort reduction percentage
+        """
+        if hasattr(self, 'benchmarks') and self.benchmarks:
+            # Calculate based on successful automated operations
+            successful_ops = len([b for b in self.benchmarks if b.success])
+            total_ops = len(self.benchmarks)
+
+            if total_ops > 0:
+                automation_rate = (successful_ops / total_ops) * 100
+                # High automation rate = high manual effort reduction
+                return min(95.0, max(70.0, automation_rate))
+
+        # Fallback for high automation benefit
+        return 85.0
+
     def get_session_summary(self) -> Dict[str, Any]:
         """Get comprehensive session summary for audit trail."""
         total_duration = time.time() - self.session_start_time