Add Firstrade strategy precheck runtime reports

application/rebalance_service.py

@@ -292,6 +292,8 @@ def run_strategy_cycle(
     state_store: GcsStateStore | None = None,
     notification_sender: Callable[[str], None] | None = None,
     env_reader: Callable[[str, str | None], str | None] = os.getenv,
+    send_cycle_notification: bool = True,
+    dispatch_plugin_alerts: bool = True,
 ) -> dict[str, Any]:
     now = _utcnow()
     settings = runtime_settings or load_platform_runtime_settings(project_id_resolver=get_project_id)
@@ -440,15 +442,16 @@ def run_strategy_cycle(
             )
     strategy_plugin_alert_result = None
     strategy_plugin_alert_error = None
-    try:
-        strategy_plugin_alert_result = publish_strategy_plugin_alerts(
-            strategy_plugin_signals,
-            settings=settings,
-            translator=translator,
-            env_reader=env_reader,
-        )
-    except Exception as exc:
-        strategy_plugin_alert_error = f"{type(exc).__name__}: {exc}"
+    if dispatch_plugin_alerts:
+        try:
+            strategy_plugin_alert_result = publish_strategy_plugin_alerts(
+                strategy_plugin_signals,
+                settings=settings,
+                translator=translator,
+                env_reader=env_reader,
+            )
+        except Exception as exc:
+            strategy_plugin_alert_error = f"{type(exc).__name__}: {exc}"
     strategy_run_persisted = False
     strategy_run_persistence_error = None
     if persist_strategy_runs:
