detectkit 0.4.0__tar.gz → 0.5.0__tar.gz

{detectkit-0.4.0/detectkit.egg-info → detectkit-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: detectkit
-Version: 0.4.0
+Version: 0.5.0
 Summary: Metric monitoring with automatic anomaly detection
 Author: detectkit team
 License: MIT
@@ -55,7 +55,7 @@ Requires-Dist: timesfm>=0.1.0; extra == "all"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0; extra == "dev"
-Requires-Dist: pytest-requests-mock>=0.1; extra == "dev"
+Requires-Dist: pytest-mock>=3.0; extra == "dev"
 Requires-Dist: requests-mock>=1.12; extra == "dev"
 Requires-Dist: black>=23.0; extra == "dev"
 Requires-Dist: mypy>=1.0; extra == "dev"

{detectkit-0.4.0 → detectkit-0.5.0}/detectkit/__init__.py

@@ -4,7 +4,7 @@ detectk - Anomaly Detection for Time-Series Metrics
 A Python library for data analysts and engineers to monitor metrics with automatic anomaly detection.
 """
 
-__version__ = "0.4.0"
+__version__ = "0.5.0"
 
 from detectkit.core.interval import Interval
 from detectkit.core.models import ColumnDefinition, TableModel

{detectkit-0.4.0 → detectkit-0.5.0}/detectkit/alerting/channels/__init__.py

@@ -1,13 +1,12 @@
 """Alert channels for external notifications."""
 
 from detectkit.alerting.channels.base import AlertData, BaseAlertChannel
+from detectkit.alerting.channels.email import EmailChannel
+from detectkit.alerting.channels.factory import AlertChannelFactory
 from detectkit.alerting.channels.mattermost import MattermostChannel
 from detectkit.alerting.channels.slack import SlackChannel
-from detectkit.alerting.channels.webhook import WebhookChannel
 from detectkit.alerting.channels.telegram import TelegramChannel
-from detectkit.alerting.channels.email import EmailChannel
-
-from detectkit.alerting.channels.factory import AlertChannelFactory
+from detectkit.alerting.channels.webhook import WebhookChannel
 
 __all__ = [
     "AlertData",

{detectkit-0.4.0 → detectkit-0.5.0}/detectkit/alerting/channels/base.py

@@ -7,9 +7,7 @@ the send() method for delivering alerts to specific destinations.
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional
-
-from detectkit.detectors.base import DetectionResult
+from typing import Any
 
 
 @dataclass
@@ -23,7 +21,7 @@ class AlertData:
         metric_name: Name of the metric
         timestamp: Timestamp of the anomaly (datetime64)
         timezone: Timezone for display (e.g., "Europe/Moscow")
-        value: Actual metric value
+        value: Actual metric value (None for no-data alerts)
         confidence_lower: Lower confidence bound
         confidence_upper: Upper confidence bound
         detector_name: Name/ID of detector that found the anomaly
@@ -32,23 +30,29 @@ class AlertData:
         severity: Severity score
         detection_metadata: Additional metadata from detector
         consecutive_count: Number of consecutive anomalies
+        is_recovery: True for recovery notifications
+        is_no_data: True for missing-data alerts (no_data_alert)
     """
 
     metric_name: str
     timestamp: Any  # datetime64 or datetime
     timezone: str
-    value: float
-    confidence_lower: Optional[float]
-    confidence_upper: Optional[float]
+    value: float | None
+    confidence_lower: float | None
+    confidence_upper: float | None
     detector_name: str
     detector_params: str
     direction: str
     severity: float
-    detection_metadata: Dict[str, Any]
+    detection_metadata: dict[str, Any]
     consecutive_count: int = 1
     is_recovery: bool = False
-    description: Optional[str] = None
-    mentions: List[str] = field(default_factory=list)
+    is_no_data: bool = False
+    is_error: bool = False
+    error_type: str | None = None
+    error_message: str | None = None
+    description: str | None = None
+    mentions: list[str] = field(default_factory=list)
 
 
 class BaseAlertChannel(ABC):
@@ -71,7 +75,7 @@ class BaseAlertChannel(ABC):
     def send(
         self,
         alert_data: AlertData,
-        template: Optional[str] = None,
+        template: str | None = None,
     ) -> bool:
         """
         Send alert to this channel.
@@ -101,8 +105,8 @@ class BaseAlertChannel(ABC):
     def format_message(
         self,
         alert_data: AlertData,
-        template: Optional[str] = None,
-        recovery_template: Optional[str] = None,
+        template: str | None = None,
+        recovery_template: str | None = None,
     ) -> str:
         """
         Format alert message from template.
@@ -111,13 +115,14 @@ class BaseAlertChannel(ABC):
         - {metric_name}
         - {timestamp}
         - {timezone}
-        - {value}
+        - {value} / {value_display}
         - {confidence_lower}
         - {confidence_upper}
         - {detector_name}
         - {direction}
         - {severity}
         - {consecutive_count}
+        - {status}
 
         Args:
             alert_data: Alert data to format
@@ -131,13 +136,19 @@ class BaseAlertChannel(ABC):
             >>> message = channel.format_message(alert_data, template)
         """
         if template is None:
-            if alert_data.is_recovery:
+            if alert_data.is_error:
+                template = self.get_default_error_template()
+            elif alert_data.is_no_data:
+                template = self.get_default_no_data_template()
+            elif alert_data.is_recovery:
                 template = recovery_template or self.get_default_recovery_template()
             else:
                 template = self.get_default_template()
 
         # Format timestamp to string
+        import math
         from datetime import datetime
+
         import numpy as np
 
         ts = alert_data.timestamp
@@ -147,6 +158,7 @@ class BaseAlertChannel(ABC):
         # Convert naive UTC timestamp to target timezone if specified
         if alert_data.timezone:
             from zoneinfo import ZoneInfo
+
             ts = ts.replace(tzinfo=ZoneInfo("UTC")).astimezone(ZoneInfo(alert_data.timezone))
             ts_str = f"{ts.strftime('%Y-%m-%d %H:%M:%S')} ({alert_data.timezone})"
         else:
@@ -154,10 +166,21 @@ class BaseAlertChannel(ABC):
 
         # Format confidence interval
         if alert_data.confidence_lower is not None and alert_data.confidence_upper is not None:
-            confidence_str = f"[{alert_data.confidence_lower:.2f}, {alert_data.confidence_upper:.2f}]"
+            confidence_str = (
+                f"[{alert_data.confidence_lower:.2f}, {alert_data.confidence_upper:.2f}]"
+            )
         else:
             confidence_str = "N/A"
 
+        # Display-safe value: stays usable even when value is None/NaN (no-data).
+        raw_value = alert_data.value
+        if raw_value is None or (isinstance(raw_value, float) and math.isnan(raw_value)):
+            value_display = "no data"
+            value_for_template: Any = "no data"
+        else:
+            value_display = f"{raw_value}"
+            value_for_template = raw_value
+
         # Format description line (empty string if no description)
         description_line = f"{alert_data.description}\n" if alert_data.description else ""
 
@@ -166,14 +189,22 @@ class BaseAlertChannel(ABC):
         mentions_line = f"\n{mentions_str}" if mentions_str else ""
 
         # Format message
-        status = "RECOVERED" if alert_data.is_recovery else "ANOMALY"
+        if alert_data.is_error:
+            status = "ERROR"
+        elif alert_data.is_no_data:
+            status = "NO_DATA"
+        elif alert_data.is_recovery:
+            status = "RECOVERED"
+        else:
+            status = "ANOMALY"
 
         try:
             message = template.format(
                 metric_name=alert_data.metric_name,
                 timestamp=ts_str,
                 timezone=alert_data.timezone,
-                value=alert_data.value,
+                value=value_for_template,
+                value_display=value_display,
                 confidence_lower=alert_data.confidence_lower,
                 confidence_upper=alert_data.confidence_upper,
                 confidence_interval=confidence_str,
@@ -183,18 +214,33 @@ class BaseAlertChannel(ABC):
                 severity=alert_data.severity,
                 consecutive_count=alert_data.consecutive_count,
                 status=status,
+                error_type=alert_data.error_type or "",
+                error_message=alert_data.error_message or "",
                 description=alert_data.description or "",
                 description_line=description_line,
                 mentions=mentions_str,
                 mentions_line=mentions_line,
             )
-        except KeyError as e:
-            # If template has unknown variables, fall back to default
-            message = self.format_message(alert_data, self.get_default_template())
+        except (KeyError, ValueError, TypeError):
+            # Template has an unknown variable or a format spec that doesn't fit
+            # the actual value (e.g. ``{value:.2f}`` in a no-data template where
+            # value is a string). Fall back to the kind-appropriate default.
+            if alert_data.is_error:
+                fallback = self.get_default_error_template()
+            elif alert_data.is_no_data:
+                fallback = self.get_default_no_data_template()
+            elif alert_data.is_recovery:
+                fallback = self.get_default_recovery_template()
+            else:
+                fallback = self.get_default_template()
+            if template == fallback:
+                # Already on the default — re-raise instead of recursing.
+                raise
+            message = self.format_message(alert_data, fallback)
 
         return message
 
-    def format_mentions(self, mentions: List[str]) -> str:
+    def format_mentions(self, mentions: list[str]) -> str:
         """
         Format mentions list into platform-native syntax.
 
@@ -227,7 +273,11 @@ class BaseAlertChannel(ABC):
         Returns:
             Formatted title string
         """
-        if alert_data.is_recovery:
+        if alert_data.is_error:
+            title_template = self.get_default_error_title_template()
+        elif alert_data.is_no_data:
+            title_template = self.get_default_no_data_title_template()
+        elif alert_data.is_recovery:
             title_template = self.get_default_recovery_title_template()
         else:
             title_template = self.get_default_title_template()
@@ -289,6 +339,39 @@ class BaseAlertChannel(ABC):
         """
         return "Metric recovered: {metric_name}"
 
+    def get_default_no_data_template(self) -> str:
+        """
+        Get default message template for no-data alerts.
+
+        Used when ``no_data_alert: true`` and the latest expected interval
+        has no datapoint (no row OR row with NULL/NaN value).
+        """
+        return (
+            "No data for metric: {metric_name}\n"
+            "{description_line}"
+            "Time: {timestamp}\n"
+            "Status: query returned no datapoint for the latest interval"
+            "{mentions_line}"
+        )
+
+    def get_default_no_data_title_template(self) -> str:
+        """Get default title template for no-data alerts."""
+        return "No data: {metric_name}"
+
+    def get_default_error_template(self) -> str:
+        """Default body template for project-level error alerts."""
+        return (
+            "Pipeline failed for metric: {metric_name}\n"
+            "{description_line}"
+            "Time: {timestamp}\n"
+            "Error: {error_type}: {error_message}"
+            "{mentions_line}"
+        )
+
+    def get_default_error_title_template(self) -> str:
+        """Default title template for project-level error alerts."""
+        return "Pipeline error: {metric_name}"
+
     def __repr__(self) -> str:
         """String representation of channel."""
         return f"{self.__class__.__name__}()"

{detectkit-0.4.0 → detectkit-0.5.0}/detectkit/alerting/channels/email.py

@@ -7,7 +7,6 @@ Sends anomaly alerts via SMTP email.
 import smtplib
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
-from typing import List, Optional
 
 from detectkit.alerting.channels.base import AlertData, BaseAlertChannel
 
@@ -51,12 +50,12 @@ class EmailChannel(BaseAlertChannel):
         smtp_host: str,
         smtp_port: int,
         from_email: str,
-        to_emails: List[str],
-        smtp_username: Optional[str] = None,
-        smtp_password: Optional[str] = None,
+        to_emails: list[str],
+        smtp_username: str | None = None,
+        smtp_password: str | None = None,
         use_tls: bool = True,
         subject_template: str = "Anomaly Alert: {metric_name}",
-        template: Optional[str] = None,
+        template: str | None = None,
         **kwargs,
     ):
         """
@@ -115,9 +114,7 @@ class EmailChannel(BaseAlertChannel):
         msg = MIMEMultipart("alternative")
         msg["From"] = self.from_email
         msg["To"] = ", ".join(self.to_emails)
-        msg["Subject"] = self.subject_template.format(
-            metric_name=alert_data.metric_name
-        )
+        msg["Subject"] = self.subject_template.format(metric_name=alert_data.metric_name)
 
         # Attach plain text body
         msg.attach(MIMEText(message_body, "plain"))
@@ -139,9 +136,9 @@ class EmailChannel(BaseAlertChannel):
             server.quit()
 
         except smtplib.SMTPException as e:
-            raise smtplib.SMTPException(f"Failed to send email alert: {e}")
+            raise smtplib.SMTPException(f"Failed to send email alert: {e}") from e
 
-    def format_mentions(self, mentions: List[str]) -> str:
+    def format_mentions(self, mentions: list[str]) -> str:
         """
         Format mentions for email.
 

