robusta-cli 0.11.0__tar.gz → 0.12.0__tar.gz

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robusta-cli
-Version: 0.11.0
+Version: 0.12.0
 Summary: 
 Author: Natan Yellin
 Author-email: aantn@users.noreply.github.com
@@ -17,6 +17,8 @@ Requires-Dist: apprise (>=1.5.0,<2.0.0)
 Requires-Dist: attrs (>=23.1.0,<24.0.0)
 Requires-Dist: better-exceptions (>=0.3.3,<0.4.0) ; extra == "all"
 Requires-Dist: bitmath (>=1.3.3.1,<2.0.0.0)
+Requires-Dist: boto3 (==1.28.72)
+Requires-Dist: botocore (==1.31.72)
 Requires-Dist: click-spinner (>=0.1.10,<0.2.0)
 Requires-Dist: colorlog (>=5.0.1,<6.0.0)
 Requires-Dist: croniter (>=1.3.15,<2.0.0)
@@ -28,6 +30,7 @@ Requires-Dist: dulwich (==0.20.28) ; extra == "all"
 Requires-Dist: fpdf2 (>=2.7.1,<3.0.0)
 Requires-Dist: grafana-api (>=1.0.3,<2.0.0) ; extra == "all"
 Requires-Dist: hikaru-model-26 (>=1.1.1,<2.0.0)
+Requires-Dist: humanize (>=3.13.1,<4.0.0)
 Requires-Dist: jinja2 (==3.1.3)
 Requires-Dist: kafka-python (>=2.0.2,<3.0.0) ; extra == "all"
 Requires-Dist: kubernetes (>=26.1.0,<27.0.0)

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "robusta-cli"
-version = "0.11.0"
+version = "0.12.0"
 description = ""
 authors = ["Natan Yellin <aantn@users.noreply.github.com>"]
 packages = [
@@ -58,6 +58,11 @@ watchgod = "^0.7"
 webexteamssdk = "^1.6.1"
 bitmath = "^1.3.3.1"
 croniter = "^1.3.15"
+humanize = "^3.13.1"
+
+# The following are added to speed up poetry dependency resolution
+botocore = "1.31.72"
+boto3 = "1.28.72"
 
 # we're freezing a specific version here because the latest version doesn't have prebuilt wheels on pypi
 # and therefore requires gcc to install which we'd like to avoid
@@ -88,7 +93,6 @@ sphinxcontrib-images = "^0.9.4"
 jsonref = "^0.2"
 Pillow = "^10.3.0"
 sphinxcontrib-mermaid = "^0.7.1"
-humanize = "^3.13.1"
 cssselect = "^1.1.0"
 pygal = "^3.0.0"
 tinycss = "^0.4"

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/src/robusta/_version.py

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

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/src/robusta/core/model/env_vars.py

@@ -113,3 +113,8 @@ RUN_AS_SUBPROCESS = load_bool("RUN_AS_SUBPROCESS", True)
 ARGO_ROLLOUTS = load_bool("ARGO_ROLLOUTS", False)
 # lowered case k8s kinds in a json array string. "[\"configmap\", \"secret\"]"
 RESOURCE_YAML_BLOCK_LIST = json.loads(os.environ.get("RESOURCE_YAML_BLOCK_LIST", "[]"))
+
+NAMESPACE_DATA_TTL = int(os.environ.get("NAMESPACE_DATA_TTL", 30*60))  # in seconds
+
+PROCESSED_ALERTS_CACHE_TTL = int(os.environ.get("PROCESSED_ALERT_CACHE_TTL", 2*3600))
+PROCESSED_ALERTS_CACHE_MAX_SIZE = int(os.environ.get("PROCESSED_ALERTS_CACHE_MAX_SIZE", 100_000))

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/src/robusta/core/model/runner_config.py

@@ -25,6 +25,7 @@ from robusta.core.sinks.webex.webex_sink_params import WebexSinkConfigWrapper
 from robusta.core.sinks.webhook.webhook_sink_params import WebhookSinkConfigWrapper
 from robusta.core.sinks.yamessenger.yamessenger_sink_params import YaMessengerSinkConfigWrapper
 from robusta.core.sinks.pushover.pushover_sink_params import PushoverSinkConfigWrapper
+from robusta.core.sinks.zulip.zulip_sink_params import ZulipSinkConfigWrapper
 from robusta.model.alert_relabel_config import AlertRelabel
 from robusta.model.playbook_definition import PlaybookDefinition
 from robusta.utils.base64_utils import is_base64_encoded
@@ -63,6 +64,7 @@ class RunnerConfig(BaseModel):
                 PushoverSinkConfigWrapper,
                 GoogleChatSinkConfigWrapper,
                 ServiceNowSinkConfigWrapper,
+                ZulipSinkConfigWrapper
             ]
         ]
     ]

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/src/robusta/core/playbooks/pod_utils/imagepull_utils.py

