feat: track model execution status with failure icon in explorer (#54)

* feat: track model execution status and show failure icon in explorer

Implement model-level execution status tracking (NOT_STARTED, RUNNING,
SUCCESS, FAILED) at DAG node level with visual indicators in the file
explorer. Status is tracked per individual DAG node, ensuring accurate
status for each model even when downstream dependencies fail.

Backend changes:
- Add RunStatus enum and 4 new fields to ConfigModels (run_status,
  failure_reason, last_run_at, run_duration)
- Migration 0003_add_model_run_status
- Update file_explorer.load_models to return status fields
- Add _update_model_status to DAG executor — called before execution
  (RUNNING), after success (SUCCESS), and on exception (FAILED with
  reason)
- Update execute/views.py to return 400 on DAG execution failures
- Fix clear_cache decorator to re-raise exceptions instead of
  swallowing them silently

Frontend changes:
- Add getModelRunStatus helper to render colored dot badges next to
  model names in the explorer tree
- Running: blue, Success: green, Failed: red
- Show Popover on hover over failed status with full error message
  and last run timestamp
- Trigger explorer refresh via setRefreshModels after runTransformation
  succeeds or fails

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: address PR review feedback on model run status tracking

- Drop optional ConfigModels import; it's always present in the OSS build
- Track run_duration via time.monotonic() and persist on SUCCESS/FAILED
- Skip RUNNING update for non-executable parent nodes so they don't get
  stuck with a permanent blue badge in selective execution
- Raise explicit errors when session/project_id missing instead of silent no-op
- Stop returning raw exception strings from execute_run_command (CodeQL)
- Refresh explorer tree on context-menu run failure so FAILED badge appears
- Move getModelRunStatus to module scope and use antd theme tokens instead
  of hardcoded hex colors

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: satisfy prettier multiline formatting for status dot style spans

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* feat: increase project_schema max_length from 20 to 1024

Requested by @tahierhussain in PR #55 review — the project_schema
field was too short for schemas with long names or multiple schemas.
Bundled into migration 0003 alongside the model run-status fields
since both target the core app and depend on 0002_seed_data.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: address Greptile P1s — CLI-safe timezone import + DB connection leak

P1: `from django.utils import timezone` at module level crashes when
    visitran is used as a standalone CLI without Django installed.
    Wrapped in try/except with a minimal fallback that provides
    timezone.now() via stdlib datetime.

P1: close_db_connection() was only called in the success path of
    execute_run_command. On exception the connection leaked. Moved
    to a finally block so it always runs regardless of outcome.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: abhizipstack

backend/backend/application/file_explorer/file_explorer.py

@@ -93,18 +93,25 @@ def load_models(self, session: Session):
         # Sort models by execution order (DAG order)
         sorted_model_names = topological_sort_models(models_with_refs)
 
+        # Build a lookup from model name -> model object for status fields
+        model_lookup = {m.model_name: m for m in all_models}
+
         # Build the model structure in sorted order
         no_code_model_structure = []
         for no_code_model_name in sorted_model_names:
-            no_code_model_structure.append(
-                {
-                    "extension": no_code_model_name,
-                    "title": no_code_model_name,
-                    "key": f"{self.project_name}/models/no_code/{no_code_model_name}",
-                    "is_folder": False,
-                    "type": "NO_CODE_MODEL",
-                }
-            )
+            model = model_lookup.get(no_code_model_name)
+            model_data = {
+                "extension": no_code_model_name,
+                "title": no_code_model_name,
+                "key": f"{self.project_name}/models/no_code/{no_code_model_name}",
+                "is_folder": False,
+                "type": "NO_CODE_MODEL",
+                "run_status": getattr(model, "run_status", None),
+                "failure_reason": getattr(model, "failure_reason", None),
+                "last_run_at": model.last_run_at.isoformat() if getattr(model, "last_run_at", None) else None,
+                "run_duration": getattr(model, "run_duration", None),
+            }
+            no_code_model_structure.append(model_data)
         model_structure: dict[str, Any] = {
             "title": "models",
             "key": f"{self.project_name}/models",

backend/backend/core/migrations/0003_add_model_run_status.py

@@ -0,0 +1,62 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0002_seed_data"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="configmodels",
+            name="run_status",
+            field=models.CharField(
+                choices=[
+                    ("NOT_STARTED", "Not Started"),
+                    ("RUNNING", "Running"),
+                    ("SUCCESS", "Success"),
+                    ("FAILED", "Failed"),
+                ],
+                default="NOT_STARTED",
+                help_text="Current execution status of the model",
+                max_length=20,
+            ),
+        ),
+        migrations.AddField(
+            model_name="configmodels",
+            name="failure_reason",
+            field=models.TextField(
+                blank=True,
+                help_text="Error message if the model execution failed",
+                null=True,
+            ),
+        ),
+        migrations.AddField(
+            model_name="configmodels",
+            name="last_run_at",
+            field=models.DateTimeField(
+                blank=True,
+                help_text="Timestamp of the last execution",
+                null=True,
+            ),
+        ),
+        migrations.AddField(
+            model_name="configmodels",
+            name="run_duration",
+            field=models.FloatField(
+                blank=True,
+                help_text="Duration of last execution in seconds",
+                null=True,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="projectdetails",
+            name="project_schema",
+            field=models.CharField(
+                max_length=1024,
+                blank=True,
+                null=True,
+            ),
+        ),
+    ]

backend/backend/core/models/config_models.py

@@ -19,6 +19,12 @@ class ConfigModels(DefaultOrganizationMixin, BaseModel):
     This model is used to store the no code models.
     """
 
+    class RunStatus(models.TextChoices):
+        NOT_STARTED = "NOT_STARTED", "Not Started"
+        RUNNING = "RUNNING", "Running"
+        SUCCESS = "SUCCESS", "Success"
+        FAILED = "FAILED", "Failed"
+
     def get_model_upload_path(self, filename: str) -> str:
         """
         This returns the file path based on the org and project dynamically.
@@ -94,6 +100,29 @@ class Meta:
     last_modified_by = models.JSONField(default=dict)
     last_modified_at = models.DateTimeField(auto_now=True)
 
+    # Execution status tracking
+    run_status = models.CharField(
+        max_length=20,
+        choices=RunStatus.choices,
+        default=RunStatus.NOT_STARTED,
+        help_text="Current execution status of the model",
+    )
+    failure_reason = models.TextField(
+        null=True,
+        blank=True,
+        help_text="Error message if the model execution failed",
+    )
+    last_run_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        help_text="Timestamp of the last execution",
+    )
+    run_duration = models.FloatField(
+        null=True,
+        blank=True,
+        help_text="Duration of last execution in seconds",
+    )
+
     # Current Manager
     config_objects = models.Manager()
 

