robusta-api 0.46.0__tar.gz → 0.47.0__tar.gz

{robusta_api-0.46.0 → robusta_api-0.47.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robusta-api
-Version: 0.46.0
+Version: 0.47.0
 Summary: 
 Author: Arik Alon
 Author-email: arikalon1@users.noreply.github.com

{robusta_api-0.46.0 → robusta_api-0.47.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "robusta-api"
-version = "0.46.0"
+version = "0.47.0"
 description = ""
 authors = ["Arik Alon <arikalon1@users.noreply.github.com>"]
 packages = [

{robusta_api-0.46.0 → robusta_api-0.47.0}/src/robusta/_version.py

@@ -1,2 +1,2 @@
 # this is updated by .github/workflows/release.yaml
-__version__ = "0.46.0"
+__version__ = "0.47.0"

{robusta_api-0.46.0 → robusta_api-0.47.0}/src/robusta/core/reporting/blocks.py

@@ -38,6 +38,9 @@ from robusta.core.reporting.custom_rendering import render_value
 
 BLOCK_SIZE_LIMIT = 2997  # due to slack block size limit of 3000
 
+# Don't shrink a text column below this, or its values become unreadable.
+TABLE_MIN_COLUMN_WIDTH = 4
+
 
 class MarkdownBlock(BaseBlock):
     """
@@ -364,25 +367,53 @@ class TableBlock(BaseBlock):
         if table_format:
             self.metadata["format"] = TableBlockFormat.vertical.value
 
+    @classmethod
+    def __is_number(cls, value) -> bool:
+        try:
+            float(str(value))
+            return True
+        except (TypeError, ValueError):
+            return False
+
+    @classmethod
+    def __numeric_column_indices(cls, rendered_rows, num_columns: int) -> set:
+        # Numeric columns (e.g. counters) are kept at full width.
+        numeric_indices = set()
+        for idx in range(num_columns):
+            non_empty = [str(row[idx]) for row in rendered_rows if idx < len(row) and str(row[idx]).strip()]
+            if non_empty and all(cls.__is_number(v) for v in non_empty):
+                numeric_indices.add(idx)
+        return numeric_indices
+
     @classmethod
     def __calc_max_width(cls, headers, rendered_rows, table_max_width: int) -> List[int]:
-        # We need to make sure the total table width, doesn't exceed the max width,
-        # otherwise, the table is printed corrupted
-        columns_max_widths = [len(header) for header in headers]
+        # Keep the total table width within the max, otherwise it renders corrupted.
+        num_columns = max(len(headers), max((len(row) for row in rendered_rows), default=0))
+        columns_max_widths = [0] * num_columns
+        for idx, header in enumerate(headers):
+            columns_max_widths[idx] = len(str(header))
         for row in rendered_rows:
             for idx, val in enumerate(row):
                 columns_max_widths[idx] = max(len(str(val)), columns_max_widths[idx])
 
-        if sum(columns_max_widths) > table_max_width:  # We want to limit the widest column
-            largest_width = max(columns_max_widths)
-            widest_column_idx = columns_max_widths.index(largest_width)
-            diff = sum(columns_max_widths) - table_max_width
-            columns_max_widths[widest_column_idx] = largest_width - diff
-            if columns_max_widths[widest_column_idx] < 0:  # in case the diff is bigger than the largest column
-                # just divide equally
-                columns_max_widths = [
-                    int(table_max_width / len(columns_max_widths)) for i in range(0, len(columns_max_widths))
-                ]
+        if sum(columns_max_widths) <= table_max_width:
+            return columns_max_widths
+
+        # Only shrink text columns, so numeric columns never get wrapped. If every
+        # column is numeric, leave the widths as-is rather than wrapping numbers.
+        numeric_indices = cls.__numeric_column_indices(rendered_rows, num_columns)
+        shrinkable = [idx for idx in range(num_columns) if idx not in numeric_indices]
+        if not shrinkable:
+            return columns_max_widths
+
+        # Water-fill: trim the widest shrinkable column by one char at a time (fair
+        # distribution), never below TABLE_MIN_COLUMN_WIDTH.
+        while sum(columns_max_widths) > table_max_width:
+            candidates = [idx for idx in shrinkable if columns_max_widths[idx] > TABLE_MIN_COLUMN_WIDTH]
+            if not candidates:
+                break
+            widest = max(candidates, key=lambda idx: columns_max_widths[idx])
+            columns_max_widths[widest] -= 1
 
         return columns_max_widths
 
@@ -410,25 +441,88 @@ class TableBlock(BaseBlock):
 
         return "\n".join(lines[:lines_to_include]) + truncator
 
+    @staticmethod
+    def default_omission_note(omitted_rows: List[List[str]]) -> str:
+        return f"... {len(omitted_rows)} more rows not shown"
+
+    def __render_within_budget(self, max_chars: int, table_max_width: int, table_fmt: str, omission_note) -> str:
+        """Render the table, dropping whole rows to fit max_chars.
+
+        Values themselves are never cut - long ones wrap onto extra lines - so rows must be
+        dropped as complete units. Cutting by physical line would leave a wrapped value's
+        continuation behind and show a partial value as if it were the whole thing.
+        """
+        rows = self.__to_strings_rows(self.render_rows())
+        # Column widths are computed once from all rows, so dropping rows never reflows
+        # the columns and the rendered size shrinks monotonically with the row count.
+        col_max_width = self.__calc_max_width(self.headers, rows, table_max_width)
+
+        def render(subset: List[List[str]]) -> str:
+            if not subset:  # tabulate raises IndexError on maxcolwidths with no rows
+                return tabulate(subset, headers=self.headers, tablefmt=table_fmt)
+            return tabulate(subset, headers=self.headers, tablefmt=table_fmt, maxcolwidths=col_max_width)
+
+        full = render(rows)
+        if len(full) <= max_chars:
+            return full
+
+        # Largest number of whole rows that fits alongside the "N more rows" note.
+        best = None
+        low, high = 0, len(rows)
+        while low <= high:
+            mid = (low + high) // 2
+            candidate = render(rows[:mid])
+            if mid < len(rows):
+                candidate = f"{candidate}\n{omission_note(rows[mid:])}"
+            if len(candidate) <= max_chars:
+                best = candidate
+                low = mid + 1
+            else:
+                high = mid - 1
+
+        # Fall back to the line-based trim if not even a header-only table fits.
+        return best if best is not None else self.__trim_rows(full, max_chars)
+
     @classmethod
     def __to_strings_rows(cls, rows):
         # This is just to assert all row column values are strings. Tabulate might fail on other types
         return [list(map(lambda column_value: str(column_value), row)) for row in rows]
 
-    def to_markdown(self, max_chars=None, add_table_header: bool = True) -> MarkdownBlock:
-        table_header = f"{self.table_name}\n" if self.table_name else ""
-        table_header = "" if not add_table_header else table_header
-        prefix = f"{table_header}```\n"
-        suffix = "\n```"
-        table_contents = self.to_table_string()
-        if max_chars is not None:
-            max_chars = max_chars - len(prefix) - len(suffix)
-            table_contents = self.__trim_rows(table_contents, max_chars)
+    def to_markdown(self, max_chars=None, add_table_header: bool = True, omission_note=None) -> MarkdownBlock:
+        """:param omission_note: builds the note shown when rows are dropped to fit the size limit.
+        Receives the dropped rows, so callers can summarise what was left out (e.g. residual counts)."""
+        # Stay under BLOCK_SIZE_LIMIT even when no caller-supplied limit: MarkdownBlock
+        # would otherwise blindly cut the text and lose the closing ``` fence, which
+        # makes the whole table render as unformatted (non-monospace) text.
+        budget = BLOCK_SIZE_LIMIT - 1 if max_chars is None else min(max_chars, BLOCK_SIZE_LIMIT - 1)
+
+        table_header = f"{self.table_name}\n" if self.table_name and add_table_header else ""
+        opening_fence, suffix = "```\n", "\n```"
+        # The table name is caller-supplied and can be arbitrarily long, so trim it rather than
+        # let the envelope alone push the block past the limit and cost us the closing fence.
+        table_header = table_header[: max(0, budget - len(opening_fence) - len(suffix))]
+        prefix = f"{table_header}{opening_fence}"
+
+        content_budget = budget - len(prefix) - len(suffix)
+        # With no room left for content, emit an empty (but properly closed) block rather than
+        # an overflow marker that wouldn't fit either.
+        table_contents = (
+            self.__render_within_budget(
+                content_budget,
+                PRINTED_TABLE_MAX_WIDTH,
+                "presto",
+                omission_note or self.default_omission_note,
+            )
+            if content_budget > 0
+            else ""
+        )
 
         return MarkdownBlock(f"{prefix}{table_contents}{suffix}")
 
     def to_table_string(self, table_max_width: int = PRINTED_TABLE_MAX_WIDTH, table_fmt: str = "presto") -> str:
         rendered_rows = self.__to_strings_rows(self.render_rows())
+        if not rendered_rows:  # tabulate raises IndexError on maxcolwidths with no rows
+            return tabulate(rendered_rows, headers=self.headers, tablefmt=table_fmt)
         col_max_width = self.__calc_max_width(self.headers, rendered_rows, table_max_width)
         return tabulate(
             rendered_rows,

{robusta_api-0.46.0 → robusta_api-0.47.0}/src/robusta/core/sinks/sink_base.py

@@ -36,6 +36,11 @@ class NotificationSummary(BaseModel):
     start_ts: float = Field(default_factory=lambda: time.time())  # Timestamp of the first notification
     # Keys for the table are determined by grouping.notification_mode.summary.by
     summary_table: DefaultDict[KeyT, List[int]] = None
+    # The full summary table is attached as a file when it doesn't fit in the message. Files
+    # can't be edited in place, so the previous one is deleted whenever a new one is uploaded.
+    attachment_file_id: Optional[str] = None
+    attachment_permalink: Optional[str] = None
+    attachment_ts: float = 0  # when the attachment was last refreshed
 
     def register_notification(self, summary_key: KeyT, resolved: bool, interval: int):
         now_ts = time.time()
@@ -45,6 +50,12 @@ class NotificationSummary(BaseModel):
             self.summary_table = defaultdict(lambda: [0, 0])
             self.start_ts = now_ts
             self.message_id = None
+            # Forget the previous interval's attachment entirely. Its summary message stays in
+            # the channel and keeps linking that file, so it must not be deleted later - only
+            # files superseded within the same message may be.
+            self.attachment_file_id = None
+            self.attachment_permalink = None
+            self.attachment_ts = 0
         self.summary_table[summary_key][idx] += 1
 
 

{robusta_api-0.46.0 → robusta_api-0.47.0}/src/robusta/core/sinks/slack/slack_sink.py

@@ -1,4 +1,6 @@
+import json
 import logging
+from urllib.parse import urlencode
 
 from robusta.core.model.env_vars import ROBUSTA_UI_DOMAIN
 from robusta.core.reporting.base import Finding, FindingStatus
@@ -89,6 +91,7 @@ class SlackSink(SinkBase):
                     investigate_uri=investigate_uri,
                     grouping_interval=self.params.grouping.interval,
                     channel=resolved_channel,
+                    summary_state=notification_summary,
                 )
                 notification_summary.message_id = slack_thread_ts
                 should_send_notification = self.params.grouping.notification_mode.summary.threaded
@@ -104,7 +107,13 @@ class SlackSink(SinkBase):
                 )
 
     def get_timeline_uri(self, account_id: str, cluster_name: str) -> str:
-        return f"{ROBUSTA_UI_DOMAIN}/graphs?account_id={account_id}&cluster={cluster_name}"
+        # The timeline reads its filters as JSON-encoded query params, and expects "clusters"
+        # (a list) rather than a single "cluster" - passing the latter left the link unfiltered.
+        params = {
+            "account_id": account_id,
+            "clusters": json.dumps([cluster_name]),
+        }
+        return f"{ROBUSTA_UI_DOMAIN}/graphs?{urlencode(params)}"
 
     def __replace_callback_with_string(self, slack_message, block_id, message_string):
         """

{robusta_api-0.46.0 → robusta_api-0.47.0}/src/robusta/integrations/slack/sender.py

@@ -1,11 +1,12 @@
 import copy
 import logging
+import time
 import ssl
 import tempfile
 import re
 from datetime import datetime, timedelta
 from itertools import chain
-from typing import Any, Dict, List, Optional, Set, Union
+from typing import Any, Dict, List, Optional, Set, Tuple, Union
 import certifi
 import humanize
 from dateutil import tz
@@ -56,6 +57,11 @@ ACTION_TRIGGER_PLAYBOOK = "trigger_playbook"
 ACTION_LINK = "link"
 SlackBlock = Dict[str, Any]
 MAX_BLOCK_CHARS = 3000
+# A file can hold a far wider table than a message can.
+SUMMARY_ATTACHMENT_TABLE_WIDTH = 250
+# The summary message is rewritten on every notification; don't re-upload the attachment
+# that often.
+SUMMARY_ATTACHMENT_REFRESH_SECONDS = 60
 MENTION_PATTERN = re.compile(r"<[^>]+>")
 
 
@@ -860,6 +866,98 @@ class SlackSender:
             output_blocks=slack_blocks,
         )
 
+    @staticmethod
+    def __summary_table_block(table_block: TableBlock) -> Tuple[BaseBlock, int]:
+        """Render the summary table, noting the totals of any rows dropped to fit the size limit.
+
+        Without the residual counts the numbers in the table wouldn't add up to the notification
+        count in the message header, making the summary look wrong.
+
+        Returns the block and the number of rows that didn't fit.
+        """
+        if len(table_block.headers) <= 2:
+            return table_block, 0  # rendered as a bullet list rather than a table, see __to_slack_table
+
+        omitted_count = 0
+
+        def omission_note(omitted_rows: List[List[str]]) -> str:
+            nonlocal omitted_count
+            omitted_count = len(omitted_rows)
+            fired = resolved = 0
+            for row in omitted_rows:
+                try:
+                    fired += int(row[-2])
+                    resolved += int(row[-1])
+                except (IndexError, ValueError):  # not the expected numeric columns - just count rows
+                    return TableBlock.default_omission_note(omitted_rows)
+            return f"... {len(omitted_rows)} more groups ({fired} fired, {resolved} resolved) not shown"
+
+        block = table_block.to_markdown(omission_note=omission_note)
+        return block, omitted_count
+
+    def __refresh_summary_attachment(
+        self, table_block: TableBlock, summary_state, channel_id: Optional[str], thread_ts: Optional[str]
+    ) -> Tuple[Optional[str], Optional[str]]:
+        """Attach the complete table as a file, since the message can only show part of it.
+
+        Slack files are immutable, but the summary message is rewritten on every notification, so
+        a fresh file is uploaded rather than edited. That is throttled - re-uploading on every
+        single notification would be wasteful.
+
+        Returns the permalink and the id of the file it supersedes. The caller must only delete
+        that file once the message actually points at the new one, otherwise a failed update
+        leaves the message linking a file that no longer exists.
+        """
+        if summary_state is None:
+            return None, None
+
+        if not channel_id or not thread_ts:
+            # The file is shared into the summary message's own thread, so it needs that message
+            # to exist first. This only defers the attachment past the very first summary - the
+            # message is updated on the next notification, and the file appears then.
+            logging.debug("Summary message not posted yet, deferring the attachment")
+            return None, None
+
+        now = time.time()
+        if summary_state.attachment_permalink and now - summary_state.attachment_ts < SUMMARY_ATTACHMENT_REFRESH_SECONDS:
+            return summary_state.attachment_permalink, None
+
+        # A much wider table fits in a file than in a message, so nothing wraps there.
+        contents = table_block.to_table_string(table_max_width=SUMMARY_ATTACHMENT_TABLE_WIDTH)
+        file_block = FileBlock("alerts-summary.txt", contents.encode("utf-8"))
+        try:
+            resp = self.slack_client.files_upload_v2(
+                # Without a channel the file is only linkable, not shared: the permalink opens
+                # an empty preview that other members can't read or download. Sharing it into
+                # the summary's thread rather than the channel keeps the channel readable when
+                # there are many groups - otherwise every group adds a file message to it.
+                channel=channel_id,
+                thread_ts=thread_ts,
+                title=file_block.filename,
+                filename=file_block.filename,
+                content=file_block.contents,
+            )
+            permalink = resp["file"]["permalink"]
+            new_file_id = resp["file"]["id"]
+        except Exception:
+            logging.exception("Failed to upload the full summary table to Slack")
+            return summary_state.attachment_permalink, None
+
+        superseded_file_id = summary_state.attachment_file_id
+        summary_state.attachment_file_id = new_file_id
+        summary_state.attachment_permalink = permalink
+        summary_state.attachment_ts = now
+        return permalink, superseded_file_id
+
+    def __delete_superseded_attachment(self, file_id: Optional[str]) -> None:
+        if not file_id:
+            return
+        # Best effort - a leftover file is preferable to failing the summary update.
+        try:
+            self.slack_client.files_delete(file=file_id)
+        except Exception as e:
+            logging.warning(f"Could not delete the superseded summary attachment: {e}")
+
     def send_or_update_summary_message(
         self,
         group_by_classification_header: List[str],
@@ -873,12 +971,23 @@ class SlackSender:
         investigate_uri: str = None,
         grouping_interval: int = None,  # in seconds
         channel: str = None,  # pre-resolved channel (when channel_override uses labels/annotations)
+        summary_state=None,  # NotificationSummary, for tracking the attachment across updates
     ):
         """Create or update a summary message with tabular information about the amount of events
         fired/resolved and a header describing the event group that this information concerns."""
         rows = []
         n_total_alerts = 0
-        for key, value in sorted(summary_table.items()):
+        # Sort by firing count, then resolved count (both descending), so that when the table
+        # is too long to fit in a message the rows that get dropped are the least significant
+        # ones rather than whichever groups happen to sort last alphabetically. The key is only
+        # a final tie-break, to keep the order stable between updates of the same message. It is
+        # normalised to strings first: keys hold raw attribute values, which may mix None with
+        # strings (e.g. "workload" is None for a finding with no service) and aren't comparable.
+        def sort_key(item):
+            group_key, (fired, resolved) = item
+            return -fired, -resolved, tuple(str(value) for value in group_key)
+
+        for key, value in sorted(summary_table.items(), key=sort_key):
             # key is a tuple of attribute names; value is a 2-element list with
             # the number of firing and resolved notifications.
             row = list(str(e) for e in chain(key, value))
@@ -924,21 +1033,17 @@ class SlackSender:
         else:
             blocks.append(MarkdownBlock(text=cluster_txt))
 
+        summary_block, omitted_count = self.__summary_table_block(table_block)
         blocks.extend(
             [
                 MarkdownBlock(f"*Matching criteria*: {group_by_criteria_str}"),
                 MarkdownBlock(text=time_text),
-                table_block,
+                summary_block,
             ]
         )
 
-        if threaded:
-            blocks.append(MarkdownBlock(text="See thread for individual alerts"))
-
-        output_blocks = []
-        for block in blocks:
-            output_blocks.extend(self.__to_slack(block, sink_params.name))
-
+        # Resolve the target before building the rest of the message, so that bailing out
+        # doesn't leave an uploaded attachment behind.
         if not channel:
             # Fallback: resolve channel without labels/annotations (only cluster_name will work)
             channel = ChannelTransformer.template(
@@ -948,6 +1053,7 @@ class SlackSender:
                 {},
                 {},
             )
+        channel_name = channel
         if msg_ts is not None:
             method = self.slack_client.chat_update
             kwargs = {"ts": msg_ts}
@@ -964,14 +1070,47 @@ class SlackSender:
             method = self.slack_client.chat_postMessage
             kwargs = {}
 
+        attachment_permalink = None
+        superseded_file_id = None
+        if omitted_count:
+            # Too many groups to show inline - attach the complete table as a file. The link has
+            # to sit outside the table's code block, Slack doesn't render links inside one.
+            # Only on the update path do we have both the channel id and the summary message to
+            # thread the file under - `channel` has already been swapped for the id there.
+            attachment_permalink, superseded_file_id = self.__refresh_summary_attachment(
+                table_block, summary_state, channel if msg_ts is not None else None, msg_ts
+            )
+            if attachment_permalink:
+                blocks.append(MarkdownBlock(text=f"<{attachment_permalink}|See all {len(rows)} groups> (attached)"))
+
+        if threaded:
+            blocks.append(MarkdownBlock(text="See thread for individual alerts"))
+
+        output_blocks = []
+        for block in blocks:
+            output_blocks.extend(self.__to_slack(block, sink_params.name))
+
+        message_text = "Summary for: " + ", ".join(group_by_classification_header)
+        if attachment_permalink:
+            # Uploaded files have to be referenced from the message text, not just the blocks,
+            # for Slack to actually share them (see prepare_slack_text).
+            message_text = f"{message_text}\n<{attachment_permalink}|alerts-summary.txt>"
+
         try:
             resp = method(
                 channel=channel,
-                text="Summary for: " + ", ".join(group_by_classification_header),
+                text=message_text,
                 blocks=output_blocks,
                 display_as_bot=True,
                 **kwargs,
             )
+            # Updating this message later needs the channel id, and a summary-only sink never
+            # sends anything else that would record it (individual alerts, which do, are only
+            # sent in threaded mode). Without this the message can never be updated, and a new
+            # summary gets posted for every notification instead.
+            self.channel_name_to_id[channel_name] = resp["channel"]
+            # Only now that the message points at the new file is the old one safe to remove.
+            self.__delete_superseded_attachment(superseded_file_id)
             return resp["ts"]
         except Exception as e:
             logging.exception(f"error sending message to slack\n{e}\nchannel={channel}\n")