Feat: Include stack trace in rendering exception handling

Author: themisvaltinos

sqlmesh/core/renderer.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+import traceback
 import typing as t
 from contextlib import contextmanager
 from functools import partial
@@ -211,12 +212,16 @@ def _resolve_table(table: str | exp.Table) -> str:
                     expressions = [e for e in parse(rendered_expression, read=self._dialect) if e]
 
                     if not expressions:
-                        raise ConfigError(f"Failed to parse an expression:\n{self._expression}")
+                        raise ConfigError(
+                            f"{traceback.format_exc()}"
+                            + f"Failed to parse an expression:\n{self._expression}"
+                        )
             except ParsetimeAdapterCallError:
                 raise
             except Exception as ex:
                 raise ConfigError(
-                    f"Could not render or parse jinja at '{self._path}'.\n{ex}"
+                    f"{traceback.format_exc()}"
+                    + f"Could not render or parse jinja at '{self._path}'.\n{ex}"
                 ) from ex
 
         macro_evaluator.locals.update(render_kwargs)
@@ -228,7 +233,10 @@ def _resolve_table(table: str | exp.Table) -> str:
             try:
                 macro_evaluator.evaluate(definition)
             except Exception as ex:
-                raise_config_error(f"Failed to evaluate macro '{definition}'. {ex}", self._path)
+                raise_config_error(
+                    f"{traceback.format_exc()}" + f"Failed to evaluate macro '{definition}'. {ex}",
+                    self._path,
+                )
 
         resolved_expressions: t.List[t.Optional[exp.Expression]] = []
 
@@ -237,7 +245,8 @@ def _resolve_table(table: str | exp.Table) -> str:
                 transformed_expressions = ensure_list(macro_evaluator.transform(expression))
             except Exception as ex:
                 raise_config_error(
-                    f"Failed to resolve macros for\n{expression.sql(dialect=self._dialect, pretty=True)}\n{ex}",
+                    f"{traceback.format_exc()}"
+                    + f"Failed to resolve macros for\n{expression.sql(dialect=self._dialect, pretty=True)}\n{ex}",
                     self._path,
                 )
 
@@ -532,18 +541,26 @@ def render(
             expressions = [e for e in expressions if not isinstance(e, exp.Semicolon)]
 
             if not expressions:
-                raise ConfigError(f"Failed to render query at '{self._path}':\n{self._expression}")
+                raise ConfigError(
+                    f"{traceback.format_exc()}"
+                    + f"Failed to render query at '{self._path}':\n{self._expression}"
+                )
 
             if len(expressions) > 1:
-                raise ConfigError(f"Too many statements in query:\n{self._expression}")
+                raise ConfigError(
+                    f"{traceback.format_exc()}"
+                    + f"Too many statements in query:\n{self._expression}"
+                )
 
             query = expressions[0]  # type: ignore
 
             if not query:
                 return None
             if not isinstance(query, exp.Query):
                 raise_config_error(
-                    f"Model query needs to be a SELECT or a UNION, got {query}.", self._path
+                    f"{traceback.format_exc()}"
+                    + f"Model query needs to be a SELECT or a UNION, got {query}.",
+                    self._path,
                 )
                 raise
 
@@ -581,7 +598,9 @@ def update_cache(
     ) -> None:
         if optimized:
             if not isinstance(expression, exp.Query):
-                raise SQLMeshError(f"Expected a Query but got: {expression}")
+                raise SQLMeshError(
+                    f"{traceback.format_exc()}" + f"Expected a Query but got: {expression}"
+                )
             self._optimized_cache = expression
         else:
             super().update_cache(expression)
@@ -634,7 +653,8 @@ def _optimize_query(self, query: exp.Query, all_deps: t.Set[str]) -> exp.Query:
 
         except Exception as ex:
             raise_config_error(
-                f"Failed to optimize query, please file an issue at https://github.com/TobikoData/sqlmesh/issues/new. {ex}",
+                f"{traceback.format_exc()}"
+                + f"Failed to optimize query, please file an issue at https://github.com/TobikoData/sqlmesh/issues/new. {ex}",
                 self._path,
             )
 

tests/core/test_model.py

@@ -1,5 +1,6 @@
 # ruff: noqa: F811
 import json
+import re
 import typing as t
 from datetime import date, datetime
 from pathlib import Path
@@ -8449,6 +8450,37 @@ def test_blueprinting_with_quotes(tmp_path: Path) -> None:
     assert t.cast(exp.Query, m2.render_query()).sql() == '''SELECT 'c d' AS "c1", "c d" AS "c2"'''
 
 
+def test_blueprinting_with_error(tmp_path: Path) -> None:
+    init_example_project(tmp_path, dialect="duckdb", template=ProjectTemplate.EMPTY)
+
+    template_with_errors = tmp_path / "models/template_with_errors.sql"
+    template_with_errors.parent.mkdir(parents=True, exist_ok=True)
+    template_with_errors.write_text(
+        """
+        MODEL (
+          name m.@{bp_var},
+          blueprints (
+            (bp_var := "a b"),
+            (bp_var := 'c d'),
+          ),
+        );
+
+        SELECT @bp_var AS c1, @var{bp_var} AS c2
+        """
+    )
+
+    # Validate we display the stack trace as well before the error message
+    with pytest.raises(
+        ConfigError,
+        match=re.compile(
+            r"Traceback \(most recent call last\):.*Failed to resolve macros for", re.DOTALL
+        ),
+    ):
+        ctx = Context(
+            config=Config(model_defaults=ModelDefaultsConfig(dialect="duckdb")), paths=tmp_path
+        )
+
+
 def test_blueprint_variable_precedence_sql(tmp_path: Path, assert_exp_eq: t.Callable) -> None:
     init_example_project(tmp_path, dialect="duckdb", template=ProjectTemplate.EMPTY)