try:

val = request.cookies.get('project_area')

return val if isinstance(val, str) and val.strip() else None

except Exception:

out = dict(base or {})

for k, v in (override or {}).items():

if isinstance(v, dict) and isinstance(out.get(k), dict):

out[k] = _deep_merge_dicts(out.get(k) or {}, v)

else:

out[k] = v

try:

from metrics_config import METRICS_CONFIG as BASE

except Exception:

BASE = {}

try:

if os.path.exists(METRICS_RUNTIME_PATH):

with open(METRICS_RUNTIME_PATH, 'r', encoding='utf-8') as f:

override = json.load(f)

if isinstance(override, dict):

return _deep_merge_dicts(BASE, override)

except Exception:

return BASE

'overall': 'overall_prompt.txt',

'judge': 'judge_prompt.txt',

'critic': 'critic_prompt.txt',

'database': 'database_prompt.txt',

'kafka': 'kafka_prompt.txt',

'microservices': 'microservices_prompt.txt',

'jvm': 'jvm_prompt.txt',

'hard_resources': 'hard_resources_prompt.txt',

'lt_framework': 'lt_framework_prompt.txt',

prompts: dict[str, str] = {}

for domain, fname in PROMPT_DOMAIN_FILES.items():

try:

p = os.path.join(PROMPTS_DIR, fname)

if os.path.exists(p):

with open(p, 'r', encoding='utf-8') as f:

prompts[domain] = f.read()

else:

prompts[domain] = ''

except Exception:

prompts[domain] = ''

base = _load_base_prompts()

if not area:

return base

# прочитаем overrides из settings_runtime.json: per_area[area].prompts

try:

if os.path.exists(CONFIG_RUNTIME_PATH):

with open(CONFIG_RUNTIME_PATH, 'r', encoding='utf-8') as f:

rt = json.load(f)

per_area = (rt.get('per_area') or {}) if isinstance(rt, dict) else {}

area_cfg = (per_area.get(area) or {}) if isinstance(per_area, dict) else {}

overrides = (area_cfg.get('prompts') or {}) if isinstance(area_cfg, dict) else {}

if isinstance(overrides, dict):

for k, v in overrides.items():

if isinstance(v, str) and k in base:

base[k] = v

except Exception:

pass

# Устанавливаем область в cookie и отдаём страницу отчёта

resp = make_response(render_template('reports.html'))

try:

resp.set_cookie('project_area', service, max_age=60*60*24*365, samesite='Lax')

except Exception:

pass

cfg = (CONFIG.get("storage", {}) or {}).get("timescale", {})

return psycopg2.connect(

host=cfg.get("host"),

port=cfg.get("port"),

dbname=cfg.get("dbname"),

user=cfg.get("user"),

password=cfg.get("password"),

sslmode=cfg.get("sslmode", "prefer"),

try:

q = (CONFIG.get("queries", {}) or {}).get(domain, {})

labels = list(q.get("labels", []) or [])

keys_list = list(q.get("label_keys_list", []) or [])

if query_label in labels:

idx = labels.index(query_label)

if idx < len(keys_list):

keys = list(keys_list[idx] or [])

if keys:

return str(keys[0])

# fallback: если в домене одна группа ключей — берём первый

if keys_list:

keys = list(keys_list[0] or [])

if keys:

return str(keys[0])

except Exception:

pass

try:

cfg = (CONFIG.get("storage", {}) or {}).get("timescale", {})

schema = cfg.get("schema", "public")

table = cfg.get("llm_table", "llm_reports")

conn = _ts_conn()

pa = _active_project_area()

last_run = None

verdict_counts = {"Успешно": 0, "Есть риски": 0, "Провал": 0, "Недостаточно данных": 0}

with conn, conn.cursor() as cur:

# Последний запуск по времени создания итогового отчёта (final)

if pa:

cur.execute(

f"""

""",

(pa,)

)

else:

cur.execute(

f"""

)

r = cur.fetchone()

if r:

last_run = {

"run_name": r[0],

"service": r[1],

"start_ms": int(r[2]) if r[2] is not None else None,

"end_ms": int(r[3]) if r[3] is not None else None,

"verdict": r[4],

"created_at": r[5].isoformat() if r[5] else None,

}

# Распределение статусов по последнему финальному вердикту каждого запуска

if pa:

cur.execute(

f"""

""",

(pa,)

)

else:

cur.execute(

f"""

)

rows = cur.fetchall()

for v, cnt in rows:

if v in verdict_counts:

verdict_counts[v] = int(cnt)

else:

# неизвестные значения складываем в "Недостаточно данных"

verdict_counts["Недостаточно данных"] += int(cnt)

conn.close()

return jsonify({"last_run": last_run, "verdict_counts": verdict_counts})

except Exception as e:

run_a = request.args.get("run_a")

run_b = request.args.get("run_b")

domain = request.args.get("domain")

if not all([run_a, run_b, domain]):

return jsonify({"error": "run_a, run_b, domain обязательны"}), 400

try:

conn = _ts_conn()

pa = _active_project_area()

with conn, conn.cursor() as cur:

if pa:

cur.execute(

"""

""",

(run_a, run_b, domain, pa, run_a, run_b)

)

else:

cur.execute(

"""

""",

(run_a, run_b, domain, run_a, run_b)

)

rows = cur.fetchall()

conn.close()

def _safe_float(x):

try:

return float(x) if x is not None else None

except Exception:

return None

out = []

for ql, a, b in rows:

a_f = _safe_float(a)

b_f = _safe_float(b)

trend = None

if a_f is not None and b_f is not None:

denom = abs(a_f) if abs(a_f) > 1e-9 else 1.0

trend = ((b_f - a_f) / denom) * 100.0

out.append({

"query_label": ql,

"p95_a": a_f,

"p95_b": b_f,

"trend_pct": trend

})

return jsonify(out)

except Exception as e:

run_a = request.args.get("run_a")

run_b = request.args.get("run_b")

domain = request.args.get("domain")

ql = request.args.get("query_label")

series_key = request.args.get("series_key")

if not all([run_a, run_b, domain, ql]):

return jsonify({"error": "run_a, run_b, domain, query_label обязательны"}), 400

try:

# Автоматически подобрать ключ серии, если не задан

if not series_key or series_key == "auto":

series_key = _series_key_for(domain, ql, default_key="application")

conn = _ts_conn()

pa = _active_project_area()

sql_common = f"""

with conn, conn.cursor() as cur:

if pa:

cur.execute(

f"""

""",

(run_a, run_b, domain, ql, pa, run_a, run_b)

)

else:

cur.execute(

f"""

""",

(run_a, run_b, domain, ql, run_a, run_b)

)

rows = cur.fetchall()

conn.close()

def _safe_float(x):

try:

return float(x) if x is not None else None

except Exception:

return None

out = []

for s, a, b in rows:

a_f = _safe_float(a)

b_f = _safe_float(b)

trend = None

if a_f is not None and b_f is not None:

denom = abs(a_f) if abs(a_f) > 1e-9 else 1.0

trend = ((b_f - a_f) / denom) * 100.0

out.append({

"series": s,

"p95_a": a_f,

"p95_b": b_f,

"trend_pct": trend

})

return jsonify({"query_label": ql, "series_key": series_key, "rows": out})

except Exception as e:

run_name = request.args.get("run_name")

if not run_name:

return jsonify({"error": "run_name обязателен"}), 400

try:

cfg = (CONFIG.get("storage", {}) or {}).get("timescale", {})

schema = cfg.get("schema", "public")

table = cfg.get("llm_table", "llm_reports")

conn = _ts_conn()

pa = _active_project_area()

with conn, conn.cursor() as cur:

if pa:

cur.execute(

f"""

""",

(run_name, pa)

)

else:

cur.execute(

f"""

""",

(run_name,)

)

rows = cur.fetchall()

conn.close()

data = []

for r in rows:

data.append({

"run_name": r[0],

"service": r[1],

"start_ms": int(r[2]) if r[2] is not None else None,

"end_ms": int(r[3]) if r[3] is not None else None,

"domain": r[4],

"verdict": r[5],

"text": r[6],

"parsed": r[7],

"scores": r[8],

"created_at": r[9].isoformat() if r[9] else None,

})

return jsonify(data)

except Exception as e:

try:

cfg = (CONFIG.get("storage", {}) or {}).get("timescale", {})

schema = cfg.get("schema", "public")

llm_table = cfg.get("llm_table", "llm_reports")

pa = _active_project_area()

q = request.args.get('q', '').strip()

offset = int(request.args.get('offset', '0') or 0)

limit = int(request.args.get('limit', '20') or 20)

sort = (request.args.get('sort', 'end_time') or 'end_time').lower()

direction = (request.args.get('dir', 'desc') or 'desc').lower()

# Безопасная сортировка

sort_map = {

'run_name': 'run_name',

'service': 'service',

'start_time': 'start_time',

'end_time': 'end_time',

}

sort_sql = sort_map.get(sort, 'end_time')

dir_sql = 'ASC' if direction == 'asc' else 'DESC'

params = []

where_q = ''

if q:

where_q = " AND (run_name ILIKE %s OR service ILIKE %s)"

like = f"%{q}%"

params.extend([like, like])

conn = _ts_conn()

test_type_supported = True

with conn, conn.cursor() as cur:

try:

if pa:

cur.execute(

f"""

""",

(pa, *params, pa, offset, limit)

)

else:

cur.execute(

f"""

""",

(*params, offset, limit)

)

rows = cur.fetchall()

except Exception:

# Fallback для старых таблиц без test_type

test_type_supported = False

try:

conn.rollback()

except Exception:

pass

try:

if pa:

cur.execute(

f"""

""",

(pa, *params, pa, offset, limit)

)

else:

cur.execute(

f"""

""",

(*params, offset, limit)

)

rows = cur.fetchall()

except Exception:

# Минимальный фолбэк без verdict/test_type

try:

conn.rollback()

except Exception:

pass

if pa:

cur.execute(

f"""

""",

(pa, *params, pa, offset, limit)

)

else:

cur.execute(

f"""

""",

(*params, offset, limit)

)

rows = cur.fetchall()

conn.close()

out = []

for r in rows:

item = {

"run_name": r[0],

"start_time": r[1].isoformat() if r[1] else None,

"end_time": r[2].isoformat() if r[2] else None,

"service": r[3],

"verdict": r[4],

"report_created_at": (r[5].isoformat() if r[5] else None),

}

if test_type_supported:

item["test_type"] = r[6] or ""

else:

item["test_type"] = ""

out.append(item)

return jsonify(out)

except Exception as e:

try:

conn = _ts_conn()

pa = _active_project_area()

with conn, conn.cursor() as cur:

if pa:

cur.execute(

"""

""",

(pa,)

)

else:

cur.execute(

"""

)

rows = cur.fetchall()

conn.close()

out = {}

for d, ql, cnt in rows:

out.setdefault(d, []).append({"query_label": ql, "count": int(cnt)})

return jsonify(out)

except Exception as e:

run_a = request.args.get("run_a")

run_b = request.args.get("run_b")

domain = request.args.get("domain")

ql = request.args.get("query_label")

series_key = request.args.get("series_key")

align = request.args.get("align", "offset") # absolute|offset

if not all([run_a, run_b, domain, ql]):

return jsonify({"error": "run_a, run_b, domain, query_label обязательны"}), 400

try:

# Автоматически подобрать ключ серии, если не задан или задан как 'auto'

if not series_key or series_key == "auto":

series_key = _series_key_for(domain, ql, default_key="application")

conn = _ts_conn()

pa = _active_project_area()

sql_common = f"""

with conn, conn.cursor() as cur:

if align == "absolute":

cur.execute(

f"""

""",

((run_a, run_b, domain, ql, pa) if pa else (run_a, run_b, domain, ql))

)

rows = cur.fetchall()

data = [{"t": r[0].isoformat(), "run_name": r[1], "series": r[2], "value": float(r[3])} for r in rows]

else:

# Фиксированная дискретизация смещения: 60 секунд

bucket_secs = 60

cur.execute(

f"""

""",

((run_a, run_b, domain, ql, pa, bucket_secs, bucket_secs) if pa else (run_a, run_b, domain, ql, bucket_secs, bucket_secs))

)

rows = cur.fetchall()

data = [{"t_offset_sec": int(r[0]), "run_name": r[1], "series": r[2], "value": float(r[3])} for r in rows]

conn.close()

return jsonify({"align": align, "points": data})

except Exception as e:

run_name = request.args.get("run_name")

domain = request.args.get("domain")

ql = request.args.get("query_label")

series_key = request.args.get("series_key")

align = request.args.get("align", "absolute")

if not all([run_name, domain, ql]):

return jsonify({"error": "run_name, domain, query_label обязательны"}), 400

try:

# Автоматически подобрать ключ серии, если не задан или задан как 'auto'

if not series_key or series_key == "auto":

series_key = _series_key_for(domain, ql, default_key="application")

conn = _ts_conn()

pa = _active_project_area()

sql_common = f"""

""".replace("{series_key}", series_key)

with conn, conn.cursor() as cur:

if align == "absolute":

cur.execute(

f"""

""",

((run_name, domain, ql, pa) if pa else (run_name, domain, ql))

)

rows = cur.fetchall()

data = [{"t": r[0].isoformat(), "series": r[1], "value": float(r[2])} for r in rows]

else:

bucket_secs = 60

cur.execute(

f"""

""",

((run_name, domain, ql, pa, bucket_secs, bucket_secs) if pa else (run_name, domain, ql, bucket_secs, bucket_secs))

)

rows = cur.fetchall()

data = [{"t_offset_sec": int(r[0]), "series": r[1], "value": float(r[2])} for r in rows]

conn.close()

return jsonify({"align": align, "points": data})

except Exception as e:

data = request.json # Получаем JSON-данные от формы

start_str = data.get('start')

end_str = data.get('end')

service = data.get('service')

test_type = (data.get('test_type') or '').strip()

use_llm = bool(data.get('use_llm', True))

save_to_db = bool(data.get('save_to_db', False))

web_only = bool(data.get('web_only', False))

run_name = data.get('run_name') if isinstance(data.get('run_name'), str) else None

# Проверка наличия необходимых параметров

if not all([start_str, end_str, service]):

return jsonify({"status": "error", "message": "Пожалуйста, укажите время начала, окончания и сервис"}), 400

# Конвертация времени в timestamp

try:

start = convert_to_timestamp(start_str)

end = convert_to_timestamp(end_str)

except ValueError:

return jsonify({"status": "error", "message": "Некорректный формат времени. Используйте формат YYYY-MM-DDTHH:MM"}), 400

# Проверка наличия конфигурации для выбранного сервиса (по активному metrics_config)

if service not in (_active_metrics_config() or {}):

return jsonify({"status": "error", "message": f"Конфигурация для сервиса '{service}' не найдена"}), 400

# Проверка уникальности имени запуска (в пределах выбранной области/сервиса)

run_name = (run_name or '').strip() if isinstance(run_name, str) else ''

if run_name:

try:

cfg = (CONFIG.get("storage", {}) or {}).get("timescale", {})

schema = cfg.get("schema", "public")

llm_table = cfg.get("llm_table", "llm_reports")

conn = _ts_conn()

exists = False

with conn, conn.cursor() as cur:

try:

cur.execute("SELECT 1 FROM public.metrics WHERE run_name = %s AND service = %s LIMIT 1", (run_name, service))

if cur.fetchone():

exists = True

except Exception:

exists = False if exists is False else True

if not exists:

try:

cur.execute(f"SELECT 1 FROM {schema}.{llm_table} WHERE run_name = %s AND service = %s LIMIT 1", (run_name, service))

if cur.fetchone():

exists = True

except Exception:

pass

conn.close()

if exists:

return jsonify({"status": "error", "message": f"Запуск с именем '{run_name}' уже существует для области '{service}'. Выберите другое имя."}), 400

except Exception:

# В случае ошибки проверки не блокируем, но логичнее отклонить — оставим мягко

pass