08 - Productivity Metrics - Measuring Developer Velocity vs Quality Impact

# DORA Metrics Tracker per sviluppo AI-assisted
from datetime import datetime, timedelta
from typing import List, Dict

class DORAMetricsTracker:
    """Traccia le DORA metrics con segmentazione AI vs umano"""

    def __init__(self, deployments, incidents, changes):
        self.deployments = deployments
        self.incidents = incidents
        self.changes = changes

    def deployment_frequency(self, period_days=30):
        """Frequenza di deploy nel periodo"""
        cutoff = datetime.now() - timedelta(days=period_days)
        deploys = [d for d in self.deployments if d["date"] > cutoff]
        total = len(deploys)
        ai_related = len([d for d in deploys
                          if d.get("contains_ai_code", False)])
        return {
            "total_deployments": total,
            "ai_code_deployments": ai_related,
            "frequency_per_day": round(total / period_days, 2),
            "ai_ratio": round(ai_related / total, 2) if total > 0 else 0
        }

    def lead_time_for_changes(self):
        """Tempo dal primo commit al deploy in produzione"""
        lead_times = {"ai": [], "human": []}
        for change in self.changes:
            lt = (change["deployed_at"] - change["first_commit"]).total_seconds()
            category = "ai" if change.get("ai_generated") else "human"
            lead_times[category].append(lt / 3600)  # in ore

        return {
            "ai_avg_hours": self._avg(lead_times["ai"]),
            "human_avg_hours": self._avg(lead_times["human"]),
            "ai_p50_hours": self._percentile(lead_times["ai"], 50),
            "ai_p95_hours": self._percentile(lead_times["ai"], 95),
        }

    def change_failure_rate(self):
        """Percentuale di deploy che causano failure"""
        total = len(self.deployments)
        failures = {"ai": 0, "human": 0, "total": 0}
        for d in self.deployments:
            if d.get("caused_incident"):
                failures["total"] += 1
                if d.get("contains_ai_code"):
                    failures["ai"] += 1
                else:
                    failures["human"] += 1

        ai_deploys = len([d for d in self.deployments
                          if d.get("contains_ai_code")])
        human_deploys = total - ai_deploys

        return {
            "overall_rate": self._rate(failures["total"], total),
            "ai_code_rate": self._rate(failures["ai"], ai_deploys),
            "human_code_rate": self._rate(failures["human"], human_deploys),
            "ai_risk_multiplier": round(
                self._rate(failures["ai"], ai_deploys) /
                max(self._rate(failures["human"], human_deploys), 0.01), 2
            )
        }

    def time_to_restore(self):
        """Tempo medio di ripristino dopo un incidente"""
        restore_times = {"ai": [], "human": []}
        for incident in self.incidents:
            duration = (incident["resolved_at"] -
                        incident["started_at"]).total_seconds() / 3600
            category = "ai" if incident.get("ai_code_related") else "human"
            restore_times[category].append(duration)

        return {
            "ai_mttr_hours": self._avg(restore_times["ai"]),
            "human_mttr_hours": self._avg(restore_times["human"]),
            "ai_incidents_count": len(restore_times["ai"]),
            "human_incidents_count": len(restore_times["human"])
        }

    def _avg(self, values):
        return round(sum(values) / len(values), 2) if values else 0

    def _rate(self, count, total):
        return round(count / total * 100, 2) if total > 0 else 0

    def _percentile(self, values, p):
        if not values:
            return 0
        sorted_vals = sorted(values)
        idx = int(len(sorted_vals) * p / 100)
        return round(sorted_vals[min(idx, len(sorted_vals)-1)], 2)
      

# Cost of Quality Calculator per codice AI
class CostOfQualityCalculator:
    """Calcola il costo totale della qualità per codice AI-generated"""

    def __init__(self, team_metrics, financial_data):
        self.metrics = team_metrics
        self.finance = financial_data

    def calculate_total_coq(self):
        """Calcola il CoQ totale suddiviso per categoria"""
        prevention = self._prevention_costs()
        inspection = self._inspection_costs()
        internal_failure = self._internal_failure_costs()
        external_failure = self._external_failure_costs()

        total = prevention + inspection + internal_failure + external_failure
        return {
            "prevention": prevention,
            "inspection": inspection,
            "internal_failure": internal_failure,
            "external_failure": external_failure,
            "total_coq": total,
            "coq_percentage_of_revenue": round(
                total / self.finance["annual_revenue"] * 100, 2
            ),
            "optimal_investment": self._calculate_optimal_investment(
                prevention, inspection, internal_failure, external_failure
            )
        }

    def _prevention_costs(self):
        """Costi di prevenzione: training, tool, quality engineering"""
        return (
            self.finance["ai_tool_licenses"] +          # Copilot, etc.
            self.finance["quality_tool_licenses"] +     # SonarQube, etc.
            self.finance["training_hours"] * self.finance["hourly_rate"] +
            self.finance["quality_engineering_hours"] * self.finance["hourly_rate"]
        )

    def _inspection_costs(self):
        """Costi di ispezione: code review, testing, scanning"""
        review_hours = self.metrics["ai_pr_count"] * self.metrics["avg_review_hours"]
        testing_hours = self.metrics["ai_pr_count"] * self.metrics["avg_testing_hours"]
        return (review_hours + testing_hours) * self.finance["hourly_rate"]

    def _internal_failure_costs(self):
        """Costi di failure interna: bug trovati prima del deploy"""
        bugs_found = self.metrics["ai_bugs_pre_production"]
        return bugs_found * self.metrics["avg_bug_fix_hours"] * self.finance["hourly_rate"]

    def _external_failure_costs(self):
        """Costi di failure esterna: incidenti in produzione"""
        incidents = self.metrics["ai_production_incidents"]
        incident_cost = (
            self.metrics["avg_incident_hours"] * self.finance["hourly_rate"] +
            self.finance["avg_revenue_loss_per_incident"]
        )
        return incidents * incident_cost