add

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,12 +1,231 @@
----
-title: MultiAgentLogsAnalyze
-emoji: 🔥
-colorFrom: gray
-colorTo: indigo
-sdk: gradio
-sdk_version: 6.2.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: MultiAgentLogsAnalyze
+emoji: 🔥
+colorFrom: gray
+colorTo: indigo
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+---
+
+# 🔍 Мультиагентная система анализа логов
+
+Интерактивное веб-приложение для автоматизированного анализа лог-файлов с использованием трёх логически разделённых агентов.
+
+## 📋 Описание
+
+Система обеспечивает автоматизированный анализ логов с:
+- Структурированием данных
+- Выявлением аномалий
+- Интерпретацией причин и выдачей рекомендаций
+
+## 🏗️ Архитектура
+
+Проект реализован как мультиагентная система с **строго 3 независимыми агентами**, каждый из которых выполняет определённую функцию в цепочке анализа.
+
+### Агент 1: Log Parser Agent (`agents/parser_agent.py`)
+
+**Назначение:** Преобразование сырых логов в структурированное представление.
+
+**Функциональность:**
+- Разбор строк логов
+- Извлечение временных меток
+- Определение уровней логирования (INFO, WARNING, ERROR, CRITICAL, DEBUG)
+- Извлечение сообщений
+- Группировка по типам событий (CONNECTION, HTTP_REQUEST, DATABASE, AUTHENTICATION, EXCEPTION, SYSTEM, GENERAL)
+
+**Выход:** Структурированный JSON-объект с полями:
+- `events` - список всех распарсенных событий
+- `errors` - список ошибок
+- `warnings` - список предупреждений
+- `statistics` - статистика по логам
+
+### Агент 2: Anomaly Detection Agent (`agents/anomaly_agent.py`)
+
+**Назначение:** Выявление аномалий и подозрительных паттернов в структурированных логах.
+
+**Функциональность:**
+- Подсчёт частоты событий
+- Поиск повторяющихся ошибок
+- Обнаружение временных всплесков
+- Эвристический анализ последовательностей событий
+
+**Типы обнаруживаемых аномалий:**
+- **BURST_ERRORS** - всплески ошибок (более 5 ошибок в короткий промежуток времени)
+- **REPEATED_ERRORS** - повторяющиеся ошибки (одна и та же ошибка более 3 раз)
+- **ERROR_BEFORE_CRASH** - паттерны "ошибка перед крашем"
+- **TEMPORAL_SPIKE** - временные всплески событий (превышение среднего в 2 раза)
+- **REPEATED_STACK_TRACES** - повторяющиеся stack traces
+
+**Выход:** JSON-отчёт об аномалиях с описанием, метаданными и статистикой.
+
+### Агент 3: Root Cause & Recommendation Agent (`agents/rca_agent.py`)
+
+**Назначение:** Интерпретация аномалий и формирование рекомендаций.
+
+**Функциональность:**
+- Определение возможных первопричин на основе типа аномалий
+- Формирование человеко-читаемого отчёта в формате Markdown
+- Генерация рекомендаций по устранению проблем с приоритетами
+- Предоставление конкретных действий для решения проблем
+
+**Выход:** Markdown-текст с анализом первопричин и рекомендациями.
+
+## 🔄 Процесс анализа
+
+Анализ выполняется последовательно:
+
+1. **Пользователь** загружает или вставляет логи в интерфейс
+2. **Agent 1** (Log Parser) обрабатывает сырые логи → структурированный JSON
+3. **Agent 2** (Anomaly Detection) анализирует структурированные данные → отчёт об аномалиях
+4. **Agent 3** (Root Cause) интерпретирует аномалии → Markdown с рекомендациями
+5. **Результаты** отображаются в интерфейсе в трёх вкладках
+
+## 🚀 Использование
+
+### Локальный запуск
+
+1. Установите зависимости:
+```bash
+pip install -r requirements.txt
+```
+
+2. Запустите приложение:
+```bash
+python app.py
+```
+
+3. Откройте браузер по адресу `http://localhost:7860`
+
+### Использование в Hugging Face Spaces
+
+Приложение автоматически развернётся при загрузке на Hugging Face Spaces.
+
+## 📁 Структура проекта
+
+```
+MultiAgentLogsAnalyze/
+├── agents/
+│   ├── __init__.py          # Экспорт агентов
+│   ├── parser_agent.py      # Agent 1: Log Parser Agent
+│   ├── anomaly_agent.py     # Agent 2: Anomaly Detection Agent
+│   └── rca_agent.py         # Agent 3: Root Cause Agent
+├── app.py                   # Gradio приложение и оркестрация
+├── requirements.txt         # Зависимости Python
+├── README.md               # Документация проекта
+└── space_config.yaml       # Конфигурация для Hugging Face Spaces
+```
+
+## 🔧 Технические детали
+
+### Зависимости
+
+- `gradio>=4.0.0,<5.0.0` - веб-интерфейс
+
+Все агенты реализованы на чистом Python 3.10+ без использования LLM или трансформеров.
+
+### Производительность
+
+- Поддержка анализа до 10,000 строк логов
+- Время обработки ≤ 10 секунд для типичных логов
+
+### Обработка ошибок
+
+- Валидация входных данных
+- Обработка некорректных логов без падения приложения
+- Информативные сообщения об ошибках
+
+## 🎯 Пример использования
+
+### Пример входных логов:
+
+```
+2024-01-15 10:00:00 INFO Application started
+2024-01-15 10:00:05 INFO Database connection established
+2024-01-15 10:01:00 ERROR Connection timeout to external API
+2024-01-15 10:01:05 ERROR Connection timeout to external API
+2024-01-15 10:01:10 ERROR Connection timeout to external API
+2024-01-15 10:01:15 WARNING High memory usage detected: 85%
+2024-01-15 10:02:00 CRITICAL System crash detected
+2024-01-15 10:02:01 INFO Application shutdown
+```
+
+### Пример выхода Agent 1 (структурированные данные):
+
+```json
+{
+  "events": [
+    {
+      "line_number": 1,
+      "timestamp": "2024-01-15 10:00:00",
+      "level": "INFO",
+      "message": "Application started",
+      "type": "SYSTEM"
+    },
+    ...
+  ],
+  "errors": [...],
+  "warnings": [...],
+  "statistics": {
+    "total_lines": 8,
+    "parsed_events": 8,
+    "errors": 3,
+    "warnings": 1,
+    ...
+  }
+}
+```
+
+### Пример выхода Agent 2 (аномалии):
+
+```json
+{
+  "anomalies": [
+    {
+      "type": "BURST_ERRORS",
+      "severity": "HIGH",
+      "description": "Обнаружен всплеск из 3 последовательных ошибок",
+      "count": 3,
+      ...
+    },
+    {
+      "type": "ERROR_BEFORE_CRASH",
+      "severity": "CRITICAL",
+      "description": "Обнаружен паттерн: ошибка перед возможным крашем системы",
+      ...
+    }
+  ],
+  ...
+}
+```
+
+### Пример выхода Agent 3 (рекомендации):
+
+Markdown-отчёт с:
+- Анализом первопричин
+- Детальным описанием аномалий
+- Приоритизированными рекомендациями
+- Конкретными действиями для решения проблем
+
+## 🔌 Расширяемость
+
+Система разработана с учётом расширяемости:
+
+- **Независимые агенты:** Каждый агент реализован как отдельный класс и может быть заменён без изменения остальных
+- **Чёткий интерфейс:** Агенты взаимодействуют через стандартизированные форматы данных (JSON)
+- **Добавление новых правил:** Легко добавить новые типы аномалий в `AnomalyDetectionAgent`
+- **Кастомные парсеры:** Можно расширить `LogParserAgent` для поддержки новых форматов логов
+
+## 📝 Лицензия
+
+Этот проект создан в рамках технического задания для демонстрации мультиагентной архитектуры.
+
+## 🤝 Вклад
+
+Проект готов к расширению и улучшению. Возможные направления:
+- Поддержка дополнительных форматов логов
+- Интеграция с LLM для более глубокого анализа
+- Поддержка потоковой обработки больших файлов
+- Экспорт результатов в различные форматы
+- Интеграция с системами мониторинга