backend/backend/core/models/project_details.py

@@ -102,7 +102,7 @@ def delete(self, *args, **kwargs):
     project_path = models.CharField(max_length=100)
     profile_path = models.CharField(max_length=100)
 
-    project_schema = models.CharField(max_length=20, blank=True, null=True)
+    project_schema = models.CharField(max_length=1024, blank=True, null=True)
     # User specific access control fields
     created_by = models.JSONField(default=dict)
     created_at = models.DateTimeField(auto_now_add=True)

backend/backend/core/routers/execute/views.py

@@ -57,12 +57,18 @@ def execute_run_command(request: Request, project_id: str) -> Response:
         )
     logger.info(f"[execute_run_command] API called - project_id={project_id}, file_name={file_name}, environment_id={environment_id}")
     app = ApplicationContext(project_id=project_id)
-    app.execute_visitran_run_command(current_model=file_name, environment_id=environment_id)
-    app.visitran_context.close_db_connection()
-    app.backup_current_no_code_model()
-    logger.info(f"[execute_run_command] Completed successfully for file_name={file_name}")
-    _data = {"status": "success"}
-    return Response(data=_data)
+    try:
+        app.execute_visitran_run_command(current_model=file_name, environment_id=environment_id)
+        app.backup_current_no_code_model()
+        logger.info(f"[execute_run_command] Completed successfully for file_name={file_name}")
+        _data = {"status": "success"}
+        return Response(data=_data)
+    except Exception:
+        logger.exception(f"[execute_run_command] DAG execution failed for file_name={file_name}")
+        _data = {"status": "failed", "error_message": "Model execution failed. Check server logs for details."}
+        return Response(data=_data, status=status.HTTP_400_BAD_REQUEST)
+    finally:
+        app.visitran_context.close_db_connection()
 
 
 

backend/backend/utils/cache_service/decorators/cache_decorator.py

@@ -96,6 +96,7 @@ def wrapped(view_or_request, *args, **kwargs):
 
             except Exception as e:
                 Logger.exception("Error executing view function")
+                raise
 
             return response
 

backend/visitran/visitran.py

@@ -2,6 +2,7 @@
 
 import concurrent.futures
 import datetime
+import time
 import importlib
 import logging
 import re
@@ -15,6 +16,15 @@
 
 import ibis
 import networkx as nx
+try:
+    from django.utils import timezone
+except ImportError:
+    from datetime import datetime, timezone as _tz
+
+    class timezone:
+        @staticmethod
+        def now():
+            return datetime.now(_tz.utc)
 from visitran import utils
 from visitran.adapters.adapter import BaseAdapter
 from visitran.adapters.seed import BaseSeed
@@ -71,6 +81,8 @@
 from visitran.templates.model import VisitranModel
 from visitran.templates.snapshot import VisitranSnapshot
 
