Dashboard метрик DevOps для QA: метрики DORA, стабильность тестов и инсайты качества

# metrics/dora_metrics_collector.py
from dataclasses import dataclass
from datetime import datetime, timedelta
from typing import List, Dict
import requests

@dataclass
class СобытиеРазвертывания:
    timestamp: datetime
    окружение: str
    версия: str
    статус: str  # success, failed, rolled_back
    результаты_тестов: Dict

class СборщикМетрикDORA:
    def __init__(self, url_jenkins: str, url_github: str):
        self.url_jenkins = url_jenkins
        self.url_github = url_github

    def вычислить_частоту_развертывания(self, дни: int = 30) -> Dict:
        """Вычислить частоту развертывания и корреляцию с тестами"""
        развертывания = self._получить_развертывания(дни=дни)

        успешные_развертывания = [d for d in развертывания if d.статус == 'success']
        неудачные_развертывания = [d for d in развертывания if d.статус == 'failed']

        всего_дней = дни
        частота_в_день = len(успешные_развертывания) / всего_дней

        # Анализировать корреляцию покрытия тестами
        корреляция_покрытия_тестами = self._коррелировать_покрытие_тестами_с_успехом(развертывания)

        return {
            'частота_в_день': частота_в_день,
            'всего_развертываний': len(развертывания),
            'успешных_развертываний': len(успешные_развертывания),
            'неудачных_развертываний': len(неудачные_развертывания),
            'процент_успеха': len(успешные_развертывания) / len(развертывания) * 100,
            'корреляция_покрытия_тестами': корреляция_покрытия_тестами,
            'период_дней': дни
        }

    def вычислить_lead_time_изменений(self, дни: int = 30) -> Dict:
        """Вычислить lead time с разбивкой по фазе тестирования"""
        коммиты = self._получить_коммиты(дни=дни)

        lead_times = []
        длительности_тестирования = []

        for коммит in коммиты:
            # Время от коммита до продакшена
            время_коммита = коммит['timestamp']
            развертывание = self._найти_развертывание_для_коммита(коммит['sha'])

            if развертывание:
                lead_time = (развертывание.timestamp - время_коммита).total_seconds() / 3600
                lead_times.append(lead_time)

                # Длительность фазы тестирования
                длительность_тестирования = self._вычислить_длительность_тестирования(коммит['sha'])
                длительности_тестирования.append(длительность_тестирования)

        if not lead_times:
            return {'ошибка': 'Нет доступных данных'}

        средний_lead_time = sum(lead_times) / len(lead_times)
        средняя_длительность_тестирования = sum(длительности_тестирования) / len(длительности_тестирования)
        процент_тестирования = (средняя_длительность_тестирования / средний_lead_time) * 100

        return {
            'средний_lead_time_часов': средний_lead_time,
            'медианный_lead_time_часов': sorted(lead_times)[len(lead_times)//2],
            'p95_lead_time_часов': sorted(lead_times)[int(len(lead_times)*0.95)],
            'средняя_длительность_тестирования_часов': средняя_длительность_тестирования,
            'процент_тестирования_от_lead_time': процент_тестирования,
            'образцов': len(lead_times)
        }

    def вычислить_частоту_сбоев_изменений(self, дни: int = 30) -> Dict:
        """Вычислить частоту сбоев изменений с корреляцией качества тестов"""
        развертывания = self._получить_развертывания(дни=дни)

        неудачные_изменения = []
        успешные_изменения = []

        for развертывание in развертывания:
            if развертывание.статус in ['failed', 'rolled_back']:
                неудачные_изменения.append(развертывание)
            else:
                успешные_изменения.append(развертывание)

        чси = len(неудачные_изменения) / len(развертывания) * 100 if развертывания else 0

        # Анализировать сбои по покрытию
        сбои_по_покрытию = self._анализировать_сбои_по_покрытию(неудачные_изменения)

        # Идентифицировать пробелы в тестах в неудачных развертываниях
        пробелы_тестов = self._идентифицировать_пробелы_тестов(неудачные_изменения)

        return {
            'частота_сбоев_изменений_процент': чси,
            'всего_развертываний': len(развертывания),
            'неудачных_развертываний': len(неудачные_изменения),
            'сбои_по_покрытию': сбои_по_покрытию,
            'идентифицированные_пробелы_тестов': пробелы_тестов,
            'рекомендация': self._генерировать_рекомендацию_чси(чси, пробелы_тестов)
        }

    def вычислить_mttr(self, дни: int = 30) -> Dict:
        """Вычислить среднее время восстановления с анализом влияния тестирования"""
        инциденты = self._получить_инциденты(дни=дни)

        времена_восстановления = []
        времена_выполнения_тестовых_наборов = []

        for инцидент in инциденты:
            время_разрешения = (инцидент.разрешен_в - инцидент.создан_в).total_seconds() / 3600
            времена_восстановления.append(время_разрешения)

            # Время выполнения тестовых наборов во время инцидента
            время_тестов = self._вычислить_время_тестов_инцидента(инцидент)
            времена_выполнения_тестовых_наборов.append(время_тестов)

        if not времена_восстановления:
            return {'ошибка': 'Нет инцидентов за период'}

        среднее_mttr = sum(времена_восстановления) / len(времена_восстановления)
        среднее_время_тестов = sum(времена_выполнения_тестовых_наборов) / len(времена_выполнения_тестовых_наборов)

        return {
            'среднее_время_восстановления_часов': среднее_mttr,
            'медианное_mttr_часов': sorted(времена_восстановления)[len(времена_восстановления)//2],
            'среднее_время_выполнения_тестов': среднее_время_тестов,
            'процент_времени_тестов': (среднее_время_тестов / среднее_mttr) * 100,
            'проанализировано_инцидентов': len(инциденты),
            'рекомендация': self._генерировать_рекомендацию_mttr(среднее_mttr, среднее_время_тестов)
        }

    def _коррелировать_покрытие_тестами_с_успехом(self, развертывания: List[СобытиеРазвертывания]) -> Dict:
        """Анализировать корреляцию между покрытием тестами и успехом развертывания"""
        диапазоны_покрытия = {
            '0-50%': {'успех': 0, 'неудача': 0},
            '50-70%': {'успех': 0, 'неудача': 0},
            '70-85%': {'успех': 0, 'неудача': 0},
            '85-100%': {'успех': 0, 'неудача': 0}
        }

        for развертывание in развертывания:
            покрытие = развертывание.результаты_тестов.get('coverage', 0)

            if покрытие < 50:
                ключ_диапазона = '0-50%'
            elif покрытие < 70:
                ключ_диапазона = '50-70%'
            elif покрытие < 85:
                ключ_диапазона = '70-85%'
            else:
                ключ_диапазона = '85-100%'

            if развертывание.статус == 'success':
                диапазоны_покрытия[ключ_диапазона]['успех'] += 1
            else:
                диапазоны_покрытия[ключ_диапазона]['неудача'] += 1

        # Вычислить проценты успеха по диапазонам покрытия
        проценты_успеха = {}
        for ключ_диапазона, счетчики in диапазоны_покрытия.items():
            всего = счетчики['успех'] + счетчики['неудача']
            if всего > 0:
                проценты_успеха[ключ_диапазона] = (счетчики['успех'] / всего) * 100

        return проценты_успеха

# metrics/flaky_test_analyzer.py
from collections import defaultdict
from datetime import datetime, timedelta
from typing import List, Dict, Tuple
import statistics

class АнализаторНестабильныхТестов:
    def __init__(self, бд_результатов_тестов):
        self.бд = бд_результатов_тестов

    def идентифицировать_нестабильные_тесты(self, дни: int = 14, мин_запусков: int = 10) -> List[Dict]:
        """Идентифицировать тесты с непостоянными паттернами прошло/не прошло"""
        запуски_тестов = self._получить_запуски_тестов(дни=дни)

        карта_результатов_тестов = defaultdict(list)

        for запуск in запуски_тестов:
            for тест in запуск.тесты:
                карта_результатов_тестов[тест.имя].append({
                    'статус': тест.статус,
                    'длительность': тест.длительность,
                    'timestamp': запуск.timestamp,
                    'commit_sha': запуск.commit_sha,
                    'окружение': запуск.окружение
                })

        нестабильные_тесты = []

        for имя_теста, результаты in карта_результатов_тестов.items():
            if len(результаты) < мин_запусков:
                continue

            # Вычислить показатель нестабильности
            количество_прошедших = sum(1 for r in результаты if r['статус'] == 'passed')
            количество_неудачных = sum(1 for r in результаты if r['статус'] == 'failed')
            всего_запусков = len(результаты)

            # Тест нестабилен если он и проходит и падает в одном периоде
            if количество_прошедших > 0 and количество_неудачных > 0:
                показатель_нестабильности = min(количество_прошедших, количество_неудачных) / всего_запусков * 100

                # Анализировать паттерны
                паттерны = self._анализировать_паттерны_нестабильности(результаты)

                нестабильные_тесты.append({
                    'имя_теста': имя_теста,
                    'показатель_нестабильности': показатель_нестабильности,
                    'процент_прохождения': (количество_прошедших / всего_запусков) * 100,
                    'всего_запусков': всего_запусков,
                    'количество_прошедших': количество_прошедших,
                    'количество_неудачных': количество_неудачных,
                    'паттерны': паттерны,
                    'влияние': self._вычислить_влияние_нестабильного_теста(результаты),
                    'рекомендация': self._генерировать_рекомендацию_нестабильного_теста(паттерны)
                })

        # Сортировать по показателю нестабильности
        return sorted(нестабильные_тесты, key=lambda x: x['показатель_нестабильности'], reverse=True)

    def вычислить_стабильность_тестового_набора(self, дни: int = 30) -> Dict:
        """Вычислить общие метрики стабильности тестового набора"""
        запуски_тестов = self._получить_запуски_тестов(дни=дни)

        данные_стабильности = {
            'всего_запусков': len(запуски_тестов),
            'консистентных_запусков': 0,
            'нестабильных_запусков': 0,
            'средняя_длительность': 0,
            'дисперсия_длительности': 0
        }

        длительности = []
        количество_нестабильных_запусков = 0

        for запуск in запуски_тестов:
            длительности.append(запуск.общая_длительность)

            # Подсчет запусков с нестабильными тестами
            if запуск.количество_нестабильных_тестов > 0:
                количество_нестабильных_запусков += 1
            else:
                данные_стабильности['консистентных_запусков'] += 1

        данные_стабильности['нестабильных_запусков'] = количество_нестабильных_запусков
        данные_стабильности['показатель_стабильности'] = (данные_стабильности['консистентных_запусков'] / len(запуски_тестов)) * 100

        if длительности:
            данные_стабильности['средняя_длительность'] = statistics.mean(длительности)
            данные_стабильности['дисперсия_длительности'] = statistics.stdev(длительности) if len(длительности) > 1 else 0
            данные_стабильности['коэффициент_вариации_длительности'] = (
                данные_стабильности['дисперсия_длительности'] / данные_стабильности['средняя_длительность'] * 100
            )

        return данные_стабильности

# grafana/qa-metrics-dashboard.json
{
  "dashboard": {
    "title": "Dashboard метрик QA DevOps",
    "tags": ["qa", "devops", "metrics"],
    "timezone": "browser",
    "panels": [
      {
        "id": 1,
        "title": "Частота развертывания и процент успеха",
        "type": "graph",
        "targets": [
          {
            "expr": "rate(deployments_total[24h])",
            "legendFormat": "Частота развертывания"
          },
          {
            "expr": "(sum(deployments_total{status=\"success\"}) / sum(deployments_total)) * 100",
            "legendFormat": "Процент успеха %"
          }
        ]
      },
      {
        "id": 2,
        "title": "Метрики выполнения тестов",
        "type": "stat",
        "targets": [
          {
            "expr": "sum(test_runs_total)",
            "legendFormat": "Всего запусков тестов"
          },
          {
            "expr": "sum(test_passed) / sum(test_runs_total) * 100",
            "legendFormat": "Процент прохождения %"
          }
        ]
      },
      {
        "id": 3,
        "title": "Нестабильные тесты со временем",
        "type": "graph",
        "targets": [
          {
            "expr": "flaky_tests_count",
            "legendFormat": "Нестабильные тесты"
          }
        ]
      }
    ]
  }
}