agents/anomaly_agent.py

@@ -0,0 +1,415 @@
+"""
+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

@@ -0,0 +1,217 @@
+"""
+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

@@ -0,0 +1,316 @@
+"""
+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
+
+✅ **Система работает стабильно.** В логах не обнаружено значительных аномалий или паттернов, указывающих на проблемы.
+
+### Общие рекомендации
+
+- Продолжайте регулярный мониторинг логов
+- Поддерживайте текущий уровень логирования
+- Настройте автоматические проверки для раннего обнаружения проблем
+- Регулярно просматривайте метрики производительности
+"""

app.py

@@ -0,0 +1,218 @@
+"""
+Gradio приложение для мультиагентной системы анализа логов.
+Оркестрирует работу трёх агентов и предоставляет веб-интерфейс.
+"""
+
+import gradio as gr
+import json
+from typing import Tuple, Dict, Any
+
+from agents import LogParserAgent, AnomalyDetectionAgent, RootCauseAgent
+
+
+class LogAnalysisOrchestrator:
+    """Оркестратор для последовательного выполнения агентов."""
+    
+    def __init__(self):
+        """Инициализация оркестратора и агентов."""
+        self.parser_agent = LogParserAgent()
+        self.anomaly_agent = AnomalyDetectionAgent()
+        self.rca_agent = RootCauseAgent()
+    
+    def analyze(self, raw_logs: str) -> Tuple[str, str, str]:
+        """
+        Выполняет полный цикл анализа логов через всех агентов.
+        
+        Args:
+            raw_logs: Сырые логи в виде строки
+            
+        Returns:
+            Кортеж из трёх строк:
+            - JSON с распарсенными логами
+            - JSON с обнаруженными аномалиями
+            - Markdown с рекомендациями
+        """
+        try:
+            # Валидация входных данных
+            if not raw_logs or not raw_logs.strip():
+                empty_json = json.dumps({"error": "Логи не предоставлены"}, ensure_ascii=False, indent=2)
+                return empty_json, empty_json, "# Ошибка\n\nЛоги не предоставлены для анализа."
+            
+            # Agent 1: Парсинг логов
+            try:
+                structured_data = self.parser_agent.parse(raw_logs)
+                parsed_json = json.dumps(structured_data, ensure_ascii=False, indent=2)
+            except Exception as e:
+                error_msg = {"error": f"Ошибка парсинга логов: {str(e)}"}
+                parsed_json = json.dumps(error_msg, ensure_ascii=False, indent=2)
+                return parsed_json, parsed_json, f"# Ошибка\n\nОшибка на этапе парсинга: {str(e)}"
+            
+            # Agent 2: Обнаружение аномалий
+            try:
+                anomaly_report = self.anomaly_agent.detect(structured_data)
+                anomalies_json = json.dumps(anomaly_report, ensure_ascii=False, indent=2)
+            except Exception as e:
+                error_msg = {"error": f"Ошибка обнаружения аномалий: {str(e)}"}
+                anomalies_json = json.dumps(error_msg, ensure_ascii=False, indent=2)
+                return parsed_json, anomalies_json, f"# Ошибка\n\nОшибка на этапе обнаружения аномалий: {str(e)}"
+            
+            # Agent 3: Анализ первопричин и рекомендации
+            try:
+                recommendations_md = self.rca_agent.analyze(anomaly_report)
+            except Exception as e:
+                recommendations_md = f"# Ошибка\n\nОшибка на этапе анализа первопричин: {str(e)}"
+            
+            return parsed_json, anomalies_json, recommendations_md
+            
+        except Exception as e:
+            error_json = json.dumps({"error": f"Критическая ошибка: {str(e)}"}, ensure_ascii=False, indent=2)
+            return error_json, error_json, f"# Критическая ошибка\n\n{str(e)}"
+
+
+# Глобальный экземпляр оркестратора
+orchestrator = LogAnalysisOrchestrator()
+
+
+def analyze_logs(raw_logs: str) -> Tuple[str, str, str]:
+    """
+    Обёртка для Gradio интерфейса.
+    
+    Args:
+        raw_logs: Сырые логи из интерфейса
+        
+    Returns:
+        Кортеж результатов для отображения
+    """
+    return orchestrator.analyze(raw_logs)
+
+
+def create_interface():
+    """Создаёт и настраивает Gradio интерфейс."""
+    
+    # Описание интерфейса
+    description = """
+    # 🔍 Мультиагентная система анализа логов
+    
+    Система использует трёх независимых агентов для анализа логов:
+    1. **Log Parser Agent** - парсит и структурирует логи
+    2. **Anomaly Detection Agent** - обнаруживает аномалии и паттерны
+    3. **Root Cause Agent** - анализирует первопричины и генерирует рекомендации
+    
+    Вставьте логи в поле ниже или загрузите лог-файл, затем нажм��те "Анализировать".
+    """
+    
+    # Создание интерфейса
+    with gr.Blocks(title="Multi-Agent Log Analysis") as app:
+        gr.Markdown(description)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                log_input = gr.Textbox(
+                    label="Логи для анализа",
+                    placeholder="Вставьте логи здесь или используйте кнопку загрузки ниже...",
+                    lines=15,
+                    max_lines=30
+                )
+                
+                upload_btn = gr.UploadButton(
+                    "📁 Загрузить лог-файл",
+                    file_types=[".log", ".txt"],
+                    file_count="single"
+                )
+                
+                analyze_btn = gr.Button("🔍 Анализировать", variant="primary", size="lg")
+                
+                # Обработчик загрузки файла
+                def load_file(file):
+                    if file is None:
+                        return ""
+                    try:
+                        with open(file.name, 'r', encoding='utf-8') as f:
+                            content = f.read()
+                        return content
+                    except Exception as e:
+                        return f"Ошибка чтения файла: {str(e)}"
+                
+                upload_btn.upload(load_file, inputs=upload_btn, outputs=log_input)
+        
+        with gr.Row():
+            with gr.Tabs():
+                with gr.Tab("📊 Распарсенные логи (JSON)"):
+                    parsed_output = gr.JSON(
+                        label="Структурированные данные"
+                    )
+                
+                with gr.Tab("⚠️ Обнаруженные аномалии (JSON)"):
+                    anomalies_output = gr.JSON(
+                        label="Отчёт об аномалиях"
+                    )
+                
+                with gr.Tab("💡 Анализ и рекомендации (Markdown)"):
+                    recommendations_output = gr.Markdown(
+                        label="Рекомендации по устранению проблем"
+                    )
+        
+        # Примеры логов для тестирования
+        gr.Markdown("### 📝 Примеры логов для тестирования")
+        with gr.Row():
+            example_logs = [
+                """2024-01-15 10:00:00 INFO Application started
+2024-01-15 10:00:05 INFO Database connection established
+2024-01-15 10:01:00 ERROR Connection timeout to external API
+2024-01-15 10:01:05 ERROR Connection timeout to external API
+2024-01-15 10:01:10 ERROR Connection timeout to external API
+2024-01-15 10:01:15 WARNING High memory usage detected: 85%
+2024-01-15 10:02:00 CRITICAL System crash detected
+2024-01-15 10:02:01 INFO Application shutdown""",
+                
+                """[2024-01-15 14:30:00] INFO User authentication successful
+[2024-01-15 14:30:01] DEBUG Request received: GET /api/users
+[2024-01-15 14:30:02] ERROR Database query failed: connection lost
+[2024-01-15 14:30:03] ERROR Database query failed: connection lost
+[2024-01-15 14:30:04] ERROR Database query failed: connection lost
+[2024-01-15 14:30:05] ERROR Database query failed: connection lost
+[2024-01-15 14:30:06] WARNING Retrying database connection
+[2024-01-15 14:30:10] INFO Database connection restored"""
+            ]
+            
+            example_btn1 = gr.Button("Загрузить пример 1", size="sm")
+            example_btn2 = gr.Button("Загрузить пример 2", size="sm")
+            
+            example_btn1.click(
+                lambda: example_logs[0],
+                outputs=log_input
+            )
+            
+            example_btn2.click(
+                lambda: example_logs[1],
+                outputs=log_input
+            )
+        
+        # Связывание кнопки анализа с обработчиком
+        analyze_btn.click(
+            fn=analyze_logs,
+            inputs=log_input,
+            outputs=[parsed_output, anomalies_output, recommendations_output]
+        )
+        
+        # Информация о системе
+        gr.Markdown("""
+        ---
+        ### ℹ️ Информация о системе
+        
+        - **Архитектура:** Мультиагентная система (3 независимых агента)
+        - **Платформа:** Hugging Face Spaces
+        - **Интерфейс:** Gradio
+        - **Поддержка:** До 10,000 строк логов
+        """)
+    
+    return app
+
+
+# Создание и запуск приложения
+if __name__ == "__main__":
+    app = create_interface()
+    app.launch(server_name="0.0.0.0", server_port=7860, theme=gr.themes.Soft())
+else:
+    # Для Hugging Face Spaces
+    app = create_interface()

