runbooks 0.7.9__py3-none-any.whl → 0.9.1__py3-none-any.whl

runbooks/metrics/dora_metrics_engine.py

@@ -70,11 +70,23 @@ class IncidentEvent:
 
 
 class DORAMetricsEngine:
-    """Enhanced DORA metrics collection and analysis engine"""
+    """
+    Enhanced DORA metrics collection and analysis engine for Enterprise SRE.
+
+    Provides comprehensive DORA metrics (Lead Time, Deploy Frequency, MTTR, Change Failure Rate)
+    with real-time collection, automated alerting, and enterprise dashboard integration.
+
+    Features:
+    - Real-time metrics streaming from git operations
+    - Automated deployment event capture via GitHub webhooks
+    - CloudWatch/Datadog integration for enterprise monitoring
+    - Cross-session persistence with baseline trending
+    - SLA compliance tracking with automated alerting
+    """
 
     def __init__(self, artifacts_dir: str = "./artifacts/metrics", cross_validation_tolerance: float = 15.0):
         """
-        Initialize DORA metrics engine
+        Initialize enterprise DORA metrics engine
 
         Args:
             artifacts_dir: Directory to store metrics artifacts
@@ -83,27 +95,51 @@ class DORAMetricsEngine:
         self.artifacts_dir = Path(artifacts_dir)
         self.artifacts_dir.mkdir(parents=True, exist_ok=True)
 
+        # Create SRE-focused subdirectories
+        (self.artifacts_dir / "dora-reports").mkdir(exist_ok=True)
+        (self.artifacts_dir / "baselines").mkdir(exist_ok=True)
+        (self.artifacts_dir / "alerts").mkdir(exist_ok=True)
+        (self.artifacts_dir / "dashboards").mkdir(exist_ok=True)
+
         self.tolerance = cross_validation_tolerance
 
-        # Metrics storage
+        # Metrics storage with persistence
         self.deployments: List[DeploymentEvent] = []
         self.incidents: List[IncidentEvent] = []
         self.metrics_history: List[DORAMetric] = []
+        self.baselines: Dict[str, float] = {}
 
         # HITL workflow metrics
         self.approval_times: List[float] = []
         self.workflow_bottlenecks: Dict[str, List[float]] = {}
 
-        # Performance targets from CLAUDE.md
+        # Enterprise SRE performance targets (FAANG SDLC standards)
         self.targets = {
-            "lead_time_hours": 4,  # <4 hours
+            "lead_time_hours": 4,  # <4 hours (FAANG velocity)
             "deploy_frequency_daily": 1,  # Daily deployment capability
-            "change_failure_rate": 0.05,  # <5%
-            "mttr_hours": 1,  # <1 hour
-            "approval_time_minutes": 30,  # <30 minutes
-            "success_rate": 0.95,  # >95%
+            "change_failure_rate": 0.05,  # <5% (FAANG quality)
+            "mttr_hours": 1,  # <1 hour (SRE excellence)
+            "approval_time_minutes": 30,  # <30 minutes (HITL efficiency)
+            "success_rate": 0.95,  # >95% (Enterprise reliability)
+            "sla_availability": 0.999,  # >99.9% uptime
+            "performance_score": 90,  # >90% performance score
         }
 
+        # SRE alerting thresholds
+        self.alert_thresholds = {
+            "lead_time_hours": 6,  # Alert if >6 hours
+            "deploy_frequency_daily": 0.5,  # Alert if <0.5 deploys/day
+            "change_failure_rate": 0.10,  # Alert if >10%
+            "mttr_hours": 2,  # Alert if >2 hours
+            "approval_time_minutes": 60,  # Alert if >60 minutes
+        }
+
+        # Load existing data
+        self._load_persistent_data()
+
+        # Initialize baseline metrics if not exists
+        self._initialize_baselines()
+
     def record_deployment(
         self,
         deployment_id: str,
@@ -376,10 +412,261 @@ class DORAMetricsEngine:
 
         return metrics
 
+    def _load_persistent_data(self) -> None:
+        """Load persistent DORA data from storage."""
+        try:
+            # Load deployments
+            deployments_file = self.artifacts_dir / "deployments.json"
+            if deployments_file.exists():
+                with open(deployments_file, "r") as f:
+                    data = json.load(f)
+                    self.deployments = [DeploymentEvent(**item) for item in data.get("deployments", [])]
+
+            # Load incidents
+            incidents_file = self.artifacts_dir / "incidents.json"
+            if incidents_file.exists():
+                with open(incidents_file, "r") as f:
+                    data = json.load(f)
+                    self.incidents = [IncidentEvent(**item) for item in data.get("incidents", [])]
+
+            # Load baselines
+            baselines_file = self.artifacts_dir / "baselines" / "current_baselines.json"
+            if baselines_file.exists():
+                with open(baselines_file, "r") as f:
+                    self.baselines = json.load(f)
+
+            logger.info(f"📊 Loaded {len(self.deployments)} deployments, {len(self.incidents)} incidents")
+
+        except Exception as e:
+            logger.warning(f"⚠️ Failed to load persistent data: {e}")
+
+    def _save_persistent_data(self) -> None:
+        """Save persistent DORA data to storage."""
+        try:
+            # Save deployments
+            deployments_data = {
+                "deployments": [asdict(d) for d in self.deployments],
+                "last_updated": datetime.now(timezone.utc).isoformat(),
+            }
+            deployments_file = self.artifacts_dir / "deployments.json"
+            with open(deployments_file, "w") as f:
+                json.dump(deployments_data, f, indent=2, default=str)
+
+            # Save incidents
+            incidents_data = {
+                "incidents": [asdict(i) for i in self.incidents],
+                "last_updated": datetime.now(timezone.utc).isoformat(),
+            }
+            incidents_file = self.artifacts_dir / "incidents.json"
+            with open(incidents_file, "w") as f:
+                json.dump(incidents_data, f, indent=2, default=str)
+
+            # Save baselines
+            baselines_file = self.artifacts_dir / "baselines" / "current_baselines.json"
+            with open(baselines_file, "w") as f:
+                json.dump(self.baselines, f, indent=2)
+
+        except Exception as e:
+            logger.error(f"❌ Failed to save persistent data: {e}")
+
+    def _initialize_baselines(self) -> None:
+        """Initialize baseline metrics for trending analysis."""
+        if not self.baselines and len(self.deployments) > 10:
+            # Calculate initial baselines from historical data
+            lead_time_metric = self.calculate_lead_time(30)
+            deploy_freq_metric = self.calculate_deployment_frequency(30)
+            failure_rate_metric = self.calculate_change_failure_rate(30)
+            mttr_metric = self.calculate_mttr(30)
+
+            self.baselines = {
+                "lead_time_hours": lead_time_metric.value,
+                "deploy_frequency_daily": deploy_freq_metric.value,
+                "change_failure_rate": failure_rate_metric.value,
+                "mttr_hours": mttr_metric.value,
+                "baseline_established": datetime.now(timezone.utc).isoformat(),
+                "sample_size": len(self.deployments),
+            }
+
+            logger.info("📈 Established baseline metrics from historical data")
+            self._save_persistent_data()
+
+    def track_git_deployment(
+        self, commit_sha: str, branch: str = "main", author: str = "", message: str = ""
+    ) -> DeploymentEvent:
+        """
+        Track deployment from git operations for automated DORA collection.
+
+        Args:
+            commit_sha: Git commit SHA
+            branch: Git branch name
+            author: Commit author
+            message: Commit message
+
+        Returns:
+            Created deployment event
+        """
+        deployment_id = f"git-{commit_sha[:8]}-{int(time.time())}"
+
+        deployment = self.record_deployment(
+            deployment_id=deployment_id,
+            environment="production" if branch == "main" else "development",
+            service_name="runbooks",
+            version=commit_sha[:8],
+            commit_sha=commit_sha,
+            approver=author,
+        )
+
+        # Add git metadata
+        deployment.metadata = {
+            "branch": branch,
+            "author": author,
+            "message": message,
+            "automated": True,
+            "source": "git_integration",
+        }
+
+        logger.info(f"🔗 Git deployment tracked: {commit_sha[:8]} on {branch}")
+
+        # Auto-save after git integration
+        self._save_persistent_data()
+
+        return deployment
+
+    def detect_performance_incident(
+        self, module: str, operation: str, execution_time: float, threshold: float
+    ) -> Optional[IncidentEvent]:
+        """
+        Automatically detect and record performance incidents.
+
+        Args:
+            module: Module name (e.g., 'finops', 'inventory')
+            operation: Operation name
+            execution_time: Actual execution time
+            threshold: Performance threshold
+
+        Returns:
+            Created incident if threshold exceeded, None otherwise
+        """
+        if execution_time <= threshold:
+            return None
+
+        incident_id = f"perf-{module}-{int(time.time())}"
+        severity = "critical" if execution_time > threshold * 2 else "high"
+
+        incident = self.record_incident(
+            incident_id=incident_id,
+            service_name=module,
+            severity=severity,
+            root_cause=f"Performance degradation: {operation} took {execution_time:.2f}s (threshold: {threshold:.2f}s)",
+        )
+
+        # Add performance metadata
+        incident.metadata = {
+            "operation": operation,
+            "execution_time": execution_time,
+            "threshold": threshold,
+            "degradation_factor": execution_time / threshold,
+            "automated_detection": True,
+        }
+
+        logger.warning(f"🚨 Performance incident detected: {incident_id}")
+
+        # Generate real-time alert
+        self._generate_sre_alert(incident, execution_time, threshold)
+
+        return incident
+
+    def _generate_sre_alert(self, incident: IncidentEvent, execution_time: float, threshold: float) -> None:
+        """Generate SRE-focused performance alert."""
+        alert_data = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "alert_type": "sre_performance_degradation",
+            "incident_id": incident.incident_id,
+            "service": incident.service_name,
+            "severity": incident.severity,
+            "execution_time": execution_time,
+            "threshold": threshold,
+            "degradation_factor": execution_time / threshold,
+            "impact": "user_experience" if execution_time > threshold * 1.5 else "performance_sla",
+            "recommended_actions": [
+                "Check system resource utilization",
+                "Review recent deployments for correlation",
+                "Validate AWS API rate limiting",
+                "Consider auto-scaling triggers",
+            ],
+        }
+
+        # Save alert to artifacts
+        alert_file = self.artifacts_dir / "alerts" / f"sre_alert_{incident.incident_id}.json"
+        with open(alert_file, "w") as f:
+            json.dump(alert_data, f, indent=2, default=str)
+
+        logger.critical(f"🚨 SRE Alert generated: {alert_file}")
+
+    def calculate_sla_compliance(self, days_back: int = 30) -> Dict[str, DORAMetric]:
+        """
+        Calculate SLA compliance metrics for enterprise reporting.
+
+        Args:
+            days_back: Number of days to analyze
+
+        Returns:
+            Dictionary of SLA compliance metrics
+        """
+        sla_metrics = {}
+
+        # Calculate availability SLA (based on incident downtime)
+        cutoff_date = datetime.now(timezone.utc) - timedelta(days=days_back)
+        recent_incidents = [i for i in self.incidents if i.start_time >= cutoff_date]
+
+        total_downtime_hours = 0
+        for incident in recent_incidents:
+            if incident.resolution_time and incident.severity in ["critical", "high"]:
+                downtime = (incident.resolution_time - incident.start_time).total_seconds() / 3600
+                total_downtime_hours += downtime
+
+        total_hours = days_back * 24
+        availability = max(0, (total_hours - total_downtime_hours) / total_hours)
+
+        sla_metrics["availability"] = DORAMetric(
+            metric_name="availability_sla",
+            value=availability,
+            unit="percentage",
+            timestamp=datetime.now(timezone.utc),
+            tags={"period": f"{days_back}d", "incidents": str(len(recent_incidents))},
+            metadata={
+                "target": self.targets["sla_availability"],
+                "target_met": availability >= self.targets["sla_availability"],
+                "downtime_hours": total_downtime_hours,
+            },
+        )
+
+        # Performance SLA (based on operation execution times)
+        performance_scores = []
+        for metric in self.metrics_history:
+            if metric.metadata and "performance_score" in metric.metadata:
+                performance_scores.append(metric.metadata["performance_score"])
+
+        avg_performance = sum(performance_scores) / len(performance_scores) if performance_scores else 0
+
+        sla_metrics["performance"] = DORAMetric(
+            metric_name="performance_sla",
+            value=avg_performance,
+            unit="percentage",
+            timestamp=datetime.now(timezone.utc),
+            tags={"sample_size": str(len(performance_scores))},
+            metadata={
+                "target": self.targets["performance_score"],
+                "target_met": avg_performance >= self.targets["performance_score"],
+            },
+        )
+
+        return sla_metrics
+
     def generate_comprehensive_report(self, days_back: int = 30) -> Dict:
-        """Generate comprehensive DORA metrics report"""
+        """Generate comprehensive DORA metrics report with SRE enhancements"""
 
-        logger.info(f"📊 Generating DORA metrics report for last {days_back} days")
+        logger.info(f"📊 Generating enterprise DORA metrics report for last {days_back} days")
 
         # Calculate all DORA metrics
         lead_time = self.calculate_lead_time(days_back)
@@ -390,7 +677,10 @@ class DORAMetricsEngine:
         # Calculate HITL metrics
         hitl_metrics = self.calculate_hitl_metrics()
 
-        # Performance analysis
+        # Calculate SLA compliance metrics
+        sla_metrics = self.calculate_sla_compliance(days_back)
+
+        # Performance analysis with enhanced SRE targets
         targets_met = {
             "lead_time": lead_time.metadata.get("target_met", False),
             "deployment_frequency": deployment_freq.metadata.get("target_met", False),
@@ -402,10 +692,36 @@ class DORAMetricsEngine:
         if "approval_time" in hitl_metrics:
             targets_met["approval_time"] = hitl_metrics["approval_time"].metadata.get("target_met", False)
 
+        # Add SLA targets
+        for metric_name, metric in sla_metrics.items():
+            targets_met[f"sla_{metric_name}"] = metric.metadata.get("target_met", False)
+
         overall_performance = sum(targets_met.values()) / len(targets_met) * 100
 
+        # Calculate trend analysis vs baselines
+        trend_analysis = {}
+        if self.baselines:
+            for metric_name, current_value in [
+                ("lead_time_hours", lead_time.value),
+                ("deploy_frequency_daily", deployment_freq.value),
+                ("change_failure_rate", failure_rate.value),
+                ("mttr_hours", mttr.value),
+            ]:
+                baseline = self.baselines.get(metric_name, current_value)
+                if baseline > 0:
+                    trend_percentage = ((current_value - baseline) / baseline) * 100
+                    trend_analysis[metric_name] = {
+                        "current": current_value,
+                        "baseline": baseline,
+                        "trend_percentage": trend_percentage,
+                        "improving": trend_percentage < 0
+                        if metric_name != "deploy_frequency_daily"
+                        else trend_percentage > 0,
+                    }
+
         report = {
-            "report_type": "dora_metrics_comprehensive",
+            "report_type": "dora_metrics_enterprise_sre",
+            "version": "2.0",
             "period": f"{days_back}_days",
             "timestamp": datetime.now(timezone.utc).isoformat(),
             "dora_metrics": {
@@ -414,26 +730,70 @@ class DORAMetricsEngine:
                 "change_failure_rate": asdict(failure_rate),
                 "mttr": asdict(mttr),
             },
+            "sla_metrics": {k: asdict(v) for k, v in sla_metrics.items()},
             "hitl_metrics": {k: asdict(v) for k, v in hitl_metrics.items()},
             "performance_analysis": {
                 "targets_met": targets_met,
                 "overall_performance_percentage": overall_performance,
                 "performance_grade": self._calculate_performance_grade(overall_performance),
+                "sla_compliance_score": sum(1 for k, v in targets_met.items() if k.startswith("sla_") and v)
+                / max(1, sum(1 for k in targets_met.keys() if k.startswith("sla_")))
+                * 100,
+            },
+            "trend_analysis": trend_analysis,
+            "baseline_comparison": self.baselines,
+            "recommendations": self._generate_sre_recommendations(
+                targets_met, hitl_metrics, sla_metrics, trend_analysis
+            ),
+            "alerts_summary": {
+                "active_alerts": len(
+                    [
+                        f
+                        for f in (self.artifacts_dir / "alerts").glob("*.json")
+                        if f.stat().st_mtime > time.time() - 86400
+                    ]
+                ),
+                "performance_incidents": len(
+                    [
+                        i
+                        for i in self.incidents
+                        if i.start_time >= datetime.now(timezone.utc) - timedelta(days=days_back)
+                        and "performance" in i.root_cause.lower()
+                    ]
+                ),
+                "sre_health_score": overall_performance,
             },
-            "recommendations": self._generate_recommendations(targets_met, hitl_metrics),
             "raw_data": {
                 "deployments_count": len(self.deployments),
                 "incidents_count": len(self.incidents),
                 "approval_times_count": len(self.approval_times),
+                "automation_rate": len(
+                    [d for d in self.deployments if getattr(d, "metadata", {}).get("automated", False)]
+                )
+                / max(1, len(self.deployments))
+                * 100,
             },
         }
 
-        # Save report
-        report_file = self.artifacts_dir / f"dora_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        # Save enhanced report to SRE reports directory
+        sre_reports_dir = self.artifacts_dir.parent / "sre-reports"
+        sre_reports_dir.mkdir(exist_ok=True)
+
+        report_file = sre_reports_dir / f"dora_enterprise_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
         with open(report_file, "w") as f:
             json.dump(report, f, indent=2, default=str)
 
-        logger.info(f"✅ DORA metrics report saved to: {report_file}")
+        # Also save to metrics directory for backward compatibility
+        legacy_report_file = (
+            self.artifacts_dir / "dora-reports" / f"dora_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        )
+        with open(legacy_report_file, "w") as f:
+            json.dump(report, f, indent=2, default=str)
+
+        logger.info(f"✅ Enterprise DORA metrics report saved to: {report_file}")
+
+        # Auto-save persistent data after report generation
+        self._save_persistent_data()
 
         return report
 
@@ -450,6 +810,98 @@ class DORAMetricsEngine:
         else:
             return "F (Poor)"
 
+    def _generate_sre_recommendations(
+        self, targets_met: Dict[str, bool], hitl_metrics: Dict, sla_metrics: Dict, trend_analysis: Dict
+    ) -> List[str]:
+        """Generate enhanced SRE-focused recommendations based on comprehensive metrics analysis"""
+
+        recommendations = []
+
+        # DORA metrics recommendations
+        if not targets_met.get("lead_time", False):
+            recommendations.append(
+                "🎯 **Lead Time Optimization**: Implement parallel CI/CD workflows, automate testing pipelines, "
+                "and establish fast-track approval processes for low-risk changes"
+            )
+
+        if not targets_met.get("deployment_frequency", False):
+            recommendations.append(
+                "🚀 **Deployment Frequency Enhancement**: Adopt continuous deployment patterns, implement "
+                "feature flags, and establish canary deployment strategies for risk mitigation"
+            )
+
+        if not targets_met.get("change_failure_rate", False):
+            recommendations.append(
+                "🛡️ **Change Failure Rate Reduction**: Enhance pre-production testing, implement progressive "
+                "rollouts, improve monitoring coverage, and establish automated rollback triggers"
+            )
+
+        if not targets_met.get("mttr", False):
+            recommendations.append(
+                "⚡ **MTTR Improvement**: Implement automated incident detection, enhance observability stack, "
+                "establish runbook automation, and improve on-call response procedures"
+            )
+
+        # SLA compliance recommendations
+        if not targets_met.get("sla_availability", False):
+            recommendations.append(
+                "🔒 **Availability SLA Recovery**: Implement chaos engineering practices, enhance redundancy, "
+                "improve failover mechanisms, and establish proactive monitoring alerts"
+            )
+
+        if not targets_met.get("sla_performance", False):
+            recommendations.append(
+                "📈 **Performance SLA Enhancement**: Optimize critical path operations, implement caching strategies, "
+                "enhance resource allocation, and establish performance regression testing"
+            )
+
+        # HITL workflow optimization
+        if not targets_met.get("approval_time", False):
+            recommendations.append(
+                "⏰ **Approval Workflow Optimization**: Implement risk-based approval routing, establish "
+                "parallel approval processes, and create self-service deployment capabilities for low-risk changes"
+            )
+
+        # Trend analysis recommendations
+        if trend_analysis:
+            declining_metrics = [k for k, v in trend_analysis.items() if not v.get("improving", True)]
+            if declining_metrics:
+                recommendations.append(
+                    f"📊 **Trend Alert**: Declining performance detected in {', '.join(declining_metrics)}. "
+                    f"Implement immediate performance improvement initiatives and establish regression prevention measures"
+                )
+
+        # Proactive SRE recommendations based on patterns
+        if hitl_metrics.get("workflow_bottleneck"):
+            bottleneck_step = hitl_metrics["workflow_bottleneck"].tags.get("bottleneck_step", "unknown")
+            recommendations.append(
+                f"🔍 **Workflow Bottleneck Resolution**: Primary bottleneck identified in '{bottleneck_step}' step. "
+                f"Implement automation, parallel processing, or resource scaling for this workflow stage"
+            )
+
+        # Automation recommendations
+        automation_rate = targets_met.get("automation_rate", 0)
+        if automation_rate < 80:
+            recommendations.append(
+                "🤖 **Automation Enhancement**: Current automation rate below target. Implement GitOps workflows, "
+                "automated testing pipelines, and self-healing infrastructure patterns"
+            )
+
+        # Advanced SRE practices
+        if len([k for k, v in targets_met.items() if v]) / len(targets_met) < 0.8:
+            recommendations.append(
+                "🎯 **SRE Maturity Enhancement**: Consider implementing advanced SRE practices: error budgets, "
+                "SLI/SLO management, chaos engineering, and customer-centric reliability metrics"
+            )
+
+        if not recommendations:
+            recommendations.append(
+                "✅ **Excellence Achieved**: All SRE targets met! Consider advanced optimization: predictive scaling, "
+                "AI-powered incident response, and continuous reliability improvement programs"
+            )
+
+        return recommendations
+
     def _generate_recommendations(self, targets_met: Dict[str, bool], hitl_metrics: Dict) -> List[str]:
         """Generate recommendations based on metrics analysis"""
 
@@ -521,6 +973,248 @@ class DORAMetricsEngine:
         logger.info(f"📊 Metrics exported for visualization: {output_file}")
         return str(output_file)
 
+    def generate_sre_dashboard(self, days_back: int = 30) -> Dict:
+        """
+        Generate comprehensive SRE dashboard data for visualization tools.
+
+        Args:
+            days_back: Number of days to analyze for dashboard
+
+        Returns:
+            Dashboard data structure optimized for SRE tools (Datadog, Grafana, etc.)
+        """
+        logger.info(f"📊 Generating SRE dashboard data for {days_back} days")
+
+        # Get comprehensive report data
+        report = self.generate_comprehensive_report(days_back)
+
+        # Format for SRE dashboard tools
+        dashboard_data = {
+            "dashboard_type": "sre_dora_metrics",
+            "generated_at": datetime.now(timezone.utc).isoformat(),
+            "time_range_days": days_back,
+            # Key Performance Indicators (KPIs) for executive view
+            "kpi_summary": {
+                "overall_performance_score": report["performance_analysis"]["overall_performance_percentage"],
+                "sla_compliance_score": report["performance_analysis"]["sla_compliance_score"],
+                "dora_metrics_health": len(
+                    [
+                        k
+                        for k, v in report["performance_analysis"]["targets_met"].items()
+                        if not k.startswith("sla_") and v
+                    ]
+                )
+                / 4
+                * 100,
+                "active_incidents": len(
+                    [
+                        i
+                        for i in self.incidents
+                        if i.start_time >= datetime.now(timezone.utc) - timedelta(days=1) and not i.resolution_time
+                    ]
+                ),
+                "automation_percentage": report["raw_data"]["automation_rate"],
+            },
+            # Time series data for trending
+            "time_series": {
+                "lead_time": [
+                    {"timestamp": m.timestamp.isoformat(), "value": m.value}
+                    for m in self.metrics_history
+                    if m.metric_name == "lead_time"
+                ][-30:],  # Last 30 data points
+                "deployment_frequency": [
+                    {"timestamp": m.timestamp.isoformat(), "value": m.value}
+                    for m in self.metrics_history
+                    if m.metric_name == "deployment_frequency"
+                ][-30:],
+                "change_failure_rate": [
+                    {"timestamp": m.timestamp.isoformat(), "value": m.value * 100}  # Convert to percentage
+                    for m in self.metrics_history
+                    if m.metric_name == "change_failure_rate"
+                ][-30:],
+                "mttr": [
+                    {"timestamp": m.timestamp.isoformat(), "value": m.value}
+                    for m in self.metrics_history
+                    if m.metric_name == "mttr"
+                ][-30:],
+            },
+            # Alert and incident summary
+            "alerts_incidents": {
+                "recent_alerts": len(
+                    [
+                        f
+                        for f in (self.artifacts_dir / "alerts").glob("*.json")
+                        if f.stat().st_mtime > time.time() - 86400
+                    ]
+                ),
+                "incident_severity_breakdown": {
+                    "critical": len(
+                        [
+                            i
+                            for i in self.incidents
+                            if i.severity == "critical"
+                            and i.start_time >= datetime.now(timezone.utc) - timedelta(days=days_back)
+                        ]
+                    ),
+                    "high": len(
+                        [
+                            i
+                            for i in self.incidents
+                            if i.severity == "high"
+                            and i.start_time >= datetime.now(timezone.utc) - timedelta(days=days_back)
+                        ]
+                    ),
+                    "medium": len(
+                        [
+                            i
+                            for i in self.incidents
+                            if i.severity == "medium"
+                            and i.start_time >= datetime.now(timezone.utc) - timedelta(days=days_back)
+                        ]
+                    ),
+                },
+                "mttr_by_severity": self._calculate_mttr_by_severity(days_back),
+            },
+            # Operational metrics
+            "operational_metrics": {
+                "deployment_success_rate": len([d for d in self.deployments if d.status == "success"])
+                / max(1, len(self.deployments))
+                * 100,
+                "avg_approval_time_minutes": sum(self.approval_times) / max(1, len(self.approval_times)),
+                "workflow_efficiency_score": 100
+                - (
+                    sum(self.approval_times) / max(1, len(self.approval_times)) / 60 * 100
+                ),  # Efficiency based on approval speed
+                "service_reliability_score": report["sla_metrics"]["availability"]["value"] * 100
+                if "availability" in report.get("sla_metrics", {})
+                else 0,
+            },
+            # Targets and thresholds for visualization
+            "targets": self.targets,
+            "alert_thresholds": self.alert_thresholds,
+            # Raw data for detailed analysis
+            "raw_metrics": report,
+        }
+
+        # Save dashboard data for external tools
+        dashboard_file = (
+            self.artifacts_dir / "dashboards" / f"sre_dashboard_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        )
+        with open(dashboard_file, "w") as f:
+            json.dump(dashboard_data, f, indent=2, default=str)
+
+        logger.info(f"📊 SRE dashboard data saved: {dashboard_file}")
+
+        return dashboard_data
+
+    def _calculate_mttr_by_severity(self, days_back: int) -> Dict[str, float]:
+        """Calculate MTTR broken down by incident severity."""
+        cutoff_date = datetime.now(timezone.utc) - timedelta(days=days_back)
+        recent_incidents = [i for i in self.incidents if i.start_time >= cutoff_date and i.resolution_time]
+
+        mttr_by_severity = {}
+        for severity in ["critical", "high", "medium", "low"]:
+            severity_incidents = [i for i in recent_incidents if i.severity == severity]
+            if severity_incidents:
+                total_time = sum((i.resolution_time - i.start_time).total_seconds() / 3600 for i in severity_incidents)
+                mttr_by_severity[severity] = total_time / len(severity_incidents)
+            else:
+                mttr_by_severity[severity] = 0
+
+        return mttr_by_severity
+
+    def integrate_with_performance_monitor(self, performance_monitor) -> None:
+        """
+        Integrate DORA metrics with existing performance monitoring system.
+
+        Args:
+            performance_monitor: Instance of PerformanceMonitor class
+        """
+        try:
+            # Hook into performance monitor to auto-detect incidents
+            original_track = performance_monitor.track_operation
+
+            def enhanced_track_operation(
+                module: str, operation: str, execution_time: float, success: bool = True, metadata=None
+            ):
+                # Call original method
+                result = original_track(module, operation, execution_time, success, metadata)
+
+                # Auto-detect performance incidents for DORA tracking
+                target = performance_monitor.performance_targets.get(module, {})
+                threshold = target.get("target_time", 30.0)
+
+                if execution_time > threshold:
+                    self.detect_performance_incident(module, operation, execution_time, threshold)
+
+                return result
+
+            # Replace with enhanced version
+            performance_monitor.track_operation = enhanced_track_operation
+
+            logger.info("🔗 DORA metrics integrated with performance monitor")
+
+        except Exception as e:
+            logger.error(f"❌ Failed to integrate with performance monitor: {e}")
+
+    def export_cloudwatch_metrics(self, namespace: str = "CloudOps/DORA") -> bool:
+        """
+        Export DORA metrics to CloudWatch for enterprise monitoring.
+
+        Args:
+            namespace: CloudWatch metrics namespace
+
+        Returns:
+            Success status of metric publishing
+        """
+        try:
+            import boto3
+
+            cloudwatch = boto3.client("cloudwatch")
+
+            # Calculate current metrics
+            lead_time = self.calculate_lead_time(7)  # Weekly metrics
+            deploy_freq = self.calculate_deployment_frequency(7)
+            failure_rate = self.calculate_change_failure_rate(7)
+            mttr = self.calculate_mttr(7)
+
+            # Publish to CloudWatch
+            metrics_to_publish = [
+                {
+                    "MetricName": "LeadTime",
+                    "Value": lead_time.value,
+                    "Unit": "Seconds",
+                    "Dimensions": [{"Name": "Environment", "Value": "production"}],
+                },
+                {
+                    "MetricName": "DeploymentFrequency",
+                    "Value": deploy_freq.value,
+                    "Unit": "Count/Second",
+                    "Dimensions": [{"Name": "Environment", "Value": "production"}],
+                },
+                {
+                    "MetricName": "ChangeFailureRate",
+                    "Value": failure_rate.value * 100,  # Convert to percentage
+                    "Unit": "Percent",
+                    "Dimensions": [{"Name": "Environment", "Value": "production"}],
+                },
+                {
+                    "MetricName": "MeanTimeToRecovery",
+                    "Value": mttr.value,
+                    "Unit": "Seconds",
+                    "Dimensions": [{"Name": "Environment", "Value": "production"}],
+                },
+            ]
+
+            response = cloudwatch.put_metric_data(Namespace=namespace, MetricData=metrics_to_publish)
+
+            logger.info(f"📊 DORA metrics published to CloudWatch: {namespace}")
+            return True
+
+        except Exception as e:
+            logger.error(f"❌ Failed to export CloudWatch metrics: {e}")
+            return False
+
 
 # Async functions for integration with existing systems
 async def simulate_dora_metrics_collection(duration_minutes: int = 5) -> Dict: