detectkit 0.2.2__tar.gz → 0.2.4__tar.gz

{detectkit-0.2.2/detectkit.egg-info → detectkit-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: detectkit
-Version: 0.2.2
+Version: 0.2.4
 Summary: Metric monitoring with automatic anomaly detection
 Author: detectkit team
 License: MIT

{detectkit-0.2.2 → detectkit-0.2.4}/detectkit/cli/commands/run.py

@@ -282,10 +282,14 @@ def select_metrics(selector: str, project_root: Path) -> List[tuple[Path, Metric
     Select metrics based on selector and validate uniqueness.
 
     Selector types:
-    - Metric name: "cpu_usage"
-    - Path pattern: "metrics/critical/*.yml"
+    - Metric name: "cpu_usage" (searches by 'name' field recursively in subdirectories)
+    - Path pattern: "metrics/critical/*.yml" or "league/cpu_usage"
     - Tag: "tag:critical"
 
+    For name selector:
+    1. First tries filename-based search in root metrics/ directory
+    2. If not found, searches recursively by 'name' field in all subdirectories
+
     Args:
         selector: Selector string
         project_root: Project root path
@@ -312,8 +316,9 @@ def select_metrics(selector: str, project_root: Path) -> List[tuple[Path, Metric
     elif "*" in selector or "/" in selector:
         pattern = selector if selector.startswith("metrics/") else f"metrics/{selector}"
         metric_paths = list(project_root.glob(pattern))
-    # Metric name selector (only searches root metrics/ directory)
+    # Metric name selector
     else:
+        # First try filename-based search in root (backward compatibility)
         metric_file = metrics_dir / f"{selector}.yml"
         if metric_file.exists():
             metric_paths = [metric_file]
@@ -322,6 +327,11 @@ def select_metrics(selector: str, project_root: Path) -> List[tuple[Path, Metric
             metric_file = metrics_dir / f"{selector}.yaml"
             if metric_file.exists():
                 metric_paths = [metric_file]
+            else:
+                # Fall back to recursive search by 'name' field
+                found_metric = find_metric_by_name(metrics_dir, selector)
+                if found_metric:
+                    metric_paths = [found_metric]
 
     if not metric_paths:
         return []
@@ -361,6 +371,35 @@ def find_metrics_by_tag(metrics_dir: Path, tag: str) -> List[Path]:
     return matching_metrics
 
 
+def find_metric_by_name(metrics_dir: Path, name: str) -> Optional[Path]:
+    """
+    Find metric by name field (searches recursively in subdirectories).
+
+    Args:
+        metrics_dir: Metrics directory path
+        name: Metric name to search for (from 'name' field in YAML)
+
+    Returns:
+        Path to metric file if found, None otherwise
+    """
+    import yaml
+
+    # Search both .yml and .yaml extensions
+    for pattern in ["**/*.yml", "**/*.yaml"]:
+        for metric_file in metrics_dir.glob(pattern):
+            try:
+                with open(metric_file) as f:
+                    config = yaml.safe_load(f)
+
+                if config and config.get("name") == name:
+                    return metric_file
+            except Exception:
+                # Skip files that can't be parsed
+                continue
+
+    return None
+
+
 def process_metric(
     metric_path: Path,
     config: MetricConfig,
@@ -406,6 +445,11 @@ def process_metric(
 
     # Run pipeline
     try:
+        # Log step headers
+        if PipelineStep.LOAD in steps:
+            click.echo()
+            click.echo(click.style("  ┌─ LOAD", fg="cyan", bold=True))
+
         result = task_manager.run_metric(
             config=config,
             steps=steps,
@@ -415,18 +459,10 @@ def process_metric(
             force=force,
         )
 
-        # Display results
+        # Display results - task_manager already printed details
+        click.echo()
         if result["status"] == "success":
-            click.echo(click.style("  ✓ Success!", fg="green", bold=True))
-
-            if PipelineStep.LOAD in steps:
-                click.echo(f"    Loaded: {result['datapoints_loaded']} datapoints")
-
-            if PipelineStep.DETECT in steps:
-                click.echo(f"    Detected: {result['anomalies_detected']} anomalies")
-
-            if PipelineStep.ALERT in steps:
-                click.echo(f"    Sent: {result['alerts_sent']} alerts")
+            click.echo(click.style("✓ Pipeline completed successfully", fg="green", bold=True))
         else:
             click.echo(
                 click.style(

{detectkit-0.2.2 → detectkit-0.2.4}/detectkit/database/clickhouse_manager.py

@@ -330,8 +330,8 @@ class ClickHouseDatabaseManager(BaseDatabaseManager):
         """
         from detectkit.database.tables import TABLE_TASKS
 
-        # Get current UTC time
-        now = datetime.now(timezone.utc)
+        # Get current UTC time (convert to naive UTC for numpy compatibility)
+        now = datetime.now(timezone.utc).replace(tzinfo=None)
 
         # First, delete existing record (if any)
         delete_query = f"""
@@ -350,6 +350,14 @@ class ClickHouseDatabaseManager(BaseDatabaseManager):
             }
         )
 
+        # Convert last_processed_timestamp to naive UTC if needed
+        last_ts_naive = None
+        if last_processed_timestamp:
+            if last_processed_timestamp.tzinfo is not None:
+                last_ts_naive = last_processed_timestamp.replace(tzinfo=None)
+            else:
+                last_ts_naive = last_processed_timestamp
+
         # Then insert new record
         insert_data = {
             "metric_name": np.array([metric_name]),
@@ -358,7 +366,7 @@ class ClickHouseDatabaseManager(BaseDatabaseManager):
             "status": np.array([status]),
             "started_at": np.array([now], dtype="datetime64[ms]"),
             "updated_at": np.array([now], dtype="datetime64[ms]"),
-            "last_processed_timestamp": np.array([last_processed_timestamp], dtype="datetime64[ms]") if last_processed_timestamp else np.array([None]),
+            "last_processed_timestamp": np.array([last_ts_naive], dtype="datetime64[ms]") if last_ts_naive else np.array([None]),
             "error_message": np.array([error_message]),
             "timeout_seconds": np.array([timeout_seconds], dtype=np.int32),
         }

{detectkit-0.2.2 → detectkit-0.2.4}/detectkit/database/internal_tables.py

@@ -125,7 +125,7 @@ class InternalTablesManager:
                 num_rows, ",".join(seasonality_columns), dtype=object
             ),
             "created_at": np.full(
-                num_rows, datetime.now(timezone.utc), dtype="datetime64[ms]"
+                num_rows, datetime.now(timezone.utc).replace(tzinfo=None), dtype="datetime64[ms]"
             ),
         }
 
@@ -196,7 +196,7 @@ class InternalTablesManager:
             "detector_params": np.full(num_rows, detector_params, dtype=object),
             "detection_metadata": data["detection_metadata"],
             "created_at": np.full(
-                num_rows, datetime.now(timezone.utc), dtype="datetime64[ms]"
+                num_rows, datetime.now(timezone.utc).replace(tzinfo=None), dtype="datetime64[ms]"
             ),
         }
 

{detectkit-0.2.2 → detectkit-0.2.4}/detectkit/orchestration/task_manager.py

@@ -12,6 +12,7 @@ from enum import Enum
 from typing import Dict, List, Optional
 import json
 
+import click
 import numpy as np
 
 from detectkit.alerting.channels.base import AlertData, BaseAlertChannel
@@ -165,12 +166,16 @@ class TaskManager:
 
                 # Step 2: Detect anomalies
                 if PipelineStep.DETECT in steps:
+                    click.echo()
+                    click.echo(click.style("  ┌─ DETECT", fg="cyan", bold=True))
                     detect_result = self._run_detect_step(config, from_date, to_date, full_refresh)
                     result["anomalies_detected"] = detect_result["anomalies_count"]
                     result["steps_completed"].append(PipelineStep.DETECT)
 
                 # Step 3: Send alerts
                 if PipelineStep.ALERT in steps:
+                    click.echo()
+                    click.echo(click.style("  ┌─ ALERT", fg="cyan", bold=True))
                     alert_result = self._run_alert_step(config)
                     result["alerts_sent"] = alert_result["alerts_sent"]
                     result["steps_completed"].append(PipelineStep.ALERT)
@@ -221,6 +226,7 @@ class TaskManager:
 
         # Determine date range
         if full_refresh:
+            click.echo("  │ Deleting existing datapoints...")
             # Delete existing data for this metric
             self.internal.delete_datapoints(
                 metric_name=config.name,
@@ -239,12 +245,14 @@ class TaskManager:
                 # Start from next interval after last timestamp
                 interval = config.get_interval()
                 actual_from = last_ts + timedelta(seconds=interval.seconds)
+                click.echo(f"  │ Resuming from last saved: {last_ts.strftime('%Y-%m-%d %H:%M:%S')}")
             else:
                 # No data yet - use loading_start_time from config
                 if config.loading_start_time:
                     actual_from = datetime.strptime(
                         config.loading_start_time, "%Y-%m-%d %H:%M:%S"
                     ).replace(tzinfo=timezone.utc)
+                    click.echo(f"  │ Starting fresh from: {config.loading_start_time}")
                 else:
                     raise ValueError(
                         "No existing data and no loading_start_time configured. "
@@ -260,16 +268,26 @@ class TaskManager:
         total_points = int(total_seconds / interval.seconds)
         batch_size = config.loading_batch_size
 
+        click.echo(f"  │ Loading from {actual_from.strftime('%Y-%m-%d %H:%M:%S')} to {actual_to.strftime('%Y-%m-%d %H:%M:%S')}")
+        click.echo(f"  │ Total points: ~{total_points:,} | Batch size: {batch_size:,}")
+
         # If total points <= batch_size, load in one go
         if total_points <= batch_size:
+            click.echo("  │ Loading in single batch...")
             rows_inserted = loader.load_and_save(from_date=actual_from, to_date=actual_to)
+            click.echo(click.style(f"  └─ Loaded {rows_inserted:,} datapoints", fg="green"))
             return {"points_loaded": rows_inserted}
 
         # Load in batches
         total_loaded = 0
         current_from = actual_from
+        num_batches = int(total_points / batch_size) + 1
+        batch_num = 0
+
+        click.echo(f"  │ Loading in {num_batches} batches...")
 
         while current_from < actual_to:
+            batch_num += 1
             # Calculate batch end time
             batch_seconds = batch_size * interval.seconds
             batch_to = current_from + timedelta(seconds=batch_seconds)
@@ -280,9 +298,12 @@ class TaskManager:
             rows = loader.load_and_save(from_date=current_from, to_date=batch_to)
             total_loaded += rows
 
+            click.echo(f"  │   Batch {batch_num}/{num_batches}: +{rows:,} points (total: {total_loaded:,})")
+
             # Move to next batch
             current_from = batch_to
 
+        click.echo(click.style(f"  └─ Loaded {total_loaded:,} datapoints", fg="green"))
         return {"points_loaded": total_loaded}
 
     def _run_detect_step(
@@ -308,10 +329,12 @@ class TaskManager:
 
         # Skip if no detectors configured
         if not config.detectors:
+            click.echo("  │ No detectors configured, skipping detection")
             return {"anomalies_count": 0}
 
         # Get interval
         interval = config.get_interval()
+        click.echo(f"  │ Running {len(config.detectors)} detector(s)...")
 
         # Determine to_date if not specified
         actual_to = to_date or datetime.now(timezone.utc)
@@ -325,7 +348,10 @@ class TaskManager:
             normalized_from_date = normalized_from_date.replace(tzinfo=None)
 
         # Run each detector
-        for detector_config in config.detectors:
+        for idx, detector_config in enumerate(config.detectors, 1):
+            click.echo(f"  │")
+            click.echo(f"  │ [{idx}/{len(config.detectors)}] Detector: {detector_config.type}")
+
             # Create detector to get detector_id
             # Combine algorithm params with execution params (seasonality_components)
             detector_params = detector_config.get_algorithm_params()
@@ -344,6 +370,7 @@ class TaskManager:
 
             # Delete existing detections if full_refresh
             if full_refresh:
+                click.echo("  │   Deleting existing detections...")
                 self.internal.delete_detections(
                     metric_name=config.name,
                     detector_id=detector_id,
@@ -387,6 +414,7 @@ class TaskManager:
 
             # Skip if nothing to detect
             if not actual_from or actual_from >= actual_to:
+                click.echo("  │   Nothing to detect (already up to date)")
                 continue
 
             # Get batch_size and context_size
@@ -397,10 +425,17 @@ class TaskManager:
             total_seconds = (actual_to - actual_from).total_seconds()
             total_points = int(total_seconds / interval.seconds)
 
+            click.echo(f"  │   Detecting from {actual_from.strftime('%Y-%m-%d %H:%M:%S')} to {actual_to.strftime('%Y-%m-%d %H:%M:%S')}")
+            click.echo(f"  │   Total points: ~{total_points:,} | Batch size: {batch_size:,}")
+
             # BATCHING: Process in batches
             current_from = actual_from
+            detector_anomalies = 0
+            num_batches = int(total_points / batch_size) + 1 if total_points > batch_size else 1
+            batch_num = 0
 
             while current_from < actual_to:
+                batch_num += 1
                 # Calculate batch end
                 batch_seconds = batch_size * interval.seconds
                 batch_to = current_from + timedelta(seconds=batch_seconds)
@@ -461,11 +496,19 @@ class TaskManager:
                     )
 
                     # Count anomalies
-                    anomalies_count += sum(1 for r in batch_results if r.is_anomaly)
+                    batch_anomalies = sum(1 for r in batch_results if r.is_anomaly)
+                    detector_anomalies += batch_anomalies
+                    anomalies_count += batch_anomalies
+
+                    if num_batches > 1:
+                        click.echo(f"  │     Batch {batch_num}/{num_batches}: {len(batch_results):,} points, {batch_anomalies} anomalies")
 
                 # Move to next batch
                 current_from = batch_to
 
+            click.echo(click.style(f"  │   └─ Detected {detector_anomalies:,} anomalies", fg="yellow" if detector_anomalies > 0 else "green"))
+
+        click.echo(click.style(f"  └─ Total anomalies: {anomalies_count:,}", fg="yellow" if anomalies_count > 0 else "green"))
         return {"anomalies_count": anomalies_count}
 
     def _run_alert_step(self, config: MetricConfig) -> Dict[str, int]:
@@ -482,11 +525,15 @@ class TaskManager:
 
         # Check if alerting is configured
         if not config.alerting or not config.alerting.enabled:
+            click.echo("  │ Alerting not enabled")
             return {"alerts_sent": 0}
 
         if not config.alerting.channels:
+            click.echo("  │ No alert channels configured")
             return {"alerts_sent": 0}
 
+        click.echo(f"  │ Checking alert conditions...")
+
         # Get alerting config
         alerting_config = config.alerting
 
@@ -515,12 +562,15 @@ class TaskManager:
         )
 
         if not recent_detections:
+            click.echo("  │ No recent detections found")
             return {"alerts_sent": 0}
 
         # Check if alert should be sent
         should_alert, alert_data = orchestrator.should_alert(recent_detections)
 
         if should_alert:
+            click.echo(click.style(f"  │ ⚠ Alert triggered! Sending to {len(alerting_config.channels)} channel(s)...", fg="yellow", bold=True))
+
             # Create alert channels from config
             channels = self._create_alert_channels(alerting_config.channels)
 
@@ -529,6 +579,16 @@ class TaskManager:
                 results = orchestrator.send_alerts(alert_data, channels)
                 alerts_sent = sum(1 for success in results.values() if success)
 
+                for channel_name, success in results.items():
+                    status = click.style("✓", fg="green") if success else click.style("✗", fg="red")
+                    click.echo(f"  │   {status} {channel_name}")
+
+                click.echo(click.style(f"  └─ Sent {alerts_sent}/{len(channels)} alerts", fg="green" if alerts_sent > 0 else "yellow"))
+            else:
+                click.echo(click.style("  └─ No valid alert channels available", fg="yellow"))
+        else:
+            click.echo("  └─ No alert needed (conditions not met)")
+
         return {"alerts_sent": alerts_sent}
 
     def _load_recent_detections(

{detectkit-0.2.2 → detectkit-0.2.4/detectkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: detectkit
-Version: 0.2.2
+Version: 0.2.4
 Summary: Metric monitoring with automatic anomaly detection
 Author: detectkit team
 License: MIT

{detectkit-0.2.2 → detectkit-0.2.4}/pyproject.toml

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