nginx-lens 0.3.4__py3-none-any.whl → 0.4.0__py3-none-any.whl

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)

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))

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):

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")

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():

commands/logs.py

@@ -1,17 +1,36 @@
+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()
 
-log_line_re = re.compile(r'(?P<ip>\S+) \S+ \S+ \[(?P<time>[^\]]+)\] "(?P<method>\S+) (?P<path>\S+) [^\"]+" (?P<status>\d{3})')
+# Улучшенный 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="Сколько топ-значений выводить")
+    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.
@@ -22,40 +41,261 @@ def logs(
       - Топ 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:
-        with open(log_path) as f:
-            lines = list(f)
+        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]")
-        return
+        sys.exit(1)
     except Exception as e:
         console.print(f"[red]Ошибка при чтении {log_path}: {e}[/red]")
-        return
+        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:
-            ip = m.group('ip')
-            path = m.group('path')
-            status = m.group('status')
-            status_counter[status] += 1
-            path_counter[path] += 1
-            ip_counter[ip] += 1
-            if status.startswith('4') or status.startswith('5'):
-                errors[status].append(path)
-        # user-agent (если есть)
-        if '" "' in line:
-            ua = line.rsplit('" "', 1)[-1].strip().strip('"')
-            if ua:
-                user_agent_counter[ua] += 1
+            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")

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")

commands/route.py

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

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

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:

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()
+

exporter/json_yaml.py

