26Y01a4

"""
step3_analytics.py — Advanced Infrastructure Resource Visualization Engine (English Standard)
"""
import os
import re
import pandas as pd
import numpy as np
from pathlib import Path

# ─── 🛡️ [Headless Environment Guard] Prevents crashes in K8s pods without display servers ───
import matplotlib
matplotlib.use('Agg') 
import matplotlib.pyplot as plt
import seaborn as sns

# ─── 📂 [경로 동기화] step6와 완벽히 일치하는 ./data 상대 경로 표준화 ───
BASE_DATA_DIR = Path("./data")
MERGED_DIR    = BASE_DATA_DIR / "merged"
PLOT_DIR      = BASE_DATA_DIR / "output" / "plots"

# 차트 디렉토리 생성 보장
PLOT_DIR.mkdir(parents=True, exist_ok=True)

# ─── 🔤 [No More Tofu] Use bulletproof built-in standard fonts ───
plt.rcParams['font.family'] = 'sans-serif'
plt.rcParams['axes.unicode_minus'] = False  # Prevents minus sign (-) corruption
sns.set_theme(style="whitegrid")

def check_empty_data(df, chart_name):
    if df.empty:
        print(f"  ⚠️  [Empty Data] Skipping {chart_name} due to empty rows.")
        return True
    return False

