Add performance profiling toggle with detailed timing metrics for health check evaluation, multi-RAT views, traffic computation, delta calculation, and Excel export with per-sheet write timings and row/column counts

panel_app/convert_to_excel_panel.py

@@ -1,11 +1,15 @@
 import io
+import time
 from typing import Iterable, Sequence
 
 import pandas as pd
 
 
 def write_dfs_to_excel(
-    dfs: Sequence[pd.DataFrame], sheet_names: Sequence[str], index: bool = True
+    dfs: Sequence[pd.DataFrame],
+    sheet_names: Sequence[str],
+    index: bool = True,
+    profile: dict | None = None,
 ) -> bytes:
     """Simple Excel export for Panel.
 
@@ -14,10 +18,38 @@ def write_dfs_to_excel(
     and avoid Streamlit runtime warnings.
     """
     bytes_io = io.BytesIO()
+    t0 = time.perf_counter() if profile is not None else 0.0
     with pd.ExcelWriter(bytes_io, engine="xlsxwriter") as writer:
         for df, name in zip(dfs, sheet_names):
             # Ensure we always write a valid DataFrame, even if None was passed
             safe_df = df if isinstance(df, pd.DataFrame) else pd.DataFrame()
+            t_sheet0 = time.perf_counter() if profile is not None else 0.0
             safe_df.to_excel(writer, sheet_name=str(name), index=index)
+            t_sheet1 = time.perf_counter() if profile is not None else 0.0
+
+            if profile is not None:
+                sheets = profile.get("excel_sheets")
+                if not isinstance(sheets, list):
+                    sheets = []
+                    profile["excel_sheets"] = sheets
+                try:
+                    rows = int(len(safe_df))
+                except Exception:  # noqa: BLE001
+                    rows = 0
+                try:
+                    cols = int(safe_df.shape[1])
+                except Exception:  # noqa: BLE001
+                    cols = 0
+                sheets.append(
+                    {
+                        "name": str(name),
+                        "rows": rows,
+                        "cols": cols,
+                        "seconds": float(t_sheet1 - t_sheet0),
+                    }
+                )
+
+    if profile is not None:
+        profile["excel_total_seconds"] = float(time.perf_counter() - t0)
 
     return bytes_io.getvalue()

panel_app/kpi_health_check_panel.py

@@ -1388,6 +1388,11 @@ export_include_raw_data = pn.widgets.Checkbox(
     value=True,
 )
 
+perf_profiling = pn.widgets.Checkbox(
+    name="Perf profiling",
+    value=False,
+)
+
 alert_pack_button = pn.widgets.FileDownload(
     label="Download Alert Pack",
     filename="KPI_Alert_Pack.xlsx",
@@ -3241,8 +3246,13 @@ def run_health_check(event=None) -> None:
         all_status = []
         all_summary = []
 
+        do_profile = bool(perf_profiling.value)
+        t_run0 = time.perf_counter() if do_profile else 0.0
+        rat_timings = []
+
         for rat, daily in current_daily_by_rat.items():
             d = _filtered_daily(daily)
+            t0 = time.perf_counter() if do_profile else 0.0
             status_df, summary_df = evaluate_health_check(
                 d,
                 rat,
@@ -3253,6 +3263,14 @@ def run_health_check(event=None) -> None:
                 int(mcd),
                 granularity=str(granularity_select.value or "Daily"),
             )
+            if do_profile:
+                rat_timings.append(
+                    {
+                        "rat": str(rat),
+                        "seconds": float(time.perf_counter() - t0),
+                        "rows": int(len(d)) if isinstance(d, pd.DataFrame) else 0,
+                    }
+                )
             if not status_df.empty:
                 all_status.append(status_df)
             if not summary_df.empty:
@@ -3266,11 +3284,15 @@ def run_health_check(event=None) -> None:
         )
         site_summary_table.value = current_summary_df
 
+        t_mr0 = time.perf_counter() if do_profile else 0.0
         current_multirat_raw, current_top_anomalies_raw = compute_multirat_views(
             current_status_df
         )
+        mr_seconds = float(time.perf_counter() - t_mr0) if do_profile else 0.0
 
+        t_tr0 = time.perf_counter() if do_profile else 0.0
         traffic_df = _compute_site_traffic_gb(current_daily_by_rat)
