Cleanup: Remove old rule-based agent files, all agents now use DeepSeek via smolagents

agents/anomaly_agent.py

@@ -1,415 +0,0 @@
-"""
-Agent 2: Anomaly Detection Agent
-Выявляет аномалии и подозрительные паттерны в структурированных логах.
-"""
-
-import re
-import json
-from typing import Dict, List, Any
-from collections import defaultdict, Counter
-from datetime import datetime
-
-
-class AnomalyDetectionAgent:
-    """Обнаруживает аномалии в структурированных логах."""
-    
-    def __init__(self):
-        """Инициализация агента."""
-        self.burst_threshold = 5  # Минимальное количество ошибок для burst
-        self.burst_time_window = 60  # Окно времени в секундах для burst
-        self.repeat_threshold = 3  # Минимальное количество повторений
-    
-    def detect(self, structured_data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Выявляет аномалии в структурированных данных.
-        
-        Args:
-            structured_data: Структурированные данные от LogParserAgent
-            
-        Returns:
-            JSON-отчёт об аномалиях с описанием и метаданными
-        """
-        if not structured_data or not structured_data.get('events'):
-            return self._empty_report()
-        
-        events = structured_data.get('events', [])
-        errors = structured_data.get('errors', [])
-        
-        anomalies = []
-        
-        # 1. Обнаружение burst errors
-        burst_anomalies = self._detect_burst_errors(events, errors)
-        anomalies.extend(burst_anomalies)
-        
-        # 2. Обнаружение повторяющихся ошибок
-        repeat_anomalies = self._detect_repeated_errors(errors)
-        anomalies.extend(repeat_anomalies)
-        
-        # 3. Обнаружение паттернов "ошибка перед крашем"
-        crash_patterns = self._detect_error_before_crash(errors, events)
-        anomalies.extend(crash_patterns)
-        
-        # 4. Обнаружение временных всплесков
-        spike_anomalies = self._detect_temporal_spikes(events)
-        anomalies.extend(spike_anomalies)
-        
-        # 5. Обнаружение повторяющихся stack traces
-        stack_trace_anomalies = self._detect_repeated_stack_traces(events)
-        anomalies.extend(stack_trace_anomalies)
-        
-        # Подсчёт статистики
-        anomaly_stats = self._calculate_anomaly_statistics(anomalies)
-        
-        return {
-            'anomalies': anomalies,
-            'statistics': anomaly_stats,
-            'severity_summary': self._calculate_severity_summary(anomalies)
-        }
-    
-    def _detect_burst_errors(self, events: List[Dict], errors: List[Dict]) -> List[Dict[str, Any]]:
-        """Обнаруживает всплески ошибок (burst errors)."""
-        anomalies = []
-        
-        if len(errors) < self.burst_threshold:
-            return anomalies
-        
-        # Группировка ошибок по времени (если доступны временные метки)
-        error_times = []
-        for error in errors:
-            timestamp_str = error.get('timestamp')
-            if timestamp_str:
-                try:
-                    timestamp = self._parse_timestamp_simple(timestamp_str)
-                    if timestamp:
-                        error_times.append((timestamp, error))
-                except:
-                    pass
-        
-        # Если временные метки доступны, анализируем временные окна
-        if error_times:
-            error_times.sort(key=lambda x: x[0] if x[0] else datetime.min)
-            
-            # Поиск кластеров ошибок во временных окнах
-            i = 0
-            while i < len(error_times):
-                cluster_start = error_times[i][0]
-                cluster_errors = [error_times[i][1]]
-                
-                j = i + 1
-                while j < len(error_times) and error_times[j][0]:
-                    time_diff = (error_times[j][0] - cluster_start).total_seconds()
-                    if time_diff <= self.burst_time_window:
-                        cluster_errors.append(error_times[j][1])
-                        j += 1
-                    else:
-                        break
-                
-                if len(cluster_errors) >= self.burst_threshold:
-                    messages = [e.get('message', '')[:100] for e in cluster_errors[:3]]
-                    anomalies.append({
-                        'type': 'BURST_ERRORS',
-                        'severity': 'HIGH',
-                        'description': f'Обнаружен всплеск из {len(cluster_errors)} ошибок в течение {self.burst_time_window} секунд',
-                        'count': len(cluster_errors),
-                        'time_window_seconds': self.burst_time_window,
-                        'sample_messages': messages,
-                        'first_occurrence': cluster_start.isoformat() if cluster_start else None,
-                        'metadata': {
-                            'threshold': self.burst_threshold,
-                            'affected_lines': [e.get('line_number') for e in cluster_errors[:10]]
-                        }
-                    })
-                
-                i = j
-        else:
-            # Если временных меток нет, проверяем последовательные ошибки
-            consecutive_count = 0
-            start_idx = 0
-            
-            for i, error in enumerate(errors):
-                if i > 0:
-                    prev_error = errors[i - 1]
-                    # Проверяем, являются ли ошибки последовательными (по номерам строк)
-                    if error.get('line_number', 0) - prev_error.get('line_number', 0) <= 5:
-                        consecutive_count += 1
-                    else:
-                        if consecutive_count >= self.burst_threshold:
-                            anomalies.append(self._create_burst_anomaly(
-                                errors[start_idx:i], consecutive_count + 1
-                            ))
-                        consecutive_count = 0
-                        start_idx = i
-                else:
-                    consecutive_count = 1
-            
-            # Проверка последнего кластера
-            if consecutive_count >= self.burst_threshold:
-                anomalies.append(self._create_burst_anomaly(
-                    errors[start_idx:], consecutive_count
-                ))
-        
-        return anomalies
-    
-    def _create_burst_anomaly(self, errors: List[Dict], count: int) -> Dict[str, Any]:
-        """Создаёт запись об аномалии burst errors."""
-        messages = [e.get('message', '')[:100] for e in errors[:3]]
-        return {
-            'type': 'BURST_ERRORS',
-            'severity': 'HIGH',
-            'description': f'Обнаружен всплеск из {count} последовательных ошибок',
-            'count': count,
-            'sample_messages': messages,
-            'metadata': {
-                'threshold': self.burst_threshold,
-                'affected_lines': [e.get('line_number') for e in errors[:10]]
-            }
-        }
-    
-    def _detect_repeated_errors(self, errors: List[Dict]) -> List[Dict[str, Any]]:
-        """Обнаруживает повторяющиеся ошибки."""
-        anomalies = []
-        
-        if not errors:
-            return anomalies
-        
-        # Группировка ошибок по сообщениям (нормализованным)
-        error_groups = defaultdict(list)
-        for error in errors:
-            message = self._normalize_message(error.get('message', ''))
-            error_groups[message].append(error)
-        
-        # Поиск повторяющихся ошибок
-        for message, error_list in error_groups.items():
-            if len(error_list) >= self.repeat_threshold:
-                line_numbers = [e.get('line_number') for e in error_list]
-                timestamps = [e.get('timestamp') for e in error_list if e.get('timestamp')]
-                
-                anomalies.append({
-                    'type': 'REPEATED_ERRORS',
-                    'severity': 'MEDIUM',
-                    'description': f'Одна и та же ошибка повторяется {len(error_list)} раз(а)',
-                    'count': len(error_list),
-                    'error_message': message[:200],
-                    'first_occurrence': timestamps[0] if timestamps else None,
-                    'last_occurrence': timestamps[-1] if timestamps else None,
-                    'metadata': {
-                        'threshold': self.repeat_threshold,
-                        'affected_lines': line_numbers[:20]
-                    }
-                })
-        
-        return anomalies
-    
-    def _detect_error_before_crash(self, errors: List[Dict], events: List[Dict]) -> List[Dict[str, Any]]:
-        """Обнаруживает паттерны "ошибка перед крашем"."""
-        anomalies = []
-        
-        if not errors:
-            return anomalies
-        
-        # Ищем последовательности критических ошибок в конце логов
-        # Или ошибки, за которыми следует остановка системы
-        crash_keywords = ['crash', 'shutdown', 'fatal', 'terminate', 'abort', 'exit']
-        
-        # Проверяем последние события на наличие паттернов краша
-        last_events = events[-50:] if len(events) > 50 else events
-        last_errors = errors[-20:] if len(errors) > 20 else errors
-        
-        for i, error in enumerate(last_errors):
-            error_msg_lower = error.get('message', '').lower()
-            error_level = error.get('level', '').upper()
-            
-            # Проверяем, является ли это критической ошибкой
-            if error_level in ['CRITICAL', 'ERROR']:
-                # Проверяем последующие события на признаки краша
-                error_line = error.get('line_number', 0)
-                subsequent_events = [e for e in last_events if e.get('line_number', 0) > error_line][:10]
-                
-                crash_indicators = []
-                for event in subsequent_events:
-                    event_msg_lower = event.get('message', '').lower()
-                    if any(keyword in event_msg_lower for keyword in crash_keywords):
-                        crash_indicators.append(event.get('message', '')[:100])
-                
-                if crash_indicators or i == len(last_errors) - 1:
-                    anomalies.append({
-                        'type': 'ERROR_BEFORE_CRASH',
-                        'severity': 'CRITICAL',
-                        'description': 'Обнаружен паттерн: ошибка перед возможным крашем системы',
-                        'error_message': error.get('message', '')[:200],
-                        'error_level': error_level,
-                        'crash_indicators': crash_indicators[:3],
-                        'metadata': {
-                            'error_line': error_line,
-                            'is_last_error': i == len(last_errors) - 1
-                        }
-                    })
-        
-        return anomalies
-    
-    def _detect_temporal_spikes(self, events: List[Dict]) -> List[Dict[str, Any]]:
-        """Обнаруживает временные всплески событий."""
-        anomalies = []
-        
-        # Группировка событий по времени (если доступны временные метки)
-        events_with_time = [(e.get('timestamp'), e) for e in events if e.get('timestamp')]
-        
-        if len(events_with_time) < 10:
-            return anomalies
-        
-        # Группировка по минутам (или другим временным окнам)
-        time_groups = defaultdict(list)
-        for timestamp_str, event in events_with_time:
-            try:
-                timestamp = self._parse_timestamp_simple(timestamp_str)
-                if timestamp:
-                    # Группируем по минутам
-                    time_key = timestamp.strftime('%Y-%m-%d %H:%M')
-                    time_groups[time_key].append(event)
-            except:
-                pass
-        
-        if not time_groups:
-            return anomalies
-        
-        # Вычисляем среднее количество событий на временное окно
-        event_counts = [len(events) for events in time_groups.values()]
-        if not event_counts:
-            return anomalies
-        
-        avg_count = sum(event_counts) / len(event_counts)
-        threshold = avg_count * 2  # Всплеск - это превышение среднего в 2 раза
-        
-        # Поиск всплесков
-        for time_key, events_in_window in time_groups.items():
-            if len(events_in_window) > threshold:
-                error_count = len([e for e in events_in_window if e.get('level', '').upper() in ['ERROR', 'CRITICAL']])
-                
-                anomalies.append({
-                    'type': 'TEMPORAL_SPIKE',
-                    'severity': 'MEDIUM',
-                    'description': f'Обнаружен временной всплеск: {len(events_in_window)} событий за период {time_key} (среднее: {avg_count:.1f})',
-                    'time_window': time_key,
-                    'event_count': len(events_in_window),
-                    'average_count': round(avg_count, 1),
-                    'error_count': error_count,
-                    'metadata': {
-                        'threshold_multiplier': 2.0
-                    }
-                })
-        
-        return anomalies
-    
-    def _detect_repeated_stack_traces(self, events: List[Dict]) -> List[Dict[str, Any]]:
-        """Обнаруживает повторяющиеся stack traces."""
-        anomalies = []
-        
-        # Ищем строки, похожие на stack traces
-        stack_trace_keywords = ['traceback', 'stack trace', 'at ', 'exception', 'file "', 'line ', 'in ']
-        potential_stacks = []
-        
-        for event in events:
-            message = event.get('message', '').lower()
-            if any(keyword in message for keyword in stack_trace_keywords):
-                # Проверяем длину сообщения (stack traces обычно длинные)
-                if len(event.get('message', '')) > 100:
-                    potential_stacks.append(event)
-        
-        if len(potential_stacks) < self.repeat_threshold:
-            return anomalies
-        
-        # Группировка по нормализованным сообщениям
-        stack_groups = defaultdict(list)
-        for stack in potential_stacks:
-            normalized = self._normalize_stack_trace(stack.get('message', ''))
-            stack_groups[normalized].append(stack)
-        
-        # Поиск повторяющихся
-        for normalized_stack, stack_list in stack_groups.items():
-            if len(stack_list) >= self.repeat_threshold:
-                anomalies.append({
-                    'type': 'REPEATED_STACK_TRACES',
-                    'severity': 'HIGH',
-                    'description': f'Один и тот же stack trace повторяется {len(stack_list)} раз(а)',
-                    'count': len(stack_list),
-                    'stack_trace_preview': normalized_stack[:300],
-                    'metadata': {
-                        'threshold': self.repeat_threshold,
-                        'affected_lines': [s.get('line_number') for s in stack_list[:10]]
-                    }
-                })
-        
-        return anomalies
-    
-    def _normalize_message(self, message: str) -> str:
-        """Нормализует сообщение для группировки (удаляет переменные части)."""
-        # Удаляем числа и даты
-        normalized = re.sub(r'\d+', 'N', message)
-        # Удаляем пути к файлам
-        normalized = re.sub(r'[A-Z]:\\[^\s]+|/[^\s]+', 'PATH', normalized)
-        # Удаляем URL
-        normalized = re.sub(r'https?://[^\s]+', 'URL', normalized)
-        return normalized.strip()
-    
-    def _normalize_stack_trace(self, stack: str) -> str:
-        """Нормализует stack trace для сравнения."""
-        # Оставляем только ключевые части stack trace
-        lines = stack.split('\n')[:5]  # Первые 5 строк обычно достаточны
-        normalized = '\n'.join([line.strip() for line in lines])
-        # Удаляем пути и номера строк
-        normalized = re.sub(r'File "[^"]+", line \d+', 'File "FILE", line N', normalized)
-        return normalized
-    
-    def _parse_timestamp_simple(self, timestamp_str: str) -> datetime | None:
-        """Простой парсер временных меток."""
-        timestamp_str = timestamp_str.strip('[]')
-        formats = [
-            '%Y-%m-%d %H:%M:%S',
-            '%Y-%m-%dT%H:%M:%S',
-            '%Y-%m-%d %H:%M:%S.%f',
-            '%Y-%m-%dT%H:%M:%S.%f',
-            '%d/%m/%Y %H:%M:%S',
-        ]
-        
-        for fmt in formats:
-            try:
-                return datetime.strptime(timestamp_str, fmt)
-            except ValueError:
-                continue
-        
-        return None
-    
-    def _calculate_anomaly_statistics(self, anomalies: List[Dict]) -> Dict[str, Any]:
-        """Вычисляет статистику аномалий."""
-        if not anomalies:
-            return {
-                'total': 0,
-                'by_type': {},
-                'by_severity': {}
-            }
-        
-        by_type = Counter(a.get('type') for a in anomalies)
-        by_severity = Counter(a.get('severity') for a in anomalies)
-        
-        return {
-            'total': len(anomalies),
-            'by_type': dict(by_type),
-            'by_severity': dict(by_severity)
-        }
-    
-    def _calculate_severity_summary(self, anomalies: List[Dict]) -> Dict[str, int]:
-        """Вычисляет сводку по уровням серьёзности."""
-        severity_counts = Counter(a.get('severity', 'UNKNOWN') for a in anomalies)
-        return dict(severity_counts)
-    
-    def _empty_report(self) -> Dict[str, Any]:
-        """Возвращает пустой отчёт при отсутствии данных."""
-        return {
-            'anomalies': [],
-            'statistics': {
-                'total': 0,
-                'by_type': {},
-                'by_severity': {}
-            },
-            'severity_summary': {}
-        }

agents/parser_agent.py

@@ -1,217 +0,0 @@
-"""
-Agent 1: Log Parser Agent
-Преобразует сырые логи в структурированное представление.
-"""
-
-import re
-import json
-from datetime import datetime
-from typing import Dict, List, Any
-from collections import defaultdict
-
-
-class LogParserAgent:
-    """Парсит сырые логи и преобразует их в структурированный JSON."""
-    
-    # Паттерны для распознавания уровней логирования
-    LOG_LEVELS = ['CRITICAL', 'ERROR', 'WARNING', 'INFO', 'DEBUG', 'TRACE']
-    
-    # Паттерны для временных меток (поддержка различных форматов)
-    TIMESTAMP_PATTERNS = [
-        r'\d{4}-\d{2}-\d{2}[\sT]\d{2}:\d{2}:\d{2}(?:\.\d+)?',  # ISO 8601
-        r'\d{2}/\d{2}/\d{4}[\s]\d{2}:\d{2}:\d{2}',  # DD/MM/YYYY HH:MM:SS
-        r'\[(?:[A-Z][a-z]{2}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2})\]',  # [Mon Jan 1 12:00:00]
-    ]
-    
-    def __init__(self):
-        """Инициализация агента."""
-        self.compiled_patterns = [re.compile(pattern) for pattern in self.TIMESTAMP_PATTERNS]
-    
-    def parse(self, raw_logs: str) -> Dict[str, Any]:
-        """
-        Парсит сырые логи и возвращает структурированный JSON.
-        
-        Args:
-            raw_logs: Строка с сырыми логами
-            
-        Returns:
-            Структурированный JSON-объект с событиями, ошибками, предупреждениями и статистикой
-        """
-        if not raw_logs or not raw_logs.strip():
-            return self._empty_result()
-        
-        lines = raw_logs.strip().split('\n')
-        events = []
-        errors = []
-        warnings = []
-        
-        for line_num, line in enumerate(lines, start=1):
-            if not line.strip():
-                continue
-            
-            parsed_event = self._parse_line(line, line_num)
-            if parsed_event:
-                events.append(parsed_event)
-                
-                level = parsed_event.get('level', '').upper()
-                if level == 'ERROR' or level == 'CRITICAL':
-                    errors.append(parsed_event)
-                elif level == 'WARNING':
-                    warnings.append(parsed_event)
-        
-        # Группировка по типам событий
-        event_types = defaultdict(int)
-        for event in events:
-            event_type = event.get('type', 'UNKNOWN')
-            event_types[event_type] += 1
-        
-        # Статистика
-        statistics = {
-            'total_lines': len(lines),
-            'parsed_events': len(events),
-            'errors': len(errors),
-            'warnings': len(warnings),
-            'info_messages': len([e for e in events if e.get('level', '').upper() == 'INFO']),
-            'event_types': dict(event_types),
-            'time_range': self._calculate_time_range(events),
-        }
-        
-        return {
-            'events': events,
-            'errors': errors,
-            'warnings': warnings,
-            'statistics': statistics
-        }
-    
-    def _parse_line(self, line: str, line_num: int) -> Dict[str, Any] | None:
-        """
-        Парсит одну строку лога.
-        
-        Args:
-            line: Строка лога
-            line_num: Номер строки
-            
-        Returns:
-            Словарь с распарсенными данными или None
-        """
-        # Поиск временной метки
-        timestamp = None
-        timestamp_str = None
-        for pattern in self.compiled_patterns:
-            match = pattern.search(line)
-            if match:
-                timestamp_str = match.group(0)
-                try:
-                    # Попытка парсинга различных форматов
-                    timestamp = self._parse_timestamp(timestamp_str)
-                except:
-                    pass
-                break
-        
-        # Поиск уровня логирования
-        level = None
-        for log_level in self.LOG_LEVELS:
-            if log_level in line.upper():
-                level = log_level
-                break
-        
-        # Если уровень не найден, определяем по ключевым словам
-        if not level:
-            line_upper = line.upper()
-            if any(word in line_upper for word in ['ERROR', 'EXCEPTION', 'FAILED', 'FAILURE']):
-                level = 'ERROR'
-            elif any(word in line_upper for word in ['WARN', 'WARNING']):
-                level = 'WARNING'
-            elif any(word in line_upper for word in ['INFO', 'INFORMATION']):
-                level = 'INFO'
-            elif any(word in line_upper for word in ['DEBUG']):
-                level = 'DEBUG'
-            else:
-                level = 'INFO'  # По умолчанию
-        
-        # Извлечение сообщения (часть после временной метки и уровня)
-        message = line
-        if timestamp_str:
-            message = message.replace(timestamp_str, '', 1).strip()
-        
-        # Определение типа события
-        event_type = self._detect_event_type(line)
-        
-        return {
-            'line_number': line_num,
-            'timestamp': timestamp_str if timestamp_str else None,
-            'level': level,
-            'message': message.strip(),
-            'type': event_type,
-            'raw': line
-        }
-    
-    def _parse_timestamp(self, timestamp_str: str) -> datetime | None:
-        """Парсит строку временной метки в объект datetime."""
-        # Удаление скобок если есть
-        timestamp_str = timestamp_str.strip('[]')
-        
-        # Попытка различных форматов
-        formats = [
-            '%Y-%m-%d %H:%M:%S',
-            '%Y-%m-%dT%H:%M:%S',
-            '%Y-%m-%d %H:%M:%S.%f',
-            '%Y-%m-%dT%H:%M:%S.%f',
-            '%d/%m/%Y %H:%M:%S',
-            '%a %b %d %H:%M:%S %Y',  # [Mon Jan 1 12:00:00 2024]
-        ]
-        
-        for fmt in formats:
-            try:
-                return datetime.strptime(timestamp_str, fmt)
-            except ValueError:
-                continue
-        
-        return None
-    
-    def _detect_event_type(self, line: str) -> str:
-        """Определяет тип события по содержимому строки."""
-        line_lower = line.lower()
-        
-        if any(keyword in line_lower for keyword in ['connection', 'connect', 'disconnect']):
-            return 'CONNECTION'
-        elif any(keyword in line_lower for keyword in ['request', 'response', 'http', 'api']):
-            return 'HTTP_REQUEST'
-        elif any(keyword in line_lower for keyword in ['database', 'db', 'query', 'sql']):
-            return 'DATABASE'
-        elif any(keyword in line_lower for keyword in ['authentication', 'auth', 'login', 'logout']):
-            return 'AUTHENTICATION'
-        elif any(keyword in line_lower for keyword in ['exception', 'error', 'failure']):
-            return 'EXCEPTION'
-        elif any(keyword in line_lower for keyword in ['start', 'stop', 'shutdown', 'initialized']):
-            return 'SYSTEM'
-        else:
-            return 'GENERAL'
-    
-    def _calculate_time_range(self, events: List[Dict[str, Any]]) -> Dict[str, str] | None:
-        """Вычисляет временной диапазон событий."""
-        timestamps = [e.get('timestamp') for e in events if e.get('timestamp')]
-        if not timestamps:
-            return None
-        
-        return {
-            'start': timestamps[0],
-            'end': timestamps[-1]
-        }
-    
-    def _empty_result(self) -> Dict[str, Any]:
-        """Возвращает пустой результат при отсутствии логов."""
-        return {
-            'events': [],
-            'errors': [],
-            'warnings': [],
-            'statistics': {
-                'total_lines': 0,
-                'parsed_events': 0,
-                'errors': 0,
-                'warnings': 0,
-                'info_messages': 0,
-                'event_types': {},
-                'time_range': None
-            }
-        }

agents/rca_agent.py

@@ -1,316 +0,0 @@
-"""
-Agent 3: Root Cause & Recommendation Agent
-Интерпретирует аномалии и формирует рекомендации.
-"""
-
-from typing import Dict, List, Any
-import json
-
-
-class RootCauseAgent:
-    """Анализирует аномалии и генерирует рекомендации."""
-    
-    def __init__(self):
-        """Инициализация агента."""
-        self.root_cause_templates = self._init_root_cause_templates()
-        self.recommendation_templates = self._init_recommendation_templates()
-    
-    def analyze(self, anomaly_report: Dict[str, Any]) -> str:
-        """
-        Анализирует отчёт об аномалиях и генерирует рекомендации.
-        
-        Args:
-            anomaly_report: Отчёт об аномалиях от AnomalyDetectionAgent
-            
-        Returns:
-            Markdown-текст с анализом и рекомендациями
-        """
-        if not anomaly_report or not anomaly_report.get('anomalies'):
-            return self._generate_no_anomalies_report()
-        
-        anomalies = anomaly_report.get('anomalies', [])
-        statistics = anomaly_report.get('statistics', {})
-        severity_summary = anomaly_report.get('severity_summary', {})
-        
-        # Генерация отчёта
-        report_parts = []
-        
-        # Заголовок
-        report_parts.append("# Анализ первопричин и рекомендации\n")
-        report_parts.append(f"**Обнаружено аномалий:** {statistics.get('total', 0)}\n")
-        
-        # Сводка по серьёзности
-        if severity_summary:
-            report_parts.append("\n## Сводка по уровням серьёзности\n")
-            severity_order = ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW']
-            for severity in severity_order:
-                count = severity_summary.get(severity, 0)
-                if count > 0:
-                    emoji = self._get_severity_emoji(severity)
-                    report_parts.append(f"- {emoji} **{severity}:** {count}\n")
-        
-        # Группировка аномалий по типам
-        anomalies_by_type = {}
-        for anomaly in anomalies:
-            anomaly_type = anomaly.get('type', 'UNKNOWN')
-            if anomaly_type not in anomalies_by_type:
-                anomalies_by_type[anomaly_type] = []
-            anomalies_by_type[anomaly_type].append(anomaly)
-        
-        # Анализ каждого типа аномалий
-        report_parts.append("\n## Детальный анализ аномалий\n")
-        
-        for anomaly_type, type_anomalies in anomalies_by_type.items():
-            report_parts.append(f"\n### {self._get_anomaly_type_name(anomaly_type)}\n")
-            
-            # Анализ первопричин
-            root_causes = self._identify_root_causes(anomaly_type, type_anomalies)
-            if root_causes:
-                report_parts.append("#### Возможные первопричины:\n")
-                for i, cause in enumerate(root_causes, 1):
-                    report_parts.append(f"{i}. {cause}\n")
-            
-            # Детали аномалий
-            report_parts.append("\n#### Детали:\n")
-            for i, anomaly in enumerate(type_anomalies[:5], 1):  # Показываем до 5 примеров
-                severity = anomaly.get('severity', 'UNKNOWN')
-                description = anomaly.get('description', 'Без описания')
-                report_parts.append(f"**Аномалия {i}** ({severity}):\n")
-                report_parts.append(f"- {description}\n")
-                
-                # Дополнительная информация
-                if anomaly.get('count'):
-                    report_parts.append(f"- Количество: {anomaly.get('count')}\n")
-                if anomaly.get('error_message'):
-                    error_msg = anomaly.get('error_message', '')[:150]
-                    report_parts.append(f"- Сообщение: `{error_msg}`\n")
-                if anomaly.get('metadata'):
-                    metadata = anomaly.get('metadata', {})
-                    if metadata.get('affected_lines'):
-                        lines = metadata.get('affected_lines', [])[:5]
-                        report_parts.append(f"- Затронутые строки: {', '.join(map(str, lines))}\n")
-            
-            if len(type_anomalies) > 5:
-                report_parts.append(f"\n*... и ещё {len(type_anomalies) - 5} аномалий этого типа*\n")
-        
-        # Рекомендации
-        report_parts.append("\n## Рекомендации по устранению\n")
-        recommendations = self._generate_recommendations(anomalies)
-        
-        for i, recommendation in enumerate(recommendations, 1):
-            priority = recommendation.get('priority', 'MEDIUM')
-            emoji = self._get_priority_emoji(priority)
-            report_parts.append(f"\n### {emoji} Рекомендация {i} (Приоритет: {priority})\n")
-            report_parts.append(f"{recommendation.get('text', '')}\n")
-            
-            if recommendation.get('actions'):
-                report_parts.append("**Конкретные действия:**\n")
-                for action in recommendation.get('actions', []):
-                    report_parts.append(f"- {action}\n")
-        
-        # Общие рекомендации
-        report_parts.append("\n## Общие рекомендации\n")
-        general_recommendations = self._generate_general_recommendations(anomalies, statistics)
-        for rec in general_recommendations:
-            report_parts.append(f"- {rec}\n")
-        
-        return ''.join(report_parts)
-    
-    def _identify_root_causes(self, anomaly_type: str, anomalies: List[Dict]) -> List[str]:
-        """Определяет возможные первопричины для типа аномалий."""
-        causes = []
-        
-        if anomaly_type == 'BURST_ERRORS':
-            causes.extend([
-                "Внезапная перегрузка системы или внешнего сервиса",
-                "Сбой в инфраструктуре (сеть, база данных, диск)",
-                "Проблемы с зависимыми сервисами или API",
-                "Некорректное обновление или развертывание кода"
-            ])
-        elif anomaly_type == 'REPEATED_ERRORS':
-            causes.extend([
-                "Проблема в коде, которая воспроизводится при определённых условиях",
-                "Недостаточная обработка ошибок в цикле или повторяющемся процессе",
-                "Проблема конфигурации, влияющая на конкретную функциональность",
-                "Ресурсные ограничения (память, диск, соединения)"
-            ])
-        elif anomaly_type == 'ERROR_BEFORE_CRASH':
-            causes.extend([
-                "Критическая ошибка, приводящая к падению процесса",
-                "Исчерпание ресурсов (память, дескрипторы файлов)",
-                "Некорректное состояние приложения после длительной работы",
-                "Проблемы с внешними зависимостями"
-            ])
-        elif anomaly_type == 'TEMPORAL_SPIKE':
-            causes.extend([
-                "Плановые задачи (cron jobs, scheduled tasks)",
-                "Резкое увеличение нагрузки от пользователей",
-                "Внешние события, вызывающие массовые запросы",
-                "Проблемы с кэшированием или сессиями"
-            ])
-        elif anomaly_type == 'REPEATED_STACK_TRACES':
-            causes.extend([
-                "Необработанное исключение в часто вызываемом коде",
-                "Проблема в библиотеке или зависимостях",
-                "Некорректные входные данные, вызывающие исключение",
-                "Race condition или проблема конкурентности"
-            ])
-        else:
-            causes.append("Требуется дополнительный анализ для определения первопричины")
-        
-        return causes
-    
-    def _generate_recommendations(self, anomalies: List[Dict]) -> List[Dict[str, Any]]:
-        """Генерирует рекомендации на основе обнаруженных аномалий."""
-        recommendations = []
-        
-        # Группировка по типам для приоритизации
-        anomaly_types = [a.get('type') for a in anomalies]
-        severities = [a.get('severity') for a in anomalies]
-        
-        has_critical = any(s == 'CRITICAL' for s in severities)
-        has_high = any(s == 'HIGH' for s in severities)
-        has_burst = 'BURST_ERRORS' in anomaly_types
-        has_crash = 'ERROR_BEFORE_CRASH' in anomaly_types
-        
-        # Критические рекомендации
-        if has_crash:
-            recommendations.append({
-                'priority': 'CRITICAL',
-                'text': 'Обнаружены признаки возможн��го краша системы. Требуется немедленное внимание.',
-                'actions': [
-                    'Проверить состояние системы и процессов',
-                    'Проанализировать последние ошибки перед крашем',
-                    'Убедиться, что мониторинг и алертинг настроены корректно',
-                    'Рассмотреть возможность отката последних изменений'
-                ]
-            })
-        
-        if has_burst:
-            recommendations.append({
-                'priority': 'HIGH',
-                'text': 'Обнаружены всплески ошибок. Необходимо определить источник нагрузки.',
-                'actions': [
-                    'Проверить метрики нагрузки (CPU, память, сеть)',
-                    'Изучить логи зависимых сервисов',
-                    'Проверить состояние базы данных и внешних API',
-                    'Рассмотреть возможность масштабирования или rate limiting'
-                ]
-            })
-        
-        # Рекомендации по повторяющимся ошибкам
-        if 'REPEATED_ERRORS' in anomaly_types:
-            recommendations.append({
-                'priority': 'HIGH',
-                'text': 'Обнаружены повторяющиеся ошибки. Требуется исправление в коде или конфигурации.',
-                'actions': [
-                    'Идентифицировать конкретный участок кода, вызывающий ошибку',
-                    'Добавить более детальное логирование для отладки',
-                    'Улучшить обработку ошибок с логированием контекста',
-                    'Провести code review проблемного участка'
-                ]
-            })
-        
-        # Рекомендации по stack traces
-        if 'REPEATED_STACK_TRACES' in anomaly_types:
-            recommendations.append({
-                'priority': 'MEDIUM',
-                'text': 'Обнаружены повторяющиеся stack traces. Необходимо исправить необработанные исключения.',
-                'actions': [
-                    'Найти и исправить источник исключения',
-                    'Добавить обработку исключений (try-except блоки)',
-                    'Улучшить валидацию входных данных',
-                    'Обновить проблемные библиотеки или зависимости'
-                ]
-            })
-        
-        # Общие рекомендации по мониторингу
-        if has_high or has_critical:
-            recommendations.append({
-                'priority': 'MEDIUM',
-                'text': 'Улучшить систему мониторинга и алертинга для раннего обнаружения проблем.',
-                'actions': [
-                    'Настроить алерты на критические ошибки',
-                    'Внедрить мониторинг метрик производительности',
-                    'Настроить дашборды для визуализации состояния системы',
-                    'Реализовать автоматические проверки здоровья (health checks)'
-                ]
-            })
-        
-        return recommendations
-    
-    def _generate_general_recommendations(self, anomalies: List[Dict], statistics: Dict) -> List[str]:
-        """Генерирует общие рекомендации."""
-        recommendations = []
-        
-        total = statistics.get('total', 0)
-        if total == 0:
-            return ["Логи не содержат аномалий. Система работает стабильно."]
-        
-        recommendations.append("Регулярно проверяйте логи на наличие паттернов и трендов")
-        recommendations.append("Настройте автоматическое уведомление о критических ошибках")
-        
-        if total > 10:
-            recommendations.append("Обнаружено значительное количество аномалий - рекомендуется провести комплексный анализ системы")
-        
-        recommendations.append("Ведите документацию по известным проблемам и их решениям")
-        recommendations.append("Рассмотрите возможность внедрения централизованного логирования (ELK, Splunk и т.д.)")
-        
-        return recommendations
-    
-    def _get_anomaly_type_name(self, anomaly_type: str) -> str:
-        """Возвращает читаемое название типа аномалии."""
-        names = {
-            'BURST_ERRORS': 'Всплески ошибок',
-            'REPEATED_ERRORS': 'Повторяющиеся ошибки',
-            'ERROR_BEFORE_CRASH': 'Ошибки перед крашем',
-            'TEMPORAL_SPIKE': 'Временные всплески',
-            'REPEATED_STACK_TRACES': 'Повторяющиеся stack traces'
-        }
-        return names.get(anomaly_type, anomaly_type)
-    
-    def _get_severity_emoji(self, severity: str) -> str:
-        """Возвращает emoji для уровня серьёзности."""
-        emoji_map = {
-            'CRITICAL': '🔴',
-            'HIGH': '🟠',
-            'MEDIUM': '🟡',
-            'LOW': '🟢'
-        }
-        return emoji_map.get(severity, '⚪')
-    
-    def _get_priority_emoji(self, priority: str) -> str:
-        """Возвращает emoji для приоритета."""
-        emoji_map = {
-            'CRITICAL': '🔴',
-            'HIGH': '🟠',
-            'MEDIUM': '🟡',
-            'LOW': '🟢'
-        }
-        return emoji_map.get(priority, '⚪')
-    
-    def _init_root_cause_templates(self) -> Dict[str, List[str]]:
-        """Инициализирует шаблоны первопричин."""
-        return {}
-    
-    def _init_recommendation_templates(self) -> Dict[str, List[str]]:
-        """Инициализирует шаблоны рекомендаций."""
-        return {}
-    
-    def _generate_no_anomalies_report(self) -> str:
-        """Генерирует отчёт, когда аномалий не обнаружено."""
-        return """# Анализ первопричин и рекомендации
-
-## Результаты анализа
-
-**Обнаружено аномалий:** 0
-
-✅ **Система работает стабильно.** В логах не обнаружено значительных аномалий или паттернов, указывающих на проблемы.
-
-### Общие рекомендации
-
-- Продолжайте регулярный мониторинг логов
-- Поддерживайте текущий уровень логирования
-- Настройте автоматические проверки для раннего обнаружения проблем
-- Регулярно просматривайте метрики производительности
-"""