fixing template

Author: Avi-Robusta

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

@@ -1,14 +1,24 @@
 import json
 import logging
 import os
-from typing import Dict, Any, Optional, List, Tuple
+import re
+from typing import Any, Dict, List
 
 from jinja2 import Environment, FileSystemLoader, Template, select_autoescape
 
 # Get the directory where our templates are stored
 TEMPLATE_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)))
 
 
+def escape_raw_newlines_in_json_strings(raw_json: str) -> str:
+    def fix_string(match):
+        s = match.group(1)
+        return s.replace("\n", "\\n")  # Escape raw newlines in strings
+
+    STRING_LITERAL_RE = re.compile(r'("(?:\\.|[^"\\])*")', flags=re.DOTALL)
+    return STRING_LITERAL_RE.sub(fix_string, raw_json)
+
+
 class SlackTemplateLoader:
     """
     Loads and renders Jinja2 templates for Slack messages.
@@ -28,10 +38,10 @@ def __init__(self):
     def get_template(self, template_name: str) -> Template:
         """
         Get a template by name, loading from file if not already cached.
-        
+
         Args:
             template_name: The name of the template file (e.g., "header.j2")
-            
+
         Returns:
             A Jinja2 Template object
         """
@@ -42,41 +52,73 @@ def get_template(self, template_name: str) -> Template:
                 logging.error(f"Error loading template {template_name}: {e}")
                 # Return a simple default template as fallback
                 return Template("Template loading error")
-        
+
         return self._templates[template_name]
 
     def render_to_blocks(self, template_name: str, 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.
-        
+
         Args:
             template_name: The name of the template file
             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 block_str.strip():
-                    try:
-                        block = json.loads(block_str)
-                        blocks.append(block)
-                    except json.JSONDecodeError as e:
-                        logging.error(f"Error parsing JSON from template output: {e}")
-                        logging.debug(f"Problematic JSON: {block_str}")
-            
+                if not block_str.strip():
+                    continue
+
+                try:
+                    block_str_fixed = escape_raw_newlines_in_json_strings(block_str)
+                    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)}")
+
             return blocks
         except Exception as e:
             logging.error(f"Error rendering template {template_name}: {e}")
             return []
 
+    def render_custom_or_file_template_to_blocks(self, template_name: str, context: Dict[str, Any], custom_template: str = None) -> List[Dict[str, Any]]:
+        """
+        Render a custom Jinja template string (if provided) or a file-based template to Slack blocks.
+        Args:
+            template_name: The name of the file-based template (e.g., "header.j2")
+            context: Dictionary of variables to pass to the template
+            custom_template: Optional Jinja template string to use instead of file-based template
+        Returns:
+            List of Slack block objects (dictionaries)
+        """
+        if custom_template:
+            try:
+                template = Template(custom_template)
+                rendered_blocks = []
+                for block_str in template.render(**context).strip().split("\n\n"):
+                    if block_str.strip():
+                        block_str_fixed = escape_raw_newlines_in_json_strings(block_str)
+                        block = json.loads(block_str_fixed)
+                        rendered_blocks.append(block)
+                return rendered_blocks
+            except Exception as e:
+                logging.error(f"Error rendering custom template: {e}")
+                # Fall back to file-based template
+
+        # Use file-based template
+        return self.render_to_blocks(template_name, context)
+
 
 # Singleton instance
-template_loader = SlackTemplateLoader()
+template_loader = SlackTemplateLoader()

src/robusta/integrations/slack/sender.py

@@ -507,23 +507,11 @@ def __create_finding_header(
             "resource_emoji": resource_emoji,
             "finding": finding
         }
-        
-        # If custom template provided, use it directly with Jinja
-        if custom_template:
-            try:
-                template = Template(custom_template)
-                rendered_blocks = []
-                for block_str in template.render(**template_context).strip().split("\n\n"):
-                    if block_str.strip():
-                        block = json.loads(block_str)
-                        rendered_blocks.append(block)
-                return rendered_blocks
-            except Exception as e:
-                logging.error(f"Error rendering custom template: {e}")
-                # Fall back to file-based template
-        
-        # Use file-based template
-        return template_loader.render_to_blocks(template_name, template_context)
+
+        # Use the new template loader method for both custom and file-based templates
+        return template_loader.render_custom_or_file_template_to_blocks(
+            template_name, template_context, custom_template
+        )
 
     def __create_links(
         self,