requirements.txt

@@ -0,0 +1,2 @@
+gradio>=4.0.0,<5.0.0
+pillow>=11.0

run.bat

@@ -0,0 +1,5 @@
+@echo off
+echo Starting Multi-Agent Log Analysis System...
+echo.
+python app.py
+pause

space_config.yaml

@@ -0,0 +1,11 @@
+# Конфигурация для Hugging Face Spaces
+# Эта конфигурация также может быть указана в README.md через фронт-матер
+
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+title: Multi-Agent Log Analysis System
+emoji: 🔥
+colorFrom: gray
+colorTo: indigo
+pinned: false

test_large_logs.py

@@ -0,0 +1,468 @@
+"""
+Генератор больших тестовых лог-файлов и скрипт для тестирования системы.
+"""
+
+import random
+import os
+from datetime import datetime, timedelta
+from agents import LogParserAgent, AnomalyDetectionAgent, RootCauseAgent
+import time
+
+def generate_log_entry(timestamp, level, message_template, **kwargs):
+    """Генерирует одну запись лога."""
+    message = message_template.format(**kwargs)
+    return f"{timestamp.strftime('%Y-%m-%d %H:%M:%S')} {level} {message}\n"
+
+def generate_log_file_1():
+    """Лог-файл 1: Обычные логи с редкими ошибками (3000 строк)"""
+    lines = []
+    base_time = datetime(2024, 1, 15, 10, 0, 0)
+    
+    messages = [
+        "User {user_id} logged in from IP {ip}",
+        "Request GET /api/users/{user_id} processed successfully",
+        "Database query executed in {time}ms",
+        "Cache hit for key: {key}",
+        "Request POST /api/data processed in {time}ms",
+        "Session {session_id} created",
+        "File {filename} uploaded successfully",
+        "Processing job {job_id} started",
+        "Background task {task_id} completed",
+    ]
+    
+    error_messages = [
+        "Connection timeout to external API: {api_url}",
+        "Database connection lost, retrying...",
+        "Invalid token received from user {user_id}",
+    ]
+    
+    for i in range(3000):
+        timestamp = base_time + timedelta(seconds=i * 2)
+        
+        if i % 100 == 0:  # Каждая 100-я строка - ошибка
+            level = random.choice(["ERROR", "WARNING"])
+            template = random.choice(error_messages)
+            message = template.format(
+                api_url=f"api-{random.randint(1,5)}.example.com",
+                user_id=random.randint(1000, 9999),
+            )
+        else:
+            level = "INFO"
+            template = random.choice(messages)
+            message = template.format(
+                user_id=random.randint(1000, 9999),
+                ip=f"192.168.{random.randint(1,255)}.{random.randint(1,255)}",
+                time=random.randint(10, 500),
+                key=f"cache_key_{random.randint(1,100)}",
+                session_id=f"session_{random.randint(10000,99999)}",
+                filename=f"file_{random.randint(1,1000)}.txt",
+                job_id=random.randint(1000, 9999),
+                task_id=random.randint(10000, 99999),
+            )
+        
+        lines.append(f"{timestamp.strftime('%Y-%m-%d %H:%M:%S')} {level} {message}\n")
+    
+    return ''.join(lines)
+
+def generate_log_file_2():
+    """Лог-файл 2: Burst errors (5000 строк с всплеском ошибок)"""
+    lines = []
+    base_time = datetime(2024, 1, 15, 14, 0, 0)
+    
+    for i in range(5000):
+        timestamp = base_time + timedelta(seconds=i)
+        
+        # Всплеск ошибок между 2000-2050 строками
+        if 2000 <= i < 2050:
+            level = random.choice(["ERROR", "ERROR", "ERROR", "CRITICAL"])
+            message = f"Database connection failed: unable to connect to host db-{random.randint(1,3)}.internal"
+        elif 2050 <= i < 2060:
+            level = "WARNING"
+            message = f"High latency detected: {random.randint(5000, 15000)}ms response time"
+        else:
+            level = "INFO"
+            message = f"Request processed: {random.choice(['GET', 'POST', 'PUT'])} /api/v1/{random.choice(['users', 'data', 'files'])}"
+        
+        lines.append(f"{timestamp.strftime('%Y-%m-%d %H:%M:%S')} {level} {message}\n")
+    
+    return ''.join(lines)
+
+def generate_log_file_3():
+    """Лог-файл 3: Повторяющиеся ошибки (4000 строк)"""
+    lines = []
+    base_time = datetime(2024, 1, 15, 16, 0, 0)
+    
+    repeated_error = "Authentication failed for user admin@example.com: invalid credentials"
+    
+    for i in range(4000):
+        timestamp = base_time + timedelta(seconds=i * 3)
+        
+        # Одна и та же ошибка повторяется каждые 50 строк
+        if i % 50 == 0:
+            level = "ERROR"
+            message = repeated_error
+        elif i % 75 == 0:
+            level = "WARNING"
+            message = f"Rate limit approaching: {random.randint(80, 95)}% of limit used"
+        else:
+            level = "INFO"
+            message = f"HTTP {random.choice([200, 200, 200, 201, 304])} {random.choice(['GET', 'POST'])} /api/{random.choice(['users', 'orders', 'products'])}"
+        
+        lines.append(f"{timestamp.strftime('%Y-%m-%d %H:%M:%S')} {level} {message}\n")
+    
+    return ''.join(lines)
+
+def generate_log_file_4():
+    """Лог-файл 4: Stack traces (3500 строк)"""
+    lines = []
+    base_time = datetime(2024, 1, 15, 18, 0, 0)
+    
+    stack_trace = """Traceback (most recent call last):
+  File "/app/services/api.py", line {line}, in process_request
+    result = external_api.call(data)
+  File "/app/lib/external_api.py", line {line2}, in call
+    raise ConnectionError("Service unavailable")
+ConnectionError: Service unavailable"""
+    
+    for i in range(3500):
+        timestamp = base_time + timedelta(seconds=i * 2)
+        
+        if i % 200 == 0:
+            level = "ERROR"
+            message = stack_trace.format(
+                line=random.randint(100, 500),
+                line2=random.randint(50, 300)
+            )
+        else:
+            level = random.choice(["INFO", "DEBUG"])
+            message = f"Processing request {random.randint(10000, 99999)}"
+        
+        lines.append(f"{timestamp.strftime('%Y-%m-%d %H:%M:%S')} {level} {message}\n")
+    
+    return ''.join(lines)
+
+def generate_log_file_5():
+    """Лог-файл 5: Временные всплески (4500 строк)"""
+    lines = []
+    base_time = datetime(2024, 1, 16, 8, 0, 0)
+    
+    for i in range(4500):
+        # Группируем по минутам для создания всплесков
+        timestamp = base_time + timedelta(minutes=i // 60, seconds=i % 60)
+        
+        # Всплески в определённые минуты
+        minute = (i // 60) % 60
+        if minute in [5, 15, 25, 35, 45]:
+            # Много событий в эти минуты
+            level = random.choice(["INFO", "INFO", "INFO", "WARNING", "ERROR"])
+            message = f"High traffic: {random.randint(100, 1000)} requests/min"
+        else:
+            level = "INFO"
+            message = f"Normal traffic: {random.randint(10, 50)} requests/min"
+        
+        lines.append(f"{timestamp.strftime('%Y-%m-%d %H:%M:%S')} {level} {message}\n")
+    
+    return ''.join(lines)
+
+def generate_log_file_6():
+    """Лог-файл 6: Ошибка перед крашем (3000 строк)"""
+    lines = []
+    base_time = datetime(2024, 1, 16, 12, 0, 0)
+    
+    for i in range(3000):
+        timestamp = base_time + timedelta(seconds=i)
+        
+        # Последние 50 строк - критические ошибки
+        if i >= 2950:
+            level = random.choice(["CRITICAL", "ERROR"])
+            messages = [
+                "Out of memory: cannot allocate additional resources",
+                "Fatal error: database connection pool exhausted",
+                "Critical: unable to process requests, system overloaded",
+                "ERROR: Service unavailable, shutting down",
+            ]
+            message = random.choice(messages)
+        elif i >= 2900:
+            level = "ERROR"
+            message = f"System resource exhaustion detected: memory usage {random.randint(95, 99)}%"
+        else:
+            level = random.choice(["INFO", "DEBUG"])
+            message = f"System operation: {random.choice(['cache_update', 'db_query', 'api_call'])}"
+        
+        lines.append(f"{timestamp.strftime('%Y-%m-%d %H:%M:%S')} {level} {message}\n")
+    
+    return ''.join(lines)
+
+def generate_log_file_7():
+    """Лог-файл 7: Разнообразные форматы логов (4000 строк)"""
+    lines = []
+    base_time = datetime(2024, 1, 16, 14, 30, 0)
+    
+    formats = [
+        "{timestamp} [{level}] {message}",
+        "[{timestamp}] {level}: {message}",
+        "{timestamp} {level} - {message}",
+    ]
+    
+    for i in range(4000):
+        timestamp = base_time + timedelta(seconds=i * 2)
+        level = random.choice(["INFO", "WARNING", "ERROR", "DEBUG"])
+        
+        if level == "ERROR" and i % 100 == 0:
+            message = f"Error processing transaction {random.randint(100000, 999999)}"
+        else:
+            message = f"Event {i}: {random.choice(['user_action', 'system_check', 'data_sync'])}"
+        
+        fmt = random.choice(formats)
+        if fmt.startswith("["):
+            lines.append(fmt.format(
+                timestamp=timestamp.strftime('%Y-%m-%d %H:%M:%S'),
+                level=level,
+                message=message
+            ) + "\n")
+        else:
+            lines.append(fmt.format(
+                timestamp=timestamp.strftime('%Y-%m-%d %H:%M:%S'),
+                level=level,
+                message=message
+            ) + "\n")
+    
+    return ''.join(lines)
+
+def generate_log_file_8():
+    """Лог-файл 8: Смешанные паттерны (5000 строк)"""
+    lines = []
+    base_time = datetime(2024, 1, 17, 9, 0, 0)
+    
+    for i in range(5000):
+        timestamp = base_time + timedelta(seconds=i)
+        
+        # Разные паттерны в разных секциях
+        if 1000 <= i < 1100:
+            # Burst errors
+            level = "ERROR"
+            message = f"API endpoint /api/data failed: {random.choice(['timeout', '500', 'connection refused'])}"
+        elif 2000 <= i < 2100 and i % 10 == 0:
+            # Repeated errors
+            level = "ERROR"
+            message = "Validation error: email format is invalid"
+        elif 3000 <= i < 3050:
+            # Stack traces
+            level = "ERROR"
+            message = f"Exception in handler: ValueError at line {random.randint(1, 500)}"
+        elif i >= 4900:
+            # Error before crash
+            level = random.choice(["CRITICAL", "ERROR"])
+            message = "System failure: critical service unavailable"
+        else:
+            level = "INFO"
+            message = f"Normal operation: {random.choice(['request', 'response', 'cache', 'db'])} processed"
+        
+        lines.append(f"{timestamp.strftime('%Y-%m-%d %H:%M:%S')} {level} {message}\n")
+    
+    return ''.join(lines)
+
+def generate_log_file_9():
+    """Лог-файл 9: Web server logs format (4500 строк)"""
+    lines = []
+    base_time = datetime(2024, 1, 17, 15, 0, 0)
+    
+    ips = [f"192.168.{x}.{y}" for x in range(1, 10) for y in range(1, 50)]
+    
+    for i in range(4500):
+        timestamp = base_time + timedelta(seconds=i)
+        ip = random.choice(ips)
+        method = random.choice(["GET", "POST", "PUT", "DELETE"])
+        endpoint = random.choice(["/api/users", "/api/orders", "/api/products", "/static/css", "/static/js"])
+        status = random.choice([200, 200, 200, 201, 404, 500, 503])
+        
+        if status >= 500:
+            level = "ERROR"
+        elif status >= 400:
+            level = "WARNING"
+        else:
+            level = "INFO"
+        
+        message = f'{ip} - - [{timestamp.strftime("%d/%b/%Y:%H:%M:%S")}] "{method} {endpoint} HTTP/1.1" {status} {random.randint(100, 5000)}'
+        lines.append(f"{timestamp.strftime('%Y-%m-%d %H:%M:%S')} {level} {message}\n")
+    
+    return ''.join(lines)
+
+def generate_log_file_10():
+    """Лог-файл 10: Application logs с метаданными (4000 строк)"""
+    lines = []
+    base_time = datetime(2024, 1, 18, 10, 0, 0)
+    
+    for i in range(4000):
+        timestamp = base_time + timedelta(seconds=i * 2)
+        
+        # Периодические проблемы
+        if i % 300 == 0:
+            level = "ERROR"
+            message = f"Service health check failed: service-{random.randint(1, 5)}.internal is down"
+        elif i % 150 == 0:
+            level = "WARNING"
+            message = f"Performance degradation: p95 latency increased to {random.randint(1000, 5000)}ms"
+        elif 3500 <= i < 3600:
+            # Проблемы перед концом
+            level = random.choice(["ERROR", "WARNING"])
+            message = f"Resource constraint: {random.choice(['CPU', 'Memory', 'Disk'])} usage critical"
+        else:
+            level = "INFO"
+            message = f"[thread-{random.randint(1, 20)}] Processing job {random.randint(10000, 99999)}: status={random.choice(['completed', 'in_progress'])}"
+        
+        lines.append(f"{timestamp.strftime('%Y-%m-%d %H:%M:%S')} {level} {message}\n")
+    
+    return ''.join(lines)
+
+def test_log_file(content, file_num):
+    """Тестирует обработку одного лог-файла."""
+    print(f"\n{'='*60}")
+    print(f"Testing log file {file_num}")
+    print(f"{'='*60}")
+    
+    # Подсчёт строк
+    line_count = len(content.split('\n'))
+    print(f"Lines in file: {line_count}")
+    
+    # Замер времени
+    start_time = time.time()
+    
+    # Agent 1: Парсинг
+    parser = LogParserAgent()
+    parsed_start = time.time()
+    structured_data = parser.parse(content)
+    parsed_time = time.time() - parsed_start
+    
+    events_count = len(structured_data.get('events', []))
+    errors_count = len(structured_data.get('errors', []))
+    warnings_count = len(structured_data.get('warnings', []))
+    
+    print(f"\n[OK] Agent 1 (Parser): {parsed_time:.2f} sec")
+    print(f"  - Events: {events_count}")
+    print(f"  - Errors: {errors_count}")
+    print(f"  - Warnings: {warnings_count}")
+    
+    # Agent 2: Обнаружение аномалий
+    anomaly_start = time.time()
+    anomaly_agent = AnomalyDetectionAgent()
+    anomaly_report = anomaly_agent.detect(structured_data)
+    anomaly_time = time.time() - anomaly_start
+    
+    anomalies_count = len(anomaly_report.get('anomalies', []))
+    print(f"\n[OK] Agent 2 (Anomaly Detection): {anomaly_time:.2f} sec")
+    print(f"  - Anomalies detected: {anomalies_count}")
+    
+    if anomalies_count > 0:
+        by_type = anomaly_report.get('statistics', {}).get('by_type', {})
+        for anomaly_type, count in by_type.items():
+            print(f"    - {anomaly_type}: {count}")
+    
+    # Agent 3: Анализ первопричин
+    rca_start = time.time()
+    rca_agent = RootCauseAgent()
+    recommendations = rca_agent.analyze(anomaly_report)
+    rca_time = time.time() - rca_start
+    
+    print(f"\n[OK] Agent 3 (Root Cause Analysis): {rca_time:.2f} sec")
+    print(f"  - Report size: {len(recommendations)} characters")
+    
+    total_time = time.time() - start_time
+    print(f"\n[TIME] Total processing time: {total_time:.2f} sec")
+    print(f"   Speed: {line_count / total_time:.0f} lines/sec")
+    
+    return {
+        'file_num': file_num,
+        'lines': line_count,
+        'events': events_count,
+        'errors': errors_count,
+        'warnings': warnings_count,
+        'anomalies': anomalies_count,
+        'parsed_time': parsed_time,
+        'anomaly_time': anomaly_time,
+        'rca_time': rca_time,
+        'total_time': total_time
+    }
+
+def main():
+    """Главная функция для генерации и тестирования."""
+    print("=" * 60)
+    print("ГЕНЕРАЦИЯ И ТЕСТИРОВАНИЕ БОЛЬШИХ ЛОГ-ФАЙЛОВ")
+    print("=" * 60)
+    
+    # Создаём папку для тестовых файлов
+    test_dir = "test_logs"
+    os.makedirs(test_dir, exist_ok=True)
+    
+    # Генераторы лог-файлов
+    generators = [
+        ("normal_logs.log", generate_log_file_1),
+        ("burst_errors.log", generate_log_file_2),
+        ("repeated_errors.log", generate_log_file_3),
+        ("stack_traces.log", generate_log_file_4),
+        ("temporal_spikes.log", generate_log_file_5),
+        ("error_before_crash.log", generate_log_file_6),
+        ("mixed_formats.log", generate_log_file_7),
+        ("mixed_patterns.log", generate_log_file_8),
+        ("web_server.log", generate_log_file_9),
+        ("application_metadata.log", generate_log_file_10),
+    ]
+    
+    # Генерируем файлы
+    print(f"\n[GENERATING] Generating {len(generators)} test files...")
+    files_data = []
+    
+    for filename, generator in generators:
+        filepath = os.path.join(test_dir, filename)
+        print(f"  Generating: {filename}...", end=" ")
+        content = generator()
+        with open(filepath, 'w', encoding='utf-8') as f:
+            f.write(content)
+        
+        line_count = len(content.split('\n'))
+        file_size = len(content.encode('utf-8')) / 1024  # KB
+        print(f"OK ({line_count} lines, {file_size:.1f} KB)")
+        files_data.append((filepath, content))
+    
+    print(f"\n[SUCCESS] All files created in '{test_dir}' folder")
+    
+    # Тестируем каждый файл
+    print(f"\n[TESTING] Starting tests...")
+    results = []
+    
+    for i, (filepath, content) in enumerate(files_data, 1):
+        result = test_log_file(content, i)
+        results.append(result)
+    
+    # Итоговая статистика
+    print(f"\n\n{'='*60}")
+    print("SUMMARY STATISTICS")
+    print(f"{'='*60}")
+    print(f"\n{'#':<3} {'Lines':<8} {'Time (sec)':<12} {'Lines/sec':<12} {'Anomalies':<10}")
+    print("-" * 60)
+    
+    total_lines = 0
+    total_time = 0
+    
+    for result in results:
+        speed = result['lines'] / result['total_time'] if result['total_time'] > 0 else 0
+        print(f"{result['file_num']:<3} {result['lines']:<8} {result['total_time']:<12.2f} {speed:<12.0f} {result['anomalies']:<10}")
+        total_lines += result['lines']
+        total_time += result['total_time']
+    
+    print("-" * 60)
+    avg_speed = total_lines / total_time if total_time > 0 else 0
+    print(f"{'TOTAL':<3} {total_lines:<8} {total_time:<12.2f} {avg_speed:<12.0f}")
+    
+    print(f"\n[SUCCESS] Testing completed!")
+    print(f"   Total processed: {total_lines} lines in {total_time:.2f} seconds")
+    print(f"   Average speed: {avg_speed:.0f} lines/sec")
+    
+    # Проверка производительности
+    if total_time > 100:  # Если больше 100 секунд для всех файлов
+        print(f"\n[WARNING] Total processing time exceeds 100 seconds")
+    else:
+        print(f"\n[OK] Performance is within normal range (<100 sec for all files)")
+
+if __name__ == "__main__":
+    main()