{detectkit-0.4.0 → detectkit-0.5.0}/detectkit/alerting/channels/factory.py

@@ -2,14 +2,12 @@
 Alert channel factory for creating channel instances from configuration.
 """
 
-from typing import Dict, List
-
 from detectkit.alerting.channels.base import BaseAlertChannel
+from detectkit.alerting.channels.email import EmailChannel
 from detectkit.alerting.channels.mattermost import MattermostChannel
 from detectkit.alerting.channels.slack import SlackChannel
-from detectkit.alerting.channels.webhook import WebhookChannel
 from detectkit.alerting.channels.telegram import TelegramChannel
-from detectkit.alerting.channels.email import EmailChannel
+from detectkit.alerting.channels.webhook import WebhookChannel
 from detectkit.utils.env_interpolation import interpolate_env_vars
 
 
@@ -36,7 +34,7 @@ class AlertChannelFactory:
     }
 
     @classmethod
-    def create(cls, channel_type: str, params: Dict) -> BaseAlertChannel:
+    def create(cls, channel_type: str, params: dict) -> BaseAlertChannel:
         """
         Create alert channel instance from type and parameters.
 
@@ -64,8 +62,7 @@ class AlertChannelFactory:
         if channel_type not in cls.CHANNEL_TYPES:
             available = ", ".join(sorted(cls.CHANNEL_TYPES.keys()))
             raise ValueError(
-                f"Unknown channel type: '{channel_type}'. "
-                f"Available types: {available}"
+                f"Unknown channel type: '{channel_type}'. " f"Available types: {available}"
             )
 
         # Interpolate environment variables in params
