robusta-api 0.35.0__tar.gz → 0.36.0__tar.gz

{robusta_api-0.35.0 → robusta_api-0.36.0}/PKG-INFO

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

{robusta_api-0.35.0 → robusta_api-0.36.0}/pyproject.toml

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

{robusta_api-0.35.0 → robusta_api-0.36.0}/src/robusta/_version.py

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

{robusta_api-0.35.0 → robusta_api-0.36.0}/src/robusta/core/model/base_params.py

@@ -188,6 +188,7 @@ class ToolApprovalDecision(BaseModel):
     tool_call_id: str
     approved: bool
     save_prefixes: Optional[List[str]] = None  # Prefixes to remember for session
+    decision: Optional[Dict[str, Any]] = None  # Structured decision data (e.g. OAuth callback params). Parsed by Holmes.
 
 
 class HolmesChatParams(HolmesParams):
@@ -216,6 +217,21 @@ class HolmesIssueChatParams(HolmesChatParams):
     context: HolmesIssueChatParamsContext
 
 
+class HolmesOAuthParams(ActionParams):
+    """
+    Forwards OAuth callback data to Holmes.
+    Params are intentionally generic (extra=allow) — the actual contract
+    is defined by Holmes and can evolve without runner changes.
+
+    :var toolset_name: The MCP toolset to authenticate
+    """
+
+    toolset_name: str
+
+    class Config:
+        extra = "allow"
+
+
 class HolmesConversationParams(HolmesParams):
     """
     :var resource: The resource related to this investigation. A resource has a `name` and `kind`, and may have `namespace` and `node`

{robusta_api-0.35.0 → robusta_api-0.36.0}/src/robusta/core/model/env_vars.py

@@ -72,6 +72,7 @@ RUNNER_SERVICE_ACCOUNT = os.environ.get("RUNNER_SERVICE_ACCOUNT", f"{RELEASE_NAM
 TELEMETRY_PERIODIC_SEC = int(os.environ.get("TELEMETRY_PERIODIC_SEC", 60 * 60 * 24))  # 24H
 
 SLACK_REQUEST_TIMEOUT = int(os.environ.get("SLACK_REQUEST_TIMEOUT", 90))
+SLACK_RATE_LIMIT_RETRIES = int(os.environ.get("SLACK_RATE_LIMIT_RETRIES", 2))
 SLACK_TABLE_COLUMNS_LIMIT = int(os.environ.get("SLACK_TABLE_COLUMNS_LIMIT", 3))
 SLACK_FORWARD_URL = os.environ.get("SLACK_FORWARD_URL")  # forward endpoint "https://api.robusta.dev/slack/"
 DISCORD_TABLE_COLUMNS_LIMIT = int(os.environ.get("DISCORD_TABLE_COLUMNS_LIMIT", 4))

{robusta_api-0.35.0 → robusta_api-0.36.0}/src/robusta/core/playbooks/internal/ai_integration.py

@@ -12,6 +12,7 @@ from robusta.core.model.base_params import (
     HolmesChatParams,
     HolmesConversationParams,
     HolmesIssueChatParams,
+    HolmesOAuthParams,
     ResourceInfo,
 )
 from robusta.core.model.events import ExecutionBaseEvent
@@ -385,6 +386,45 @@ def holmes_chat(event: ExecutionBaseEvent, params: HolmesChatParams):
         handle_holmes_error(e)
 
 
+@action
+def holmes_oauth(event: ExecutionBaseEvent, params: HolmesOAuthParams):
+    """
+    Forwards OAuth callback data to Holmes for token exchange and storage.
+
+    This action is a thin pass-through — the actual OAuth contract is defined
+    in Holmes. Params use extra=allow so Holmes can evolve the contract
+    (e.g. add new fields) without requiring runner changes.
+    """
+    holmes_url = HolmesDiscovery.find_holmes_url(params.holmes_url)
+    if not holmes_url:
+        raise ActionException(
+            ErrorCodes.HOLMES_DISCOVERY_FAILED,
+            "Robusta couldn't connect to the Holmes client.",
+        )
+
+    try:
+        result = requests.post(
+            f"{holmes_url}/api/oauth/callback",
+            json=params.dict(),
+            timeout=60,
+        )
+        result.raise_for_status()
+        response_data = result.json()
+
+        finding = Finding(
+            title="Holmes OAuth",
+            aggregation_key="HolmesOAuthResult",
+            subject=FindingSubject(subject_type=FindingSubjectType.TYPE_NONE),
+            finding_type=FindingType.AI_ANALYSIS,
+            failure=not response_data.get("success", False),
+        )
+        event.add_finding(finding)
+
+    except Exception as e:
+        logging.exception("Failed to complete Holmes OAuth callback")
+        handle_holmes_error(e)
+
+
 def stream_and_render_graphs(url, holmes_req, event):
     with requests.post(
         url,

{robusta_api-0.35.0 → robusta_api-0.36.0}/src/robusta/core/sinks/sink_base.py

@@ -8,8 +8,8 @@ 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
+from robusta.core.sinks.sink_base_params import ActivityInterval, ActivityParams, MuteInterval, SinkBaseParams
+from robusta.core.sinks.timing import MuteDateInterval, TimeSlice, TimeSliceAlways
 
 
 KeyT = Tuple[str, ...]
@@ -71,6 +71,7 @@ class SinkBase(ABC):
         self.signing_key = global_config.get("signing_key", "")
 
         self.time_slices = self._build_time_slices_from_params(self.params.activity)
+        self.mute_date_intervals = self._build_mute_intervals_from_params(self.params.mute_intervals)
 
         self.grouping_summary_mode = False
         self.grouping_enabled = False
@@ -151,6 +152,14 @@ class SinkBase(ABC):
     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 _build_mute_intervals_from_params(self, params: Optional[List[MuteInterval]]):
+        if not params:
+            return []
+        return [
+            MuteDateInterval(interval.start_date, interval.end_date, interval.timezone)
+            for interval in params
+        ]
+
     def is_global_config_changed(self) -> bool:
         # registry global config can be updated without these stored values being changed
         global_config = self.registry.get_global_config()
@@ -163,6 +172,8 @@ class SinkBase(ABC):
         pass
 
     def accepts(self, finding: Finding) -> bool:
+        if any(mute.is_muted_now() for mute in self.mute_date_intervals):
+            return False
         return (
             finding.matches(self.params.match, self.params.scope)
             and any(time_slice.is_active_now() for time_slice in self.time_slices)

{robusta_api-0.35.0 → robusta_api-0.36.0}/src/robusta/core/sinks/sink_base_params.py

@@ -57,6 +57,42 @@ class ActivityParams(BaseModel):
         return intervals
 
 
+DATE_TIME_RE = re.compile(r"^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$")
+
+
+def check_date_time_format(value: str) -> str:
+    if not DATE_TIME_RE.match(value):
+        raise ValueError(f"invalid date-time: {value}. Expected format: YYYY-MM-DD HH:MM")
+    date_part, time_part = value.split(" ", 1)
+    year, month, day = date_part.split("-")
+    hour, minute = time_part.split(":")
+    year, month, day, hour, minute = int(year), int(month), int(day), int(hour), int(minute)
+    if not (1 <= month <= 12):
+        raise ValueError(f"invalid month: {month}")
+    if not (1 <= day <= 31):
+        raise ValueError(f"invalid day: {day}")
+    if not (0 <= hour <= 23):
+        raise ValueError(f"invalid hour: {hour}")
+    if not (0 <= minute <= 59):
+        raise ValueError(f"invalid minute: {minute}")
+    return value
+
+
+class MuteInterval(BaseModel):
+    start_date: str  # YYYY-MM-DD HH:MM
+    end_date: str    # YYYY-MM-DD HH:MM
+    timezone: str = "UTC"
+
+    _validator_start = validator("start_date", allow_reuse=True)(check_date_time_format)
+    _validator_end = validator("end_date", allow_reuse=True)(check_date_time_format)
+
+    @validator("timezone")
+    def check_timezone(cls, timezone: str):
+        if timezone not in pytz.all_timezones:
+            raise ValueError(f"unknown timezone {timezone}")
+        return timezone
+
+
 class RegularNotificationModeParams(BaseModel):
     # This is mandatory because using the regular mode without setting it
     # would make no sense - all the notifications would just pass through
@@ -108,6 +144,7 @@ class SinkBaseParams(ABC, BaseModel):
     match: dict = {}
     scope: Optional[ScopeParams]
     activity: Optional[ActivityParams]
+    mute_intervals: Optional[List[MuteInterval]]
     grouping: Optional[GroupingParams]
     stop: bool = False  # Stop processing if this sink has been matched
 

{robusta_api-0.35.0 → robusta_api-0.36.0}/src/robusta/core/sinks/timing.py

@@ -65,3 +65,29 @@ class TimeSlice(TimeSliceBase):
 class TimeSliceAlways(TimeSliceBase):
     def is_active_now(self) -> bool:
         return True
+
+
+class MuteDateInterval:
+    """Checks if the current date/time falls within a mute interval.
+
+    start_date and end_date are in YYYY-MM-DD HH:MM format.
+    """
+
+    def __init__(self, start_date: str, end_date: str, timezone: str = "UTC"):
+        self.start = self._parse(start_date)
+        self.end = self._parse(end_date)
+        try:
+            self.timezone = pytz.timezone(timezone)
+        except pytz.exceptions.UnknownTimeZoneError:
+            raise ValueError(f"Unknown time zone {timezone}")
+
+    def _parse(self, date_str: str) -> Tuple[int, int, int, int, int]:
+        date_part, time_part = date_str.strip().split(" ")
+        year, month, day = date_part.split("-")
+        hour, minute = time_part.split(":")
+        return int(year), int(month), int(day), int(hour), int(minute)
+
+    def is_muted_now(self) -> bool:
+        now = datetime.now(self.timezone)
+        current = (now.year, now.month, now.day, now.hour, now.minute)
+        return self.start <= current <= self.end

{robusta_api-0.35.0 → robusta_api-0.36.0}/src/robusta/integrations/slack/sender.py

@@ -12,12 +12,14 @@ from dateutil import tz
 from slack_sdk import WebClient
 from slack_sdk.errors import SlackApiError
 from slack_sdk.http_retry import all_builtin_retry_handlers
+from slack_sdk.http_retry.builtin_handlers import RateLimitErrorRetryHandler
 from robusta.core.sinks.slack.templates.template_loader import template_loader
 
 from robusta.core.model.env_vars import (
     ADDITIONAL_CERTIFICATE,
     HOLMES_ASK_SLACK_BUTTON_ENABLED,
     HOLMES_ENABLED,
+    SLACK_RATE_LIMIT_RETRIES,
     SLACK_REQUEST_TIMEOUT,
     SLACK_TABLE_COLUMNS_LIMIT,
     SLACK_FORWARD_URL,
@@ -57,6 +59,15 @@ MAX_BLOCK_CHARS = 3000
 MENTION_PATTERN = re.compile(r"<[^>]+>")
 
 
+def _build_retry_handlers():
+    handlers = all_builtin_retry_handlers()
+    return [
+        RateLimitErrorRetryHandler(max_retry_count=SLACK_RATE_LIMIT_RETRIES)
+        if isinstance(h, RateLimitErrorRetryHandler) else h
+        for h in handlers
+    ]
+
+
 class SlackSender:
     verified_api_tokens: Set[str] = set()
     channel_name_to_id = {}
@@ -77,7 +88,7 @@ class SlackSender:
             token=slack_token,
             ssl=ssl_context,
             timeout=SLACK_REQUEST_TIMEOUT,
-            retry_handlers=all_builtin_retry_handlers(),
+            retry_handlers=_build_retry_handlers(),
             base_url=SLACK_FORWARD_URL or WebClient.BASE_URL
         )
         if SLACK_FORWARD_URL:

{robusta_api-0.35.0 → robusta_api-0.36.0}/src/robusta/runner/config_loader.py

@@ -184,6 +184,8 @@ class ConfigLoader:
     @classmethod
     def __import_playbooks_package(cls, actions_registry: ActionsRegistry, package_name: str):
         logging.info(f"Importing actions package {package_name}")
+        # Clear stale FileFinder caches so walk_packages discovers new .py files
+        importlib.invalidate_caches()
         # Reload is required for modules that are already loaded
         pkg = importlib.reload(importlib.import_module(package_name))
         playbooks_modules = [name for _, name, _ in pkgutil.walk_packages(path=pkg.__path__)]

{robusta_api-0.35.0 → robusta_api-0.36.0}/src/robusta/runner/web.py

@@ -11,7 +11,7 @@ from werkzeug.middleware.dispatcher import DispatcherMiddleware
 
 from robusta.clients.robusta_client import fetch_runner_info
 from robusta.core.model.env_vars import NUM_EVENT_THREADS, PORT, TRACE_INCOMING_ALERTS, TRACE_INCOMING_REQUESTS, \
-    PROCESSED_ALERTS_CACHE_TTL, PROCESSED_ALERTS_CACHE_MAX_SIZE, RUNNER_VERSION, RUNNER_BIND_ADDR
+    PROCESSED_ALERTS_CACHE_TTL, PROCESSED_ALERTS_CACHE_MAX_SIZE, RUNNER_VERSION, RUNNER_BIND_ADDR, ENABLE_TELEMETRY
 from robusta.core.playbooks.playbooks_event_handler import PlaybooksEventHandler
 from robusta.core.triggers.helm_releases_triggers import HelmReleasesTriggerEvent, IncomingHelmReleasesEventPayload
 from robusta.integrations.kubernetes.base_triggers import IncomingK8sEventPayload, K8sTriggerEvent
@@ -46,6 +46,8 @@ class Web:
 
     @staticmethod
     def _check_version():
+        if not ENABLE_TELEMETRY:
+            return None
         runner_info = fetch_runner_info()
         if not runner_info or not runner_info.latest_version:
             # we couldn't fetch the latest version.