nginx-lens 0.3.4__tar.gz → 0.4.0__tar.gz

{nginx_lens-0.3.4/nginx_lens.egg-info → nginx_lens-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nginx-lens
-Version: 0.3.4
+Version: 0.4.0
 Summary: CLI-инструмент для анализа, визуализации и диагностики конфигураций Nginx
 Author: Daniil Astrouski
 Author-email: shelovesuastra@gmail.com
@@ -10,9 +10,14 @@ Requires-Dist: typer[all]>=0.9.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: requests>=2.25.0
 Requires-Dist: dnspython>=2.0.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
 Dynamic: author
 Dynamic: author-email
 Dynamic: license-file
+Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary

{nginx_lens-0.3.4 → nginx_lens-0.4.0}/commands/analyze.py

@@ -1,3 +1,4 @@
+import sys
 import typer
 from rich.console import Console
 from rich.table import Table
@@ -9,6 +10,7 @@ from analyzer.unused import find_unused_variables
 from parser.nginx_parser import parse_nginx_config
 from analyzer.rewrite import find_rewrite_issues
 from analyzer.dead_locations import find_dead_locations
+from exporter.json_yaml import format_analyze_results, print_export
 
 app = typer.Typer()
 console = Console()
@@ -41,7 +43,11 @@ ISSUE_META = {
 }
 SEVERITY_COLOR = {"high": "red", "medium": "orange3", "low": "yellow"}
 
-def analyze(config_path: str = typer.Argument(..., help="Путь к nginx.conf")):
+def analyze(
+    config_path: str = typer.Argument(..., help="Путь к nginx.conf"),
+    json: bool = typer.Option(False, "--json", help="Экспортировать результаты в JSON"),
+    yaml: bool = typer.Option(False, "--yaml", help="Экспортировать результаты в YAML"),
+):
     """
     Анализирует конфигурацию Nginx на типовые проблемы и best practices.
 
@@ -62,10 +68,10 @@ def analyze(config_path: str = typer.Argument(..., help="Путь к nginx.conf"
         tree = parse_nginx_config(config_path)
     except FileNotFoundError:
         console.print(f"[red]Файл {config_path} не найден. Проверьте путь к конфигу.[/red]")
-        return
+        sys.exit(1)
     except Exception as e:
         console.print(f"[red]Ошибка при разборе {config_path}: {e}[/red]")
-        return
+        sys.exit(1)
     conflicts = find_location_conflicts(tree)
     dups = find_duplicate_directives(tree)
     empties = find_empty_blocks(tree)

{nginx_lens-0.3.4 → nginx_lens-0.4.0}/commands/diff.py

@@ -1,3 +1,4 @@
+import sys
 import typer
 from rich.console import Console
 from rich.table import Table
@@ -24,10 +25,10 @@ def diff(
             lines2 = f2.readlines()
     except FileNotFoundError as e:
         console.print(f"[red]Файл {e.filename} не найден. Проверьте путь к конфигу.[/red]")
-        return
+        sys.exit(1)
     except Exception as e:
         console.print(f"[red]Ошибка при чтении файлов: {e}[/red]")
-        return
+        sys.exit(1)
     maxlen = max(len(lines1), len(lines2))
     # Выравниваем длины
     lines1 += [''] * (maxlen - len(lines1))

{nginx_lens-0.3.4 → nginx_lens-0.4.0}/commands/graph.py

@@ -1,3 +1,4 @@
+import sys
 import typer
 from rich.console import Console
 from parser.nginx_parser import parse_nginx_config
@@ -21,10 +22,10 @@ def graph(
         tree = parse_nginx_config(config_path)
     except FileNotFoundError:
         console.print(f"[red]Файл {config_path} не найден. Проверьте путь к конфигу.[/red]")
-        return
+        sys.exit(1)
     except Exception as e:
         console.print(f"[red]Ошибка при разборе {config_path}: {e}[/red]")
-        return
+        sys.exit(1)
     routes = []
     # Для каждого server/location строим маршрут
     def walk(d, chain, upstreams):

{nginx_lens-0.3.4 → nginx_lens-0.4.0}/commands/health.py

@@ -4,6 +4,7 @@ from rich.console import Console
 from rich.table import Table
 from upstream_checker.checker import check_upstreams, resolve_upstreams
 from parser.nginx_parser import parse_nginx_config
+from exporter.json_yaml import format_health_results, print_export
 
 app = typer.Typer()
 console = Console()
@@ -15,6 +16,8 @@ def health(
     mode: str = typer.Option("tcp", help="Режим проверки: tcp или http", case_sensitive=False),
     resolve: bool = typer.Option(False, "--resolve", "-r", help="Показать резолвленные IP-адреса"),
     max_workers: int = typer.Option(10, "--max-workers", "-w", help="Максимальное количество потоков для параллельной обработки"),
+    json: bool = typer.Option(False, "--json", help="Экспортировать результаты в JSON"),
+    yaml: bool = typer.Option(False, "--yaml", help="Экспортировать результаты в YAML"),
 ):
     """
     Проверяет доступность upstream-серверов, определённых в nginx.conf. Выводит таблицу.
@@ -45,6 +48,25 @@ def health(
     if resolve:
         resolved_info = resolve_upstreams(upstreams, max_workers=max_workers)
 
+    # Экспорт в JSON/YAML
+    if json or yaml:
+        export_data = format_health_results(results, resolved_info if resolve else None)
+        format_type = 'json' if json else 'yaml'
+        print_export(export_data, format_type)
+        # Exit code остается прежним
+        for name, servers in results.items():
+            for srv in servers:
+                if not srv["healthy"]:
+                    exit_code = 1
+                if resolve and name in resolved_info:
+                    for resolved_srv in resolved_info[name]:
+                        if resolved_srv["address"] == srv["address"]:
+                            if any("invalid resolve" in r for r in resolved_srv["resolved"]):
+                                exit_code = 1
+                            break
+        sys.exit(exit_code)
+
+    # Обычный вывод в таблицу
     table = Table(show_header=True, header_style="bold blue")
     table.add_column("Address")
     table.add_column("Status")

{nginx_lens-0.3.4 → nginx_lens-0.4.0}/commands/include.py

@@ -1,3 +1,4 @@
+import sys
 import typer
 from rich.console import Console
 from rich.tree import Tree
@@ -22,10 +23,10 @@ def include_tree(
         tree = build_include_tree(config_path)
     except FileNotFoundError:
         console.print(f"[red]Файл {config_path} не найден. Проверьте путь к конфигу.[/red]")
-        return
+        sys.exit(1)
     except Exception as e:
         console.print(f"[red]Ошибка при разборе {config_path}: {e}[/red]")
-        return
+        sys.exit(1)
     rich_tree = Tree(f"[bold blue]{config_path}[/bold blue]")
     def _add(node, t):
         for k, v in t.items():

nginx_lens-0.4.0/commands/logs.py

@@ -0,0 +1,337 @@
+import sys
+import typer
+from rich.console import Console
+from rich.table import Table
+import re
+import gzip
+from datetime import datetime, timedelta
+from collections import Counter, defaultdict
+from typing import Optional, List, Dict, Any
+from exporter.json_yaml import format_logs_results, print_export
+from exporter.csv import export_logs_to_csv
+
+app = typer.Typer(help="Анализ access.log/error.log: топ-статусы, пути, IP, User-Agent, ошибки.")
+console = Console()
+
+# Улучшенный regex для парсинга nginx access log (поддерживает response time)
+# Формат: IP - - [timestamp] "method path protocol" status size "referer" "user-agent" "response_time"
+log_line_re = re.compile(
+    r'(?P<ip>\S+) \S+ \S+ \[(?P<time>[^\]]+)\] "(?P<method>\S+) (?P<path>\S+) [^\"]+" '
+    r'(?P<status>\d{3}) (?P<size>\S+) "(?P<referer>[^"]*)" "(?P<user_agent>[^"]*)"'
+    r'(?: "(?P<response_time>[^"]+)")?'
+)
+
+def logs(
+    log_path: str = typer.Argument(..., help="Путь к access.log или error.log"),
+    top: int = typer.Option(10, help="Сколько топ-значений выводить"),
+    json: bool = typer.Option(False, "--json", help="Экспортировать результаты в JSON"),
+    yaml: bool = typer.Option(False, "--yaml", help="Экспортировать результаты в YAML"),
+    csv: bool = typer.Option(False, "--csv", help="Экспортировать результаты в CSV"),
+    since: Optional[str] = typer.Option(None, "--since", help="Фильтр: с даты (формат: YYYY-MM-DD или YYYY-MM-DD HH:MM:SS)"),
+    until: Optional[str] = typer.Option(None, "--until", help="Фильтр: до даты (формат: YYYY-MM-DD или YYYY-MM-DD HH:MM:SS)"),
+    status: Optional[str] = typer.Option(None, "--status", help="Фильтр по статусам (например: 404,500)"),
+    detect_anomalies: bool = typer.Option(False, "--detect-anomalies", help="Обнаруживать аномалии в логах"),
+):
+    """
+    Анализирует access.log/error.log.
+
+    Показывает:
+      - Топ HTTP-статусов (404, 500 и др.)
+      - Топ путей
+      - Топ IP-адресов
+      - Топ User-Agent
+      - Топ путей с ошибками 404/500
+      - Анализ времени ответа (если доступно)
+      - Обнаружение аномалий
+
+    Пример:
+        nginx-lens logs /var/log/nginx/access.log --top 20
+        nginx-lens logs /var/log/nginx/access.log --since "2024-01-01" --status 404,500
+        nginx-lens logs /var/log/nginx/access.log.gz --detect-anomalies --json
+    """
+    # Парсинг фильтров
+    status_filter = None
+    if status:
+        status_filter = set(s.strip() for s in status.split(','))
+    
+    since_dt = None
+    if since:
+        try:
+            if len(since) == 10:  # YYYY-MM-DD
+                since_dt = datetime.strptime(since, "%Y-%m-%d")
+            else:  # YYYY-MM-DD HH:MM:SS
+                since_dt = datetime.strptime(since, "%Y-%m-%d %H:%M:%S")
+        except ValueError:
+            console.print(f"[red]Неверный формат даты для --since: {since}. Используйте YYYY-MM-DD или YYYY-MM-DD HH:MM:SS[/red]")
+            sys.exit(1)
+    
+    until_dt = None
+    if until:
+        try:
+            if len(until) == 10:  # YYYY-MM-DD
+                until_dt = datetime.strptime(until, "%Y-%m-%d") + timedelta(days=1)
+            else:  # YYYY-MM-DD HH:MM:SS
+                until_dt = datetime.strptime(until, "%Y-%m-%d %H:%M:%S")
+        except ValueError:
+            console.print(f"[red]Неверный формат даты для --until: {until}. Используйте YYYY-MM-DD или YYYY-MM-DD HH:MM:SS[/red]")
+            sys.exit(1)
+    
+    # Чтение лога (поддержка gzip)
+    try:
+        if log_path.endswith('.gz'):
+            with gzip.open(log_path, 'rt', encoding='utf-8', errors='ignore') as f:
+                lines = list(f)
+        else:
+            with open(log_path, 'r', encoding='utf-8', errors='ignore') as f:
+                lines = list(f)
+    except FileNotFoundError:
+        console.print(f"[red]Файл {log_path} не найден. Проверьте путь к логу.[/red]")
+        sys.exit(1)
+    except Exception as e:
+        console.print(f"[red]Ошибка при чтении {log_path}: {e}[/red]")
+        sys.exit(1)
+    status_counter = Counter()
+    path_counter = Counter()
+    ip_counter = Counter()
+    user_agent_counter = Counter()
+    errors = defaultdict(list)
+    response_times = []
+    log_entries = []
+    
+    # Парсинг nginx формата времени: 01/Jan/2024:00:00:00 +0000
+    nginx_time_format = "%d/%b/%Y:%H:%M:%S %z"
+    
+    for line in lines:
+        m = log_line_re.search(line)
+        if m:
+            try:
+                # Парсинг времени
+                time_str = m.group('time')
+                log_time = datetime.strptime(time_str, nginx_time_format)
+                
+                # Убираем timezone для сравнения (приводим к naive datetime)
+                if log_time.tzinfo:
+                    log_time = log_time.replace(tzinfo=None)
+                
+                # Фильтрация по времени
+                if since_dt and log_time < since_dt:
+                    continue
+                if until_dt and log_time > until_dt:
+                    continue
+                
+                ip = m.group('ip')
+                path = m.group('path')
+                status = m.group('status')
+                method = m.group('method')
+                user_agent = m.group('user_agent') or ''
+                response_time_str = m.group('response_time')
+                
+                # Фильтрация по статусам
+                if status_filter and status not in status_filter:
+                    continue
+                
+                # Сбор данных
+                entry = {
+                    'time': log_time,
+                    'ip': ip,
+                    'path': path,
+                    'status': status,
+                    'method': method,
+                    'user_agent': user_agent,
+                    'response_time': float(response_time_str) if response_time_str else None
+                }
+                log_entries.append(entry)
+                
+                status_counter[status] += 1
+                path_counter[path] += 1
+                ip_counter[ip] += 1
+                
+                if user_agent:
+                    user_agent_counter[user_agent] += 1
+                
+                if status.startswith('4') or status.startswith('5'):
+                    errors[status].append(path)
+                
+                if response_time_str:
+                    try:
+                        response_times.append(float(response_time_str))
+                    except ValueError:
+                        pass
+            except (ValueError, AttributeError) as e:
+                # Пропускаем строки с неверным форматом
+                continue
+    
+    # Проверка на пустые результаты
+    if not log_entries:
+        if json or yaml or csv:
+            empty_data = {
+                "timestamp": __import__('datetime').datetime.now().isoformat(),
+                "summary": {"total_requests": 0},
+                "message": "Нет записей, соответствующих фильтрам"
+            }
+            if csv:
+                print("Category,Type,Value,Count\nNo Data,,,,No entries match filters")
+            else:
+                format_type = 'json' if json else 'yaml'
+                print_export(empty_data, format_type)
+        else:
+            console.print("[yellow]Нет записей, соответствующих указанным фильтрам.[/yellow]")
+        return
+    
+    # Анализ времени ответа
+    response_time_stats = {}
+    if response_times:
+        response_time_stats = {
+            "min": min(response_times),
+            "max": max(response_times),
+            "avg": sum(response_times) / len(response_times),
+            "median": sorted(response_times)[len(response_times) // 2],
+            "p95": sorted(response_times)[int(len(response_times) * 0.95)] if response_times else 0,
+            "p99": sorted(response_times)[int(len(response_times) * 0.99)] if response_times else 0,
+            "total_requests_with_time": len(response_times)
+        }
+    
+    # Обнаружение аномалий
+    anomalies = []
+    if detect_anomalies:
+        # Аномалия 1: Резкий скачок ошибок
+        if len(log_entries) > 100:
+            # Разбиваем на временные окна
+            window_size = max(100, len(log_entries) // 10)
+            error_rates = []
+            for i in range(0, len(log_entries), window_size):
+                window = log_entries[i:i+window_size]
+                error_count = sum(1 for e in window if e['status'].startswith('4') or e['status'].startswith('5'))
+                error_rates.append(error_count / len(window) if window else 0)
+            
+            if len(error_rates) > 1:
+                avg_rate = sum(error_rates) / len(error_rates)
+                for i, rate in enumerate(error_rates):
+                    if rate > avg_rate * 2:  # Удвоение ошибок
+                        anomalies.append({
+                            "type": "error_spike",
+                            "description": f"Резкий скачок ошибок в окне {i+1}: {rate*100:.1f}% (среднее: {avg_rate*100:.1f}%)",
+                            "severity": "high"
+                        })
+        
+        # Аномалия 2: Медленные запросы
+        if response_times:
+            slow_threshold = response_time_stats.get("p95", 1.0) * 2
+            slow_requests = [e for e in log_entries if e.get('response_time') and e['response_time'] > slow_threshold]
+            if slow_requests:
+                anomalies.append({
+                    "type": "slow_requests",
+                    "description": f"Найдено {len(slow_requests)} медленных запросов (> {slow_threshold:.2f}s)",
+                    "severity": "medium"
+                })
+        
+        # Аномалия 3: Необычные паттерны IP
+        if len(log_entries) > 50:
+            ip_counts = Counter(e['ip'] for e in log_entries)
+            avg_ip_requests = len(log_entries) / len(ip_counts) if ip_counts else 0
+            suspicious_ips = [ip for ip, count in ip_counts.items() if count > avg_ip_requests * 5]
+            if suspicious_ips:
+                anomalies.append({
+                    "type": "suspicious_ips",
+                    "description": f"Подозрительная активность с IP: {', '.join(suspicious_ips[:5])}",
+                    "severity": "medium"
+                })
+        
+        # Аномалия 4: Необычные пути
+        if len(log_entries) > 50:
+            path_counts = Counter(e['path'] for e in log_entries)
+            avg_path_requests = len(log_entries) / len(path_counts) if path_counts else 0
+            unusual_paths = [path for path, count in path_counts.items() if count > avg_path_requests * 10]
+            if unusual_paths:
+                anomalies.append({
+                    "type": "unusual_paths",
+                    "description": f"Необычно много запросов к путям: {', '.join(unusual_paths[:3])}",
+                    "severity": "low"
+                })
+    
+    # Экспорт в CSV
+    if csv:
+        csv_output = export_logs_to_csv(
+            status_counter, path_counter, ip_counter, user_agent_counter,
+            errors, response_time_stats, anomalies
+        )
+        print(csv_output)
+        return
+    
+    # Экспорт в JSON/YAML
+    if json or yaml:
+        export_data = format_logs_results(
+            status_counter, path_counter, ip_counter, user_agent_counter, errors, top,
+            response_time_stats if response_time_stats else None,
+            anomalies if anomalies else None
+        )
+        format_type = 'json' if json else 'yaml'
+        print_export(export_data, format_type)
+        return
+    
+    # Показываем статистику по времени ответа
+    if response_time_stats:
+        table = Table(title="Response Time Statistics", show_header=True, header_style="bold green")
+        table.add_column("Metric")
+        table.add_column("Value")
+        for metric, value in response_time_stats.items():
+            if metric != "total_requests_with_time":
+                table.add_row(metric.replace("_", " ").title(), f"{value:.3f}s")
+            else:
+                table.add_row(metric.replace("_", " ").title(), str(int(value)))
+        console.print(table)
+    
+    # Показываем аномалии
+    if anomalies:
+        table = Table(title="Detected Anomalies", show_header=True, header_style="bold red")
+        table.add_column("Type")
+        table.add_column("Description")
+        table.add_column("Severity")
+        for anomaly in anomalies:
+            severity_color = {"high": "red", "medium": "orange3", "low": "yellow"}.get(anomaly.get("severity", "low"), "white")
+            table.add_row(
+                anomaly.get("type", ""),
+                anomaly.get("description", ""),
+                f"[{severity_color}]{anomaly.get('severity', '')}[/{severity_color}]"
+            )
+        console.print(table)
+    
+    # Топ статусов
+    table = Table(title="Top HTTP Status Codes", show_header=True, header_style="bold blue")
+    table.add_column("Status")
+    table.add_column("Count")
+    for status, count in status_counter.most_common(top):
+        table.add_row(status, str(count))
+    console.print(table)
+    # Топ путей
+    table = Table(title="Top Paths", show_header=True, header_style="bold blue")
+    table.add_column("Path")
+    table.add_column("Count")
+    for path, count in path_counter.most_common(top):
+        table.add_row(path, str(count))
+    console.print(table)
+    # Топ IP
+    table = Table(title="Top IPs", show_header=True, header_style="bold blue")
+    table.add_column("IP")
+    table.add_column("Count")
+    for ip, count in ip_counter.most_common(top):
+        table.add_row(ip, str(count))
+    console.print(table)
+    # Топ User-Agent
+    if user_agent_counter:
+        table = Table(title="Top User-Agents", show_header=True, header_style="bold blue")
+        table.add_column("User-Agent")
+        table.add_column("Count")
+        for ua, count in user_agent_counter.most_common(top):
+            table.add_row(ua, str(count))
+        console.print(table)
+    # Топ 404/500
+    for err in ('404', '500'):
+        if errors[err]:
+            table = Table(title=f"Top {err} Paths", show_header=True, header_style="bold blue")
+            table.add_column("Path")
+            table.add_column("Count")
+            c = Counter(errors[err])
+            for path, count in c.most_common(top):
+                table.add_row(path, str(count))
+            console.print(table) 

{nginx_lens-0.3.4 → nginx_lens-0.4.0}/commands/resolve.py

@@ -4,6 +4,7 @@ from rich.console import Console
 from rich.table import Table
 from upstream_checker.checker import resolve_upstreams
 from parser.nginx_parser import parse_nginx_config
+from exporter.json_yaml import format_resolve_results, print_export
 
 app = typer.Typer()
 console = Console()
@@ -11,6 +12,8 @@ console = Console()
 def resolve(
     config_path: str = typer.Argument(..., help="Путь к nginx.conf"),
     max_workers: int = typer.Option(10, "--max-workers", "-w", help="Максимальное количество потоков для параллельной обработки"),
+    json: bool = typer.Option(False, "--json", help="Экспортировать результаты в JSON"),
+    yaml: bool = typer.Option(False, "--yaml", help="Экспортировать результаты в YAML"),
 ):
     """
     Резолвит DNS имена upstream-серверов в IP-адреса.
@@ -33,11 +36,33 @@ def resolve(
 
     upstreams = tree.get_upstreams()
     if not upstreams:
-        console.print("[yellow]Не найдено ни одного upstream в конфигурации.[/yellow]")
+        if json or yaml:
+            export_data = {
+                "timestamp": __import__('datetime').datetime.now().isoformat(),
+                "upstreams": [],
+                "summary": {"total_upstreams": 0, "total_servers": 0}
+            }
+            format_type = 'json' if json else 'yaml'
+            print_export(export_data, format_type)
+        else:
+            console.print("[yellow]Не найдено ни одного upstream в конфигурации.[/yellow]")
         sys.exit(0)  # Нет upstream - это не ошибка, просто нет чего проверять
     
     results = resolve_upstreams(upstreams, max_workers=max_workers)
 
+    # Экспорт в JSON/YAML
+    if json or yaml:
+        export_data = format_resolve_results(results)
+        format_type = 'json' if json else 'yaml'
+        print_export(export_data, format_type)
+        # Exit code остается прежним
+        for name, servers in results.items():
+            for srv in servers:
+                if not srv["resolved"] or any("invalid resolve" in r for r in srv["resolved"]):
+                    exit_code = 1
+        sys.exit(exit_code)
+
+    # Обычный вывод в таблицу
     table = Table(show_header=True, header_style="bold blue")
     table.add_column("Upstream Name")
     table.add_column("Address")

{nginx_lens-0.3.4 → nginx_lens-0.4.0}/commands/route.py

@@ -1,3 +1,4 @@
+import sys
 import typer
 from rich.console import Console
 from rich.panel import Panel

{nginx_lens-0.3.4 → nginx_lens-0.4.0}/commands/syntax.py

@@ -36,6 +36,7 @@ def syntax(
     if not os.path.isfile(config_path):
         console.print(f"[red]Файл {config_path} не найден. Проверьте путь к конфигу.[/red]")
         return
+    
     cmd = [nginx_path, "-t", "-c", os.path.abspath(config_path)]
     if hasattr(os, 'geteuid') and os.geteuid() != 0:
         cmd = ["sudo"] + cmd

{nginx_lens-0.3.4 → nginx_lens-0.4.0}/commands/tree.py

@@ -1,3 +1,4 @@
+import sys
 import typer
 from rich.console import Console
 from rich.tree import Tree as RichTree
@@ -38,10 +39,10 @@ def tree(
         tree_obj = parse_nginx_config(config_path)
     except FileNotFoundError:
         console.print(f"[red]Файл {config_path} не найден. Проверьте путь к конфигу.[/red]")
-        return
+        sys.exit(1)
     except Exception as e:
         console.print(f"[red]Ошибка при разборе {config_path}: {e}[/red]")
-        return
+        sys.exit(1)
     root = RichTree(f"[bold blue]nginx.conf[/bold blue]")
     _build_tree(tree_obj.directives, root)
     if markdown:

nginx_lens-0.4.0/exporter/csv.py

@@ -0,0 +1,87 @@
+"""
+Модуль для экспорта результатов в CSV формат.
+"""
+import csv
+import sys
+from typing import List, Dict, Any
+from io import StringIO
+
+
+def export_logs_to_csv(
+    status_counter,
+    path_counter,
+    ip_counter,
+    user_agent_counter,
+    errors: Dict[str, List[str]],
+    response_times: List[Dict[str, Any]] = None,
+    anomalies: List[Dict[str, Any]] = None
+) -> str:
+    """
+    Экспортирует результаты анализа логов в CSV формат.
+    
+    Args:
+        status_counter: Счетчик статусов
+        path_counter: Счетчик путей
+        ip_counter: Счетчик IP
+        user_agent_counter: Счетчик User-Agent
+        errors: Словарь ошибок по статусам
+        response_times: Список данных о времени ответа
+        anomalies: Список аномалий
+        
+    Returns:
+        CSV строка
+    """
+    output = StringIO()
+    writer = csv.writer(output)
+    
+    # Топ статусов
+    writer.writerow(["Category", "Type", "Value", "Count"])
+    writer.writerow(["Status Codes", "", "", ""])
+    for status, count in status_counter.most_common():
+        writer.writerow(["", "Status", status, count])
+    
+    writer.writerow([])
+    writer.writerow(["Paths", "", "", ""])
+    for path, count in path_counter.most_common():
+        writer.writerow(["", "Path", path, count])
+    
+    writer.writerow([])
+    writer.writerow(["IPs", "", "", ""])
+    for ip, count in ip_counter.most_common():
+        writer.writerow(["", "IP", ip, count])
+    
+    if user_agent_counter:
+        writer.writerow([])
+        writer.writerow(["User-Agents", "", "", ""])
+        for ua, count in user_agent_counter.most_common():
+            writer.writerow(["", "User-Agent", ua, count])
+    
+    # Ошибки
+    if errors:
+        writer.writerow([])
+        writer.writerow(["Errors", "", "", ""])
+        for status, paths in errors.items():
+            writer.writerow(["", f"Error {status}", f"{len(paths)} occurrences", ""])
+    
+    # Response times
+    if response_times:
+        writer.writerow([])
+        writer.writerow(["Response Times", "", "", ""])
+        writer.writerow(["", "Metric", "Value", ""])
+        for metric, value in response_times.items():
+            writer.writerow(["", metric, str(value), ""])
+    
+    # Аномалии
+    if anomalies:
+        writer.writerow([])
+        writer.writerow(["Anomalies", "Type", "Description", "Severity"])
+        for anomaly in anomalies:
+            writer.writerow([
+                "",
+                anomaly.get("type", ""),
+                anomaly.get("description", ""),
+                anomaly.get("severity", "")
+            ])
+    
+    return output.getvalue()
+