@@ -76,12 +73,10 @@ class AlertChannelFactory:
         try:
             return channel_class(**interpolated_params)
         except TypeError as e:
-            raise ValueError(
-                f"Invalid parameters for {channel_type} channel: {e}"
-            ) from e
+            raise ValueError(f"Invalid parameters for {channel_type} channel: {e}") from e
 
     @classmethod
-    def _interpolate_env_vars(cls, params: Dict) -> Dict:
+    def _interpolate_env_vars(cls, params: dict) -> dict:
         """Interpolate ``${VAR}`` and ``{{ env_var('VAR') }}`` placeholders.
 
         Delegates to :func:`detectkit.utils.env_interpolation.interpolate_env_vars`,
@@ -90,7 +85,7 @@ class AlertChannelFactory:
         return interpolate_env_vars(params)
 
     @classmethod
-    def create_from_config(cls, channel_config: Dict) -> BaseAlertChannel:
+    def create_from_config(cls, channel_config: dict) -> BaseAlertChannel:
         """
         Create channel from configuration dictionary.
 
@@ -122,7 +117,7 @@ class AlertChannelFactory:
         return cls.create(channel_type, params)
 
     @classmethod
-    def create_multiple(cls, channel_configs: List[Dict]) -> List[BaseAlertChannel]:
+    def create_multiple(cls, channel_configs: list[dict]) -> list[BaseAlertChannel]:
         """
         Create multiple channels from list of configurations.
 
@@ -148,7 +143,7 @@ class AlertChannelFactory:
         return channels
 
     @classmethod
-    def list_available_types(cls) -> List[str]:
+    def list_available_types(cls) -> list[str]:
         """
         Get list of available channel types.
 

