sqlmesh 0.200.1.dev10__tar.gz → 0.200.1.dev11__tar.gz

{sqlmesh-0.200.1.dev10 → sqlmesh-0.200.1.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.200.1.dev10
+Version: 0.200.1.dev11
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.200.1.dev10 → sqlmesh-0.200.1.dev11}/sqlmesh/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.200.1.dev10'
-__version_tuple__ = version_tuple = (0, 200, 1, 'dev10')
+__version__ = version = '0.200.1.dev11'
+__version_tuple__ = version_tuple = (0, 200, 1, 'dev11')

{sqlmesh-0.200.1.dev10 → sqlmesh-0.200.1.dev11}/sqlmesh/core/console.py

@@ -3049,34 +3049,47 @@ class CaptureTerminalConsole(TerminalConsole):
     def __init__(self, console: t.Optional[RichConsole] = None, **kwargs: t.Any) -> None:
         super().__init__(console=console, **kwargs)
         self._captured_outputs: t.List[str] = []
+        self._warnings: t.List[str] = []
         self._errors: t.List[str] = []
 
     @property
     def captured_output(self) -> str:
         return "".join(self._captured_outputs)
 
+    @property
+    def captured_warnings(self) -> str:
+        return "".join(self._warnings)
+
     @property
     def captured_errors(self) -> str:
         return "".join(self._errors)
 
     def consume_captured_output(self) -> str:
-        output = self.captured_output
-        self.clear_captured_outputs()
-        return output
+        try:
+            return self.captured_output
+        finally:
+            self._captured_outputs = []
 
-    def consume_captured_errors(self) -> str:
-        errors = self.captured_errors
-        self.clear_captured_errors()
-        return errors
+    def consume_captured_warnings(self) -> str:
+        try:
+            return self.captured_warnings
+        finally:
+            self._warnings = []
 
-    def clear_captured_outputs(self) -> None:
-        self._captured_outputs = []
+    def consume_captured_errors(self) -> str:
+        try:
+            return self.captured_errors
+        finally:
+            self._errors = []
 
-    def clear_captured_errors(self) -> None:
-        self._errors = []
+    def log_warning(self, short_message: str, long_message: t.Optional[str] = None) -> None:
+        if short_message not in self._warnings:
+            self._warnings.append(short_message)
+        super().log_warning(short_message, long_message)
 
     def log_error(self, message: str) -> None:
-        self._errors.append(message)
+        if message not in self._errors:
+            self._errors.append(message)
         super().log_error(message)
 
     def log_skipped_models(self, snapshot_names: t.Set[str]) -> None:
@@ -3087,9 +3100,8 @@ class CaptureTerminalConsole(TerminalConsole):
             super().log_skipped_models(snapshot_names)
 
     def log_failed_models(self, errors: t.List[NodeExecutionFailedError]) -> None:
-        if errors:
-            self._errors.append("\n".join(str(ex) for ex in errors))
-            super().log_failed_models(errors)
+        self._errors.extend([str(ex) for ex in errors if str(ex) not in self._errors])
+        super().log_failed_models(errors)
 
     def _print(self, value: t.Any, **kwargs: t.Any) -> None:
         with self.console.capture() as capture:
@@ -3110,6 +3122,11 @@ class MarkdownConsole(CaptureTerminalConsole):
     AUDIT_PADDING = 7
 
     def __init__(self, **kwargs: t.Any) -> None:
+        self.alert_block_max_content_length = int(kwargs.pop("alert_block_max_content_length", 500))
+        self.alert_block_collapsible_threshold = int(
+            kwargs.pop("alert_block_collapsible_threshold", 200)
+        )
+
         super().__init__(
             **{**kwargs, "console": RichConsole(no_color=True, width=kwargs.pop("width", None))}
         )
@@ -3434,18 +3451,40 @@ class MarkdownConsole(CaptureTerminalConsole):
         self._print(msg)
         self._errors.append(msg)
 
-    def log_error(self, message: str) -> None:
-        super().log_error(f"```\n\\[ERROR] {message}```\n\n")
+    @property
+    def captured_warnings(self) -> str:
+        return self._render_alert_block("WARNING", self._warnings)
 
-    def log_warning(self, short_message: str, long_message: t.Optional[str] = None) -> None:
-        logger.warning(long_message or short_message)
+    @property
+    def captured_errors(self) -> str:
+        return self._render_alert_block("CAUTION", self._errors)
 