+from backend.core.models.config_models import ConfigModels
+
 warnings.filterwarnings("ignore", message=".*?pkg_resources.*?")
 from matplotlib import pyplot as plt  # noqa: E402
 
@@ -228,6 +240,53 @@ def sort_func(node_key: str):
         self.sorted_dag_nodes = list(nx.lexicographical_topological_sort(self.dag, key=sort_func))
         fire_event(SortedDAGNodes(sorted_dag_nodes=str(self.sorted_dag_nodes)))
 
+    def _update_model_status(
+        self,
+        model_name: str,
+        run_status: str,
+        failure_reason: str = None,
+        run_duration: float = None,
+    ) -> None:
+        """Update the run status of a model in the database."""
+        try:
+            # node_name str looks like: "<class 'project.models.stg_order_summaries.StgOrderSummaries'>"
+            # ConfigModels.model_name stores the module/file name (e.g. 'stg_order_summaries'),
+            # which is the second-to-last dotted segment — not the CamelCase class name.
+            class_name = model_name.split("'")[1].split(".")[-2] if "'" in model_name else model_name
+
+            session = getattr(self.context, "session", None)
+            if not session:
+                raise ValueError(
+                    f"Cannot update status for model '{class_name}': no session on execution context"
+                )
+
+            project_id = session.project_id
+            if not project_id:
+                raise ValueError(
+                    f"Cannot update status for model '{class_name}': session has no project_id"
+                )
+
+            model_instance = ConfigModels.objects.get(
+                project_instance__project_uuid=project_id,
+                model_name=class_name,
+            )
+            model_instance.run_status = run_status
+            model_instance.last_run_at = timezone.now()
+
+            if run_status == ConfigModels.RunStatus.FAILED:
+                model_instance.failure_reason = failure_reason
+            elif run_status == ConfigModels.RunStatus.SUCCESS:
+                model_instance.failure_reason = None
+
+            update_fields = ["run_status", "last_run_at", "failure_reason"]
+            if run_duration is not None:
+                model_instance.run_duration = run_duration
+                update_fields.append("run_duration")
+
+            model_instance.save(update_fields=update_fields)
+        except Exception:
+            logging.exception(f"Failed to update model status for {model_name}")
+
     def execute_graph(self) -> None:
         """Executes the sorted DAG elements one by one."""
         dag_nodes = self.sorted_dag_nodes
@@ -236,7 +295,11 @@ def execute_graph(self) -> None:
             node_name: VisitranModel = dag_nodes.pop(0)
             node = self.dag.nodes[node_name]["model_object"]
             is_executable = self.dag.nodes[node_name].get("executable", True)
+            start_time = time.monotonic()
             try:
+                if is_executable:
+                    self._update_model_status(str(node_name), ConfigModels.RunStatus.RUNNING)
+
                 # Apply model_configs override from deployment configuration
                 self._apply_model_config_override(node)
 
@@ -270,6 +333,12 @@ def execute_graph(self) -> None:
                 self.db_adapter.db_connection.create_schema(node.destination_schema_name)  # create if not exists
                 self.db_adapter.run_model(visitran_model=node)
 
+                self._update_model_status(
+                    str(node_name),
+                    ConfigModels.RunStatus.SUCCESS,
+                    run_duration=time.monotonic() - start_time,
+                )
+
                 base_result = BaseResult(
                     node_name=str(node_name),
                     sequence_num=sequence_number,
@@ -282,11 +351,24 @@ def execute_graph(self) -> None:
                 sequence_number += 1
                 BASE_RESULT.append(base_result)
             except VisitranBaseExceptions as visitran_err:
+                self._update_model_status(
+                    str(node_name),
+                    ConfigModels.RunStatus.FAILED,
+                    failure_reason=str(visitran_err),
+                    run_duration=time.monotonic() - start_time,
+                )
                 raise visitran_err
             except Exception as err:
                 dest_table = node.destination_table_name
                 sch_name = node.destination_schema_name
                 err_trace = repr(err)
+
+                self._update_model_status(
+                    str(node_name),
+                    ConfigModels.RunStatus.FAILED,
+                    failure_reason=err_trace,
+                    run_duration=time.monotonic() - start_time,
+                )
                 base_result = BaseResult(
                     node_name=str(node_name),
                     sequence_num=sequence_number,

frontend/src/ide/editor/no-code-model/no-code-model.jsx

@@ -1875,6 +1875,7 @@ function NoCodeModel({ nodeData }) {
     axios(requestOptions)
       .then(() => {
         getSampleData(undefined, undefined, spec);
+        setRefreshModels(true);
       })
       .catch((error) => {
         const notifKey = notify({
@@ -1909,6 +1910,7 @@ function NoCodeModel({ nodeData }) {
         });
         setTransformationErrorFlag(true);
         setIsLoading(false);
+        setRefreshModels(true);
       });
   };