{detectkit-0.4.0 → detectkit-0.5.0}/detectkit/alerting/channels/mattermost.py

@@ -4,8 +4,6 @@ Mattermost alert channel.
 Convenience wrapper around WebhookChannel for Mattermost.
 """
 
-from typing import Optional
-
 from detectkit.alerting.channels.webhook import WebhookChannel
 
 
@@ -35,7 +33,7 @@ class MattermostChannel(WebhookChannel):
         webhook_url: str,
         username: str = "detectk",
         icon_emoji: str = ":warning:",
-        channel: Optional[str] = None,
+        channel: str | None = None,
         timeout: int = 10,
     ):
         """Initialize Mattermost channel with webhook URL."""
@@ -49,5 +47,7 @@ class MattermostChannel(WebhookChannel):
 
     def __repr__(self) -> str:
         """String representation."""
-        url_preview = self.webhook_url[:30] + "..." if len(self.webhook_url) > 30 else self.webhook_url
+        url_preview = (
+            self.webhook_url[:30] + "..." if len(self.webhook_url) > 30 else self.webhook_url
+        )
         return f"MattermostChannel(url='{url_preview}', username='{self.username}')"

{detectkit-0.4.0 → detectkit-0.5.0}/detectkit/alerting/channels/slack.py

@@ -4,8 +4,6 @@ Slack alert channel.
 Convenience wrapper around WebhookChannel for Slack.
 """
 