-        if not short_message.endswith("\n"):
-            short_message += (
-                "\n"  # so that the closing ``` ends up on a newline which is important for GitHub
-            )
+    def _render_alert_block(self, block_type: str, items: t.List[str]) -> str:
+        # GitHub Markdown alert syntax, https://docs.github.com/en/get-started/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax#alerts
+        if items:
+            item_contents = ""
+            list_indicator = "- " if len(items) > 1 else ""
+
+            for item in items:
+                item = item.replace("\n", "\n> ")
+                item_contents += f">\n> {list_indicator}{item}\n"
+
+                if len(item_contents) > self.alert_block_max_content_length:
+                    truncation_msg = (
+                        "...\n>\n> Truncated. Please check the console for full information.\n"
+                    )
+                    item_contents = item_contents[
+                        0 : self.alert_block_max_content_length - len(truncation_msg)
+                    ]
+                    item_contents += truncation_msg
+                    break
+
+            if len(item_contents) > self.alert_block_collapsible_threshold:
+                item_contents = f"> <details>\n{item_contents}> </details>"
+
+            return f"> [!{block_type}]\n{item_contents}\n"
 
-        self._print(f"```\n\\[WARNING] {short_message}```\n\n")
+        return ""
 
     def _print(self, value: t.Any, **kwargs: t.Any) -> None:
         self.console.print(value, **kwargs)
@@ -3472,7 +3511,7 @@ class DatabricksMagicConsole(CaptureTerminalConsole):
         super()._print(value, **kwargs)
         for captured_output in self._captured_outputs:
             print(captured_output)
-        self.clear_captured_outputs()
+        self.consume_captured_output()
 
     def _prompt(self, message: str, **kwargs: t.Any) -> t.Any:
         self._print(message)

{sqlmesh-0.200.1.dev10 → sqlmesh-0.200.1.dev11}/sqlmesh/integrations/github/cicd/command.py

