detectkit 0.5.0__tar.gz → 0.5.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: detectkit
-Version: 0.5.0
+Version: 0.5.2
 Summary: Metric monitoring with automatic anomaly detection
 Author: detectkit team
 License: MIT
@@ -79,7 +79,8 @@ Dynamic: license-file
 - **Statistical detectors** — Z-Score, MAD, IQR, Manual Bounds
 - **Multi-channel alerting** — Mattermost, Slack, Telegram, Email, Webhook
 - **@mentions** — tag users/groups in alerts, each channel formats natively
-- **Alert lifecycle** — consecutive anomalies, cooldown, recovery notifications
+- **Alert lifecycle** — consecutive anomalies, cooldown, recovery notifications, no-data alerts
+- **Project-level error alerts** — catch DB outages and pipeline crashes once per run
 - **Database agnostic** — ClickHouse, PostgreSQL, MySQL
 - **Idempotent** — resume from interruptions, no duplicate processing
 - **CLI** — `dtk init`, `dtk run --select`, tag-based selectors

{detectkit-0.5.0 → detectkit-0.5.2}/README.md

@@ -13,7 +13,8 @@
 - **Statistical detectors** — Z-Score, MAD, IQR, Manual Bounds
 - **Multi-channel alerting** — Mattermost, Slack, Telegram, Email, Webhook
 - **@mentions** — tag users/groups in alerts, each channel formats natively
-- **Alert lifecycle** — consecutive anomalies, cooldown, recovery notifications
+- **Alert lifecycle** — consecutive anomalies, cooldown, recovery notifications, no-data alerts
+- **Project-level error alerts** — catch DB outages and pipeline crashes once per run
 - **Database agnostic** — ClickHouse, PostgreSQL, MySQL
 - **Idempotent** — resume from interruptions, no duplicate processing
 - **CLI** — `dtk init`, `dtk run --select`, tag-based selectors

{detectkit-0.5.0 → detectkit-0.5.2}/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.5.0"
+__version__ = "0.5.2"
 
 from detectkit.core.interval import Interval
 from detectkit.core.models import ColumnDefinition, TableModel

{detectkit-0.5.0 → detectkit-0.5.2}/detectkit/cli/commands/run.py

@@ -14,6 +14,7 @@ from detectkit.config.profile import ProfilesConfig
 from detectkit.config.project_config import ProjectConfig
 from detectkit.config.validator import validate_metric_uniqueness
 from detectkit.database.internal_tables import InternalTablesManager
+from detectkit.orchestration.error_dispatch import dispatch_project_error_alert
 from detectkit.orchestration.task_manager import PipelineStep, TaskManager
 
 
@@ -159,6 +160,15 @@ def run_command(
                 bold=True,
             )
         )
+        # Profiles are loaded → channels can be resolved → fire the
+        # project-level error alert before bailing. Otherwise a dead DB
+        # silently kills the entire run with no notification.
+        dispatch_project_error_alert(
+            profiles_config=profiles_config,
+            project_config=project_config,
+            metric_name="<startup>",
+            exc=e,
+        )
         return
 
     # Create internal tables manager
@@ -175,6 +185,12 @@ def run_command(
                 bold=True,
             )
         )
+        dispatch_project_error_alert(
+            profiles_config=profiles_config,
+            project_config=project_config,
+            metric_name="<startup>",
+            exc=e,
+        )
         return
 
     # Create task manager

{detectkit-0.5.0 → detectkit-0.5.2}/detectkit/cli/commands/test_alert.py