@@ -101,7 +101,7 @@ def get_image_pull_backoff_enrichment(pod: Pod) -> Enrichment:
     return Enrichment(
         enrichment_type=EnrichmentType.image_pull_backoff_info,
         blocks=image_pull_table_blocks,
-        title="Container Image-Pull-Backoff Information")
+        title="Container ImagePullBackoff Information")
 
 
 def __imagepull_backoff_reason_to_fix(reason: ImagePullBackoffReason) -> Optional[Tuple[str, str]]:

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/src/robusta/core/reporting/base.py

@@ -14,6 +14,7 @@ from pydantic.main import BaseModel
 from robusta.core.discovery.top_service_resolver import TopServiceResolver
 from robusta.core.model.env_vars import ROBUSTA_UI_DOMAIN
 from robusta.core.reporting.consts import FindingSource, FindingSubjectType, FindingType
+from robusta.integrations.kubernetes.api_client_utils import get_namespace_labels
 from robusta.utils.scope import BaseScopeMatcher
 
 
@@ -106,7 +107,7 @@ class EnrichmentType(Enum):
 
 
 class Enrichment:
-    # These is the actual enrichment data
+    # This is the actual enrichment data
     blocks: List[BaseBlock] = []
     # General purpose rendering flags, that can be used by specific sinks
     annotations: Dict[str, str] = {}
@@ -138,6 +139,9 @@ class FilterableScopeMatcher(BaseScopeMatcher):
     def get_data(self) -> Dict:
         return self.data
 
+    def scope_match_namespace_labels(self, attr_matcher, attr_value):
+        return self.match_labels_annotations(attr_matcher, attr_value)
+
 
 class Filterable(ABC):
     @property
@@ -169,7 +173,12 @@ class Filterable(ABC):
         # 1. "scope" check
         accept = True
         if scope_requirements is not None:
-            matcher = FilterableScopeMatcher(self.attribute_map)
+            data = self.attribute_map
+            try:
+                data["namespace_labels"] = get_namespace_labels(data["namespace"])
+            except KeyError:
+                data["namespace_labels"] = {}
+            matcher = FilterableScopeMatcher(data)
             if scope_requirements.exclude:
                 if matcher.scope_inc_exc_matches(scope_requirements.exclude):
                     return False

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/src/robusta/core/reporting/blocks.py

@@ -427,13 +427,13 @@ class TableBlock(BaseBlock):
 
         return MarkdownBlock(f"{prefix}{table_contents}{suffix}")
 
-    def to_table_string(self, table_max_width: int = PRINTED_TABLE_MAX_WIDTH) -> str:
+    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())
         col_max_width = self.__calc_max_width(self.headers, rendered_rows, table_max_width)
         return tabulate(
             rendered_rows,
             headers=self.headers,
-            tablefmt="presto",
+            tablefmt=table_fmt,
             maxcolwidths=col_max_width,
         )
 