@@ -119,10 +119,7 @@ def _update_pr_environment(controller: GithubController) -> bool:
     except Exception as e:
         logger.exception("Error occurred when updating PR environment")
         conclusion = controller.update_pr_environment_check(
-            status=GithubCheckStatus.COMPLETED,
-            exception=e,
-            plan=controller.pr_plan_or_none,
-            plan_flags=controller.pr_plan_flags,
+            status=GithubCheckStatus.COMPLETED, exception=e
         )
         return (
             conclusion is not None

{sqlmesh-0.200.1.dev10 → sqlmesh-0.200.1.dev11}/sqlmesh/integrations/github/cicd/controller.py

@@ -494,7 +494,7 @@ class GithubController:
 
         try:
             # Clear out any output that might exist from prior steps
-            self._console.clear_captured_outputs()
+            self._console.consume_captured_output()
             if plan.restatements:
                 self._console._print("\n**Restating models**\n")
             else:
@@ -522,13 +522,115 @@ class GithubController:
             if not difference_summary and not missing_dates:
                 return f"No changes to apply.{plan_flags_section}"
 
-            return f"{difference_summary}\n{missing_dates}{plan_flags_section}"
+            warnings_block = self._console.consume_captured_warnings()
+            errors_block = self._console.consume_captured_errors()
+
+            return f"{warnings_block}{errors_block}{difference_summary}\n{missing_dates}{plan_flags_section}"
         except PlanError as e:
             logger.exception("Plan failed to generate")
             return f"Plan failed to generate. Check for pending or unresolved changes. Error: {e}"
         finally:
             self._console.verbosity = orig_verbosity
 
+    def get_pr_environment_summary(
+        self, conclusion: GithubCheckConclusion, exception: t.Optional[Exception] = None
+    ) -> str:
+        heading = ""
+        summary = ""
+
+        if conclusion.is_success:
+            summary = self._get_pr_environment_summary_success()
+        elif conclusion.is_action_required:
+            heading = f":warning: Action Required to create or update PR Environment `{self.pr_environment_name}` :warning:"
+            summary = self._get_pr_environment_summary_action_required(exception)
+        elif conclusion.is_failure:
+            heading = (
+                f":x: Failed to create or update PR Environment `{self.pr_environment_name}` :x:"
+            )
+            summary = self._get_pr_environment_summary_failure(exception)
+        elif conclusion.is_skipped:
+            heading = f":next_track_button: Skipped creating or updating PR Environment `{self.pr_environment_name}` :next_track_button:"
+            summary = self._get_pr_environment_summary_skipped(exception)
+        else:
+            heading = f":interrobang: Got an unexpected conclusion: {conclusion.value}"
+
+        # note: we just add warnings here, errors will be covered by the "failure" conclusion
+        if warnings := self._console.consume_captured_warnings():
+            summary = f"{warnings}\n{summary}"
+
+        return f"{heading}\n\n{summary}".strip()
+
+    def _get_pr_environment_summary_success(self) -> str:
+        prod_plan = self.prod_plan_with_gaps
+
+        if not prod_plan.has_changes:
+            summary = "No models were modified in this PR.\n"
+        else:
+            intro = self._generate_pr_environment_summary_intro()
+            summary = intro + self._generate_pr_environment_summary_list(prod_plan)
+
+        if prod_plan.user_provided_flags:
+            summary += self._generate_plan_flags_section(prod_plan.user_provided_flags)
+
+        return summary
+
+    def _get_pr_environment_summary_skipped(self, exception: t.Optional[Exception] = None) -> str:
+        if isinstance(exception, NoChangesPlanError):
+            skip_reason = "No changes were detected compared to the prod environment."
+        elif isinstance(exception, TestFailure):
+            skip_reason = "Unit Test(s) Failed so skipping PR creation"
+        else:
+            skip_reason = "A prior stage failed resulting in skipping PR creation."
+
+        return skip_reason
+
+    def _get_pr_environment_summary_action_required(
+        self, exception: t.Optional[Exception] = None
+    ) -> str:
+        plan = self.pr_plan_or_none
+        if isinstance(exception, UncategorizedPlanError) and plan:
+            failure_msg = f"The following models could not be categorized automatically:\n"
+            for snapshot in plan.uncategorized:
+                failure_msg += f"- {snapshot.name}\n"
+            failure_msg += (
+                f"\nRun `sqlmesh plan {self.pr_environment_name}` locally to apply these changes.\n\n"
+                "If you would like the bot to automatically categorize changes, check the [documentation](https://sqlmesh.readthedocs.io/en/stable/integrations/github/) for more information."
+            )
+        else:
+            failure_msg = "Please check the Actions Workflow logs for more information."
+
+        return failure_msg
+
+    def _get_pr_environment_summary_failure(self, exception: t.Optional[Exception] = None) -> str:
+        console_output = self._console.consume_captured_output()
+
+        if isinstance(exception, PlanError):
+            failure_msg = f"Plan application failed.\n"
+            if exception.args and (msg := exception.args[0]) and isinstance(msg, str):
+                failure_msg += f"\n{msg}\n"
+            if console_output:
+                failure_msg += f"\n{console_output}"
+        elif isinstance(exception, (SQLMeshError, SqlglotError, ValueError)):
+            # this logic is taken from the global error handler attached to the CLI, which uses `click.echo()` to output the message
+            # so cant be re-used here because it bypasses the Console
+            failure_msg = f"**Error:** {str(exception)}"
+        elif exception:
+            logger.debug(
+                "Got unexpected error. Error Type: "
+                + str(type(exception))
+                + " Stack trace: "
+                + traceback.format_exc()
+            )
+            failure_msg = f"This is an unexpected error.\n\n**Exception:**\n```\n{traceback.format_exc()}\n```"
+
+        if captured_errors := self._console.consume_captured_errors():
+            failure_msg = f"{captured_errors}\n{failure_msg}"
+
+        if plan_flags := self.pr_plan_flags:
+            failure_msg += f"\n\n{self._generate_plan_flags_section(plan_flags)}"
+
+        return failure_msg
+
     def run_tests(self) -> t.Tuple[ModelTextTestResult, str]:
         """
         Run tests for the PR
@@ -539,7 +641,7 @@ class GithubController:
         """
         Run linter for the PR
         """
-        self._console.clear_captured_outputs()
+        self._console.consume_captured_output()
         self._context.lint_models()
 
     def _get_or_create_comment(self, header: str = BOT_HEADER_MSG) -> IssueComment:
@@ -611,7 +713,22 @@ class GithubController:
         Creates a PR environment from the logic present in the PR. If the PR contains changes that are
         uncategorized, then an error will be raised.
         """
-        self._context.apply(self.pr_plan)
+        self._context.apply(self.pr_plan)  # will raise if PR environment creation fails
+
+        # update PR info comment
+        vde_title = "- :eyes: To **review** this PR's changes, use virtual data environment:"
+        comment_value = f"{vde_title}\n  - `{self.pr_environment_name}`"
+        if self.bot_config.enable_deploy_command:
+            comment_value += (
+                "\n- :arrow_forward: To **apply** this PR's plan to prod, comment:\n  - `/deploy`"
+            )
+        dedup_regex = vde_title.replace("*", r"\*") + r".*"
+        updated_comment, _ = self.update_sqlmesh_comment_info(
+            value=comment_value,
+            dedup_regex=dedup_regex,
+        )
+        if updated_comment:
+            self._append_output("created_pr_environment", "true")
 
     def deploy_to_prod(self) -> None:
         """
@@ -855,13 +972,7 @@ class GithubController:
         )
 
     def update_pr_environment_check(
-        self,
-        status: GithubCheckStatus,
-        exception: t.Optional[Exception] = None,
-        plan: t.Optional[Plan] = None,
-        plan_flags: t.Optional[
-            t.Dict[str, UserProvidedFlags]
-        ] = None,  # note: the plan flags are passed separately in case the plan fails to build
+        self, status: GithubCheckStatus, exception: t.Optional[Exception] = None
     ) -> t.Optional[GithubCheckConclusion]:
         """
         Updates the status of the merge commit for the PR environment.
@@ -882,87 +993,7 @@ class GithubController:
         def conclusion_handler(
             conclusion: GithubCheckConclusion, exception: t.Optional[Exception]
         ) -> t.Tuple[GithubCheckConclusion, str, t.Optional[str]]:
-            if conclusion.is_success:
-                prod_plan = self.prod_plan_with_gaps
-
-                if not prod_plan.has_changes:
-                    summary = "No models were modified in this PR.\n"
-                else:
-                    intro = self._generate_pr_environment_summary_intro()
-                    summary = intro + self._generate_pr_environment_summary_list(prod_plan)
-                    if prod_plan.user_provided_flags:
-                        summary += self._generate_plan_flags_section(prod_plan.user_provided_flags)
-
-                vde_title = (
-                    "- :eyes: To **review** this PR's changes, use virtual data environment:"
-                )
-                comment_value = f"{vde_title}\n  - `{self.pr_environment_name}`"
-                if self.bot_config.enable_deploy_command:
-                    comment_value += "\n- :arrow_forward: To **apply** this PR's plan to prod, comment:\n  - `/deploy`"
-                dedup_regex = vde_title.replace("*", r"\*") + r".*"
-                updated_comment, _ = self.update_sqlmesh_comment_info(
-                    value=comment_value,
-                    dedup_regex=dedup_regex,
-                )
-                if updated_comment:
-                    self._append_output("created_pr_environment", "true")
-            else:
-                if isinstance(exception, NoChangesPlanError):
-                    skip_reason = "No changes were detected compared to the prod environment."
-                elif isinstance(exception, TestFailure):
-                    skip_reason = "Unit Test(s) Failed so skipping PR creation"
-                else:
-                    skip_reason = "A prior stage failed resulting in skipping PR creation."
-
-                if not skip_reason and exception:
-                    logger.debug(
-                        f"Got {type(exception).__name__}. Stack trace: " + traceback.format_exc()
-                    )
-
-                captured_errors = self._console.consume_captured_errors()
-                if captured_errors:
-                    logger.debug(f"Captured errors: {captured_errors}")
-                    failure_msg = f"**Errors:**\n{captured_errors}\n"
-                elif isinstance(exception, UncategorizedPlanError) and plan:
-                    failure_msg = f"The following models could not be categorized automatically:\n"
-                    for snapshot in plan.uncategorized:
-                        failure_msg += f"- {snapshot.name}\n"
-                    failure_msg += (
-                        f"\nRun `sqlmesh plan {self.pr_environment_name}` locally to apply these changes.\n\n"
-                        "If you would like the bot to automatically categorize changes, check the [documentation](https://sqlmesh.readthedocs.io/en/stable/integrations/github/) for more information."
-                    )
-                elif isinstance(exception, PlanError):
-                    failure_msg = f"Plan application failed.\n"
-                    if exception.args and (msg := exception.args[0]) and isinstance(msg, str):
-                        failure_msg += f"\n{msg}\n"
-                    if self._console.captured_output:
-                        failure_msg += f"\n{self._console.captured_output}"
-                elif isinstance(exception, (SQLMeshError, SqlglotError, ValueError)):
-                    # this logic is taken from the global error handler attached to the CLI, which uses `click.echo()` to output the message
-                    # so cant be re-used here because it bypasses the Console
-                    failure_msg = f"**Error:** {str(exception)}"
-                else:
-                    logger.debug(
-                        "Got unexpected error. Error Type: "
-                        + str(type(exception))
-                        + " Stack trace: "
-                        + traceback.format_exc()
-                    )
-                    failure_msg = f"This is an unexpected error.\n\n**Exception:**\n```\n{traceback.format_exc()}\n```"
-
-                conclusion_to_summary = {
-                    GithubCheckConclusion.SKIPPED: f":next_track_button: Skipped creating or updating PR Environment `{self.pr_environment_name}`. {skip_reason}",
-                    GithubCheckConclusion.FAILURE: f":x: Failed to create or update PR Environment `{self.pr_environment_name}` :x:\n\n{failure_msg}",
-                    GithubCheckConclusion.CANCELLED: f":stop_sign: Cancelled creating or updating PR Environment `{self.pr_environment_name}`",
-                    GithubCheckConclusion.ACTION_REQUIRED: f":warning: Action Required to create or update PR Environment `{self.pr_environment_name}` :warning:\n\n{failure_msg}",
-                }
-                summary = conclusion_to_summary.get(
-                    conclusion, f":interrobang: Got an unexpected conclusion: {conclusion.value}"
-                )
-                if plan_flags:
-                    plan_flags_section = self._generate_plan_flags_section(plan_flags)
-                    summary += f"\n\n{plan_flags_section}"
-
+            summary = self.get_pr_environment_summary(conclusion, exception)
             self._append_output("pr_environment_name", self.pr_environment_name)
             return conclusion, check_title, summary
 

{sqlmesh-0.200.1.dev10 → sqlmesh-0.200.1.dev11}/sqlmesh.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.200.1.dev10
+Version: 0.200.1.dev11
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.200.1.dev10 → sqlmesh-0.200.1.dev11}/sqlmesh.egg-info/SOURCES.txt