@@ -20,6 +20,7 @@ from detectkit.utils.datetime_utils import now_utc
 
 def create_mock_alert_data(
     metric_config: MetricConfig,
+    alerting_config,
     timezone_display: str = "UTC",
 ) -> AlertData:
     """
@@ -27,6 +28,10 @@ def create_mock_alert_data(
 
     Args:
         metric_config: Metric configuration
+        alerting_config: Single ``AlertingConfig`` from
+            ``metric_config.alerting`` to source mentions/timezone from.
+            ``metric_config.alerting`` is a list — the test command
+            iterates it and passes one entry at a time.
         timezone_display: Timezone for display
 
     Returns:
@@ -35,8 +40,9 @@ def create_mock_alert_data(
     # Use current time
     now = now_utc()
 
-    # Get mentions from alerting config
-    mentions = metric_config.alerting.mentions if metric_config.alerting else []
+    # Mentions are per-AlertingConfig (different alert routes can mention
+    # different teams). Pull them from the specific config we're testing.
+    mentions = list(alerting_config.mentions) if alerting_config else []
 
     # Create realistic mock data
     return AlertData(
@@ -147,7 +153,7 @@ def run_test_alert(metric_name: str, profile: str | None = None):
         print(f"   Timezone: {timezone_display}")
         print(f"   Channels: {', '.join(alerting_config.channels)}\n")
 
-        alert_data = create_mock_alert_data(metric_config, timezone_display)
+        alert_data = create_mock_alert_data(metric_config, alerting_config, timezone_display)
 
         success_count = 0
         for channel_name in alerting_config.channels:

detectkit-0.5.2/detectkit/orchestration/error_dispatch.py

@@ -0,0 +1,151 @@
+"""Project-level error alert dispatch shared by ``TaskManager`` and the CLI.
+
+Why this lives here, not on ``TaskManager``:
+
+The task manager only sees errors that happen during ``run_metric``. Three
+classes of failures crash earlier — at the CLI level, before a TaskManager
+exists at all:
+
+1. ``profiles_config = ProfilesConfig.from_yaml(...)``  (no profile, can't
+   build channels — out of scope for this dispatcher)
+2. ``db_manager = profiles_config.create_manager(profile)``  (DB unreachable;
+   profiles ARE loaded — channels can be built and we should alert)
+3. ``internal_manager.ensure_tables()``  (DB reachable but DDL fails)
+
+For (2) and (3) the operator needs the same project-level error alert as for
+runtime failures. Extracting the dispatch into a free function lets the CLI
+call it directly without needing a TaskManager.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import click
+import numpy as np
+
+from detectkit.alerting.channels.base import AlertData
+from detectkit.alerting.channels.factory import AlertChannelFactory
+from detectkit.utils.datetime_utils import now_utc_naive
+
+
+def dispatch_project_error_alert(
+    *,
+    profiles_config: Any,
+    project_config: Any,
+    metric_name: str,
+    exc: BaseException,
+) -> bool:
+    """Send a project-level error alert based on ``project_config.error_alerting``.
+
+    Args:
+        profiles_config: Loaded ``ProfilesConfig`` (needed to resolve channel
+            names → channel instances). ``None`` short-circuits the dispatch.
+        project_config: Loaded ``ProjectConfig``. Reads ``error_alerting``.
+        metric_name: A string identifier for the failure context. Use the
+            real metric name when failing inside a metric run, or a
+            placeholder like ``"<startup>"`` for early failures.
+        exc: The exception that triggered the alert. Its type name and
+            ``str(exc)`` are passed to the channel template as
+            ``{error_type}`` and ``{error_message}``.
+
+    Returns:
+        ``True`` when the alert was actually attempted (caller should treat
+        this as "abort the rest of the run"). ``False`` when alerting is
+        disabled, has no channels configured, no profiles to resolve them
+        against, or the dispatch itself raised.
+    """
+    cfg = getattr(project_config, "error_alerting", None)
+    if not cfg or not cfg.enabled or not cfg.channels:
+        return False
+    if profiles_config is None:
+        return False
+
+    try:
+        channels = _build_channels(profiles_config, cfg.channels)
+        if not channels:
+            click.echo(
+                click.style(
+                    "  │ Project error_alerting enabled but no valid channels "
+                    "resolved — skipping.",
+                    fg="yellow",
+                ),
+                err=True,
+            )
+            return False
+
+        alert_data = AlertData(
+            metric_name=metric_name,
+            timestamp=np.datetime64(now_utc_naive(), "ms"),
+            timezone=cfg.timezone or "UTC",
+            value=None,
+            confidence_lower=None,
+            confidence_upper=None,
+            detector_name="pipeline",
+            detector_params="",
+            direction="none",
+            severity=0.0,
+            detection_metadata={"reason": "pipeline_error"},
+            consecutive_count=0,
+            is_error=True,
+            error_type=type(exc).__name__,
+            error_message=str(exc),
+            description=None,
+            mentions=cfg.mentions,
+        )
+
+        click.echo(
+            click.style(
+                f"  │ ⚠ Project error alert → sending to {len(channels)} channel(s)...",
+                fg="yellow",
+                bold=True,
+            )
+        )
+        for channel in channels:
+            channel_name = channel.__class__.__name__
+            try:
+                ok = bool(channel.send(alert_data, template=cfg.template))
+                mark = click.style("✓", fg="green") if ok else click.style("✗", fg="red")
+                click.echo(f"  │   {mark} {channel_name}")
+            except Exception as channel_exc:
+                click.echo(
+                    click.style(
+                        f"  │   ✗ {channel_name}: " f"{type(channel_exc).__name__}: {channel_exc}",
+                        fg="red",
+                    ),
+                    err=True,
+                )
+
+        return True
+    except Exception as dispatch_exc:
+        # Never let alert dispatch crash the caller — they're already
+        # handling another error and need to surface it cleanly.
+        click.echo(
+            click.style(
+                f"  │ Failed to dispatch project error alert: "
+                f"{type(dispatch_exc).__name__}: {dispatch_exc}",
+                fg="red",
+            ),
+            err=True,
+        )
+        return False
+
+
+def _build_channels(profiles_config: Any, channel_names: list[str]) -> list:
+    """Resolve channel names against the loaded profiles config.
+
+    Mirrors ``_TaskManagerBase._create_alert_channels`` but lives outside
+    the TaskManager so the CLI early-failure paths can call it before a
+    TaskManager exists.
+    """
+    channels = []
+    for name in channel_names:
+        try:
+            channel_config = profiles_config.get_alert_channel_config(name)
+            channels.append(AlertChannelFactory.create_from_config(channel_config))
+        except (ValueError, KeyError, ImportError, TypeError) as exc:
+            # Config-level problems (missing channel, bad type, missing
+            # driver, wrong constructor args) — skip this channel but
+            # keep going so a single typo doesn't kill the whole alert.
+            print(f"Warning: Failed to create channel '{name}': {type(exc).__name__}: {exc}")
+    return channels