@@ -0,0 +1,361 @@
+"""
+Модуль для экспорта результатов команд nginx-lens в JSON и YAML форматы.
+"""
+import json
+import sys
+from typing import Any, Dict, List, Optional
+from datetime import datetime
+
+try:
+    import yaml
+    YAML_AVAILABLE = True
+except ImportError:
+    YAML_AVAILABLE = False
+
+
+def export_json(data: Any, pretty: bool = True) -> str:
+    """
+    Экспортирует данные в JSON формат.
+    
+    Args:
+        data: Данные для экспорта
+        pretty: Форматировать с отступами
+        
+    Returns:
+        JSON строка
+    """
+    if pretty:
+        return json.dumps(data, ensure_ascii=False, indent=2, default=str)
+    else:
+        return json.dumps(data, ensure_ascii=False, default=str)
+
+
+def export_yaml(data: Any) -> str:
+    """
+    Экспортирует данные в YAML формат.
+    
+    Args:
+        data: Данные для экспорта
+        
+    Returns:
+        YAML строка
+        
+    Raises:
+        ImportError: Если PyYAML не установлен
+    """
+    if not YAML_AVAILABLE:
+        raise ImportError("PyYAML не установлен. Установите его: pip install pyyaml")
+    
+    return yaml.dump(data, allow_unicode=True, default_flow_style=False, sort_keys=False)
+
+
+def print_export(data: Any, format_type: str, file=None):
+    """
+    Выводит данные в указанном формате.
+    
+    Args:
+        data: Данные для экспорта
+        format_type: 'json' или 'yaml'
+        file: Файл для вывода (по умолчанию stdout)
+    """
+    if file is None:
+        file = sys.stdout
+    
+    if format_type == 'json':
+        output = export_json(data)
+    elif format_type == 'yaml':
+        output = export_yaml(data)
+    else:
+        raise ValueError(f"Неподдерживаемый формат: {format_type}")
+    
+    print(output, file=file)
+
+
+def format_health_results(results: Dict[str, List[Dict]], resolved_info: Optional[Dict] = None) -> Dict[str, Any]:
+    """
+    Форматирует результаты команды health для экспорта.
+    
+    Args:
+        results: Результаты check_upstreams
+        resolved_info: Результаты resolve_upstreams (опционально)
+        
+    Returns:
+        Словарь с данными для экспорта
+    """
+    data = {
+        "timestamp": datetime.now().isoformat(),
+        "upstreams": []
+    }
+    
+    for name, servers in results.items():
+        upstream_data = {
+            "name": name,
+            "servers": []
+        }
+        
+        for srv in servers:
+            server_data = {
+                "address": srv["address"],
+                "healthy": srv["healthy"],
+                "status": "healthy" if srv["healthy"] else "unhealthy"
+            }
+            
+            if resolved_info and name in resolved_info:
+                for resolved_srv in resolved_info[name]:
+                    if resolved_srv["address"] == srv["address"]:
+                        server_data["resolved_ips"] = resolved_srv["resolved"]
+                        # Проверяем наличие invalid resolve
+                        server_data["has_invalid_resolve"] = any("invalid resolve" in r for r in resolved_srv["resolved"])
+                        break
+            
+            upstream_data["servers"].append(server_data)
+        
+        data["upstreams"].append(upstream_data)
+    
+    # Подсчитываем статистику
+    total_servers = sum(len(servers) for servers in results.values())
+    healthy_count = sum(1 for servers in results.values() for srv in servers if srv["healthy"])
+    unhealthy_count = total_servers - healthy_count
+    
+    data["summary"] = {
+        "total_upstreams": len(results),
+        "total_servers": total_servers,
+        "healthy": healthy_count,
+        "unhealthy": unhealthy_count
+    }
+    
+    return data
+
+
+def format_resolve_results(results: Dict[str, List[Dict]]) -> Dict[str, Any]:
+    """
+    Форматирует результаты команды resolve для экспорта.
+    
+    Args:
+        results: Результаты resolve_upstreams
+        
+    Returns:
+        Словарь с данными для экспорта
+    """
+    data = {
+        "timestamp": datetime.now().isoformat(),
+        "upstreams": []
+    }
+    
+    failed_count = 0
+    invalid_count = 0
+    
+    for name, servers in results.items():
+        upstream_data = {
+            "name": name,
+            "servers": []
+        }
+        
+        for srv in servers:
+            server_data = {
+                "address": srv["address"],
+                "resolved_ips": srv["resolved"]
+            }
+            
+            if not srv["resolved"]:
+                server_data["status"] = "failed"
+                failed_count += 1
+            elif any("invalid resolve" in r for r in srv["resolved"]):
+                server_data["status"] = "invalid"
+                invalid_count += 1
+            else:
+                server_data["status"] = "success"
+            
+            upstream_data["servers"].append(server_data)
+        
+        data["upstreams"].append(upstream_data)
+    
+    data["summary"] = {
+        "total_upstreams": len(results),
+        "total_servers": sum(len(servers) for servers in results.values()),
+        "successful": sum(len(servers) for servers in results.values()) - failed_count - invalid_count,
+        "failed": failed_count,
+        "invalid": invalid_count
+    }
+    
+    return data
+
+
+def format_analyze_results(
+    conflicts: List[Dict],
+    dups: List[Dict],
+    empties: List[Dict],
+    warnings: List[Dict],
+    unused_vars: List[Dict],
+    listen_conflicts: List[Dict],
+    rewrite_issues: List[Dict],
+    dead_locations: List[Dict],
+    issue_meta: Dict[str, tuple]
+) -> Dict[str, Any]:
+    """
+    Форматирует результаты команды analyze для экспорта.
+    
+    Args:
+        conflicts: Конфликты location
+        dups: Дублирующиеся директивы
+        empties: Пустые блоки
+        warnings: Предупреждения
+        unused_vars: Неиспользуемые переменные
+        listen_conflicts: Конфликты listen/server_name
+        rewrite_issues: Проблемы с rewrite
+        dead_locations: Мертвые location
+        issue_meta: Метаданные о типах проблем
+        
+    Returns:
+        Словарь с данными для экспорта
+    """
+    data = {
+        "timestamp": datetime.now().isoformat(),
+        "issues": []
+    }
+    
+    # Добавляем все проблемы в единый список
+    for c in conflicts:
+        advice, severity = issue_meta.get('location_conflict', ("", "medium"))
+        data["issues"].append({
+            "type": "location_conflict",
+            "severity": severity,
+            "message": c.get('value', ''),
+            "advice": advice
+        })
+    
+    for d in dups:
+        advice, severity = issue_meta.get('duplicate_directive', ("", "medium"))
+        data["issues"].append({
+            "type": "duplicate_directive",
+            "severity": severity,
+            "message": d.get('value', ''),
+            "advice": advice
+        })
+    
+    for e in empties:
+        advice, severity = issue_meta.get('empty_block', ("", "low"))
+        data["issues"].append({
+            "type": "empty_block",
+            "severity": severity,
+            "message": f"{e.get('block', '')} блок пуст",
+            "advice": advice
+        })
+    
+    for w in warnings:
+        issue_type = w.get('type', '')
+        advice, severity = issue_meta.get(issue_type, ("", "medium"))
+        data["issues"].append({
+            "type": issue_type,
+            "severity": severity,
+            "message": w.get('value', ''),
+            "advice": advice
+        })
+    
+    for v in unused_vars:
+        advice, severity = issue_meta.get('unused_variable', ("", "low"))
+        data["issues"].append({
+            "type": "unused_variable",
+            "severity": severity,
+            "message": v.get('name', ''),
+            "advice": advice
+        })
+    
+    for c in listen_conflicts:
+        advice, severity = issue_meta.get('listen_servername_conflict', ("", "high"))
+        data["issues"].append({
+            "type": "listen_servername_conflict",
+            "severity": severity,
+            "message": f"server1: {c.get('server1', {}).get('arg','')} server2: {c.get('server2', {}).get('arg','')}",
+            "advice": advice
+        })
+    
+    for r in rewrite_issues:
+        advice, severity = issue_meta.get(r.get('type', ''), ("", "medium"))
+        data["issues"].append({
+            "type": r.get('type', ''),
+            "severity": severity,
+            "message": r.get('value', ''),
+            "advice": advice
+        })
+    
+    for l in dead_locations:
+        advice, severity = issue_meta.get('dead_location', ("", "low"))
+        data["issues"].append({
+            "type": "dead_location",
+            "severity": severity,
+            "message": f"server: {l.get('server', {}).get('arg','')} location: {l.get('location', {}).get('arg','')}",
+            "advice": advice
+        })
+    
+    # Подсчитываем статистику
+    severity_counts = {"high": 0, "medium": 0, "low": 0}
+    for issue in data["issues"]:
+        severity = issue.get("severity", "medium")
+        if severity in severity_counts:
+            severity_counts[severity] += 1
+    
+    data["summary"] = {
+        "total_issues": len(data["issues"]),
+        "by_severity": severity_counts
+    }
+    
+    return data
+
+
+def format_logs_results(
+    status_counter,
+    path_counter,
+    ip_counter,
+    user_agent_counter,
+    errors: Dict[str, List[str]],
+    top: int,
+    response_times: Optional[Dict[str, float]] = None,
+    anomalies: Optional[List[Dict[str, Any]]] = None
+) -> Dict[str, Any]:
+    """
+    Форматирует результаты команды logs для экспорта.
+    
+    Args:
+        status_counter: Счетчик статусов
+        path_counter: Счетчик путей
+        ip_counter: Счетчик IP
+        user_agent_counter: Счетчик User-Agent
+        errors: Словарь ошибок по статусам
+        top: Количество топ-значений
+        
+    Returns:
+        Словарь с данными для экспорта
+    """
+    data = {
+        "timestamp": datetime.now().isoformat(),
+        "top_statuses": [{"status": status, "count": count} for status, count in status_counter.most_common(top)],
+        "top_paths": [{"path": path, "count": count} for path, count in path_counter.most_common(top)],
+        "top_ips": [{"ip": ip, "count": count} for ip, count in ip_counter.most_common(top)],
+        "errors": {}
+    }
+    
+    if user_agent_counter:
+        data["top_user_agents"] = [{"user_agent": ua, "count": count} for ua, count in user_agent_counter.most_common(top)]
+    
+    for status, paths in errors.items():
+        data["errors"][status] = {
+            "count": len(paths),
+            "unique_paths": list(set(paths))[:top]
+        }
+    
+    data["summary"] = {
+        "total_requests": sum(status_counter.values()),
+        "unique_paths": len(path_counter),
+        "unique_ips": len(ip_counter),
+        "error_requests": sum(len(paths) for paths in errors.values())
+    }
+    
+    if response_times:
+        data["response_times"] = response_times
+    
+    if anomalies:
+        data["anomalies"] = anomalies
+    
+    return data
+