+        tr_seconds = float(time.perf_counter() - t_tr0) if do_profile else 0.0
         if traffic_df is not None and not traffic_df.empty:
             if current_multirat_raw is not None and not current_multirat_raw.empty:
                 current_multirat_raw = pd.merge(
@@ -3333,10 +3355,12 @@ def run_health_check(event=None) -> None:
         current_export_bytes = None
         current_alert_pack_bytes = None
 
+        t_dl0 = time.perf_counter() if do_profile else 0.0
         try:
             current_delta_df = _compute_delta_df()
         except Exception:  # noqa: BLE001
             current_delta_df = pd.DataFrame()
+        dl_seconds = float(time.perf_counter() - t_dl0) if do_profile else 0.0
         delta_table.value = current_delta_df
 
         _invalidate_drilldown_cache(healthcheck_changed=True)
@@ -3344,7 +3368,29 @@ def run_health_check(event=None) -> None:
         _update_site_view()
 
         status_pane.alert_type = "success"
-        status_pane.object = "Health check completed."
+        msg = "Health check completed."
+        if do_profile:
+            total_s = float(time.perf_counter() - t_run0)
+            rat_timings_sorted = sorted(
+                rat_timings, key=lambda x: float(x.get("seconds", 0.0)), reverse=True
+            )
+            top_lines = [
+                f"- {r['rat']}: {r['seconds']:.2f}s (rows={r['rows']})"
+                for r in rat_timings_sorted[:8]
+            ]
+            msg = (
+                msg
+                + "\n\nPerf (seconds)"
+                + f"\n- total_run: {total_s:.2f}s"
+                + (
+                    "\n- evaluate_health_check:"
+                    + ("\n" + "\n".join(top_lines) if top_lines else "")
+                )
+                + f"\n- compute_multirat_views: {mr_seconds:.2f}s"
+                + f"\n- compute_site_traffic_gb: {tr_seconds:.2f}s"
+                + f"\n- compute_delta_df: {dl_seconds:.2f}s"
+            )
+        status_pane.object = msg
 
         _refresh_validation_state()
 
@@ -3353,7 +3399,7 @@ def run_health_check(event=None) -> None:
         status_pane.object = f"Error: {exc}"
 
 
-def _build_export_bytes() -> bytes:
+def _build_export_bytes(profile: dict | None = None) -> bytes:
     include_raw = bool(export_include_raw_data.value)
     daily_by_rat = (
         current_daily_by_rat
@@ -3405,14 +3451,47 @@ def _build_export_bytes() -> bytes:
         delta_df=(
             current_delta_df if isinstance(current_delta_df, pd.DataFrame) else None
         ),
+        profile=profile,
     )
 
 
 def _export_callback() -> io.BytesIO:
     global current_export_bytes
-    if current_export_bytes is None:
+    do_profile = bool(perf_profiling.value)
+    if do_profile or current_export_bytes is None:
         try:
-            current_export_bytes = _build_export_bytes()
+            t0 = time.perf_counter() if do_profile else 0.0
+            profile = {} if do_profile else None
+            current_export_bytes = _build_export_bytes(profile=profile)
+            if do_profile:
+                total_s = float(time.perf_counter() - t0)
+                excel_s = (
+                    float(profile.get("excel_total_seconds", 0.0)) if profile else 0.0
+                )
+                prep_s = (
+                    float(profile.get("export_prep_seconds", 0.0)) if profile else 0.0
+                )
+                sheets = profile.get("excel_sheets") if profile else None
+                slow = []
+                if isinstance(sheets, list) and sheets:
+                    sheets2 = [s for s in sheets if isinstance(s, dict)]
+                    sheets2 = sorted(
+                        sheets2,
+                        key=lambda x: float(x.get("seconds", 0.0)),
+                        reverse=True,
+                    )
+                    slow = [
+                        f"- {s.get('name')}: {float(s.get('seconds', 0.0)):.2f}s (rows={s.get('rows')}, cols={s.get('cols')})"
+                        for s in sheets2[:8]
+                    ]
+                status_pane.alert_type = "primary"
+                status_pane.object = (
+                    "Export profiling"
+                    + f"\n- total_export: {total_s:.2f}s"
+                    + f"\n- export_prep: {prep_s:.2f}s"
+                    + f"\n- excel_write: {excel_s:.2f}s"
+                    + ("\n- slowest_sheets:\n" + "\n".join(slow) if slow else "")
+                )
         except Exception:  # noqa: BLE001
             current_export_bytes = b""
     return io.BytesIO(current_export_bytes or b"")
@@ -3949,6 +4028,7 @@ sidebar = pn.Column(
     ),
     pn.Card(
         export_include_raw_data,
+        perf_profiling,
         export_button,
         alert_pack_button,
         title="Export",

process_kpi/kpi_health_check/export.py

@@ -16,7 +16,13 @@ def build_export_bytes(
     complaint_top_anomalies_df: pd.DataFrame | None = None,
     ops_queue_df: pd.DataFrame | None = None,
     delta_df: pd.DataFrame | None = None,
+    profile: dict | None = None,
 ) -> bytes:
+    if profile is not None:
+        profile["export_prep_seconds"] = 0.0
+        profile["excel_total_seconds"] = 0.0
+
+    t_prep0 = pd.Timestamp.utcnow() if profile is not None else None
     dfs = [
         datasets_df if isinstance(datasets_df, pd.DataFrame) else pd.DataFrame(),
         rules_df if isinstance(rules_df, pd.DataFrame) else pd.DataFrame(),
@@ -86,4 +92,11 @@ def build_export_bytes(
             "Delta",
         ]
     )
-    return write_dfs_to_excel(dfs, sheet_names, index=False)
+
+    if profile is not None:
+        t_prep1 = pd.Timestamp.utcnow()
+        if t_prep0 is not None:
+            profile["export_prep_seconds"] = float((t_prep1 - t_prep0).total_seconds())
+        profile["sheet_count"] = int(len(sheet_names))
+
+    return write_dfs_to_excel(dfs, sheet_names, index=False, profile=profile)