@@ -579,13 +582,17 @@ def run_strategy_cycle(
         except Exception as exc:
             result["strategy_run_persisted"] = False
             result["strategy_run_persistence_error"] = f"{type(exc).__name__}: {exc}"
-    try:
-        result["notification_sent"] = _publish_cycle_notification(
-            result,
-            settings=settings,
-            notification_sender=notification_sender,
-        )
-    except Exception as exc:
+    if send_cycle_notification:
+        try:
+            result["notification_sent"] = _publish_cycle_notification(
+                result,
+                settings=settings,
+                notification_sender=notification_sender,
+            )
+        except Exception as exc:
+            result["notification_sent"] = False
+            result["notification_error"] = f"{type(exc).__name__}: {exc}"
+    else:
         result["notification_sent"] = False
-        result["notification_error"] = f"{type(exc).__name__}: {exc}"
+        result["notification_suppressed"] = True
     return result

main.py

@@ -4,7 +4,9 @@
 
 import os
 import traceback
+from dataclasses import replace
 from datetime import datetime, timezone
+from typing import Any
 
 from flask import Flask, jsonify, request
 
@@ -18,11 +20,22 @@
 from application.rebalance_service import run_strategy_cycle
 from application.session_check_service import run_session_check
 from notifications.telegram import build_sender
+from quant_platform_kit.common.runtime_reports import (
+    append_runtime_report_error,
+    build_runtime_report_base,
+    finalize_runtime_report,
+    persist_runtime_report,
+)
+from runtime_config_support import PlatformRuntimeSettings, load_platform_runtime_settings
 from strategy_registry import get_platform_profile_status_matrix
 
 app = Flask(__name__)
 
 
+def get_project_id() -> str | None:
+    return os.getenv("GOOGLE_CLOUD_PROJECT")
+
+
 def _flag(name: str, default: str = "false") -> bool:
     return (os.getenv(name, default) or "").strip().lower() == "true"
 
@@ -95,6 +108,170 @@ def _handle_strategy_run_exception(exc: Exception) -> bool:
     return _notify_runtime_error(exc)
 
 
+def _build_run_id() -> str:
+    return datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+
+
+def _service_name() -> str:
+    return os.getenv("K_SERVICE") or "firstrade-quant-service"
+
+
+def _runtime_settings(*, dry_run_override: bool | None = None) -> PlatformRuntimeSettings:
+    settings = load_platform_runtime_settings(project_id_resolver=get_project_id)
+    if dry_run_override is None:
+        return settings
+    runtime_target = settings.runtime_target
+    if runtime_target is not None:
+        runtime_target = replace(runtime_target, dry_run_only=bool(dry_run_override))
+    return replace(
+        settings,
+        dry_run_only=bool(dry_run_override),
+        live_trading_enabled=False if dry_run_override else settings.live_trading_enabled,
+        runtime_target=runtime_target,
+    )
+
+
+def _build_runtime_report(settings: PlatformRuntimeSettings, *, dry_run: bool) -> dict[str, Any]:
+    runtime_target = settings.runtime_target
+    return build_runtime_report_base(
+        platform="firstrade",
+        deploy_target="cloud_run",
+        service_name=_service_name(),
+        strategy_profile=settings.strategy_profile,
+        run_id=_build_run_id(),
+        run_source="cloud_run",
+        runtime_target=runtime_target,
+        strategy_domain=settings.strategy_domain,
+        account_scope=(
+            getattr(runtime_target, "account_scope", None)
+            if runtime_target is not None
+            else settings.account_region
+        ),
+        account_region=settings.account_region,
+        project_id=settings.project_id or get_project_id(),
+        dry_run=dry_run,
+        started_at=datetime.now(timezone.utc),
+        summary={
+            "strategy_display_name": settings.strategy_display_name,
+            "strategy_display_name_localized": settings.strategy_display_name,
+        },
+    )
+
+
+def _plugin_report_fields(result: dict[str, Any]) -> dict[str, Any]:
+    fields: dict[str, Any] = {}
+    for key, value in result.items():
+        if key == "strategy_plugins" or key.startswith("strategy_plugin_alert_"):
+            fields[key] = value
+    return fields
+
+
+def _strategy_result_summary(result: dict[str, Any], *, dry_run: bool) -> dict[str, Any]:
+    submitted_orders = list(result.get("submitted_orders") or ())
+    skipped_orders = list(result.get("skipped_orders") or ())
+    execution_notes = list(result.get("execution_notes") or ())
+    orders_previewed_count = len(submitted_orders) if dry_run else 0
+    summary = {
+        "action_done": bool(result.get("action_done")),
+        "execution_status": result.get("strategy_run_stage"),
+        "order_events_count": len(submitted_orders),
+        "orders_previewed_count": orders_previewed_count,
+        "orders_skipped_count": len(skipped_orders),
+        "notes_count": len(execution_notes),
+        "dry_run_order_preview_available": bool(dry_run and orders_previewed_count > 0),
+        "strategy_run_period": result.get("strategy_run_period"),
+        "strategy_run_stage": result.get("strategy_run_stage"),
+        "strategy_run_persisted": result.get("strategy_run_persisted"),
+        "session_reused": bool(result.get("session_reused")),
+        "live_trading_enabled": bool(result.get("live_trading_enabled")),
+        **_plugin_report_fields(result),
+    }
+    if dry_run and submitted_orders:
+        summary["orders_previewed"] = submitted_orders
+    if skipped_orders:
+        summary["orders_skipped"] = skipped_orders
+    if execution_notes:
+        summary["execution_notes"] = execution_notes
+    return summary
+
+
+def _strategy_result_diagnostics(result: dict[str, Any]) -> dict[str, Any]:
+    diagnostics: dict[str, Any] = {}
+    signal_snapshot = result.get("signal_snapshot")
+    if signal_snapshot:
+        diagnostics["signal_snapshot"] = signal_snapshot
+    for key in (
+        "strategy_plugin_error",
+        "strategy_plugin_alert_error",
+        "strategy_run_persistence_error",
+        "execution_blocked",
+        "execution_block_retryable",
+        "execution_blocking_skips",
+        "funding_blocked",
+        "error",
+    ):
+        value = result.get(key)
+        if value not in (None, "", [], {}):
+            diagnostics[key] = value
+    return diagnostics
+
+
+def _persist_runtime_report(report: dict[str, Any]) -> str | None:
+    persisted = persist_runtime_report(
+        report,
+        gcs_prefix_uri=os.getenv("EXECUTION_REPORT_GCS_URI"),
+        gcp_project_id=get_project_id(),
+    )
+    if isinstance(persisted, str):
+        return persisted
+    return getattr(persisted, "gcs_uri", None) or getattr(persisted, "local_path", None)
+
+
+def _run_strategy_cycle_with_report(
+    *,
+    dry_run_override: bool | None = None,
+    send_cycle_notification: bool = True,
+    dispatch_plugin_alerts: bool = True,
+) -> dict[str, Any]:
+    settings = _runtime_settings(dry_run_override=dry_run_override)
+    dry_run = bool(settings.dry_run_only)
+    report = _build_runtime_report(settings, dry_run=dry_run)
+    try:
+        result = run_strategy_cycle(
+            runtime_settings=settings,
+            send_cycle_notification=send_cycle_notification,
+            dispatch_plugin_alerts=dispatch_plugin_alerts,
+        )
+        finalize_runtime_report(
+            report,
+            status="ok" if result.get("ok", True) else "error",
+            summary=_strategy_result_summary(result, dry_run=dry_run),
+            diagnostics=_strategy_result_diagnostics(result),
+        )
+        try:
+            report_path = _persist_runtime_report(report)
+            if report_path:
+                print(f"execution_report {report_path}", flush=True)
+        except Exception as persist_exc:
+            print(f"failed to persist execution report: {persist_exc}", flush=True)
+        return result
+    except Exception as exc:
+        append_runtime_report_error(
+            report,
+            stage="strategy_cycle",
+            message=str(exc),
+            error_type=type(exc).__name__,
+        )
+        finalize_runtime_report(report, status="error")
+        try:
+            report_path = _persist_runtime_report(report)
+            if report_path:
+                print(f"execution_report {report_path}", flush=True)
+        except Exception as persist_exc:
+            print(f"failed to persist execution report: {persist_exc}", flush=True)
+        raise
+
+
 @app.get("/")
 def health():
     return jsonify(
@@ -196,7 +373,7 @@ def run_strategy():
             403,
         )
     try:
-        return jsonify(run_strategy_cycle())
+        return jsonify(_run_strategy_cycle_with_report())
     except (FirstradePlatformError, EnvironmentError, ValueError) as exc:
         notification_attempted = _handle_strategy_run_exception(exc)
         return (
@@ -226,7 +403,38 @@ def run_strategy():
 @app.post("/precheck")
 @app.get("/precheck")
 def precheck():
-    return health()
+    try:
+        return jsonify(
+            _run_strategy_cycle_with_report(
+                dry_run_override=True,
+                send_cycle_notification=False,
+                dispatch_plugin_alerts=False,
+            )
+        )
+    except (FirstradePlatformError, EnvironmentError, ValueError) as exc:
+        notification_attempted = _handle_strategy_run_exception(exc)
+        return (
+            jsonify(
+                {
+                    "ok": False,
+                    "error": str(exc),
+                    "runtime_error_notification_attempted": notification_attempted,
+                }
+            ),
+            500,
+        )
+    except Exception as exc:
+        notification_attempted = _handle_strategy_run_exception(exc)
+        return (
+            jsonify(
+                {
+                    "ok": False,
+                    "error": f"{type(exc).__name__}: {exc}",
+                    "runtime_error_notification_attempted": notification_attempted,
+                }
+            ),
+            500,
+        )
 
 
 @app.post("/probe")

tests/test_request_handling.py

@@ -58,7 +58,7 @@ def test_run_endpoint_is_disabled_without_explicit_http_gate(monkeypatch):
 
 def test_run_endpoint_calls_strategy_cycle_when_gate_enabled(monkeypatch):
     monkeypatch.setenv("FIRSTRADE_RUN_STRATEGY_ON_HTTP", "true")
-    monkeypatch.setattr(main, "run_strategy_cycle", lambda: {"ok": True, "action_done": False})
+    monkeypatch.setattr(main, "_run_strategy_cycle_with_report", lambda **_kwargs: {"ok": True, "action_done": False})
     client = main.app.test_client()
 
     response = client.post("/run")
@@ -98,7 +98,7 @@ def test_session_check_endpoint_calls_service_when_gate_enabled(monkeypatch):
 
 def test_root_post_calls_strategy_cycle_when_gate_enabled(monkeypatch):
     monkeypatch.setenv("FIRSTRADE_RUN_STRATEGY_ON_HTTP", "true")
-    monkeypatch.setattr(main, "run_strategy_cycle", lambda: {"ok": True, "action_done": False})
+    monkeypatch.setattr(main, "_run_strategy_cycle_with_report", lambda **_kwargs: {"ok": True, "action_done": False})
     client = main.app.test_client()
 
     response = client.post("/")
@@ -125,7 +125,7 @@ def send(message):
     monkeypatch.setattr(main, "build_sender", fake_build_sender)
     monkeypatch.setattr(
         main,
-        "run_strategy_cycle",
+        "_run_strategy_cycle_with_report",
         lambda: (_ for _ in ()).throw(ValueError("snapshot denied")),
     )
     client = main.app.test_client()
@@ -153,7 +153,7 @@ def test_run_endpoint_error_does_not_require_telegram_config(monkeypatch):
     monkeypatch.delenv("STRATEGY_PLUGIN_ALERT_TELEGRAM_CHAT_IDS", raising=False)
     monkeypatch.setattr(
         main,
-        "run_strategy_cycle",
+        "_run_strategy_cycle_with_report",
         lambda: (_ for _ in ()).throw(RuntimeError("boom")),
     )
     client = main.app.test_client()
@@ -167,11 +167,24 @@ def test_run_endpoint_error_does_not_require_telegram_config(monkeypatch):
     assert payload["runtime_error_notification_attempted"] is False
 
 
-def test_scheduler_health_routes_accept_post():
+def test_scheduler_routes_accept_post(monkeypatch):
+    observed = {}
+
+    def fake_run_strategy_cycle_with_report(**kwargs):
+        observed.update(kwargs)
+        return {"ok": True, "action_done": False}
+
+    monkeypatch.setattr(main, "_run_strategy_cycle_with_report", fake_run_strategy_cycle_with_report)
     client = main.app.test_client()
 
     precheck_response = client.post("/precheck")
     probe_response = client.post("/probe")
 
     assert precheck_response.status_code == 200
+    assert precheck_response.get_json()["ok"] is True
+    assert observed == {
+        "dry_run_override": True,
+        "send_cycle_notification": False,
+        "dispatch_plugin_alerts": False,
+    }
     assert probe_response.status_code == 200