-from typing import List, Optional
-
 from detectkit.alerting.channels.webhook import WebhookChannel
 
 
@@ -36,7 +34,7 @@ class SlackChannel(WebhookChannel):
         webhook_url: str,
         username: str = "detectk",
         icon_emoji: str = ":warning:",
-        channel: Optional[str] = None,
+        channel: str | None = None,
         timeout: int = 10,
     ):
         """Initialize Slack channel with webhook URL."""
@@ -48,7 +46,7 @@ class SlackChannel(WebhookChannel):
             timeout=timeout,
         )
 
-    def format_mentions(self, mentions: List[str]) -> str:
+    def format_mentions(self, mentions: list[str]) -> str:
         """
         Format mentions for Slack.
 
@@ -78,6 +76,8 @@ class SlackChannel(WebhookChannel):
 
     def __repr__(self) -> str:
         """String representation."""
-        url_preview = self.webhook_url[:30] + "..." if len(self.webhook_url) > 30 else self.webhook_url
+        url_preview = (
+            self.webhook_url[:30] + "..." if len(self.webhook_url) > 30 else self.webhook_url
+        )
         channel_info = f", channel='{self.channel}'" if self.channel else ""
         return f"SlackChannel(url='{url_preview}', username='{self.username}'{channel_info})"

{detectkit-0.4.0 → detectkit-0.5.0}/detectkit/alerting/channels/telegram.py

@@ -4,8 +4,6 @@ Telegram alert channel implementation.
 Sends anomaly alerts via Telegram Bot API.
 """
 
-from typing import Any, Dict, List, Optional
-
 import requests
 
 from detectkit.alerting.channels.base import AlertData, BaseAlertChannel
@@ -43,7 +41,7 @@ class TelegramChannel(BaseAlertChannel):
         chat_id: str,
         parse_mode: str = "Markdown",
         disable_notification: bool = False,
-        template: Optional[str] = None,
+        template: str | None = None,
         **kwargs,
     ):
         """
@@ -103,9 +101,9 @@ class TelegramChannel(BaseAlertChannel):
             response = requests.post(url, json=payload, timeout=10)
             response.raise_for_status()
         except requests.RequestException as e:
-            raise requests.RequestException(f"Failed to send Telegram alert: {e}")
+            raise requests.RequestException(f"Failed to send Telegram alert: {e}") from e
 
-    def format_mentions(self, mentions: List[str]) -> str:
+    def format_mentions(self, mentions: list[str]) -> str:
         """
         Format mentions for Telegram.
 

{detectkit-0.4.0 → detectkit-0.5.0}/detectkit/alerting/channels/webhook.py

@@ -5,8 +5,6 @@ Sends alerts to any webhook endpoint that accepts JSON payload.
 Compatible with Mattermost, Slack, and other webhook-based systems.
 """
 
-from typing import Dict, Optional
-
 import requests
 
 from detectkit.alerting.channels.base import AlertData, BaseAlertChannel
@@ -62,9 +60,9 @@ class WebhookChannel(BaseAlertChannel):
         webhook_url: str,
         username: str = "detectk",
         icon_emoji: str = ":warning:",
-        channel: Optional[str] = None,
+        channel: str | None = None,
         timeout: int = 10,
-        extra_headers: Optional[Dict[str, str]] = None,
+        extra_headers: dict[str, str] | None = None,
     ):
         """Initialize webhook channel."""
         if not webhook_url:
@@ -80,7 +78,7 @@ class WebhookChannel(BaseAlertChannel):
     def send(
         self,
         alert_data: AlertData,
-        template: Optional[str] = None,
+        template: str | None = None,
     ) -> bool:
         """
         Send alert to webhook.