{detectkit-0.5.0 → detectkit-0.5.2}/detectkit/orchestration/task_manager/manager.py

@@ -7,15 +7,13 @@ from datetime import datetime
 from typing import Any
 
 import click
-import numpy as np
 
-from detectkit.alerting.channels.base import AlertData
 from detectkit.config.metric_config import MetricConfig
+from detectkit.orchestration.error_dispatch import dispatch_project_error_alert
 from detectkit.orchestration.task_manager._alert_step import _AlertStepMixin
 from detectkit.orchestration.task_manager._detect_step import _DetectStepMixin
 from detectkit.orchestration.task_manager._load_step import _LoadStepMixin
 from detectkit.orchestration.task_manager._types import PipelineStep, TaskStatus
-from detectkit.utils.datetime_utils import now_utc_naive
 
 
 class TaskManager(_LoadStepMixin, _DetectStepMixin, _AlertStepMixin):
@@ -138,78 +136,23 @@ class TaskManager(_LoadStepMixin, _DetectStepMixin, _AlertStepMixin):
 
         Returns ``True`` when an alert was actually attempted (meaning the
         caller should abort the rest of the run). ``False`` when alerting
-        is disabled, already sent in this run, or the dispatch itself
-        failed — in those cases the run continues normally.
+        is disabled — in that case the run continues normally. Within one
+        TaskManager instance the alert fires at most once; subsequent
+        failures still return ``True`` so the CLI keeps aborting.
         """
         cfg = getattr(self.project_config, "error_alerting", None)
         if not cfg or not cfg.enabled:
             return False
         if self._error_alert_sent_in_run:
-            # Already alerted in this run — suppress and abort.
             return True
-        if not cfg.channels:
-            return False
-
-        try:
-            channels = self._create_alert_channels(cfg.channels)
-            if not channels:
-                click.echo(
-                    click.style(
-                        "  │ Project error_alerting enabled but no valid "
-                        "channels resolved — skipping.",
-                        fg="yellow",
-                    ),
-                    err=True,
-                )
-                return False
-
-            alert_data = AlertData(
-                metric_name=metric_name,
-                timestamp=np.datetime64(now_utc_naive(), "ms"),
-                timezone=cfg.timezone or "UTC",
-                value=None,
-                confidence_lower=None,
-                confidence_upper=None,
-                detector_name="pipeline",
-                detector_params="",
-                direction="none",
-                severity=0.0,
-                detection_metadata={"reason": "pipeline_error"},
-                consecutive_count=0,
-                is_error=True,
-                error_type=type(exc).__name__,
-                error_message=str(exc),
-                description=None,
-                mentions=cfg.mentions,
-            )
-
-            click.echo(
-                click.style(
-                    f"  │ ⚠ Project error alert → sending to " f"{len(channels)} channel(s)...",
-                    fg="yellow",
-                    bold=True,
-                )
-            )
-            sent = 0
-            for channel in channels:
-                channel_name = channel.__class__.__name__
-                try:
-                    if channel.send(alert_data, template=cfg.template):
-                        sent += 1
-                        mark = click.style("✓", fg="green")
-                    else:
-                        mark = click.style("✗", fg="red")
-                    click.echo(f"  │   {mark} {channel_name}")
-                except Exception as channel_exc:
-                    click.echo(
-                        click.style(
-                            f"  │   ✗ {channel_name}: "
-                            f"{type(channel_exc).__name__}: {channel_exc}",
-                            fg="red",
-                        ),
-                        err=True,
-                    )
 
+        sent = dispatch_project_error_alert(
+            profiles_config=self.profiles_config,
+            project_config=self.project_config,
+            metric_name=metric_name,
+            exc=exc,
+        )
+        if sent:
             click.echo(
                 click.style(
                     "  │ Aborting remaining metrics for this run.",
@@ -217,18 +160,7 @@ class TaskManager(_LoadStepMixin, _DetectStepMixin, _AlertStepMixin):
                 )
             )
             self._error_alert_sent_in_run = True
-            return True
-        except Exception as dispatch_exc:
-            # Never let alert dispatch crash the run.
-            click.echo(
-                click.style(
-                    f"  │ Failed to dispatch project error alert: "
-                    f"{type(dispatch_exc).__name__}: {dispatch_exc}",
-                    fg="red",
-                ),
-                err=True,
-            )
-            return False
+        return sent
 
     def __repr__(self) -> str:
         return f"TaskManager(db={self.db_manager.__class__.__name__})"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: detectkit
-Version: 0.5.0
+Version: 0.5.2
 Summary: Metric monitoring with automatic anomaly detection
 Author: detectkit team
 License: MIT
@@ -79,7 +79,8 @@ Dynamic: license-file
 - **Statistical detectors** — Z-Score, MAD, IQR, Manual Bounds
 - **Multi-channel alerting** — Mattermost, Slack, Telegram, Email, Webhook
 - **@mentions** — tag users/groups in alerts, each channel formats natively
-- **Alert lifecycle** — consecutive anomalies, cooldown, recovery notifications
+- **Alert lifecycle** — consecutive anomalies, cooldown, recovery notifications, no-data alerts
+- **Project-level error alerts** — catch DB outages and pipeline crashes once per run
 - **Database agnostic** — ClickHouse, PostgreSQL, MySQL
 - **Idempotent** — resume from interruptions, no duplicate processing
 - **CLI** — `dtk init`, `dtk run --select`, tag-based selectors

{detectkit-0.5.0 → detectkit-0.5.2}/detectkit.egg-info/SOURCES.txt

@@ -68,6 +68,7 @@ detectkit/loaders/__init__.py
 detectkit/loaders/metric_loader.py
 detectkit/loaders/query_template.py
 detectkit/orchestration/__init__.py
+detectkit/orchestration/error_dispatch.py
 detectkit/orchestration/task_manager/__init__.py
 detectkit/orchestration/task_manager/_alert_step.py
 detectkit/orchestration/task_manager/_base.py

{detectkit-0.5.0 → detectkit-0.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "detectkit"
-version = "0.5.0"
+version = "0.5.2"
 description = "Metric monitoring with automatic anomaly detection"
 readme = "README.md"
 requires-python = ">=3.10"