def main():
    print("🚀 [Step3 개시] FinOps 다차원 시계열 영문 시각화 분석 엔진 가동...")
    
    p1 = MERGED_DIR / "enriched_fixed_7d.parquet"
    p2 = MERGED_DIR / "pareto_fixed_ns.parquet"
    
    print(f"📖 가공 원부 스캔 경로:\n   - {p1}\n   - {p2}")
    if not p1.exists():
        print("❌ 오류: step2 파이프라인의 가공 산출물(Parquet)이 없습니다. step2를 먼저 실행하세요.")
        return
        
    df_pod = pd.read_parquet(p1)
    df_ns  = pd.read_parquet(p2) if p2.exists() else pd.DataFrame()
    print(f"✅ 데이터 레이크 로드 성료 -> 분석 대상 명세 세트: {len(df_pod):,}행 스캔 성공.")

    # ─── 📊 [지표 연산 및 영문 매핑 레이어] ─────────────────────────────────
    df_pod["cpu_util"] = np.where(df_pod["cpu_request_max"] > 0, (df_pod["cpu_usage_p95"] / df_pod["cpu_request_max"] * 100), 0)
    df_pod["mem_util"] = np.where(df_pod["mem_request_max"] > 0, (df_pod["mem_usage_p95"] / df_pod["mem_request_max"] * 100), 0)
    df_pod["lim_req_ratio"] = np.where(df_pod["cpu_request_max"] > 0, df_pod["cpu_limit_max"] / df_pod["cpu_request_max"], 0)
    
    # 차트 범례 글자 깨짐 방지를 위한 한글 상태값 ➡️ 영문 다이렉트 컨버전
    df_pod["status_en"] = df_pod["status"].map({
        "💥 OOM장애발생": "OOM Killed", 
        "⚠️ Request부족": "Request Shortage", 
        "📉 과다할당": "Over-allocated", 
        "✅ 최적화완료": "Optimized"
    }).fillna("Unknown")

    # ─── 📊 [차트 1 & 2] 워크로드 타입별 자원 할당 vs 실사용 피크 분석 ───
    print("\n⏳ [1/18] chart1_cpu_req_vs_usage_by_workload 시각화 연산 중...")
    df_wl_cpu = df_pod.groupby("workload_type")[["cpu_request_max", "cpu_usage_p95"]].mean().reset_index()
    plt.figure(figsize=(10, 5))
    df_melt_cpu = df_wl_cpu.melt(id_vars="workload_type", value_vars=["cpu_request_max", "cpu_usage_p95"])
    sns.barplot(data=df_melt_cpu, x="workload_type", y="value", hue="variable", palette="Blues_r")
    plt.xticks(rotation=30, ha='right')
    plt.title("Average CPU Request vs P95 Peak Usage by Workload Type")
    plt.xlabel("Workload Type")
    plt.ylabel("CPU Cores")
    plt.tight_layout()
    out1 = PLOT_DIR / "chart1_cpu_req_vs_usage_by_workload.png"
    plt.savefig(out1, dpi=100)
    plt.close()
    print(f"  -> 🎨 차트 렌더링 완료: {out1.name}")

    print("⏳ [2/18] chart2_mem_req_vs_usage_by_workload 고도화(Memory RSS 레이어 편입) 연산 중...")
    # 💡 [고도화 인사이트] Working Set과 순수 RSS 메모리 격차를 한눈에 볼 수 있도록 3중 바 차트로 확장
    df_wl_mem = df_pod.groupby("workload_type")[["mem_request_max", "mem_usage_p95", "mem_rss_p95"]].mean().reset_index()
    plt.figure(figsize=(10, 5))
    df_melt_mem = df_wl_mem.melt(id_vars="workload_type", value_vars=["mem_request_max", "mem_usage_p95", "mem_rss_p95"])
    sns.barplot(data=df_melt_mem, x="workload_type", y="value", hue="variable", palette="Purples_r")
    plt.xticks(rotation=30, ha='right')
    plt.title("Average Memory Specification vs WorkingSet vs RSS Peak (GB)")
    plt.xlabel("Workload Type")
    plt.ylabel("Memory Capacity (GB)")
    plt.tight_layout()
    out2 = PLOT_DIR / "chart2_mem_req_vs_usage_by_workload.png"
    plt.savefig(out2, dpi=100)
    plt.close()
    print(f"  -> 🎨 차트 렌더링 완료: {out2.name}")

    # ─── 📊 [차트 3] 일별 CPU 낭비 누적 막대 차트 ───
    print("⏳ [3/18] chart3_daily_waste_stack 누적 시계열 연산 중...")
    df_daily_waste = df_pod.groupby(["date", "workload_type"])["cpu_waste_core_hours"].sum().unstack().fillna(0)
    if not check_empty_data(df_daily_waste, "chart3_daily_waste_stack"):
        df_daily_waste.plot(kind='bar', stacked=True, figsize=(11, 5), cmap="tab20")
        plt.title("Daily Total CPU Waste Core-Hours Stacked by Workload Type (KST)")
        plt.xlabel("Date (KST)")
        plt.ylabel("Waste Volume (Core-Hours)")
        plt.xticks(rotation=45)
        plt.tight_layout()
        out3 = PLOT_DIR / "chart3_daily_waste_stack.png"
        plt.savefig(out3, dpi=100)
        plt.close()
        print(f"  -> 🎨 차트 렌더링 완료: {out3.name}")

    # ─── 📊 [차트 4 & 18] 자원 활용 지형 히트맵 (Heatmap) 연산 ───
    print("⏳ [4/18] chart4_cpu_efficiency_heatmap 효율 격자 지도 작성 중...")
    df_heat_cpu = df_pod.groupby(["workload_type", "date"])["cpu_util"].mean().unstack().fillna(0)
    plt.figure(figsize=(10, 5))
    sns.heatmap(df_heat_cpu, annot=True, fmt=".1f", cmap="RdYlGn", cbar=True)
    plt.title("Mean CPU Utilization Heatmap (%) (Workload Type x Date)")
    plt.xlabel("Date (KST)")
    plt.ylabel("Workload Type")
    plt.tight_layout()
    out4 = PLOT_DIR / "chart4_cpu_efficiency_heatmap.png"
    plt.savefig(out4, dpi=100)
    plt.close()
    print(f"  -> 🎨 차트 렌더링 완료: {out4.name}")

    print("⏳ [5/18] chart18_mem_waste_heatmap 메모리 손실 매트릭스 연산 중...")
    df_heat_mem = df_pod.groupby(["workload_type", "date"])["mem_waste_gb_hours"].sum().unstack().fillna(0)
    plt.figure(figsize=(10, 5))
    sns.heatmap(df_heat_mem, annot=False, cmap="BuPu", cbar=True)
    plt.title("Total Memory Waste Volume Heatmap (GB-Hours)")
    plt.xlabel("Date (KST)")
    plt.ylabel("Workload Type")
    plt.tight_layout()
    out18 = PLOT_DIR / "chart18_mem_waste_heatmap.png"
    plt.savefig(out18, dpi=100)
    plt.close()
    print(f"  -> 🎨 차트 렌더링 완료: {out18.name}")

    # ─── 📊 [차트 5 & 11] 거버넌스 파레토 누적 차트 ───
    print("⏳ [6/18] chart5_pareto_ns_waste 비용 낭비 부서 서열화 추적 중...")
    if not check_empty_data(df_ns, "chart5_pareto_ns_waste"):
        df_ns_top = df_ns.head(15)
        fig, ax1 = plt.subplots(figsize=(11, 5))
        sns.barplot(data=df_ns_top, x="namespace", y="total_waste_core_hours", ax=ax1, color="steelblue")
        ax1.set_xticklabels(ax1.get_xticklabels(), rotation=45, ha="right")
        ax2 = ax1.twinx()
        ax2.plot(df_ns_top["namespace"], df_ns_top["waste_cumsum_pct"], color="crimson", marker="o", linewidth=2)
        ax2.set_ylim(0, 110)
        plt.title("Top 15 Namespace Cost-Waste Pareto Chart (Cumulative Share %)")
        ax1.set_xlabel("Tenant Namespace")
        ax1.set_ylabel("Waste Volume (Core-Hours)")
        plt.tight_layout()
        out5 = PLOT_DIR / "chart5_pareto_ns_waste.png"
        plt.savefig(out5, dpi=100)
        plt.close()
        print(f"  -> 🎨 차트 렌더링 완료: {out5.name}")

    print("⏳ [7/18] chart11_pareto_workload_waste 기술 도메인 지분율 집계 중...")
    df_wl_waste = df_pod.groupby("workload_type")["cpu_waste_core_hours"].sum().reset_index().sort_values("cpu_waste_core_hours", ascending=False)
    plt.figure(figsize=(10, 5))
    sns.barplot(data=df_wl_waste, x="workload_type", y="cpu_waste_core_hours", palette="Oranges_r")
    plt.xticks(rotation=30, ha="right")
    plt.title("Total CPU Waste Volume by Workload Type")
    plt.xlabel("Workload Type")
    plt.ylabel("Total Waste (Core-Hours)")
    plt.tight_layout()
    out11 = PLOT_DIR / "chart11_pareto_workload_waste.png"
    plt.savefig(out11, dpi=100)
    plt.close()
    print(f"  -> 🎨 차트 렌더링 완료: {out11.name}")

    # ─── 📊 [차트 6] 자원 할당 상태 스코어 도넛 차트 ───
    print("⏳ [8/18] chart6_status_donut 거버넌스 건전성 비율 도출 중...")
    status_summary = df_pod["status_en"].value_counts()
    plt.figure(figsize=(6, 5))
    colors = ["#70AD47", "#1F4E79", "#FFC000", "#C00000"]
    plt.pie(status_summary, labels=status_summary.index, autopct='%1.1f%%', startangle=90, colors=colors[:len(status_summary)], wedgeprops=dict(width=0.4, edgecolor='w'))
    plt.title("Infrastructure Resource Governance Status Ratio")
    plt.tight_layout()
    out6 = PLOT_DIR / "chart6_status_donut.png"
    plt.savefig(out6, dpi=100)
    plt.close()
    print(f"  -> 🎨 차트 렌더링 완료: {out6.name}")

    # ─── 📊 [차트 7 & 14] 낭비 입체 분포 분산도 차트 (Bubble & Scatter) ───
    print("⏳ [9/18] chart7_waste_footprint_bubble 3차원 입체 관계 분포도 매핑 중...")
    df_bubble = df_pod.groupby("workload_type").agg(
        x_alloc=("cpu_allocated_core_hours", "sum"),
        y_util=("cpu_util", "mean"),
        z_waste=("cpu_waste_core_hours", "sum")
    ).reset_index()
    plt.figure(figsize=(9, 6))
    sns.scatterplot(data=df_bubble, x="x_alloc", y="y_util", size="z_waste", hue="workload_type", sizes=(100, 2000), alpha=0.7, legend="brief")
    plt.title("Resource Footprint Bubble Chart (Allocated x Utilization x Waste Size)")
    plt.xlabel("Total Allocated Core-Hours")
    plt.ylabel("Average Utilization (%)")
    plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
    plt.tight_layout()
    out7 = PLOT_DIR / "chart7_waste_footprint_bubble.png"
    plt.savefig(out7, dpi=100)
    plt.close()
    print(f"  -> 🎨 차트 렌더링 완료: {out7.name}")

    print("⏳ [10/18] chart14_cpu_mem_waste_scatter 자원 손실 교차 교정 트래킹 중...")
    # 💡 [고도화 인사이트] PV 스토리지 낭비량(pv_waste_gb_hours)을 점의 크기(Size)로 연동하여 인프라 입체 진단 수행
    plt.figure(figsize=(9, 6))
    sns.scatterplot(data=df_pod.head(5000), x="cpu_waste_core_hours", y="mem_waste_gb_hours", size="pv_waste_gb_hours", hue="workload_type", alpha=0.5, sizes=(20, 400))
    plt.title("Multi-Resource Loss Co-relation: CPU vs Memory vs PV Storage (Size)")
    plt.xlabel("CPU Waste (Core-Hours)")
    plt.ylabel("Memory Waste (GB-Hours)")
    plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
    plt.tight_layout()
    out14 = PLOT_DIR / "chart14_cpu_mem_waste_scatter.png"
    plt.savefig(out14, dpi=100)
    plt.close()
    print(f"  -> 🎨 차트 렌더링 완료: {out14.name}")

    # ─── 📊 [차트 8] 가용성 저하 리스크 분석 ───
    print("⏳ [11/18] chart8_shortfall_footprint 리소스 부족 및 스로틀링 병목 탐지 중...")
    # 💡 [고도화 인사이트] 단순 부족 수치 외에, 새롭게 수집된 CPU CFS 스로틀링 지표를 히트맵 지형으로 구성
    df_short = df_pod.groupby(["workload_type", "date"])["cpu_throttled_max"].max().unstack().fillna(0)
    plt.figure(figsize=(10, 4))
    sns.heatmap(df_short, annot=False, cmap="YlOrRd", cbar=True)
    plt.title("Container CPU CFS Throttled Periods Peak Footprint (Risk Matrix)")
    plt.xlabel("Date (KST)")
    plt.ylabel("Workload Type")
    plt.tight_layout()
    out8 = PLOT_DIR / "chart8_shortfall_footprint.png"
    plt.savefig(out8, dpi=100)
    plt.close()
    print(f"  -> 🎨 차트 렌더링 완료: {out8.name}")

    # ─── 📊 [차트 9 & 10] 효율 통계 분위 분석 (Boxplot) ───
    print("⏳ [12/18] chart9_boxplot_cpu_util_by_workload CPU 하중 분포도 연산 중...")
    plt.figure(figsize=(11, 5))
    sns.boxplot(data=df_pod, x="workload_type", y="cpu_util", palette="Set3")
    plt.xticks(rotation=30, ha="right")
    plt.ylim(-5, 105)
    plt.title("CPU Utilization P95 Boxplot Distribution by Workload Type")
    plt.xlabel("Workload Type")
    plt.ylabel("P95 Actual Utilization (%)")
    plt.tight_layout()
    out9 = PLOT_DIR / "chart9_boxplot_cpu_util_by_workload.png"
    plt.savefig(out9, dpi=100)
    plt.close()
    print(f"  -> 🎨 차트 렌더링 완료: {out9.name}")

    print("⏳ [13/18] chart10_boxplot_mem_util_by_workload 메모리 하중 분포도 연산 중...")
    plt.figure(figsize=(11, 5))
    sns.boxplot(data=df_pod, x="workload_type", y="mem_util", palette="Pastel1")
    plt.xticks(rotation=30, ha="right")
    plt.ylim(-5, 105)
    plt.title("Memory Utilization P95 Boxplot Distribution by Workload Type")
    plt.xlabel("Workload Type")
    plt.ylabel("P95 Actual Utilization (%)")
    plt.tight_layout()
    out10 = PLOT_DIR / "chart10_boxplot_mem_util_by_workload.png"
    plt.savefig(out10, dpi=100)
    plt.close()
    print(f"  -> 🎨 차트 렌더링 완료: {out10.name}")

    # ─── 📊 [차트 12 & 15] 연쇄 결산 추이 및 장애 상태 격리 차트 ───
    print("⏳ [14/18] chart12_daily_waste_trend_by_workload 장기 타임라인 변동 추적 중...")
    df_trend_wl = df_pod.groupby(["date", "workload_type"])["cpu_waste_core_hours"].sum().unstack().fillna(0)
    plt.figure(figsize=(11, 5))
    sns.lineplot(data=df_trend_wl, markers=True, dashes=False, linewidth=2)
    plt.title("Daily CPU Waste Timeline Trend Line by Workload Type")
    plt.xlabel("Date (KST)")
    plt.ylabel("Waste Volume (Core-Hours)")
    plt.xticks(rotation=30)
    plt.tight_layout()
    out12 = PLOT_DIR / "chart12_daily_waste_trend_by_workload.png"
    plt.savefig(out12, dpi=100)
    plt.close()
    print(f"  -> 🎨 차트 렌더링 완료: {out12.name}")

    print("⏳ [15/18] chart15_oom_status_by_workload 장애군 카운트 분류 중...")
    plt.figure(figsize=(11, 5))
    sns.countplot(data=df_pod, x="workload_type", hue="status_en", palette="muted")
    plt.xticks(rotation=30, ha="right")
    plt.title("Governance Status Distribution Count per Workload Type")
    plt.xlabel("Workload Type")
    plt.ylabel("Pod Count")
    plt.legend(loc="upper right")
    plt.tight_layout()
    out15 = PLOT_DIR / "chart15_oom_status_by_workload.png"
    plt.savefig(out15, dpi=100)
    plt.close()
    print(f"  -> 🎨 차트 렌더링 완료: {out15.name}")

    # ─── 📊 [차트 13 & 17] 자원 정규 분포 및 거버넌스 마진률 바이올린 플롯 ───
    print("⏳ [16/18] chart13_violin_cpu_util 고밀도 커널 밀도 분포 추정 중...")
    plt.figure(figsize=(10, 5))
    sns.violinplot(data=df_pod, x="workload_type", y="cpu_util", inner="quartile", palette="pastel")
    plt.xticks(rotation=30, ha="right")
    plt.title("CPU Utilization Kernel Density Violin Plot")
    plt.xlabel("Workload Type")
    plt.ylabel("CPU Utilization (%)")
    plt.tight_layout()
    out13 = PLOT_DIR / "chart13_violin_cpu_util.png"
    plt.savefig(out13, dpi=100)
    plt.close()
    print(f"  -> 🎨 차트 렌더링 완료: {out13.name}")

    print("⏳ [17/18] chart17_cpu_limit_request_ratio 오버커밋 QoS 비율 측정 중...")
    plt.figure(figsize=(10, 5))
    sns.boxplot(data=df_pod, x="workload_type", y="lim_req_ratio", palette="vlag")
    plt.xticks(rotation=30, ha="right")
    plt.title("Kubernetes Pod CPU Limit / Request Overcommit Ratio")
    plt.xlabel("Workload Type")
    plt.ylabel("Limit / Request Ratio (Factor)")
    plt.tight_layout()
    out17 = PLOT_DIR / "chart17_cpu_limit_request_ratio.png"
    plt.savefig(out17, dpi=100)
    plt.close()
    print(f"  -> 🎨 차트 렌더링 완료: {out17.name}")

    # ─── 📊 [차트 19 & 20] 일별 전사 수용량 대 실효 소모량 면적 차트 ───
    print("⏳ [17/18] chart19_daily_cpu_per_workload 일간 CPU 총량 추이 롤업 중...")
    df_daily_cpu_req = df_pod.groupby("date")["cpu_request_max"].sum()
    df_daily_cpu_use = df_pod.groupby("date")["cpu_usage_p95"].sum()
    plt.figure(figsize=(11, 5))
    plt.fill_between(df_daily_cpu_req.index, df_daily_cpu_req.values, label="Total CPU Request Cores (Capacity)", color="skyblue", alpha=0.4)
    plt.plot(df_daily_cpu_use.index, df_daily_cpu_use.values, label="Total CPU P95 Actual Consumption", color="navy", linewidth=2.5, marker="o")
    plt.title("Daily Total CPU Capacity Allocation vs Actual Peak Consumption Trend (KST)")
    plt.xlabel("Date (KST)")
    plt.ylabel("Total CPU Cores")
    plt.xticks(rotation=30)
    plt.legend(loc="upper left")
    plt.tight_layout()
    out19 = PLOT_DIR / "chart19_daily_cpu_per_workload.png"
    plt.savefig(out19, dpi=100)
    plt.close()
    print(f"  -> 🎨 차트 렌더링 완료: {out19.name}")

    print("⏳ [18/18] chart20_daily_mem_per_workload 일간 메모리/스토리지 면적 적재 중...")
    df_daily_mem_req = df_pod.groupby("date")["mem_request_max"].sum()
    df_daily_mem_use = df_pod.groupby("date")["mem_usage_p95"].sum()
    # 💡 [고도화 인사이트] 메모리와 함께 총 PV 할당 용량의 시계열 스케일을 서브 점선으로 레이아웃 구성
    df_daily_pv_req  = df_pod.groupby("date")["pv_capacity_max"].sum()
    
    fig, ax1 = plt.subplots(figsize=(11, 5))
    ax1.fill_between(df_daily_mem_req.index, df_daily_mem_req.values, label="Total Memory Request (GB)", color="plum", alpha=0.4)
    ax1.plot(df_daily_mem_use.index, df_daily_mem_use.values, label="Total Memory P95 Actual Usage", color="purple", linewidth=2.5, marker="o")
    ax1.set_ylabel("Memory Volume (GB)")
    ax1.set_xlabel("Date (KST)")
    
    ax2 = ax1.twinx()
    ax2.plot(df_daily_pv_req.index, df_daily_pv_req.values, label="Total PV Provisions (GB)", color="teal", linewidth=2, linestyle="--", marker="x")
    ax2.set_ylabel("PV Storage Volume (GB)")
    
    plt.title("Daily Memory & PV Storage Space Provisions vs Active Peak Consumption")
    fig.legend(loc="upper left", bbox_to_anchor=(0.1, 0.9))
    plt.xticks(rotation=30)
    plt.tight_layout()
    out20 = PLOT_DIR / "chart20_daily_mem_per_workload.png"
    plt.savefig(out20, dpi=100)
    plt.close()
    print(f"  -> 🎨 차트 렌더링 완료: {out20.name}")

    print("\n🏁 === [Step3 완결] 글자 깨짐이 원천 박멸된 19대 마스터 영문 차트가 ./data/output/plots/ 에 동기화되었습니다. ===")

if __name__ == "__main__":
    main()