{nginx_lens-0.3.4.dist-info → nginx_lens-0.4.0.dist-info}/METADATA

@@ -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.dist-info → nginx_lens-0.4.0.dist-info}/RECORD

@@ -11,28 +11,30 @@ analyzer/route.py,sha256=71dkmQaTrHqDTf4Up5gAsrgmgktNpXqWmxr7-0RAVtg,2370
 analyzer/unused.py,sha256=Ixzv0bPsw9IafblVwLiAOgugdg2dGu1MJDtuoqzPZiY,1066
 analyzer/warnings.py,sha256=zC36QMvegA2eQPvZ-P1eysrX_kXHx5A1MUKHKKNvG5c,5784
 commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-commands/analyze.py,sha256=W6begSgXNjgKJGoGeguR3WKgHPLkClWXxxpDcqvsJdc,8343
+commands/analyze.py,sha256=UUZpPOpEnPglo94AFklX-cMt6HoHPCafmqfW76CIZVg,8667
 commands/cli.py,sha256=brzp6xDDWIrm7ibaoT4x94hgAdBB2DVWniXoK8dRylE,782
-commands/diff.py,sha256=C7gRIWh6DNWHzjiQBPVTn-rZ40m2KCY75Zd6Q4URJIE,2076
-commands/graph.py,sha256=xB6KjXBkLmm5gII3e-5BMRGO7WeTwc7EFxRGzYgnme4,5947
-commands/health.py,sha256=lxrvuD-ClMLpTJ7gs7kn50fXwA4uBlHMPWA1ZxdEtAE,4167
-commands/include.py,sha256=5PTYG5C00-AlWfIgpQXLq9E7C9yTFSv7HrZkM5ogDps,2224
-commands/logs.py,sha256=RkPUdIpbO9dOVL56lemreYRuAjMjcqqMxRCKOFv2gC4,3691
-commands/resolve.py,sha256=MRruIH46tIelUyyrdrF70ai-tluuEJ13Jcj2nyRCSPA,2820
-commands/route.py,sha256=-x_71u6ENl3iO-oxK3bdE8v5eZKf4xRCydeUyXMFVrY,3163
-commands/syntax.py,sha256=ZWFdaL8LVv9S694wlk2aV3HJKb0OSKjw3wNgTlNvFR8,3418
-commands/tree.py,sha256=mDfx0Aeg1EDQSYQoJ2nJIkSd_uP7ZR7pEqy7Cw3clQ0,2161
+commands/diff.py,sha256=mf6xkf_8IKa3R-AiTsWmJDUrxqjGT5gaSAX0u5D0jjY,2097
+commands/graph.py,sha256=lBh2wCPrhsywxcEbz5UABtNdEepTMLmiIzWJt_Uu1mE,5968
+commands/health.py,sha256=e6569IAITNf9Mji_E0GbA18S9neA0yfkSsTAZcnwFoM,5343
+commands/include.py,sha256=hsheLfoQ3eUx3irAibhC2ndq3ko0VrLda-WGL9JgIlw,2245
+commands/logs.py,sha256=D6vI9YNPgStZ4weM3bSrUIzK0ncpd9Ku7V7jRBDwtPY,15415
+commands/resolve.py,sha256=eeln1_5QAR4FvsrPz1ff9cd_i_9yGlPcF_W1omkTNms,4032
+commands/route.py,sha256=4bW4sCY2cVORk-hblnE-BJH3oRL6T9cZuigL-2KCRT4,3174
+commands/syntax.py,sha256=9sjJXheQ9PRZoFm0sO73pEomzbkeYvbBV265XLU6Krk,3423
+commands/tree.py,sha256=cxq0vL6V3ah5X4ozPOmWgIH4NJbr2J48TTLNxsjzOL8,2182
 exporter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+exporter/csv.py,sha256=_hTIs9CihxP9ewB9FcoN-ERmzUKEQs8hf7U8_heHTO0,2815
 exporter/graph.py,sha256=WYUrqUgCaK6KihgxAcRHaQn4oMo6b7ybC8yb_36ZIsA,3995
 exporter/html.py,sha256=uquEM-WvBt2aV9GshgaI3UVhYd8sD0QQ-OmuNtvYUdU,798
