saving progress

Author: Avi-Robusta

src/robusta/core/sinks/sink_factory.py

@@ -22,6 +22,7 @@
 from robusta.core.sinks.sink_base import SinkBase
 from robusta.core.sinks.sink_config import SinkConfigBase
 from robusta.core.sinks.slack import SlackSink, SlackSinkConfigWrapper
+from robusta.core.sinks.slack.preview import SlackSinkPreview, SlackSinkPreviewConfigWrapper
 from robusta.core.sinks.telegram import TelegramSink, TelegramSinkConfigWrapper
 from robusta.core.sinks.victorops import VictoropsConfigWrapper, VictoropsSink
 from robusta.core.sinks.webex import WebexSink, WebexSinkConfigWrapper
@@ -35,6 +36,7 @@
 class SinkFactory:
     __sink_config_mapping: Dict[Type[SinkConfigBase], Type[SinkBase]] = {
         SlackSinkConfigWrapper: SlackSink,
+        SlackSinkPreviewConfigWrapper: SlackSinkPreview,
         RocketchatSinkConfigWrapper: RocketchatSink,
         RobustaSinkConfigWrapper: RobustaSink,
         MsTeamsSinkConfigWrapper: MsTeamsSink,

src/robusta/core/sinks/slack/preview/__init__.py

@@ -0,0 +1,2 @@
+from robusta.core.sinks.slack.preview.slack_sink_preview import SlackSinkPreview
+from robusta.core.sinks.slack.preview.slack_sink_params_preview import SlackSinkPreviewConfigWrapper, SlackSinkPreviewParams

src/robusta/core/sinks/slack/preview/slack_sink_preview.py

@@ -0,0 +1,14 @@
+from robusta.core.sinks.slack.preview.slack_sink_preview_params import SlackSinkPreviewConfigWrapper, SlackSinkPreviewParams
+from robusta.core.sinks.slack.slack_sink import SlackSink
+from robusta.integrations import slack as slack_module
+
+
+class SlackSinkPreview(SlackSink):
+    params: SlackSinkPreviewParams
+
+    def __init__(self, sink_config: SlackSinkPreviewConfigWrapper, registry):
+        self.slack_sender = slack_module.SlackSender(
+            self.api_key, self.account_id, self.cluster_name, self.signing_key, self.slack_channel, is_preview=True
+        )
+        super().__init__(sink_config.slack_sink, registry, self.slack_sender)
+

src/robusta/core/sinks/slack/preview/slack_sink_preview_params.py

@@ -0,0 +1,43 @@
+from robusta.core.sinks.sink_base_params import SinkBaseParams
+from robusta.core.sinks.sink_config import SinkConfigBase
+from robusta.core.sinks.slack import SlackSinkParams
+from enum import Enum
+from typing import Optional, Dict
+
+
+class SlackTemplateStyle(str, Enum):
+    DEFAULT = "default"
+    LEGACY = "legacy"
+
+
+class SlackSinkPreviewParams(SlackSinkParams):
+    template_style: SlackTemplateStyle = SlackTemplateStyle.DEFAULT  # Use "legacy" for old-style formatting
+    slack_custom_templates: Optional[Dict[str, str]] = None  # Template name -> custom template content
+    template_name: Optional[str] = None
+
+    def get_effective_template_name(self) -> str:
+        """
+        Returns the template name to use for this sink. If template_name is set, use it.
+        Otherwise, use 'legacy.j2' if template_style is legacy, else 'header.j2'.
+        """
+        if self.template_name:
+            return self.template_name
+        if self.template_style == SlackTemplateStyle.LEGACY:
+            return "legacy.j2"
+        return "header.j2"
+
+    def get_custom_template(self) -> Optional[str]:
+        """
+        Returns the custom template string for the effective template name, if it exists.
+        """
+        template_name = self.get_effective_template_name()
+        if self.slack_custom_templates and template_name in self.slack_custom_templates:
+            return self.slack_custom_templates[template_name]
+        return None
+
+
+class SlackSinkPreviewConfigWrapper(SinkConfigBase):
+    slack_sink: SlackSinkPreviewParams
+
+    def get_params(self) -> SinkBaseParams:
+        return self.slack_sink

src/robusta/core/sinks/slack/slack_sink.py

@@ -10,13 +10,16 @@
 class SlackSink(SinkBase):
     params: SlackSinkParams
 
-    def __init__(self, sink_config: SlackSinkConfigWrapper, registry):
+    def __init__(self, sink_config: SlackSinkConfigWrapper, registry, slack_sender=None):
         super().__init__(sink_config.slack_sink, registry)
         self.slack_channel = sink_config.slack_sink.slack_channel
         self.api_key = sink_config.slack_sink.api_key
-        self.slack_sender = slack_module.SlackSender(
-            self.api_key, self.account_id, self.cluster_name, self.signing_key, self.slack_channel
-        )
+        if slack_sender:
+            self.slack_sender = slack_sender
+        else:
+            self.slack_sender = slack_module.SlackSender(
+                self.api_key, self.account_id, self.cluster_name, self.signing_key, self.slack_channel
+            )
         self.registry.subscribe("replace_callback_with_string", self)
 
     def handle_event(self, event_name: str, **kwargs):

src/robusta/core/sinks/slack/templates/template_loader.py

@@ -55,41 +55,37 @@ def get_template(self, template_name: str) -> Template:
 
         return self._templates[template_name]
 
-    def render_to_blocks(self, template_name: str, context: Dict[str, Any]) -> List[Dict[str, Any]]:
+    def render_to_blocks(self, template: Template, context: Dict[str, Any]) -> List[Dict[str, Any]]:
         """
-        Render a template using the provided context and parse the result as JSON to get Slack blocks.
-
+        Render a Jinja2 Template object using the provided context and parse the result as JSON to get Slack blocks.
         Args:
-            template_name: The name of the template file
+            template: A Jinja2 Template object
             context: Dictionary of variables to pass to the template
-
         Returns:
             List of Slack block objects (dictionaries)
         """
-        template = self.get_template(template_name)
-
         try:
             rendered = template.render(**context)
-
-            # Split by newlines to get multiple blocks and parse each as JSON
-            blocks = []
             blocks = []
             for block_str in rendered.strip().split("\n\n"):
                 if not block_str.strip():
                     continue
-
                 try:
                     block_str_fixed = escape_raw_newlines_in_json_strings(block_str)
+                    # Try to parse as JSON, but if it fails, log and skip
                     block = json.loads(block_str_fixed)
                     blocks.append(block)
-
                 except json.JSONDecodeError as e:
                     logging.exception(f"Error parsing JSON from template output: {e}")
                     logging.warning(f"Problematic JSON (repr): {repr(block_str)}")
-
+                    continue  # Skip this block and continue
+                except Exception as e:
+                    logging.error(f"Unexpected error parsing block: {e}")
+                    logging.warning(f"Problematic JSON (repr): {repr(block_str)}")
+                    continue
             return blocks
         except Exception as e:
-            logging.error(f"Error rendering template {template_name}: {e}")
+            logging.error(f"Error rendering template: {e}")
             return []
 
     def render_custom_template_to_blocks(self, custom_template: str, context: Dict[str, Any]) -> List[Dict[str, Any]]:

src/robusta/integrations/slack/sender.py

@@ -65,8 +65,9 @@
 class SlackSender:
     verified_api_tokens: Set[str] = set()
     channel_name_to_id = {}
+    is_preview = False
 
-    def __init__(self, slack_token: str, account_id: str, cluster_name: str, signing_key: str, slack_channel: str):
+    def __init__(self, slack_token: str, account_id: str, cluster_name: str, signing_key: str, slack_channel: str, is_preview: bool = False):
         """
         Connect to Slack and verify that the Slack token is valid.
         Return True on success, False on failure
@@ -87,6 +88,7 @@ def __init__(self, slack_token: str, account_id: str, cluster_name: str, signing
         self.signing_key = signing_key
         self.account_id = account_id
         self.cluster_name = cluster_name
+        self.is_preview = is_preview
 
         if slack_token not in self.verified_api_tokens:
             try: