Feat: Add CICD bot linter logging

Author: VaggelisD

sqlmesh/core/console.py

@@ -2164,7 +2164,6 @@ def _show_categorized_snapshots(self, plan: Plan, default_catalog: t.Optional[st
     def log_test_results(
         self, result: unittest.result.TestResult, output: t.Optional[str], target_dialect: str
     ) -> None:
-        # import ipywidgets as widgets
         if result.wasSuccessful():
             self._print(
                 f"**Successfully Ran `{str(result.testsRun)}` Tests Against `{target_dialect}`**\n\n"

sqlmesh/core/context.py

@@ -62,7 +62,7 @@
     load_configs,
 )
 from sqlmesh.core.config.loader import C
-from sqlmesh.core.console import get_console
+from sqlmesh.core.console import get_console, Console
 from sqlmesh.core.context_diff import ContextDiff
 from sqlmesh.core.dialect import (
     format_model_expressions,
@@ -2394,7 +2394,7 @@ def _get_models_for_interval_end(
             )
         return models_for_interval_end
 
-    def lint_models(self, models: t.Optional[t.Iterable[t.Union[str, Model]]] = None) -> None:
+    def lint_models(self, models: t.Optional[t.Iterable[t.Union[str, Model]]] = None, console: t.Optional[Console] = None) -> None:
         found_error = False
 
         model_list = (
@@ -2403,9 +2403,12 @@ def lint_models(self, models: t.Optional[t.Iterable[t.Union[str, Model]]] = None
         for model in model_list:
             # Linter may be `None` if the context is not loaded yet
             if linter := self._linters.get(model.project):
-                found_error = linter.lint_model(model) or found_error
+                found_error = linter.lint_model(model, console=console) or found_error
 
         if found_error:
+            import traceback
+            print(f"found error {found_error}") 
+            traceback.print_stack()
             raise LinterError(
                 "Linter detected errors in the code. Please fix them before proceeding."
             )

sqlmesh/core/linter/definition.py

@@ -7,7 +7,7 @@
 from sqlmesh.core.model import Model
 
 from sqlmesh.utils.errors import raise_config_error
-from sqlmesh.core.console import get_console
+from sqlmesh.core.console import get_console, Console
 from sqlmesh.core.linter.rule import RuleSet
 
 
@@ -50,7 +50,7 @@ def from_rules(cls, all_rules: RuleSet, config: LinterConfig) -> Linter:
 
         return Linter(config.enabled, all_rules, rules, warn_rules)
 
-    def lint_model(self, model: Model) -> bool:
+    def lint_model(self, model: Model, console: t.Optional[Console] = None) -> bool:
         if not self.enabled:
             return False
 
@@ -62,11 +62,13 @@ def lint_model(self, model: Model) -> bool:
         error_violations = rules.check_model(model)
         warn_violations = warn_rules.check_model(model)
 
+        console = console or get_console()
+        print(f"lint console {console}")
         if warn_violations:
-            get_console().show_linter_violations(warn_violations, model)
+            console.show_linter_violations(warn_violations, model)
 
         if error_violations:
-            get_console().show_linter_violations(error_violations, model, is_error=True)
+            console.show_linter_violations(error_violations, model, is_error=True)
             return True
 
         return False

sqlmesh/integrations/github/cicd/command.py

@@ -13,7 +13,7 @@
     GithubController,
     TestFailure,
 )
-from sqlmesh.utils.errors import CICDBotError, ConflictingPlanError, PlanError
+from sqlmesh.utils.errors import CICDBotError, ConflictingPlanError, PlanError, LinterError
 
 logger = logging.getLogger(__name__)
 
@@ -79,6 +79,23 @@ def _run_tests(controller: GithubController) -> bool:
         )
         return False
 
+def _run_linter(controller: GithubController) -> bool:
+    controller.update_linter_check(status=GithubCheckStatus.IN_PROGRESS)
+    try:
+        controller.run_linter()
+    except LinterError:
+        controller.update_linter_check(
+            status=GithubCheckStatus.COMPLETED,
+            conclusion=GithubCheckConclusion.FAILURE,
+        )
+        return False
+
+    controller.update_linter_check(
+        status=GithubCheckStatus.COMPLETED,
+        conclusion=GithubCheckConclusion.SUCCESS,
+    )
+
+    return True
 
 @github.command()
 @click.pass_context
@@ -189,6 +206,7 @@ def deploy_production(ctx: click.Context) -> None:
 
 def _run_all(controller: GithubController) -> None:
     has_required_approval = False
+
     is_auto_deploying_prod = (
         controller.deploy_command_enabled or controller.do_required_approval_check
     )
@@ -204,11 +222,13 @@ def _run_all(controller: GithubController) -> None:
             has_required_approval = True
         else:
             raise CICDBotError(f"Unsupported command: {command}")
+    controller.update_linter_check(status=GithubCheckStatus.QUEUED)
     controller.update_pr_environment_check(status=GithubCheckStatus.QUEUED)
     controller.update_prod_plan_preview_check(status=GithubCheckStatus.QUEUED)
     controller.update_test_check(status=GithubCheckStatus.QUEUED)
     if is_auto_deploying_prod:
         controller.update_prod_environment_check(status=GithubCheckStatus.QUEUED)
+    linter_passed = _run_linter(controller)
     tests_passed = _run_tests(controller)
     if controller.do_required_approval_check:
         if has_required_approval:
@@ -218,23 +238,25 @@ def _run_all(controller: GithubController) -> None:
         else:
             controller.update_required_approval_check(status=GithubCheckStatus.QUEUED)
             has_required_approval = _check_required_approvers(controller)
-    if not tests_passed:
+    if not tests_passed or not linter_passed:
         controller.update_pr_environment_check(
             status=GithubCheckStatus.COMPLETED,
-            exception=TestFailure(),
+            exception=LinterError("") if not linter_passed else TestFailure(),
         )
         controller.update_prod_plan_preview_check(
             status=GithubCheckStatus.COMPLETED,
             conclusion=GithubCheckConclusion.SKIPPED,
-            summary="Unit Test(s) Failed so skipping creating prod plan",
+            summary=f"Linter or unit test(s) failed so skipping creating prod plan",
         )
         if is_auto_deploying_prod:
             controller.update_prod_environment_check(
                 status=GithubCheckStatus.COMPLETED,
                 conclusion=GithubCheckConclusion.SKIPPED,
-                skip_reason="Unit Test(s) Failed so skipping deploying to production",
+                skip_reason=f"Linter or unit test(s) Failed so skipping deploying to production",
             )
-        raise CICDBotError("Failed to run tests. See check status for more information.")
+
+        raise CICDBotError(f"Linter or unit test(s) failed. See check status for more information.")
+
     pr_environment_updated = _update_pr_environment(controller)
     prod_plan_generated = False
     if pr_environment_updated:

sqlmesh/integrations/github/cicd/controller.py

@@ -29,6 +29,7 @@
     format_intervals,
 )
 from sqlmesh.core.user import User
+from sqlmesh.core.config import Config
 from sqlmesh.integrations.github.cicd.config import GithubCICDBotConfig
 from sqlmesh.utils import word_characters_only, Verbosity
 from sqlmesh.utils.concurrency import NodeExecutionFailedError
@@ -38,6 +39,7 @@
     NoChangesPlanError,
     PlanError,
     UncategorizedPlanError,
+    LinterError,
 )
 from sqlmesh.utils.pydantic import PydanticModel
 
@@ -50,8 +52,6 @@
     from github.PullRequestReview import PullRequestReview
     from github.Repository import Repository
 
-    from sqlmesh.core.config import Config
-
 logger = logging.getLogger(__name__)
 
 
@@ -302,6 +302,7 @@ def __init__(
         self._prod_plan_builder: t.Optional[PlanBuilder] = None
         self._prod_plan_with_gaps_builder: t.Optional[PlanBuilder] = None
         self._check_run_mapping: t.Dict[str, CheckRun] = {}
+        self._linter_error = False
 
         if not isinstance(get_console(), MarkdownConsole):
             raise CICDBotError("Console must be a markdown console.")
@@ -326,10 +327,8 @@ def __init__(
             if review.state.lower() == "approved"
         }
         logger.debug(f"Approvers: {', '.join(self._approvers)}")
-        self._context: Context = Context(
-            paths=self._paths,
-            config=self.config,
-        )
+
+        self._context: Context = Context(paths=self._paths, config=self.config)
 
     @property
     def deploy_command_enabled(self) -> bool:
@@ -394,6 +393,7 @@ def pr_plan(self) -> Plan:
             self._pr_plan_builder = self._context.plan_builder(
                 environment=self.pr_environment_name,
                 skip_tests=True,
+                skip_linter=True,
                 categorizer_config=self.bot_config.auto_categorize_changes,
                 start=self.bot_config.default_pr_start,
                 skip_backfill=self.bot_config.skip_pr_backfill,
@@ -408,6 +408,7 @@ def prod_plan(self) -> Plan:
             self._prod_plan_builder = self._context.plan_builder(
                 c.PROD,
                 no_gaps=True,
+                skip_backfill=True,
                 skip_tests=True,
                 categorizer_config=self.bot_config.auto_categorize_changes,
                 run=self.bot_config.run_on_deploy_to_prod,
@@ -478,6 +479,13 @@ def run_tests(self) -> t.Tuple[unittest.result.TestResult, str]:
         """
         return self._context._run_tests(verbosity=Verbosity.VERBOSE)
 
+    def run_linter(self) -> None:
+        """
+        Run linter for the PR
+        """
+        # self._console.clear_captured_outputs()
+        self._context.lint_models(console=self._console)
+
     def _get_or_create_comment(self, header: str = BOT_HEADER_MSG) -> IssueComment:
         comment = seq_get(
             [comment for comment in self._issue.get_comments() if header in comment.body],
@@ -654,6 +662,34 @@ def _update_check_handler(
             full_summary=summary,
         )
 
+    def update_linter_check(
+        self,
+        status: GithubCheckStatus,
+        conclusion: t.Optional[GithubCheckConclusion] = None,
+    ) -> None:
+        def conclusion_handler(
+            conclusion: GithubCheckConclusion,
+        ) -> t.Tuple[GithubCheckConclusion, str, t.Optional[str]]:
+            linter_summary = self._console.consume_captured_output() or "Linter Success"
+
+            title = "Linter results"
+
+            return conclusion, title, linter_summary
+
+        self._update_check_handler(
+            check_name="SQLMesh - Linter",
+            status=status,
+            conclusion=conclusion,
+            status_handler=lambda status: (
+                {
+                    GithubCheckStatus.IN_PROGRESS: "Running linter",
+                    GithubCheckStatus.QUEUED: "Waiting to Run linter",
+                }[status],
+                None,
+            ),
+            conclusion_handler=conclusion_handler,
+        )
+
     def update_test_check(
         self,
         status: GithubCheckStatus,
@@ -751,7 +787,7 @@ def update_pr_environment_check(
         Updates the status of the merge commit for the PR environment.
         """
         conclusion: t.Optional[GithubCheckConclusion] = None
-        if isinstance(exception, (NoChangesPlanError, TestFailure)):
+        if isinstance(exception, (NoChangesPlanError, TestFailure, LinterError)):
             conclusion = GithubCheckConclusion.SKIPPED
         elif isinstance(exception, UncategorizedPlanError):
             conclusion = GithubCheckConclusion.ACTION_REQUIRED

tests/integrations/github/cicd/fixtures.py

@@ -3,6 +3,7 @@
 import pytest
 from pytest_mock.plugin import MockerFixture
 
+from sqlmesh.core.config import Config
 from sqlmesh.core.console import set_console, get_console, MarkdownConsole
 from sqlmesh.integrations.github.cicd.config import GithubCICDBotConfig
 from sqlmesh.integrations.github.cicd.controller import (
@@ -67,6 +68,7 @@ def _make_function(
         merge_state_status: MergeStateStatus = MergeStateStatus.CLEAN,
         bot_config: t.Optional[GithubCICDBotConfig] = None,
         mock_out_context: bool = True,
+        config: t.Optional[t.Union[Config, str]] = None,
     ) -> GithubController:
         if mock_out_context:
             mocker.patch("sqlmesh.core.context.Context.apply", mocker.MagicMock())
@@ -97,6 +99,7 @@ def _make_function(
                     else GithubEvent.from_obj(event_path)
                 ),
                 client=client,
+                config=config,
             )
         finally:
             set_console(orig_console)