Change mute_intervals to use exact dates with year (YYYY-MM-DD HH:MM)

Switches from MM-DD HH:MM (yearless) to YYYY-MM-DD HH:MM format.
This simplifies the logic (no year-boundary wrapping needed) and
gives users precise control over mute windows.

https://claude.ai/code/session_01FGiv1N3QcFMWAPT4e1pu93

Author: claude

helm/robusta/values.yaml

@@ -11,7 +11,7 @@ playbookRepos: {}
 
 # sinks configurations
 # Each sink supports an optional mute_intervals field (parallel to activity) that mutes
-# all notifications during specified date/time ranges. Format: MM-DD HH:MM (no year).
+# all notifications during specified date/time ranges. Format: YYYY-MM-DD HH:MM.
 # Example:
 #   sinksConfig:
 #   - slack_sink:
@@ -21,10 +21,10 @@ playbookRepos: {}
 #       mute_intervals:
 #         timezone: UTC
 #         intervals:
-#         - start_date: "12-24 00:00"
-#           end_date: "12-26 23:59"
-#         - start_date: "01-01 00:00"
-#           end_date: "01-01 23:59"
+#         - start_date: "2025-12-24 00:00"
+#           end_date: "2025-12-26 23:59"
+#         - start_date: "2026-01-01 00:00"
+#           end_date: "2026-01-01 23:59"
 sinksConfig: []
 
 # global parameters

src/robusta/core/sinks/sink_base_params.py

@@ -57,16 +57,16 @@ def check_intervals(cls, intervals: List[ActivityInterval]):
         return intervals
 
 
-DATE_TIME_RE = re.compile(r"^\d{2}-\d{2} \d{2}:\d{2}$")
+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: MM-DD HH:MM")
-    month, rest = value.split("-", 1)
-    day, time_part = rest.split(" ", 1)
+        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(":")
-    month, day, hour, minute = int(month), int(day), int(hour), int(minute)
+    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):
@@ -79,8 +79,8 @@ def check_date_time_format(value: str) -> str:
 
 
 class MuteInterval(BaseModel):
-    start_date: str  # MM-DD HH:MM
-    end_date: str    # MM-DD HH:MM
+    start_date: str  # YYYY-MM-DD HH:MM
+    end_date: str    # YYYY-MM-DD HH:MM
 
     _validator_start = validator("start_date", allow_reuse=True)(check_date_time_format)
     _validator_end = validator("end_date", allow_reuse=True)(check_date_time_format)

src/robusta/core/sinks/timing.py

