robusta-cli 0.10.26a4__tar.gz → 0.10.27__tar.gz

{robusta_cli-0.10.26a4 → robusta_cli-0.10.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: robusta-cli
-Version: 0.10.26a4
+Version: 0.10.27
 Summary: 
 Author: Natan Yellin
 Author-email: aantn@users.noreply.github.com

{robusta_cli-0.10.26a4 → robusta_cli-0.10.27}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "robusta-cli"
-version = "0.10.26-alpha4"
+version = "0.10.27"
 description = ""
 authors = ["Natan Yellin <aantn@users.noreply.github.com>"]
 packages = [
@@ -115,6 +115,7 @@ all = ["Flask", "grafana-api", "watchdog", "dulwich", "better-exceptions", "Cair
 [tool.poetry.group.dev.dependencies]
 sphinx-jinja = { git = "https://github.com/robusta-dev/sphinx-jinja.git" }
 sphinx-reredirects = "^0.1.1"
+freezegun = "^1.4.0"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]

{robusta_cli-0.10.26a4 → robusta_cli-0.10.27}/src/robusta/_version.py

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

{robusta_cli-0.10.26a4 → robusta_cli-0.10.27}/src/robusta/cli/main.py

@@ -11,7 +11,7 @@ from typing import Dict, List, Optional, Union
 import certifi
 import typer
 import yaml
-from hikaru.model.rel_1_26 import Container, Job, JobSpec, ObjectMeta, PodSpec, PodTemplateSpec
+from hikaru.model.rel_1_26 import Container, Job, JobSpec, ObjectMeta, PodSpec, PodTemplateSpec, SecurityContext
 from kubernetes import client, config
 from pydantic import BaseModel, Extra
 
@@ -501,6 +501,7 @@ def demo_alert(
                             name="alert-curl",
                             image=image,
                             command=command,
+                            securityContext=SecurityContext(runAsUser=2000),
                         )
                     ],
                     restartPolicy="Never",

{robusta_cli-0.10.26a4 → robusta_cli-0.10.27}/src/robusta/core/discovery/discovery.py

@@ -364,7 +364,7 @@ class Discovery:
                             # we use map here to deduplicate and pick only the latest release data
                             helm_releases_map[decoded_release_row.get_service_key()] = decoded_release_row
                         except Exception as e:
-                            logging.error(f"an error occured while decoding helm releases: {e}")
+                            logging.error(f"an error occurred while decoding helm releases: {e}")
 
                     continue_ref = secrets.metadata._continue
                     if not continue_ref:

{robusta_cli-0.10.26a4 → robusta_cli-0.10.27}/src/robusta/core/model/cluster_status.py

@@ -1,3 +1,5 @@
+from datetime import datetime
+
 from pydantic.main import BaseModel, List, Optional
 
 
@@ -18,6 +20,7 @@ class ActivityStats(BaseModel):
     alertManagerConnection: bool
     prometheusConnection: bool
     prometheusRetentionTime: str
+    managedPrometheusAlerts: bool
 
 
 class ClusterStatus(BaseModel):

{robusta_cli-0.10.26a4 → robusta_cli-0.10.27}/src/robusta/core/model/env_vars.py

@@ -34,12 +34,12 @@ INTERNAL_PLAYBOOKS_ROOT = os.environ.get("INTERNAL_PLAYBOOKS_ROOT", "/app/src/ro
 DEFAULT_TIMEZONE = pytz.timezone(os.environ.get("DEFAULT_TIMEZONE", "UTC"))
 NUM_EVENT_THREADS = int(os.environ.get("NUM_EVENT_THREADS", 20))
 INCOMING_EVENTS_QUEUE_MAX_SIZE = int(os.environ.get("INCOMING_EVENTS_QUEUE_MAX_SIZE", 500))
-EVENT_PARSING_WORKERS = int(os.environ.get("EVENT_PARSING_WORKERS", 1))
 
 FLOAT_PRECISION_LIMIT = int(os.environ.get("FLOAT_PRECISION_LIMIT", 11))
 
 PROMETHEUS_REQUEST_TIMEOUT_SECONDS = float(os.environ.get("PROMETHEUS_REQUEST_TIMEOUT_SECONDS", 90.0))
 PROMETHEUS_ENABLED = os.environ.get("PROMETHEUS_ENABLED", "false").lower() == "true"
+MANAGED_CONFIGURATION_ENABLED = os.environ.get("MANAGED_CONFIGURATION_ENABLED", "false").lower() == "true"
 PROMETHEUS_SSL_ENABLED = os.environ.get("PROMETHEUS_SSL_ENABLED", "false").lower() == "true"
 
 INCOMING_REQUEST_TIME_WINDOW_SECONDS = int(os.environ.get("INCOMING_REQUEST_TIME_WINDOW_SECONDS", 3600))
@@ -94,6 +94,10 @@ DISABLE_HELM_MONITORING = load_bool("DISABLE_HELM_MONITORING", False)
 
 PROMETHEUS_ERROR_LOG_PERIOD_SEC = int(os.environ.get("DISCOVERY_MAX_BATCHES", 14400))
 
+RRM_PERIOD_SEC = int(os.environ.get("RRM_PERIOD_SEC", 90))
+
+MAX_ALLOWED_RULES_PER_CRD_ALERT = int(os.environ.get("MAX_ALLOWED_RULES_PER_CRD_ALERT", 600))
+
 IMAGE_REGISTRY = os.environ.get("IMAGE_REGISTRY", "us-central1-docker.pkg.dev/genuine-flight-317411/devel")
 
 CLUSTER_DOMAIN = os.environ.get("CLUSTER_DOMAIN", "cluster.local")

robusta_cli-0.10.27/src/robusta/core/playbooks/base_trigger.py

@@ -0,0 +1,36 @@
+import abc
+from typing import Any, Dict, List, Optional, Type
+
+from pydantic import BaseModel
+
+from robusta.core.model.events import ExecutionBaseEvent
+from robusta.core.reporting.base import Finding
+from robusta.utils.documented_pydantic import DocumentedModel
+
+
+class TriggerEvent(BaseModel):
+    @abc.abstractmethod
+    def get_event_name(self) -> str:
+        """Return trigger event name"""
+        return ""
+
+    def get_event_description(self) -> str:
+        """Returns a description of the concrete event"""
+        return "NA"
+
+
+class BaseTrigger(DocumentedModel):
+    def get_trigger_event(self) -> str:
+        pass
+
+    def should_fire(self, event: TriggerEvent, playbook_id: str, build_context: Dict[str, Any]):
+        return True
+
+    def build_execution_event(
+        self, event: TriggerEvent, sink_findings: Dict[str, List[Finding]], build_context: Dict[str, Any]
+    ) -> Optional[ExecutionBaseEvent]:
+        pass
+
+    @staticmethod
+    def get_execution_event_type() -> Type[ExecutionBaseEvent]:
+        pass

{robusta_cli-0.10.26a4 → robusta_cli-0.10.27}/src/robusta/core/playbooks/internal/discovery_events.py

@@ -63,7 +63,7 @@ def create_debug_event_finding(event: Event):
     Create finding based on the kubernetes event
     """
     k8s_obj = event.regarding
-
+    subject_type = FindingSubjectType.from_kind(k8s_obj.kind.lower()) if k8s_obj.kind else FindingSubjectType.TYPE_NONE
     finding = Finding(
         title=f"{event.reason} {event.type} for {k8s_obj.kind} {k8s_obj.namespace}/{k8s_obj.name}",
         description=event.note,
@@ -73,7 +73,7 @@ def create_debug_event_finding(event: Event):
         aggregation_key=f"Kubernetes {event.type} Event",
         subject=FindingSubject(
             k8s_obj.name,
-            FindingSubjectType.from_kind(k8s_obj.kind.lower()),
+            subject_type,
             k8s_obj.namespace,
         ),
         creation_date=get_event_timestamp(event),

{robusta_cli-0.10.26a4 → robusta_cli-0.10.27}/src/robusta/core/playbooks/playbooks_event_handler_impl.py

@@ -17,7 +17,6 @@ from robusta.core.playbooks.trigger import Trigger
 from robusta.core.reporting import MarkdownBlock
 from robusta.core.reporting.base import Finding
 from robusta.core.reporting.consts import SYNC_RESPONSE_SINK
-from robusta.core.sinks.robusta import RobustaSink
 from robusta.core.sinks.robusta.dal.model_conversion import ModelConversion
 from robusta.model.alert_relabel_config import AlertRelabel
 from robusta.model.config import Registry
@@ -46,12 +45,13 @@ class PlaybooksEventHandlerImpl(PlaybooksEventHandler):
         execution_response = None
         execution_event: Optional[ExecutionBaseEvent] = None
         sink_findings: Dict[str, List[Finding]] = defaultdict(list)
+        build_context: Dict[str, Any] = {}
         for playbook in playbooks:
-            fired_trigger = self.__get_fired_trigger(trigger_event, playbook.triggers, playbook.get_id())
+            fired_trigger = self.__get_fired_trigger(trigger_event, playbook.triggers, playbook.get_id(), build_context)
             if fired_trigger:
                 execution_event = None
                 try:
-                    execution_event = fired_trigger.build_execution_event(trigger_event, sink_findings)
+                    execution_event = fired_trigger.build_execution_event(trigger_event, sink_findings, build_context)
                     # sink_findings needs to be shared between playbooks.
                     # build_execution_event returns a different instance because it's running in a child process
                     execution_event.sink_findings = sink_findings
@@ -281,9 +281,10 @@ class PlaybooksEventHandlerImpl(PlaybooksEventHandler):
         trigger_event: TriggerEvent,
         playbook_triggers: List[Trigger],
         playbook_id: str,
+        build_context: Dict[str, Any],
     ) -> Optional[BaseTrigger]:
         for trigger in playbook_triggers:
-            if trigger.get().should_fire(trigger_event, playbook_id):
+            if trigger.get().should_fire(trigger_event, playbook_id, build_context):
                 return trigger.get()
         return None
 
@@ -307,6 +308,11 @@ class PlaybooksEventHandlerImpl(PlaybooksEventHandler):
                         # Each sink has a different findings, but enrichments are shared
                         finding_copy = copy.deepcopy(finding)
                         sink.write_finding(finding_copy, self.registry.get_sinks().platform_enabled)
+
+                        sink_info = sinks_info[sink_name]
+                        sink_info.type = sink.__class__.__name__
+                        sink_info.findings_count += 1
+
                         if sink.params.stop:
                             return
 

{robusta_cli-0.10.26a4 → robusta_cli-0.10.27}/src/robusta/core/schedule/scheduler.py

@@ -14,7 +14,7 @@ from robusta.core.schedule.model import DynamicDelayRepeat, JobStatus, Scheduled
 # for a short time there are two runners running (old+new version) and they both
 # see the new scheduled playbook. we add a delay so that only the new runner ends up
 # running the scheduled playbook
-INITIAL_SCHEDULE_DELAY_SEC = os.environ.get("INITIAL_SCHEDULE_DELAY_SEC", 120)
+INITIAL_SCHEDULE_DELAY_SEC = int(os.environ.get("INITIAL_SCHEDULE_DELAY_SEC", 120))
 
 
 class Scheduler:

{robusta_cli-0.10.26a4 → robusta_cli-0.10.27}/src/robusta/core/sinks/pagerduty/pagerduty_sink.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, List
 
 import requests
 
@@ -233,7 +233,7 @@ class PagerdutySink(SinkBase):
         return ""
 
     @staticmethod
-    def __to_unformatted_text_for_changes(block: KubernetesDiffBlock) -> Optional[list[str]]:
+    def __to_unformatted_text_for_changes(block: KubernetesDiffBlock) -> Optional[List[str]]:
         return list(map(
             lambda diff: diff.formatted_path,
             block.diffs,

{robusta_cli-0.10.26a4 → robusta_cli-0.10.27}/src/robusta/core/sinks/robusta/dal/supabase_dal.py

@@ -1,9 +1,12 @@
 import json
 import logging
 import time
-from typing import Any, Dict, List
-
+from collections import defaultdict
+from datetime import datetime
+from typing import Any, Dict, List, Optional
 import requests
+from postgrest.base_request_builder import BaseFilterRequestBuilder
+from postgrest.utils import sanitize_param
 from postgrest.types import ReturnMethod
 from supabase import create_client
 from supabase.lib.client_options import ClientOptions
@@ -19,8 +22,10 @@ from robusta.core.reporting import Enrichment
 from robusta.core.reporting.base import Finding
 from robusta.core.reporting.blocks import EventsBlock, EventsRef, ScanReportBlock, ScanReportRow
 from robusta.core.reporting.consts import EnrichmentAnnotation
-from robusta.core.sinks.robusta import RobustaSinkParams
 from robusta.core.sinks.robusta.dal.model_conversion import ModelConversion
+from robusta.core.sinks.robusta.rrm.account_resource_fetcher import AccountResourceFetcher
+from robusta.core.sinks.robusta.rrm.types import AccountResource, ResourceKind, \
+    AccountResourceStatusType, AccountResourceStatusInfo
 
 SERVICES_TABLE = "Services"
 NODES_TABLE = "Nodes"
@@ -33,19 +38,22 @@ NAMESPACES_TABLE = "Namespaces"
 UPDATE_CLUSTER_NODE_COUNT = "update_cluster_node_count"
 SCANS_RESULT_TABLE = "ScansResults"
 RESOURCE_EVENTS = "ResourceEvents"
+ACCOUNT_RESOURCE_TABLE = "AccountResource"
+ACCOUNT_RESOURCE_STATUS_TABLE = "AccountResourceStatus"
 
 
-class SupabaseDal:
+class SupabaseDal(AccountResourceFetcher):
     def __init__(
-        self,
-        url: str,
-        key: str,
-        account_id: str,
-        email: str,
-        password: str,
-        sink_params: RobustaSinkParams,
-        cluster_name: str,
-        signing_key: str,
+            self,
+            url: str,
+            key: str,
+            account_id: str,
+            email: str,
+            password: str,
+            sink_name: str,
+            persist_events: bool,
+            cluster_name: str,
+            signing_key: str,
     ):
         httpx_logger = logging.getLogger("httpx")
         if httpx_logger:
@@ -62,7 +70,8 @@ class SupabaseDal:
         self.sign_in_time = 0
         self.sign_in()
         self.client.auth.on_auth_state_change(self.__update_token_patch)
-        self.sink_params = sink_params
+        self.sink_name = sink_name
+        self.persist_events = persist_events
         self.signing_key = signing_key
 
     def __to_db_scanResult(self, scanResult: ScanReportRow) -> Dict[Any, Any]:
@@ -115,7 +124,7 @@ class SupabaseDal:
             evidence = ModelConversion.to_evidence_json(
                 account_id=self.account_id,
                 cluster_id=self.cluster,
-                sink_name=self.sink_params.name,
+                sink_name=self.sink_name,
                 signing_key=self.signing_key,
                 finding_id=finding.id,
                 enrichment=enrichment,
@@ -176,15 +185,8 @@ class SupabaseDal:
             res = (
                 self.client.table(SERVICES_TABLE)
                 .select(
-                    "name",
-                    "type",
-                    "namespace",
-                    "classification",
-                    "config",
-                    "ready_pods",
-                    "total_pods",
-                    "is_helm_release",
-                )
+                    "name", "type", "namespace", "classification", "config", "ready_pods", "total_pods",
+                    "is_helm_release")
                 .filter("account_id", "eq", self.account_id)
                 .filter("cluster", "eq", self.cluster)
                 .filter("deleted", "eq", False)
@@ -284,6 +286,14 @@ class SupabaseDal:
             self.handle_supabase_error()
             raise
 
+    @staticmethod
+    def custom_filter_request_builder(frq: BaseFilterRequestBuilder, operator: str,
+                                      criteria: str) -> BaseFilterRequestBuilder:
+        key, val = sanitize_param(operator), f"{criteria}"
+        frq.params = frq.params.set(key, val)
+
+        return frq
+
     def get_active_jobs(self) -> List[JobInfo]:
         try:
             res = (
@@ -499,13 +509,105 @@ class SupabaseDal:
     def persist_platform_blocks(self, enrichment: Enrichment, finding_id):
         blocks = enrichment.blocks
         for i, block in enumerate(blocks):
-            if isinstance(block, EventsBlock) and self.sink_params.persist_events and block.events:
+            if isinstance(block, EventsBlock) and self.persist_events and block.events:
                 self.persist_events_block(block)
                 event = block.events[0]
                 blocks[i] = EventsRef(name=event.name, namespace=event.namespace, kind=event.kind.lower())
             if isinstance(block, ScanReportBlock):
                 self.persist_scan(block)
 
+    def get_account_resources(
+            self,
+            resource_kind: Optional[ResourceKind] = None,
+            latest_revision: Optional[datetime] = None,
+    ) -> Dict[ResourceKind, List[AccountResource]]:
+        try:
+            query_builder = (
+                self.client.table(ACCOUNT_RESOURCE_TABLE)
+                .select("entity_id", "resource_kind", "clusters_target_set", "resource_state", "deleted", "enabled",
+                        "updated_at")
+                .eq("account_id", self.account_id)
+            )
+
+            if resource_kind:
+                query_builder.eq("resource_kind", resource_kind)
+
+            if latest_revision:
+                query_builder.gt("updated_at", latest_revision.isoformat())
+            else:
+                # in the initial db fetch don't include the deleted records.
+                # in the subsequent db fetch allow even the deleted records so that they can be removed from the cluster
+                query_builder.eq("deleted", False)
+                query_builder.eq("enabled", True)
+
+                query_builder = SupabaseDal.custom_filter_request_builder(
+                    query_builder,
+                    operator="or",
+                    criteria=f'(clusters_target_set.cs.["*"], clusters_target_set.cs.["{self.cluster}"])',
+                )
+            query_builder = query_builder.order(column="updated_at", desc=False)
+
+            res = query_builder.execute()
+        except Exception as e:
+            msg = f"Failed to get existing account resources (supabase) error"
+            logging.error(msg, exc_info=True)
+            self.handle_supabase_error()
+            raise e
+
+        account_resources_map: Dict[ResourceKind, List[AccountResource]] = defaultdict(list)
+
+        for data in res.data:
+            resource = AccountResource(
+                entity_id=data["entity_id"],
+                resource_kind=data["resource_kind"],
+                clusters_target_set=data["clusters_target_set"],
+                resource_state=data["resource_state"],
+                deleted=data["deleted"],
+                enabled=data["enabled"],
+                updated_at=data["updated_at"],
+            )
+
+            account_resources_map[resource.resource_kind].append(resource)
+
+        return account_resources_map
+
+    def __to_db_account_resource_status(
+            self,
+            status_type: AccountResourceStatusType,
+            latest_revision: datetime,
+            info: Optional[AccountResourceStatusInfo] = None,
+    ) -> Dict[Any, Any]:
+        latest_revision_iso = latest_revision.isoformat()
+        data = {
+            "account_id": self.account_id,
+            "cluster_id": self.cluster,
+            "status": status_type,
+            "info": info.dict() if info else None,
+            "updated_at": "now()",
+            "latest_revision": latest_revision_iso,
+        }
+
+        if status_type != AccountResourceStatusType.error:
+            data["synced_revision"] = latest_revision_iso
+
+        return data
+
+    def set_account_resource_status(
+            self,
+            status_type: AccountResourceStatusType,
+            info: Optional[AccountResourceStatusInfo],
+            latest_revision: datetime
+    ):
+        try:
+            data = self.__to_db_account_resource_status(status_type=status_type, info=info,
+                                                        latest_revision=latest_revision)
+
+            self.client.table(ACCOUNT_RESOURCE_STATUS_TABLE).upsert(data).execute()
+        except Exception as e:
+            logging.error(f"Failed to set account resource status to {status_type}", exc_info=True)
+            self.handle_supabase_error()
+            raise
+
     def __rpc_patch(self, func_name: str, params: dict) -> Dict[str, Any]:
         """
         Supabase client is async. Sync impl of rpc call

{robusta_cli-0.10.26a4 → robusta_cli-0.10.27}/src/robusta/core/sinks/robusta/prometheus_health_checker.py

@@ -31,7 +31,7 @@ class PrometheusHealthChecker:
 
         self.__last_alertmanager_error_log_time = 0
         self.__last_prometheus_error_log_time = 0
-        self.__check_prometheus_flags = True
+        self.__check_prometheus_flags = global_config.get("check_prometheus_flags", True)
 
         self.__thread = threading.Thread(target=self.__run_checks)
         self.__thread.start()

{robusta_cli-0.10.26a4 → robusta_cli-0.10.27}/src/robusta/core/sinks/robusta/robusta_sink.py

@@ -11,13 +11,12 @@ from kubernetes.client import V1Node, V1NodeCondition, V1NodeList, V1Taint
 
 from robusta.core.discovery.discovery import DISCOVERY_STACKTRACE_TIMEOUT_S, Discovery, DiscoveryResults
 from robusta.core.discovery.top_service_resolver import TopLevelResource, TopServiceResolver
-from robusta.core.model.cluster_status import ActivityStats, ClusterStats, ClusterStatus
 from robusta.core.model.env_vars import (
-    CLUSTER_STATUS_PERIOD_SEC,
-    DISCOVERY_CHECK_THRESHOLD_SEC,
-    DISCOVERY_PERIOD_SEC,
     DISCOVERY_WATCHDOG_CHECK_SEC,
 )
+from robusta.core.model.cluster_status import ActivityStats, ClusterStats, ClusterStatus
+from robusta.core.model.env_vars import CLUSTER_STATUS_PERIOD_SEC, DISCOVERY_CHECK_THRESHOLD_SEC, DISCOVERY_PERIOD_SEC, \
+    MANAGED_CONFIGURATION_ENABLED
 from robusta.core.model.helm_release import HelmRelease
 from robusta.core.model.jobs import JobInfo
 from robusta.core.model.k8s_operation_type import K8sOperationType
@@ -29,6 +28,7 @@ from robusta.core.reporting.base import Finding
 from robusta.core.sinks.robusta.discovery_metrics import DiscoveryMetrics
 from robusta.core.sinks.robusta.prometheus_health_checker import PrometheusHealthChecker
 from robusta.core.sinks.robusta.robusta_sink_params import RobustaSinkConfigWrapper, RobustaToken
+from robusta.core.sinks.robusta.rrm.rrm import RRM
 from robusta.core.sinks.sink_base import SinkBase
 from robusta.integrations.receiver import ActionRequestReceiver
 from robusta.runner.web_api import WebApi
@@ -62,7 +62,8 @@ class RobustaSink(SinkBase):
             robusta_token.account_id,
             robusta_token.email,
             robusta_token.password,
-            sink_config.robusta_sink,
+            sink_config.robusta_sink.name,
+            sink_config.robusta_sink.persist_events,
             self.cluster_name,
             self.signing_key,
         )
@@ -71,9 +72,11 @@ class RobustaSink(SinkBase):
         self.last_send_time = 0
         self.__discovery_period_sec = DISCOVERY_PERIOD_SEC
 
+        global_config = self.get_global_config()
         self.__prometheus_health_checker = PrometheusHealthChecker(
-            discovery_period_sec=self.__discovery_period_sec, global_config=self.get_global_config()
+            discovery_period_sec=self.__discovery_period_sec, global_config=global_config
         )
+        self.__rrm_checker = RRM(dal=self.dal, cluster=self.cluster_name, account_id=self.account_id)
         self.__pods_running_count: int = 0
         self.__update_cluster_status()  # send runner version initially, then force prometheus alert time periodically.
 
@@ -215,7 +218,7 @@ class RobustaSink(SinkBase):
 
         except Exception as e:
             logging.error(
-                f"An error occured while publishing single service: name - {new_service.name}, namespace - {new_service.namespace}  service type: {new_service.service_type}  | {e}"
+                f"An error occurred while publishing single service: name - {new_service.name}, namespace - {new_service.namespace}  service type: {new_service.service_type}  | {e}"
             )
 
     def __publish_new_services(self, active_services: List[ServiceInfo]):
@@ -277,11 +280,11 @@ class RobustaSink(SinkBase):
                 timeout_delay=30,
             )
             if response != 200:
-                logging.error("Error occured while sending `helm release trigger event`")
+                logging.error("Error occurred while sending `helm release trigger event`")
             else:
                 logging.debug("Sent `helm release` trigger event.")
         except Exception:
-            logging.error("Error occured while sending `helm release` trigger event", exc_info=True)
+            logging.error("Error occurred while sending `helm release` trigger event", exc_info=True)
 
     def __discover_resources(self) -> DiscoveryResults:
         # discovery is using the k8s python API and not Hikaru, since it's performance is 10 times better
@@ -463,7 +466,7 @@ class RobustaSink(SinkBase):
         for helm_release_key in curr_helm_releases.keys():
             current_helm_release = curr_helm_releases[helm_release_key]
             if (
-                self.__helm_releases_cache.get(helm_release_key) != current_helm_release
+                    self.__helm_releases_cache.get(helm_release_key) != current_helm_release
             ):  # helm_release not in the cache, or changed
                 helm_releases.append(current_helm_release)
                 self.__helm_releases_cache[helm_release_key] = current_helm_release
@@ -478,6 +481,7 @@ class RobustaSink(SinkBase):
             alertManagerConnection=prometheus_health_checker_status.alertmanager,
             prometheusConnection=prometheus_health_checker_status.prometheus,
             prometheusRetentionTime=prometheus_health_checker_status.prometheus_retention_time,