robusta_cli-0.12.0/src/robusta/core/sinks/common/__init__.py

@@ -0,0 +1 @@
+from robusta.core.sinks.common.channel_transformer import ChannelTransformer

robusta_cli-0.12.0/src/robusta/core/sinks/common/channel_transformer.py

@@ -0,0 +1,106 @@
+from collections import defaultdict
+from string import Template
+from typing import Dict, Optional, Union
+
+import regex
+
+CLUSTER_PREF = "cluster_name"
+CLUSTER_PREF_PATTERN = regex.compile("(\$?\{?" + CLUSTER_PREF + "\}?)")  # noqa: W605
+LABELS_PREF = "labels."
+ESCAPED_LABEL_PREF = regex.escape(LABELS_PREF)
+LABEL_PREF_PATTERN = regex.compile("\$?" + ESCAPED_LABEL_PREF + "[\w.]+")  # noqa: W605
+ANNOTATIONS_PREF = "annotations."
+ESCAPED_ANNOTATIONS_PREF = regex.escape(ANNOTATIONS_PREF)
+ANNOTATIONS_PREF_PATTERN = regex.compile("\$?" + ESCAPED_ANNOTATIONS_PREF + "[\w.]+")  # noqa: W605
+BRACKETS_PATTERN = regex.compile(r"\$\{[^\}]+\}")
+COMPOSITE_PATTERN = r".*\$({?labels.[^$]+|{?annotations.[^$]+|{?cluster_name).*"
+ONLY_VALUE_PATTERN = r"^(labels.[^$]+|annotations.[^$]+|cluster_name)$"
+MISSING = "<missing>"
+
+
+class ChannelTransformer:
+    @classmethod
+    def validate_channel_override(cls, v: Union[str, None]):
+        if v:
+            if regex.match(ONLY_VALUE_PATTERN, v):
+                return "$" + v
+            if not regex.match(COMPOSITE_PATTERN, v):
+                err_msg = (
+                    f"channel_override must be '{CLUSTER_PREF}' or '{LABELS_PREF}foo' or '{ANNOTATIONS_PREF}foo' "
+                    f"or contain patters like: '${CLUSTER_PREF}'/'${LABELS_PREF}foo'/"
+                    f"'${ANNOTATIONS_PREF}foo'"
+                )
+                raise ValueError(err_msg)
+        return v
+
+    @classmethod
+    def normalize_key_string(cls, s: str) -> str:
+        return s.replace("/", "_").replace(".", "_").replace("-", "_")
+
+    @classmethod
+    def normalize_dict_keys(cls, metadata: Dict) -> Dict:
+        result = defaultdict(lambda: MISSING)
+        result.update({cls.normalize_key_string(k): v for k, v in metadata.items()})
+        return result
+
+    # if prefix not present, return ""
+    # else, if found, return replacement else return MISSING
+    @classmethod
+    def get_replacement(cls, prefix: str, value: str, normalized_replacements: Dict) -> str:
+        if prefix in value:  # value is in the format of "$prefix" or "prefix"
+            value = cls.normalize_key_string(value.replace(prefix, ""))
+            if "$" in value:
+                return Template(value).safe_substitute(normalized_replacements)
+            else:
+                return normalized_replacements[value]
+        return ""
+
+    @classmethod
+    def replace_token(
+        cls,
+        pattern: regex.Pattern,
+        prefix: str,
+        channel: str,
+        replacements: Dict[str, str],
+    ) -> str:
+        tokens = pattern.findall(channel)
+        for token in tokens:
+            clean_token = token.replace("{", "").replace("}", "")
+            replacement = cls.get_replacement(prefix, clean_token, replacements)
+            if replacement:
+                channel = channel.replace(token, replacement)
+        return channel
+
+    @classmethod
+    def template(
+        cls,
+        channel_override: Optional[str],
+        default_channel: str,
+        cluster_name: str,
+        labels: Dict[str, str],
+        annotations: Dict[str, str],
+    ) -> str:
+        if not channel_override:
+            return default_channel
+
+        channel = channel_override
+        if CLUSTER_PREF in channel:
+            # replace "cluster_name" or "$cluster_name" or ${cluster_name} with the value of the cluster name
+            channel = CLUSTER_PREF_PATTERN.sub(cluster_name, channel)
+
+        if LABELS_PREF in channel:
+            normalized_labels = cls.normalize_dict_keys(labels)
+            channel = cls.replace_token(BRACKETS_PATTERN, LABELS_PREF, channel, normalized_labels)
+            channel = cls.replace_token(LABEL_PREF_PATTERN, LABELS_PREF, channel, normalized_labels)
+
+        if ANNOTATIONS_PREF in channel:
+            normalized_annotations = cls.normalize_dict_keys(annotations)
+            channel = cls.replace_token(BRACKETS_PATTERN, ANNOTATIONS_PREF, channel, normalized_annotations)
+            channel = cls.replace_token(
+                ANNOTATIONS_PREF_PATTERN,
+                ANNOTATIONS_PREF,
+                channel,
+                normalized_annotations,
+            )
+
+        return channel if MISSING not in channel else default_channel

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/src/robusta/core/sinks/datadog/datadog_sink_params.py

