detectkit 0.1.0__py3-none-any.whl

detectkit/cli/commands/test_alert.py

@@ -0,0 +1,184 @@
+"""
+Test alert command - send test alert to configured channels.
+
+Allows testing alert rendering and channel delivery without real anomalies.
+Useful for:
+- Verifying Mattermost/Slack message formatting
+- Testing webhook connectivity
+- Previewing alert templates
+"""
+
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+import numpy as np
+
+from detectkit.alerting.channels.base import AlertData
+from detectkit.alerting.channels.factory import AlertChannelFactory
+from detectkit.config.metric_config import MetricConfig
+
+
+def create_mock_alert_data(
+    metric_config: MetricConfig,
+    timezone_display: str = "UTC",
+) -> AlertData:
+    """
+    Create realistic mock AlertData for testing.
+
+    Args:
+        metric_config: Metric configuration
+        timezone_display: Timezone for display
+
+    Returns:
+        AlertData with mock anomaly data
+    """
+    # Use current time
+    now = datetime.now(timezone.utc)
+
+    # Create realistic mock data
+    return AlertData(
+        metric_name=metric_config.name,
+        timestamp=np.datetime64(now, "ms"),
+        timezone=timezone_display,
+        value=0.8532,  # Mock anomalous value
+        confidence_lower=0.4521,
+        confidence_upper=0.6234,
+        detector_name="MADDetector:threshold=3.0",
+        detector_params='{"threshold": 3.0, "window_size": 8640}',
+        direction="above",
+        severity=4.52,
+        detection_metadata={
+            "global_median": 0.5123,
+            "adjusted_median": 0.5234,
+            "seasonality_groups": [
+                {
+                    "group": ["offset_10minutes", "league_day"],
+                    "median_multiplier": 1.023,
+                    "mad_multiplier": 0.876,
+                    "group_size": 23,
+                }
+            ],
+        },
+        consecutive_count=3,
+    )
+
+
+def run_test_alert(metric_name: str, profile: Optional[str] = None):
+    """
+    Send test alert for specified metric.
+
+    Args:
+        metric_name: Name of metric to test alert for
+        profile: Optional profile override
+    """
+    # Load project config
+    project_root = Path.cwd()
+    project_config_path = project_root / "detectkit_project.yml"
+
+    if not project_config_path.exists():
+        print("Error: No detectkit_project.yml found in current directory")
+        print("Run this command from your detectkit project root")
+        return
+
+    # Load project config manually (avoid validation issues)
+    import yaml
+
+    with open(project_config_path) as f:
+        project_data = yaml.safe_load(f)
+
+    metrics_dir_name = project_data.get("metrics_path", "metrics")
+
+    # Find metric config
+    metrics_dir = project_root / metrics_dir_name
+    metric_files = list(metrics_dir.glob("**/*.yml")) + list(
+        metrics_dir.glob("**/*.yaml")
+    )
+
+    metric_config = None
+    for metric_file in metric_files:
+        try:
+            config = MetricConfig.from_yaml_file(metric_file)
+            if config.name == metric_name:
+                metric_config = config
+                break
+        except Exception:
+            continue
+
+    if not metric_config:
+        print(f"Error: Metric '{metric_name}' not found")
+        print(f"Searched in: {metrics_dir}")
+        return
+
+    # Check if alerting is configured
+    if not metric_config.alerting or not metric_config.alerting.enabled:
+        print(f"Error: Alerting not enabled for metric '{metric_name}'")
+        print("Enable alerting in metric config (alerting.enabled: true)")
+        return
+
+    if not metric_config.alerting.channels:
+        print(f"Error: No alert channels configured for metric '{metric_name}'")
+        print("Add channels in metric config (alerting.channels: [...])")
+        return
+
+    # Load profiles
+    profiles_path = project_root / "profiles.yml"
+    if not profiles_path.exists():
+        print("Error: profiles.yml not found")
+        return
+
+    import yaml
+
+    with open(profiles_path) as f:
+        profiles_data = yaml.safe_load(f)
+
+    alert_channels_config = profiles_data.get("alert_channels", {})
+
+    # Get timezone for display
+    timezone_display = metric_config.alerting.timezone or "UTC"
+
+    # Create mock alert data
+    print(f"\n📨 Sending test alert for metric: {metric_name}")
+    print(f"   Timezone: {timezone_display}")
+    print(f"   Channels: {', '.join(metric_config.alerting.channels)}\n")
+
+    alert_data = create_mock_alert_data(metric_config, timezone_display)
+
+    # Send to each configured channel
+    success_count = 0
+    for channel_name in metric_config.alerting.channels:
+        if channel_name not in alert_channels_config:
+            print(f"⚠️  Channel '{channel_name}' not found in profiles.yml - skipping")
+            continue
+
+        channel_config = alert_channels_config[channel_name]
+
+        try:
+            # Create channel instance
+            # channel_config должен содержать 'type' + остальные параметры
+            channel = AlertChannelFactory.create_from_config(channel_config)
+
+            # Get custom template if configured
+            template = None
+            if metric_config.alerting.template_consecutive:
+                template = metric_config.alerting.template_consecutive
+
+            # Send alert
+            print(f"   → Sending to {channel_name}...", end=" ")
+            success = channel.send(alert_data, template=template)
+
+            if success:
+                print("✓ SUCCESS")
+                success_count += 1
+            else:
+                print("✗ FAILED")
+
+        except Exception as e:
+            print(f"✗ ERROR: {e}")
+
+    # Summary
+    print(f"\n{'✓' if success_count > 0 else '✗'} Sent test alert to {success_count}/{len(metric_config.alerting.channels)} channels")
+
+    if success_count > 0:
+        print("\n💡 Check your configured channels to verify message formatting")
+        print(f"   Mock data used: value=0.8532, confidence=[0.4521, 0.6234], severity=4.52")

detectkit/cli/main.py

@@ -0,0 +1,186 @@
+"""
+Main CLI entry point for detectkit.
+
+Provides dbt-like commands:
+- dtk init <project_name>
+- dtk run --select <selector>
+"""
+
+import click
+
+
+@click.group()
+@click.version_option(version="0.1.0", prog_name="detectkit")
+def cli():
+    """
+    detectkit - Metric monitoring with automatic anomaly detection.
+
+    A dbt-like tool for monitoring time-series metrics with anomaly detection
+    and alerting.
+
+    Examples:
+        dtk init my_project
+        dtk run --select cpu_usage
+        dtk run --select tag:critical --steps load,detect
+    """
+    pass
+
+
+@cli.command()
+@click.argument("project_name")
+@click.option(
+    "--target-dir",
+    "-d",
+    default=".",
+    help="Directory to create project in (default: current directory)",
+)
+def init(project_name: str, target_dir: str):
+    """
+    Initialize a new detectkit project.
+
+    Creates project structure with configuration files and directories:
+    - detectkit_project.yml (project config)
+    - profiles.yml (database connections)
+    - metrics/ (metric definitions)
+    - sql/ (SQL queries)
+
+    Example:
+        dtk init my_monitoring_project
+        dtk init analytics --target-dir /opt/projects
+    """
+    from detectkit.cli.commands.init import run_init
+
+    run_init(project_name, target_dir)
+
+
+@cli.command()
+@click.option(
+    "--select",
+    "-s",
+    help="Selector for metrics to run (metric name, path, or tag)",
+    required=True,
+)
+@click.option(
+    "--exclude",
+    "-e",
+    help="Selector for metrics to exclude (metric name, path, or tag)",
+)
+@click.option(
+    "--steps",
+    default="load,detect,alert",
+    help="Pipeline steps to execute (default: load,detect,alert)",
+)
+@click.option(
+    "--from",
+    "from_date",
+    help="Start date for data loading (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)",
+)
+@click.option(
+    "--to",
+    "to_date",
+    help="End date for data loading (YYYY-MM-DD or YYYY-MM-DD HH:MM:SS)",
+)
+@click.option(
+    "--full-refresh",
+    is_flag=True,
+    help="Delete all existing data and reload from scratch",
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    help="Ignore task locks (use with caution)",
+)
+@click.option(
+    "--profile",
+    help="Profile to use (default: from project config)",
+)
+def run(
+    select: str,
+    exclude: str,
+    steps: str,
+    from_date: str,
+    to_date: str,
+    full_refresh: bool,
+    force: bool,
+    profile: str,
+):
+    """
+    Run metric processing pipeline.
+
+    Select metrics to process using --select:
+    - Metric name: --select cpu_usage
+    - Path pattern: --select metrics/critical/*.yml
+    - Tag: --select tag:critical
+
+    Control pipeline steps with --steps:
+    - All steps: --steps load,detect,alert (default)
+    - Load only: --steps load
+    - Detect and alert: --steps detect,alert
+
+    Examples:
+        # Run all steps for single metric
+        dtk run --select cpu_usage
+
+        # Load data only for multiple metrics
+        dtk run --select "tag:critical" --steps load
+
+        # Reload data from specific date
+        dtk run --select cpu_usage --from 2024-01-01
+
+        # Full refresh (delete and reload all data)
+        dtk run --select cpu_usage --full-refresh
+
+        # Force run (ignore locks)
+        dtk run --select cpu_usage --force
+    """
+    from detectkit.cli.commands.run import run_command
+
+    run_command(
+        select=select,
+        exclude=exclude,
+        steps=steps,
+        from_date=from_date,
+        to_date=to_date,
+        full_refresh=full_refresh,
+        force=force,
+        profile=profile,
+    )
+
+
+@cli.command()
+@click.argument("metric_name")
+@click.option(
+    "--profile",
+    help="Profile to use (default: from project config)",
+)
+def test_alert(metric_name: str, profile: str):
+    """
+    Send test alert for a metric.
+
+    Sends a test alert with mock anomaly data to all configured channels
+    for the specified metric. Useful for:
+    - Testing alert channel connectivity
+    - Verifying message formatting and rendering
+    - Previewing custom alert templates
+
+    The test alert uses realistic mock data:
+    - Current timestamp
+    - Mock anomaly value (0.8532)
+    - Mock confidence interval [0.4521, 0.6234]
+    - Mock severity (4.52)
+    - 3 consecutive anomalies
+
+    Examples:
+        # Test alert for single metric
+        dtk test-alert cpu_usage
+
+        # Test with specific profile
+        dtk test-alert cpu_usage --profile production
+    """
+    from detectkit.cli.commands.test_alert import run_test_alert
+
+    run_test_alert(metric_name=metric_name, profile=profile)
+
+
+if __name__ == "__main__":
+    cli()

detectkit/config/__init__.py

@@ -0,0 +1,30 @@
+"""Configuration management for detectkit."""
+
+from detectkit.config.profile import ProfileConfig, ProfilesConfig
+from detectkit.config.metric_config import (
+    MetricConfig,
+    DetectorConfig,
+    AlertConfig,
+    QueryColumnsConfig,
+    TablesConfig,
+)
+from detectkit.config.project_config import (
+    ProjectConfig,
+    ProjectPathsConfig,
+    ProjectTablesConfig,
+    ProjectTimeoutsConfig,
+)
+
+__all__ = [
+    "ProfileConfig",
+    "ProfilesConfig",
+    "MetricConfig",
+    "DetectorConfig",
+    "AlertConfig",
+    "QueryColumnsConfig",
+    "TablesConfig",
+    "ProjectConfig",
+    "ProjectPathsConfig",
+    "ProjectTablesConfig",
+    "ProjectTimeoutsConfig",
+]