+exporter/json_yaml.py,sha256=XqLOBtrh5Xd7RMeofODU8jaTkaeBEpHMNjz4UF39WrQ,11794
 exporter/markdown.py,sha256=_0mXQIhurGEZ0dO-eq9DbsuKNrgEDIblgtL3DAgYNo8,724
-nginx_lens-0.3.4.dist-info/licenses/LICENSE,sha256=g8QXKdvZZC56rU8E12vIeYF6R4jeTWOsblOnYAda3K4,1073
+nginx_lens-0.4.0.dist-info/licenses/LICENSE,sha256=g8QXKdvZZC56rU8E12vIeYF6R4jeTWOsblOnYAda3K4,1073
 parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 parser/nginx_parser.py,sha256=Sa9FtGAkvTqNzoehBvgLUWPJHLLIZYWH9ugSHW50X8s,3699
 upstream_checker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 upstream_checker/checker.py,sha256=i3L6XqUHUH5hcyLq5PXx6wOyjzEL_Z7xYCA3FffFOrU,11257
-nginx_lens-0.3.4.dist-info/METADATA,sha256=E7ce-3zNXvNVp7-y_TvlnmtCTIjMhid2sdqzbrpgy8U,552
-nginx_lens-0.3.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-nginx_lens-0.3.4.dist-info/entry_points.txt,sha256=qEcecjSyLqcJjbIVlNlTpqAhPqDyaujUV5ZcBTAr3po,48
-nginx_lens-0.3.4.dist-info/top_level.txt,sha256=mxLJO4rZg0rbixVGhplF3fUNFs8vxDIL25ronZNvRy4,51
-nginx_lens-0.3.4.dist-info/RECORD,,
+nginx_lens-0.4.0.dist-info/METADATA,sha256=W4PE6mOQdDbsW0S4RTokPg3h2m9f39Fol0RWV3zxuJo,717
+nginx_lens-0.4.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+nginx_lens-0.4.0.dist-info/entry_points.txt,sha256=qEcecjSyLqcJjbIVlNlTpqAhPqDyaujUV5ZcBTAr3po,48
+nginx_lens-0.4.0.dist-info/top_level.txt,sha256=mxLJO4rZg0rbixVGhplF3fUNFs8vxDIL25ronZNvRy4,51
+nginx_lens-0.4.0.dist-info/RECORD,,