@@ -5,6 +5,10 @@ from robusta.core.sinks.sink_config import SinkConfigBase
 class DataDogSinkParams(SinkBaseParams):
     api_key: str
 
+    @classmethod
+    def _get_sink_type(cls):
+        return "datadog"
+
 
 class DataDogSinkConfigWrapper(SinkConfigBase):
     datadog_sink: DataDogSinkParams

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/src/robusta/core/sinks/discord/discord_sink_params.py

@@ -5,6 +5,10 @@ from robusta.core.sinks.sink_config import SinkConfigBase
 class DiscordSinkParams(SinkBaseParams):
     url: str
 
+    @classmethod
+    def _get_sink_type(cls):
+        return "discord"
+
 
 class DiscordSinkConfigWrapper(SinkConfigBase):
     discord_sink: DiscordSinkParams

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/src/robusta/core/sinks/file/file_sink_params.py

@@ -7,6 +7,10 @@ from robusta.core.sinks.sink_config import SinkConfigBase
 class FileSinkParms(SinkBaseParams):
     file_name: str = None
 
+    @classmethod
+    def _get_sink_type(cls):
+        return "file"
+
 
 class FileSinkConfigWrapper(SinkConfigBase):
     file_sink: FileSinkParms

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/src/robusta/core/sinks/google_chat/google_chat_params.py

@@ -7,6 +7,10 @@ from robusta.core.sinks.sink_config import SinkConfigBase
 class GoogleChatSinkParams(SinkBaseParams):
     webhook_url: SecretStr
 
+    @classmethod
+    def _get_sink_type(cls):
+        return "google_chat"
+
 
 class GoogleChatSinkConfigWrapper(SinkConfigBase):
     google_chat_sink: GoogleChatSinkParams

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/src/robusta/core/sinks/jira/jira_sink_params.py

@@ -19,6 +19,10 @@ class JiraSinkParams(SinkBaseParams):
     reopenStatusName: Optional[str] = "To Do"
     noReopenResolution: Optional[str] = ""
 
+    @classmethod
+    def _get_sink_type(cls):
+        return "jira"
+
 
 class JiraSinkConfigWrapper(SinkConfigBase):
     jira_sink: JiraSinkParams

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/src/robusta/core/sinks/kafka/kafka_sink_params.py

@@ -7,6 +7,10 @@ class KafkaSinkParams(SinkBaseParams):
     topic: str
     auth: dict = {}
 