+            managedPrometheusAlerts=MANAGED_CONFIGURATION_ENABLED
         )
 
         # checking the status of relay connection

robusta_cli-0.10.27/src/robusta/core/sinks/robusta/rrm/account_resource_fetcher.py

@@ -0,0 +1,22 @@
+from abc import ABC, abstractmethod
+from datetime import datetime
+from typing import List, Optional, Dict
+
+from robusta.core.sinks.robusta.rrm.types import AccountResource, ResourceKind, AccountResourceStatusType, \
+    AccountResourceStatusInfo
+
+
+class AccountResourceFetcher(ABC):
+    @abstractmethod
+    def get_account_resources(
+            self, resource_kind: Optional[ResourceKind] = None, latest_revision: Optional[datetime] = None,
+    ) -> Dict[ResourceKind, List[AccountResource]]:
+        pass
+
+    @abstractmethod
+    def set_account_resource_status(
+            self, status_type: AccountResourceStatusType,
+            info: Optional[AccountResourceStatusInfo],
+            latest_revision: datetime
+    ):
+        pass

robusta_cli-0.10.27/src/robusta/core/sinks/robusta/rrm/base_resource_manager.py

@@ -0,0 +1,13 @@
+from typing import Optional, List
+
+from robusta.core.sinks.robusta.rrm.types import ResourceKind, AccountResource
+
+
+class BaseResourceHandler:
+    def __init__(self, resource_kind: ResourceKind, cluster: str):
+        self.__latest_revision = None
+        self._resource_kind = resource_kind
+        self.cluster = cluster
+
+    def handle_resources(self, resources: List[AccountResource]) -> Optional[str]:
+        pass