@@ -103,8 +101,13 @@ class WebhookChannel(BaseAlertChannel):
         title = self.format_title(alert_data)
         body = self.format_message(alert_data, template)
 
-        # Color: red for anomaly, green for recovery
-        color = "#36A64F" if alert_data.is_recovery else "#D63232"
+        # Color: red for anomaly, green for recovery, amber for no-data.
+        if alert_data.is_recovery:
+            color = "#36A64F"
+        elif alert_data.is_no_data:
+            color = "#F0AD4E"
+        else:
+            color = "#D63232"
 
         # Prepare payload using Mattermost/Slack attachments format.
         # Attachments give us: colored left sidebar, separate title, and
@@ -175,8 +178,28 @@ class WebhookChannel(BaseAlertChannel):
             "{mentions_line}"
         )
 
+    def get_default_no_data_template(self) -> str:
+        """Default no-data body template (metric name lives in the title)."""
+        return (
+            "{description_line}"
+            "Time: {timestamp}\n"
+            "Status: query returned no datapoint for the latest interval"
+            "{mentions_line}"
+        )
+
+    def get_default_error_template(self) -> str:
+        """Default error body template (metric name lives in the title)."""
+        return (
+            "{description_line}"
+            "Time: {timestamp}\n"
+            "Error: {error_type}: {error_message}"
+            "{mentions_line}"
+        )
+
     def __repr__(self) -> str:
         """String representation."""
-        url_preview = self.webhook_url[:30] + "..." if len(self.webhook_url) > 30 else self.webhook_url
+        url_preview = (
+            self.webhook_url[:30] + "..." if len(self.webhook_url) > 30 else self.webhook_url
+        )
         channel_info = f", channel='{self.channel}'" if self.channel else ""
         return f"WebhookChannel(url='{url_preview}', username='{self.username}'{channel_info})"

{detectkit-0.4.0 → detectkit-0.5.0}/detectkit/alerting/orchestrator/_base.py

@@ -2,8 +2,6 @@
 
 from __future__ import annotations
 
-from typing import Dict, List, Optional
-
 import numpy as np
 
 from detectkit.alerting.orchestrator._types import (
@@ -19,12 +17,12 @@ class _OrchestratorBase:
         metric_name: str,
         interval: Interval,
         alert_config_id: str,
-        conditions: Optional[AlertConditions] = None,
+        conditions: AlertConditions | None = None,
         timezone_display: str = "UTC",
         internal=None,  # InternalTablesManager
         alert_config=None,  # AlertConfig
-        description: Optional[str] = None,
-        mentions: Optional[List[str]] = None,
+        description: str | None = None,
+        mentions: list[str] | None = None,
     ):
         self.metric_name = metric_name
         self.interval = interval
@@ -38,9 +36,9 @@ class _OrchestratorBase:
 
     @staticmethod
     def _group_by_timestamp(
-        detections: List[DetectionRecord],
-    ) -> Dict[np.datetime64, List[DetectionRecord]]:
-        grouped: Dict[np.datetime64, List[DetectionRecord]] = {}
+        detections: list[DetectionRecord],
+    ) -> dict[np.datetime64, list[DetectionRecord]]:
+        grouped: dict[np.datetime64, list[DetectionRecord]] = {}
         for d in detections:
             grouped.setdefault(d.timestamp, []).append(d)
         return grouped

{detectkit-0.4.0 → detectkit-0.5.0}/detectkit/alerting/orchestrator/_cooldown.py

@@ -24,9 +24,7 @@ class _CooldownMixin(_OrchestratorBase):
         if not self.internal:
             return False
 
-        last_sent = self.internal.get_last_alert_timestamp(
-            self.metric_name, self.alert_config_id
-        )
+        last_sent = self.internal.get_last_alert_timestamp(self.metric_name, self.alert_config_id)
         if not last_sent:
             return False