+    @classmethod
+    def _get_sink_type(cls):
+        return "kafka"
+
 
 class KafkaSinkConfigWrapper(SinkConfigBase):
     kafka_sink: KafkaSinkParams

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/src/robusta/core/sinks/mail/mail_sink_params.py

@@ -7,6 +7,10 @@ from robusta.core.sinks.sink_config import SinkConfigBase
 class MailSinkParams(SinkBaseParams):
     mailto: str
 
+    @classmethod
+    def _get_sink_type(cls):
+        return "mail"
+
     @validator("mailto")
     def validate_mailto(cls, mailto):
         # Make sure we only handle emails and exclude other schemes provided by apprise

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/src/robusta/core/sinks/mattermost/mattermost_sink_params.py

@@ -15,6 +15,10 @@ class MattermostSinkParams(SinkBaseParams):
     team: Optional[str]
     team_id: Optional[str]
 
+    @classmethod
+    def _get_sink_type(cls):
+        return "mattermost"
+
     @validator("url")
     def set_http_schema(cls, url):
         parsed_url = urlparse(url)

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/src/robusta/core/sinks/msteams/msteams_sink_params.py

@@ -5,6 +5,10 @@ from robusta.core.sinks.sink_config import SinkConfigBase
 class MsTeamsSinkParams(SinkBaseParams):
     webhook_url: str
 
+    @classmethod
+    def _get_sink_type(cls):
+        return "msteams"
+
 
 class MsTeamsSinkConfigWrapper(SinkConfigBase):
     ms_teams_sink: MsTeamsSinkParams

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/src/robusta/core/sinks/opsgenie/opsgenie_sink_params.py

@@ -10,6 +10,10 @@ class OpsGenieSinkParams(SinkBaseParams):
     tags: List[str] = []
     host: Optional[str] = None  # NOTE: If None, the default value will be used from opsgenie_sdk
 
+    @classmethod
+    def _get_sink_type(cls):
+        return "opsgenie"
+
 
 class OpsGenieSinkConfigWrapper(SinkConfigBase):
     opsgenie_sink: OpsGenieSinkParams

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/src/robusta/core/sinks/pagerduty/pagerduty_sink_params.py

@@ -5,6 +5,10 @@ from robusta.core.sinks.sink_config import SinkConfigBase
 class PagerdutySinkParams(SinkBaseParams):
     api_key: str
 
+    @classmethod
+    def _get_sink_type(cls):
+        return "pagerduty"
+
 
 class PagerdutyConfigWrapper(SinkConfigBase):
     pagerduty_sink: PagerdutySinkParams

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/src/robusta/core/sinks/pushover/pushover_sink_params.py

@@ -10,6 +10,11 @@ class PushoverSinkParams(SinkBaseParams):
     device: str = None
     pushover_url: str = "https://api.pushover.net/1/messages.json"
 
+    @classmethod
+    def _get_sink_type(cls):
+        return "pushover"
+
+
 class PushoverSinkConfigWrapper(SinkConfigBase):
     pushover_sink: PushoverSinkParams
 

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/src/robusta/core/sinks/robusta/robusta_sink_params.py

@@ -17,6 +17,10 @@ class RobustaSinkParams(SinkBaseParams):
     ttl_hours: int = 4380  # Time before unactive cluster data is deleted. 6 Months default.
     persist_events: bool = False
 
+    @classmethod
+    def _get_sink_type(cls):
+        return "robusta"
+
 
 class RobustaSinkConfigWrapper(SinkConfigBase):
     robusta_sink: RobustaSinkParams

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/src/robusta/core/sinks/rocketchat/rocketchat_sink_params.py

@@ -12,6 +12,10 @@ class RocketchatSinkParams(SinkBaseParams):
     user_id: str
     server_url: str
 
+    @classmethod
+    def _get_sink_type(cls):
+        return "rocketchat"
+
     def get_rocketchat_channel(self) -> str:
         return self.channel
 

