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

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.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nginx-lens
-Version: 0.3.4
+Version: 0.5.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.5.0.dist-info/RECORD

@@ -0,0 +1,48 @@
+analyzer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+analyzer/base.py,sha256=oGKg78BfMVmuzYafc08oq9p31-jEgYolGjLkUcIdkN8,607
+analyzer/conflicts.py,sha256=NSNZc8e2x51K41dflSUvuwlDq-rzBXU5ITi6WfxFbfU,2796
+analyzer/dead_locations.py,sha256=uvMu5qBGTVi0Nn960x3WpRvTljGbQuVFivU4nfe36oY,1435
+analyzer/diff.py,sha256=idvXnoLzBVUYgKi_s3uDu0v2GNMV3B8aDqTROXcdQdo,1749
+analyzer/duplicates.py,sha256=jpy_6k-BzWxaXFt2Wb3rlulIXUEzbFe9xYRm7rWR50U,1215
+analyzer/empty_blocks.py,sha256=7Zu4-5I5PS3bjhH0Ppq1CvM7rMTeRIc4fHx5n5vkMIw,517
+analyzer/include.py,sha256=FhKR4VsogLknykjLD2N8jX9OtwxZcWik5oPpvp-_luE,2465
+analyzer/rewrite.py,sha256=-jSLLG1jqmGU-dXWvU6NHCW6muB8Lfro6fXX1tDCHCQ,1834
+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=UUZpPOpEnPglo94AFklX-cMt6HoHPCafmqfW76CIZVg,8667
+commands/cli.py,sha256=_vpXlQr0Rf5bUN2t_fV2x40eAHU6nyOjAVRr8tC0eNo,1081
+commands/completion.py,sha256=I7g70tM9JDc8PddIOS-tAGiqc3HkmQhFuAzMCMe_Jck,6223
+commands/diff.py,sha256=mf6xkf_8IKa3R-AiTsWmJDUrxqjGT5gaSAX0u5D0jjY,2097
+commands/graph.py,sha256=lBh2wCPrhsywxcEbz5UABtNdEepTMLmiIzWJt_Uu1mE,5968
+commands/health.py,sha256=Q2qGB02dcMFbp247qg5uxkJFWw84rmCEzZozXcy2wtQ,7606
+commands/include.py,sha256=hsheLfoQ3eUx3irAibhC2ndq3ko0VrLda-WGL9JgIlw,2245
+commands/logs.py,sha256=scs5_AD4w4z1LXyYZvB4IBLd3T-LSV_45hD8KtHrdhc,15763
+commands/metrics.py,sha256=MawshQaCOkdeLxlopuOzDAE-Gyjlbs_u1bIP4EsB10Q,18955
+commands/resolve.py,sha256=hxGiavoESKj_RPfezelh7vsxGSccUFMQI0K4-izdrRk,5868
+commands/route.py,sha256=4bW4sCY2cVORk-hblnE-BJH3oRL6T9cZuigL-2KCRT4,3174
+commands/syntax.py,sha256=9sjJXheQ9PRZoFm0sO73pEomzbkeYvbBV265XLU6Krk,3423
+commands/tree.py,sha256=cxq0vL6V3ah5X4ozPOmWgIH4NJbr2J48TTLNxsjzOL8,2182
+commands/validate.py,sha256=LB_a4RHsaIZxXrm9jUZ1McgLefcP1aZ_bJ_i6z5huNM,22682
+config/__init__.py,sha256=vsP76D53exH8CkpWttJLTgXlW52LFgP_zBnxPKkWAtQ,107
+config/config_loader.py,sha256=fqJEnHojkEMEpAez9ymAHUR1TbD0D_RSFGZsdI7zObQ,6927
+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.5.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=b3E7P9f_7JRWqXa_mSei6LKchD9yQoLNuwindnvfWYI,13258
+upstream_checker/dns_cache.py,sha256=RiGgDFKaIvVQz8Rrm8lBorct8WzbyXHLKZy6W7WhYg4,6903
+utils/__init__.py,sha256=tl98tkuTjz9Q5TKD8cxAxBh6n1Yk65TgKCdIbPFsnz4,43
+utils/progress.py,sha256=Aqb1EW7yGJUSSzw5hTJYiKQ3XjU7ABEqAByfQo9t9P0,4797
+nginx_lens-0.5.0.dist-info/METADATA,sha256=oKRRMSyqUAZEhEVSiU5Y_uPqzC9a7kQlOtxxBljzRM4,717
+nginx_lens-0.5.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+nginx_lens-0.5.0.dist-info/entry_points.txt,sha256=qEcecjSyLqcJjbIVlNlTpqAhPqDyaujUV5ZcBTAr3po,48
+nginx_lens-0.5.0.dist-info/top_level.txt,sha256=W4rp9juDAaGS642PMW3zfoHyFMj0yTtXKAwlVz87bao,64
+nginx_lens-0.5.0.dist-info/RECORD,,

{nginx_lens-0.3.4.dist-info → nginx_lens-0.5.0.dist-info}/top_level.txt

@@ -1,5 +1,7 @@
 analyzer
 commands
+config
 exporter
 parser
 upstream_checker
+utils

upstream_checker/checker.py

@@ -3,8 +3,9 @@
 import socket
 import time
 import http.client
-from typing import Dict, List, Tuple
+from typing import Dict, List, Tuple, Optional
 from concurrent.futures import ThreadPoolExecutor, as_completed
+from utils.progress import ProgressManager
 try:
     import dns.resolver
     import dns.exception
@@ -12,6 +13,8 @@ try:
 except ImportError:
     DNS_AVAILABLE = False
 
+from upstream_checker.dns_cache import get_cache, is_cache_enabled, disable_cache, enable_cache
+
 
 def check_tcp(address: str, timeout: float, retries: int) -> bool:
     """
@@ -56,12 +59,15 @@ def check_http(address: str, timeout: float, retries: int) -> bool:
     return False
 
 
-def resolve_address(address: str) -> List[str]:
+def resolve_address(address: str, use_cache: bool = True, cache_ttl: int = 300, cache_dir: Optional[str] = None) -> List[str]:
     """
     Резолвит адрес upstream сервера в IP-адреса с информацией о CNAME.
     
     Args:
         address: Адрес в формате "host:port" или "host:port параметры"
+        use_cache: Использовать ли кэш (по умолчанию True)
+        cache_ttl: Время жизни кэша в секундах (по умолчанию 300)
+        cache_dir: Директория для кэша (опционально)
         
     Returns:
         Список строк в формате:
@@ -81,6 +87,7 @@ def resolve_address(address: str) -> List[str]:
             return []
         host, port = parts
         
+        # Проверка на IP адрес (не кэшируем IP адреса)
         try:
             socket.inet_aton(host)
             return [host_port]
@@ -95,10 +102,25 @@ def resolve_address(address: str) -> List[str]:
             except (socket.error, OSError):
                 pass
         
+        # Проверяем кэш перед резолвингом
+        if use_cache and is_cache_enabled():
+            cache = get_cache(ttl=cache_ttl, cache_dir=cache_dir)
+            cached_result = cache.get(host, port)
+            if cached_result is not None:
+                return cached_result
+        
+        # Выполняем резолвинг
         if DNS_AVAILABLE:
-            return _resolve_with_dns(host, port)
+            result = _resolve_with_dns(host, port)
         else:
-            return _resolve_with_socket(host, port)
+            result = _resolve_with_socket(host, port)
+        
+        # Сохраняем в кэш
+        if use_cache and is_cache_enabled():
+            cache = get_cache(ttl=cache_ttl, cache_dir=cache_dir)
+            cache.set(host, port, result)
+        
+        return result
     except (ValueError, IndexError, AttributeError):
         return []
 
@@ -187,7 +209,11 @@ def _resolve_with_socket(host: str, port: str) -> List[str]:
 
 def resolve_upstreams(
     upstreams: Dict[str, List[str]],
-    max_workers: int = 10
+    max_workers: int = 10,
+    use_cache: bool = True,
+    cache_ttl: int = 300,
+    cache_dir: Optional[str] = None,
+    progress_manager: Optional[ProgressManager] = None
 ) -> Dict[str, List[dict]]:
     """
     Резолвит DNS имена upstream-серверов в IP-адреса.
@@ -195,6 +221,9 @@ def resolve_upstreams(
     Args:
         upstreams: Словарь upstream серверов
         max_workers: Максимальное количество потоков для параллельной обработки
+        use_cache: Использовать ли кэш (по умолчанию True)
+        cache_ttl: Время жизни кэша в секундах (по умолчанию 300)
+        cache_dir: Директория для кэша (опционально)
     
     Возвращает:
     {
@@ -226,7 +255,10 @@ def resolve_upstreams(
     
     # Параллельная обработка резолвинга
     with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        future_to_key = {executor.submit(resolve_address, srv): key for key, srv in tasks}
+        future_to_key = {
+            executor.submit(resolve_address, srv, use_cache, cache_ttl, cache_dir): key 
+            for key, srv in tasks
+        }
         
         for future in as_completed(future_to_key):
             key = future_to_key[future]
@@ -260,7 +292,8 @@ def check_upstreams(
     timeout: float = 2.0,
     retries: int = 1,
     mode: str = "tcp",
-    max_workers: int = 10
+    max_workers: int = 10,
+    progress_manager: Optional[ProgressManager] = None
 ) -> Dict[str, List[dict]]:
     """
     Проверяет доступность upstream-серверов.
@@ -305,6 +338,9 @@ def check_upstreams(
             for key, srv in tasks
         }
         
+        completed = 0
+        total = len(tasks)
+        
         for future in as_completed(future_to_key):
             key = future_to_key[future]
             name, idx = task_to_key[key]
@@ -313,5 +349,9 @@ def check_upstreams(
                 results[name][idx] = {"address": srv, "healthy": healthy}
             except Exception:
                 results[name][idx] = {"address": key[2], "healthy": False}
+            
+            completed += 1
+            if progress_manager:
+                progress_manager.update(completed, total=total, description=f"Проверка upstream серверов ({completed}/{total})")
     
     return results