@@ -493,6 +493,7 @@ tests/core/__init__.py
 tests/core/test_audit.py
 tests/core/test_config.py
 tests/core/test_connection_config.py
+tests/core/test_console.py
 tests/core/test_context.py
 tests/core/test_dialect.py
 tests/core/test_environment.py

sqlmesh-0.200.1.dev11/tests/core/test_console.py

@@ -0,0 +1,131 @@
+from sqlmesh.core.console import MarkdownConsole
+
+
+def test_markdown_console_warning_block():
+    console = MarkdownConsole(
+        alert_block_max_content_length=100, alert_block_collapsible_threshold=45
+    )
+    assert console.consume_captured_warnings() == ""
+
+    # single warning, within threshold
+    console.log_warning("First warning")
+    assert console.consume_captured_warnings() == "> [!WARNING]\n>\n> First warning\n\n"
+
+    # multiple warnings, within threshold (list syntax)
+    console.log_warning("First warning")
+    console.log_warning("Second warning")
+    assert (
+        console.consume_captured_warnings()
+        == "> [!WARNING]\n>\n> - First warning\n>\n> - Second warning\n\n"
+    )
+
+    # single warning, within max threshold but over collapsible section threshold
+    warning = "The snowflake engine is not recommended for storing SQLMesh state in production deployments"
+    assert len(warning) > console.alert_block_collapsible_threshold
+    assert len(warning) < console.alert_block_max_content_length
+    console.log_warning(warning)
+    assert (
+        console.consume_captured_warnings()
+        == "> [!WARNING]\n> <details>\n>\n> The snowflake engine is not recommended for storing SQLMesh state in production deployments\n> </details>\n"
+    )
+
+    # single warning, over max threshold
+    warning = "The snowflake engine is not recommended for storing SQLMesh state in production deployments. Please see <web link> for a list of recommended engines and more information."
+    assert len(warning) > console.alert_block_collapsible_threshold
+    assert len(warning) > console.alert_block_max_content_length
+    console.log_warning(warning)
+    assert (
+        console.consume_captured_warnings()
+        == "> [!WARNING]\n> <details>\n>\n> The snowflake engine is not re...\n>\n> Truncated. Please check the console for full information.\n> </details>\n"
+    )
+
+    # multiple warnings, within max threshold but over collapsible section threshold
+    warning_1 = "This is the first warning"
+    warning_2 = "This is the second warning"
+    assert (len(warning_1) + len(warning_2)) > console.alert_block_collapsible_threshold
+    assert (len(warning_1) + len(warning_2)) < console.alert_block_max_content_length
+    console.log_warning(warning_1)
+    console.log_warning(warning_2)
+    assert (
+        console.consume_captured_warnings()
+        == "> [!WARNING]\n> <details>\n>\n> - This is the first warning\n>\n> - This is the second warning\n> </details>\n"
+    )
+
+    # multiple warnings, over max threshold
+    warning_1 = "This is the first warning and its really really long"
+    warning_2 = "This is the second warning and its also really really long"
+    assert (len(warning_1) + len(warning_2)) > console.alert_block_collapsible_threshold
+    assert (len(warning_1) + len(warning_2)) > console.alert_block_max_content_length
+    console.log_warning(warning_1)
+    console.log_warning(warning_2)
+    assert (
+        console.consume_captured_warnings()
+        == "> [!WARNING]\n> <details>\n>\n> - This is the first warning an...\n>\n> Truncated. Please check the console for full information.\n> </details>\n"
+    )
+
+    assert console.consume_captured_warnings() == ""
+
+
+def test_markdown_console_error_block():
+    console = MarkdownConsole(
+        alert_block_max_content_length=100, alert_block_collapsible_threshold=40
+    )
+    assert console.consume_captured_errors() == ""
+
+    # single error, within threshold
+    console.log_error("First error")
+    assert console.consume_captured_errors() == "> [!CAUTION]\n>\n> First error\n\n"
+
+    # multiple errors, within threshold (list syntax)
+    console.log_error("First error")
+    console.log_error("Second error")
+    assert (
+        console.consume_captured_errors()
+        == "> [!CAUTION]\n>\n> - First error\n>\n> - Second error\n\n"
+    )
+
+    # single error, within max threshold but over collapsible section threshold
+    error = "The snowflake engine is not recommended for storing SQLMesh state in production deployments"
+    assert len(error) > console.alert_block_collapsible_threshold
+    assert len(error) < console.alert_block_max_content_length
+    console.log_error(error)
+    assert (
+        console.consume_captured_errors()
+        == "> [!CAUTION]\n> <details>\n>\n> The snowflake engine is not recommended for storing SQLMesh state in production deployments\n> </details>\n"
+    )
+
+    # single error, over max threshold
+    error = "The snowflake engine is not recommended for storing SQLMesh state in production deployments. Please see <web link> for a list of recommended engines and more information."
+    assert len(error) > console.alert_block_collapsible_threshold
+    assert len(error) > console.alert_block_max_content_length
+    console.log_error(error)
+    assert (
+        console.consume_captured_errors()
+        == "> [!CAUTION]\n> <details>\n>\n> The snowflake engine is not re...\n>\n> Truncated. Please check the console for full information.\n> </details>\n"
+    )
+
+    # multiple errors, within max threshold but over collapsible section threshold
+    error_1 = "This is the first error"
+    error_2 = "This is the second error"
+    assert (len(error_1) + len(error_2)) > console.alert_block_collapsible_threshold
+    assert (len(error_1) + len(error_2)) < console.alert_block_max_content_length
+    console.log_error(error_1)
+    console.log_error(error_2)
+    assert (
+        console.consume_captured_errors()
+        == "> [!CAUTION]\n> <details>\n>\n> - This is the first error\n>\n> - This is the second error\n> </details>\n"
+    )
+
+    # multiple errors, over max threshold
+    error_1 = "This is the first error and its really really long"
+    error_2 = "This is the second error and its also really really long"
+    assert (len(error_1) + len(error_2)) > console.alert_block_collapsible_threshold
+    assert (len(error_1) + len(error_2)) > console.alert_block_max_content_length
+    console.log_error(error_1)
+    console.log_error(error_2)
+    assert (
+        console.consume_captured_errors()
+        == "> [!CAUTION]\n> <details>\n>\n> - This is the first error and ...\n>\n> Truncated. Please check the console for full information.\n> </details>\n"
+    )
+
+    assert console.consume_captured_errors() == ""

{sqlmesh-0.200.1.dev10 → sqlmesh-0.200.1.dev11}/tests/integrations/github/cicd/test_github_controller.py

@@ -19,11 +19,13 @@ from sqlmesh.integrations.github.cicd.config import GithubCICDBotConfig, MergeMe
 from sqlmesh.integrations.github.cicd.controller import (
     BotCommand,
     MergeStateStatus,
+    GithubCheckConclusion,
 )
 from sqlmesh.integrations.github.cicd.controller import GithubController
 from sqlmesh.integrations.github.cicd.command import _update_pr_environment
 from sqlmesh.utils.date import to_datetime, now
 from tests.integrations.github.cicd.conftest import MockIssueComment
+from sqlmesh.utils.errors import SQLMeshError
 
 pytestmark = pytest.mark.github
 
@@ -644,3 +646,54 @@ def test_get_plan_summary_doesnt_truncate_backfill_list(
 * `memory.sushi.waiter_revenue_by_day`: [2025-06-30 - 2025-07-06]"""
         in summary
     )
+
+
+def test_get_plan_summary_includes_warnings_and_errors(
+    github_client, make_controller: t.Callable[..., GithubController]
+):
+    controller = make_controller(
+        "tests/fixtures/github/pull_request_synchronized.json",
+        github_client,
+        mock_out_context=False,
+    )
+
+    controller._console.log_warning("Warning 1\nWith multiline")
+    controller._console.log_warning("Warning 2")
+    controller._console.log_error("Error 1")
+
+    summary = controller.get_plan_summary(controller.prod_plan)
+
+    assert ("> [!WARNING]\n>\n> - Warning 1\n> With multiline\n>\n> - Warning 2\n\n") in summary
+
+    assert ("> [!CAUTION]\n>\n> Error 1\n\n") in summary
+
+
+def test_get_pr_environment_summary_includes_warnings_and_errors(
+    github_client, make_controller: t.Callable[..., GithubController]
+):
+    controller = make_controller(
+        "tests/fixtures/github/pull_request_synchronized.json",
+        github_client,
+        mock_out_context=False,
+    )
+
+    controller._console.log_warning("Warning 1")
+    controller._console.log_error("Error 1")
+
+    # completed with no exception triggers a SUCCESS conclusion and only shows warnings
+    success_summary = controller.get_pr_environment_summary(
+        conclusion=GithubCheckConclusion.SUCCESS
+    )
+    assert "> [!WARNING]\n>\n> Warning 1\n" in success_summary
+    assert "> [!CAUTION]\n>\n> Error 1" not in success_summary
+
+    # since they got consumed in the previous call
+    controller._console.log_warning("Warning 1")
+    controller._console.log_error("Error 1")
+
+    # completed with an exception triggers a FAILED conclusion and shows errors
+    error_summary = controller.get_pr_environment_summary(
+        conclusion=GithubCheckConclusion.FAILURE, exception=SQLMeshError("Something broke")
+    )
+    assert "> [!WARNING]\n>\n> Warning 1\n" in error_summary
+    assert "> [!CAUTION]\n>\n> Error 1" in error_summary

{sqlmesh-0.200.1.dev10 → sqlmesh-0.200.1.dev11}/tests/integrations/github/cicd/test_integration.py

@@ -846,7 +846,7 @@ def test_merge_pr_has_no_changes(
     assert GithubCheckConclusion(pr_checks_runs[2]["conclusion"]).is_skipped
     assert pr_checks_runs[2]["output"]["title"] == "PR Virtual Data Environment: hello_world_2"
     assert (
-        ":next_track_button: Skipped creating or updating PR Environment `hello_world_2`. No changes were detected compared to the prod environment."
+        ":next_track_button: Skipped creating or updating PR Environment `hello_world_2` :next_track_button:\n\nNo changes were detected compared to the prod environment."
         in pr_checks_runs[2]["output"]["summary"]
     )