{robusta_cli-0.11.0 → robusta_cli-0.12.0}/src/robusta/core/sinks/servicenow/servicenow_sink_params.py

@@ -12,6 +12,10 @@ class ServiceNowSinkParams(SinkBaseParams):
     password: SecretStr
     caller_id: Optional[str]
 
+    @classmethod
+    def _get_sink_type(cls):
+        return "servicenow"
+
 
 class ServiceNowSinkConfigWrapper(SinkConfigBase):
     service_now_sink: ServiceNowSinkParams

robusta_cli-0.12.0/src/robusta/core/sinks/sink_base.py

@@ -0,0 +1,185 @@
+import threading
+import time
+from abc import abstractmethod, ABC
+from collections import defaultdict
+from typing import Any, List, Dict, Tuple, DefaultDict, Optional
+
+from pydantic import BaseModel, Field
+
+from robusta.core.model.k8s_operation_type import K8sOperationType
+from robusta.core.reporting.base import Finding
+from robusta.core.sinks.sink_base_params import ActivityInterval, ActivityParams, SinkBaseParams
+from robusta.core.sinks.timing import TimeSlice, TimeSliceAlways
+
+
+KeyT = Tuple[str, ...]
+
+
+class NotificationGroup(BaseModel):
+    timestamps: List[float] = []
+
+    def register_notification(self, interval: int, threshold: int) -> bool:
+        """Record information about an incoming notification. Returns True if this
+        notification should be emitted by a sink, False otherwise."""
+        now_ts = time.time()
+
+        # Prune any events older than the interval
+        while self.timestamps and now_ts - self.timestamps[0] > interval:
+            self.timestamps.pop(0)
+
+        self.timestamps.append(now_ts)
+        return len(self.timestamps) >= threshold
+
+
+class NotificationSummary(BaseModel):
+    message_id: Optional[str] = None  # identifier of the summary message
+    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
+
+    def register_notification(self, summary_key: KeyT, resolved: bool, interval: int):
+        now_ts = time.time()
+        idx = 1 if resolved else 0
+        if now_ts - self.start_ts > interval or not self.summary_table:
+            # Expired or the first summary ever for this group_key, reset the data
+            self.summary_table = defaultdict(lambda: [0, 0])
+            self.start_ts = now_ts
+            self.message_id = None
+        self.summary_table[summary_key][idx] += 1
+
+
+class SinkBase(ABC):
+    grouping_enabled: bool
+    grouping_summary_mode: bool
+
+    # Keys for groups and summaries are determined by grouping.group_by
+    groups: DefaultDict[KeyT, NotificationGroup]
+    summaries: DefaultDict[KeyT, NotificationSummary]
+
+    # Notification summaries
+    summary_header: List[str]  # descriptive header for the summary table
+
+    def __init__(self, sink_params: SinkBaseParams, registry):
+        self.sink_name = sink_params.name
+        self.params = sink_params
+        self.default = sink_params.default
+        self.registry = registry
+        global_config = self.registry.get_global_config()
+
+        self.account_id: str = global_config.get("account_id", "")
+        self.cluster_name: str = global_config.get("cluster_name", "")
+        self.signing_key = global_config.get("signing_key", "")
+
+        self.time_slices = self._build_time_slices_from_params(self.params.activity)
+
+        self.grouping_summary_mode = False
+        self.grouping_enabled = False
+
+        if sink_params.grouping:
+            self.finding_group_lock = threading.RLock()
+            self.grouping_enabled = True
+            if sink_params.grouping.notification_mode.summary:
+                self.grouping_summary_mode = True
+                self.summaries = defaultdict(lambda: NotificationSummary())
+                self.summary_header = self.create_summary_header()
+            else:
+                self.grouping_summary_mode = False
+                self.groups = defaultdict(lambda: NotificationGroup())
+
+    def create_summary_header(self):
+        summary_header = []
+        for attr in self.params.grouping.notification_mode.summary.by:
+            if isinstance(attr, str):
+                summary_header.append("notification" if attr == "identifier" else attr)
+            elif isinstance(attr, dict):
+                keys = list(attr.keys())
+                if len(keys) > 1:
+                    raise ValueError(
+                        "Invalid sink configuration: multiple values for one of the elements in"
+                        "grouping.notification_mode.summary.by"
+                    )
+                key = keys[0]
+                if key not in ["labels", "annotations"]:
+                    raise ValueError(
+                        f"Sink configuration: grouping.notification_mode.summary.by.{key} is invalid "
+                        "(only labels/annotations allowed)"
+                    )
+                for label_or_attr_name in attr[key]:
+                    summary_header.append(f"{key[:-1]}:{label_or_attr_name}")
+        return summary_header
+
+    def get_group_key_and_header(self, finding_data: Dict, attributes: List) -> Tuple[KeyT, List[str]]:
+        """Generates group key and descriptive header from finding data.
+
+        For example, for finding_data = {"a":1, "b":2, "x": 3, "y": None} and attributes = ["x", "y"]
+        this method will return ((3, "(undefined)"), [])"""
+        values = ()
+        descriptions = []
+        for attr in attributes:
+            if isinstance(attr, str):
+                if attr not in finding_data:
+                    continue
+                value = finding_data[attr]
+                values += (value, )
+                descriptions.append(
+                    f"{'notification' if attr=='identifier' else attr}: {self.display_value(value)}"
+                )
+            elif isinstance(attr, dict):
+                # This is typically for labels and annotations
+                top_level_attr_name = list(attr.keys())[0]
+                values += tuple(
+                    finding_data.get(top_level_attr_name, {}).get(element_name)
+                    for element_name in sorted(attr[top_level_attr_name])
+                )
+                subvalues = []
+                for subattr_name in sorted(attr[top_level_attr_name]):
+                    subvalues.append((subattr_name, finding_data.get(top_level_attr_name, {}).get(subattr_name)))
+                subvalues_str = ", ".join(f"{key}={self.display_value(value)}" for key, value in sorted(subvalues))
+                descriptions.append(f"{top_level_attr_name}: {subvalues_str}")
+        return values, descriptions
+
+    def display_value(self, value: Optional[str]) -> str:
+        return value if value is not None else "(undefined)"
+
+    def _build_time_slices_from_params(self, params: ActivityParams):
+        if params is None:
+            return [TimeSliceAlways()]
+        else:
+            timezone = params.timezone
+            return [self._interval_to_time_slice(timezone, interval) for interval in params.intervals]
+
+    def _interval_to_time_slice(self, timezone: str, interval: ActivityInterval):
+        return TimeSlice(interval.days, [(time.start, time.end) for time in interval.hours], timezone)
+
+    def is_global_config_changed(self):
+        # registry global config can be updated without these stored values being changed
+        global_config = self.registry.get_global_config()
+        account_id = global_config.get("account_id", "")
+        cluster_name = global_config.get("cluster_name", "")
+        signing_key = global_config.get("signing_key", "")
+        return self.account_id != account_id or self.cluster_name != cluster_name or self.signing_key != signing_key
+
+    def stop(self):
+        pass
+
+    def accepts(self, finding: Finding) -> bool:
+        return (
+            finding.matches(self.params.match, self.params.scope)
+            and any(time_slice.is_active_now for time_slice in self.time_slices)
+        )
+
+    @abstractmethod
+    def write_finding(self, finding: Finding, platform_enabled: bool):
+        raise NotImplementedError(f"write_finding not implemented for sink {self.sink_name}")
+
+    def is_healthy(self) -> bool:
+        """
+        Sink health check. Concrete sinks can implement real health checks
+        """
+        return True
+
+    def handle_service_diff(self, new_obj: Any, operation: K8sOperationType):
+        pass
+
+    def set_cluster_active(self, active: bool):
+        pass