@@ -70,36 +70,24 @@ def is_active_now(self) -> bool:
 class MuteDateInterval:
     """Checks if the current date/time falls within a mute interval.
 
-    start_date and end_date are in MM-DD HH:MM format (no year).
-    The interval applies to the current year. If start_date > end_date
-    (e.g. 12-20 to 01-05), it wraps across the year boundary.
+    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_month, self.start_day, self.start_hour, self.start_minute = self._parse(start_date)
-        self.end_month, self.end_day, self.end_hour, self.end_minute = self._parse(end_date)
+        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]:
+    def _parse(self, date_str: str) -> Tuple[int, int, int, int, int]:
         date_part, time_part = date_str.strip().split(" ")
-        month, day = date_part.split("-")
+        year, month, day = date_part.split("-")
         hour, minute = time_part.split(":")
-        return int(month), int(day), int(hour), int(minute)
-
-    def _to_tuple(self, month: int, day: int, hour: int, minute: int) -> Tuple[int, int, int, int]:
-        return (month, day, hour, minute)
+        return int(year), int(month), int(day), int(hour), int(minute)
 
     def is_muted_now(self) -> bool:
         now = datetime.now(self.timezone)
-        current = self._to_tuple(now.month, now.day, now.hour, now.minute)
-        start = self._to_tuple(self.start_month, self.start_day, self.start_hour, self.start_minute)
-        end = self._to_tuple(self.end_month, self.end_day, self.end_hour, self.end_minute)
-
-        if start <= end:
-            return start <= current <= end
-        else:
-            # Wraps across year boundary (e.g. 12-20 00:00 to 01-05 00:00)
-            return current >= start or current <= end
+        current = (now.year, now.month, now.day, now.hour, now.minute)
+        return self.start <= current <= self.end

tests/test_sink_timing.py

@@ -48,24 +48,22 @@ def test_unknown_timezone(self):
         "start_date,end_date,timezone,expected_muted",
         [
             # 2012-01-01 13:45 UTC - currently muted (within range)
-            ("01-01 00:00", "01-01 23:59", "UTC", True),
-            # Currently muted (multi-day range)
-            ("12-31 00:00", "01-02 10:00", "UTC", True),
+            ("2012-01-01 00:00", "2012-01-01 23:59", "UTC", True),
+            # Currently muted (multi-day range spanning year boundary)
+            ("2011-12-31 00:00", "2012-01-02 10:00", "UTC", True),
             # Not muted (range in February)
-            ("02-01 00:00", "02-28 23:59", "UTC", False),
-            # Not muted (same day but hours don't match - before current time)
-            ("01-01 00:00", "01-01 13:00", "UTC", False),
+            ("2012-02-01 00:00", "2012-02-28 23:59", "UTC", False),
+            # Not muted (same day but end is before current time)
+            ("2012-01-01 00:00", "2012-01-01 13:00", "UTC", False),
             # Muted (same day, hours match)
-            ("01-01 13:00", "01-01 14:00", "UTC", True),
-            # Year-boundary wrap: Dec 20 to Jan 5 should mute on Jan 1
-            ("12-20 00:00", "01-05 23:59", "UTC", True),
-            # Year-boundary wrap: March to Feb wraps around, Jan 1 IS inside that range
-            ("03-01 00:00", "02-15 23:59", "UTC", True),
-            # Not muted: range is Feb 1 to Feb 28, Jan 1 is outside
-            ("02-01 00:00", "02-10 23:59", "UTC", False),
+            ("2012-01-01 13:00", "2012-01-01 14:00", "UTC", True),
+            # Not muted (range is entirely in the past)
+            ("2011-06-01 00:00", "2011-06-30 23:59", "UTC", False),
+            # Not muted (range is entirely in the future)
+            ("2013-01-01 00:00", "2013-12-31 23:59", "UTC", False),
             # Timezone test: 2012-01-01 13:45 UTC = 2012-01-01 14:45 CET
-            ("01-01 14:00", "01-01 15:00", "CET", True),
-            ("01-01 15:00", "01-01 16:00", "CET", False),
+            ("2012-01-01 14:00", "2012-01-01 15:00", "CET", True),
+            ("2012-01-01 15:00", "2012-01-01 16:00", "CET", False),
         ],
     )
     def test_is_muted_now(self, start_date, end_date, timezone, expected_muted):
@@ -111,7 +109,7 @@ def test_accepts_muted(self):
         mock_registry = Mock(get_global_config=lambda: Mock())
         sink = _TestSinkBase(registry=mock_registry, sink_params=Mock())
         sink.time_slices = [TimeSlice(["sun"], [("13:30", "14:00")], "UTC")]
-        sink.mute_date_intervals = [MuteDateInterval("01-01 00:00", "01-01 23:59", "UTC")]
+        sink.mute_date_intervals = [MuteDateInterval("2012-01-01 00:00", "2012-01-01 23:59", "UTC")]
         mock_finding = Mock(matches=Mock(return_value=True))
         with freeze_time("2012-01-01 13:45"):  # this is UTC time, Sunday
             # Would normally be accepted (Sunday 13:45 in 13:30-14:00), but muted
@@ -122,7 +120,7 @@ def test_accepts_not_muted(self):
         mock_registry = Mock(get_global_config=lambda: Mock())
         sink = _TestSinkBase(registry=mock_registry, sink_params=Mock())
         sink.time_slices = [TimeSlice(["sun"], [("13:30", "14:00")], "UTC")]
-        sink.mute_date_intervals = [MuteDateInterval("02-01 00:00", "02-28 23:59", "UTC")]
+        sink.mute_date_intervals = [MuteDateInterval("2012-02-01 00:00", "2012-02-28 23:59", "UTC")]
         mock_finding = Mock(matches=Mock(return_value=True))
         with freeze_time("2012-01-01 13:45"):  # this is UTC time, Sunday
             # Mute is for February, so should still accept