detectkit 0.2.0__tar.gz → 0.2.1__tar.gz

{detectkit-0.2.0/detectkit.egg-info → detectkit-0.2.1}/PKG-INFO

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

{detectkit-0.2.0 → detectkit-0.2.1}/detectkit/alerting/channels/base.py

@@ -159,6 +159,7 @@ class BaseAlertChannel(ABC):
                 confidence_upper=alert_data.confidence_upper,
                 confidence_interval=confidence_str,
                 detector_name=alert_data.detector_name,
+                detector_params=alert_data.detector_params,
                 direction=alert_data.direction,
                 severity=alert_data.severity,
                 consecutive_count=alert_data.consecutive_count,
@@ -182,6 +183,7 @@ class BaseAlertChannel(ABC):
             "Value: {value}\n"
             "Confidence interval: {confidence_interval}\n"
             "Detector: {detector_name}\n"
+            "Parameters: {detector_params}\n"
             "Direction: {direction}\n"
             "Severity: {severity:.2f}"
         )

{detectkit-0.2.0 → detectkit-0.2.1}/detectkit/alerting/orchestrator.py

@@ -35,6 +35,7 @@ class DetectionRecord:
     timestamp: np.datetime64
     detector_name: str
     detector_id: str
+    detector_params: str  # JSON string with detector parameters
     value: float
     is_anomaly: bool
     confidence_lower: Optional[float]
@@ -242,9 +243,9 @@ class AlertOrchestrator:
             detector_names = [d.detector_name for d in anomalies]
             detector_name = f"{len(anomalies)} detectors"
             detector_params_list = [
-                f"{d.detector_name}({d.detector_id[:8]})" for d in anomalies
+                f"{d.detector_name}: {d.detector_params}" for d in anomalies
             ]
-            detector_params = ", ".join(detector_params_list)
+            detector_params = "; ".join(detector_params_list)
 
             # Combine metadata
             combined_metadata = {
@@ -256,7 +257,7 @@ class AlertOrchestrator:
         else:
             max_severity = primary.severity
             detector_name = primary.detector_name
-            detector_params = f"{primary.detector_id[:16]}"
+            detector_params = primary.detector_params
             combined_metadata = primary.detection_metadata
 
         # Convert numpy timestamp for AlertData

{detectkit-0.2.0 → detectkit-0.2.1}/detectkit/database/internal_tables.py

@@ -9,7 +9,7 @@ methods underneath. It does NOT duplicate logic - just provides semantic wrapper
 """
 
 from datetime import datetime, timezone
-from typing import Dict, Optional
+from typing import Dict, List, Optional
 
 import numpy as np
 
@@ -142,6 +142,7 @@ class InternalTablesManager:
         self,
         metric_name: str,
         detector_id: str,
+        detector_name: str,
         data: Dict[str, np.ndarray],
         detector_params: str,
     ) -> int:
@@ -151,6 +152,7 @@ class InternalTablesManager:
         Args:
             metric_name: Metric identifier
             detector_id: Detector identifier (hash)
+            detector_name: Detector class name (e.g., "MADDetector")
             data: Dictionary with keys:
                 - timestamp: np.array of datetime64
                 - is_anomaly: np.array of bool
@@ -175,7 +177,7 @@ class InternalTablesManager:
             ...     "detection_metadata": np.array(['{"severity": 0.0}', '{"severity": 0.8}']),
             ... }
             >>> rows = internal.save_detections(
-            ...     "cpu_usage", "mad_abc123", data, '{"threshold": 3.0}'
+            ...     "cpu_usage", "mad_abc123", "MADDetector", data, '{"threshold": 3.0}'
             ... )
         """
         num_rows = len(data["timestamp"])
@@ -184,6 +186,7 @@ class InternalTablesManager:
         insert_data = {
             "metric_name": np.full(num_rows, metric_name, dtype=object),
             "detector_id": np.full(num_rows, detector_id, dtype=object),
+            "detector_name": np.full(num_rows, detector_name, dtype=object),
             "timestamp": data["timestamp"],
             "is_anomaly": data["is_anomaly"],
             "confidence_lower": data["confidence_lower"],
@@ -417,6 +420,143 @@ class InternalTablesManager:
         # ClickHouse ALTER TABLE DELETE is async, return 0
         return 0
 
+    def get_recent_detections(
+        self,
+        metric_name: str,
+        last_point: datetime,
+        num_points: int,
+    ) -> List[Dict]:
+        """
+        Get recent detection results grouped by timestamp.
+
+        This method is fully database-agnostic - uses simple SELECT
+        and groups data in Python (no GROUP BY, no database-specific functions).
+
+        Args:
+            metric_name: Metric identifier
+            last_point: Last complete timestamp to query up to
+            num_points: Number of recent timestamps to retrieve
+
+        Returns:
+            List of dicts, each containing:
+                - timestamp: Detection timestamp
+                - detector_ids: List of detector IDs for this timestamp
+                - detector_names: List of detector names
+                - detector_params_list: List of detector params (JSON strings)
+                - is_anomaly_flags: List of is_anomaly bools
+                - confidence_lowers: List of lower confidence bounds
+                - confidence_uppers: List of upper confidence bounds
+                - value: Metric value (same for all detectors at this timestamp)
+
+        Example:
+            >>> detections = internal.get_recent_detections(
+            ...     "cpu_usage",
+            ...     datetime(2024, 1, 1, 12, 0, 0),
+            ...     5
+            ... )
+            >>> for det in detections:
+            ...     print(f"{det['timestamp']}: {len(det['detector_ids'])} detectors")
+        """
+        full_table_name = self._manager.get_full_table_name(
+            TABLE_DETECTIONS, use_internal=True
+        )
+
+        # Step 1: Get distinct timestamps (database-agnostic)
+        # Find last N timestamps with detections
+        timestamps_query = f"""
+        SELECT DISTINCT timestamp
+        FROM {full_table_name}
+        WHERE metric_name = %(metric_name)s
+          AND timestamp <= %(last_point)s
+        ORDER BY timestamp DESC
+        LIMIT %(num_points)s
+        """
+
+        timestamp_results = self._manager.execute_query(
+            timestamps_query,
+            params={
+                "metric_name": metric_name,
+                "last_point": last_point,
+                "num_points": num_points,
+            },
+        )
+
+        if not timestamp_results:
+            return []
+
+        # Extract timestamps
+        timestamps = [row["timestamp"] for row in timestamp_results]
+
+        # Step 2: Get all detections for these timestamps (simple SELECT)
+        # Build IN clause with timestamps
+        timestamps_str = ", ".join([
+            f"'{ts.strftime('%Y-%m-%d %H:%M:%S')}'" for ts in timestamps
+        ])
+
+        detections_query = f"""
+        SELECT
+            timestamp,
+            detector_id,
+            detector_name,
+            detector_params,
+            is_anomaly,
+            confidence_lower,
+            confidence_upper,
+            value
+        FROM {full_table_name}
+        WHERE metric_name = %(metric_name)s
+          AND timestamp IN ({timestamps_str})
+        ORDER BY timestamp DESC, detector_id
+        """
+
+        detection_results = self._manager.execute_query(
+            detections_query,
+            params={"metric_name": metric_name},
+        )
+
+        if not detection_results:
+            return []
+
+        # Step 3: Group by timestamp in Python (no pandas, pure Python)
+        # Use timestamp string as key to avoid datetime comparison issues
+        grouped = {}
+        for row in detection_results:
+            ts = row["timestamp"]
+            # Convert timestamp to string key for grouping
+            if isinstance(ts, str):
+                ts_key = ts
+                ts_value = ts
+            else:
+                # datetime object - normalize and convert to string
+                if hasattr(ts, 'tzinfo') and ts.tzinfo is not None:
+                    ts = ts.replace(tzinfo=None)
+                ts_key = ts.isoformat()
+                ts_value = ts
+
+            if ts_key not in grouped:
+                grouped[ts_key] = {
+                    "timestamp": ts_value,
+                    "detector_ids": [],
+                    "detector_names": [],
+                    "detector_params_list": [],
+                    "is_anomaly_flags": [],
+                    "confidence_lowers": [],
+                    "confidence_uppers": [],
+                    "value": row["value"],  # Same for all detectors at this timestamp
+                }
+
+            grouped[ts_key]["detector_ids"].append(row["detector_id"])
+            grouped[ts_key]["detector_names"].append(row["detector_name"])
+            grouped[ts_key]["detector_params_list"].append(row["detector_params"])
+            grouped[ts_key]["is_anomaly_flags"].append(row["is_anomaly"])
+            grouped[ts_key]["confidence_lowers"].append(row["confidence_lower"])
+            grouped[ts_key]["confidence_uppers"].append(row["confidence_upper"])
+
+        # Step 4: Convert to list, sorted by timestamp key (desc)
+        result = [grouped[ts_key] for ts_key in sorted(grouped.keys(), reverse=True)]
+
+        return result
+
     def acquire_lock(
         self,
         metric_name: str,

{detectkit-0.2.0 → detectkit-0.2.1}/detectkit/database/tables.py

@@ -48,6 +48,7 @@ def get_detections_table_model() -> TableModel:
     Schema:
         - metric_name: Metric identifier
         - detector_id: Detector identifier (hash of class + params)
+        - detector_name: Detector class name (e.g., "MADDetector", "ZScoreDetector")
         - timestamp: Detection timestamp (UTC, millisecond precision)
         - is_anomaly: Whether point is anomalous
         - confidence_lower: Lower confidence bound
@@ -64,6 +65,7 @@ def get_detections_table_model() -> TableModel:
         columns=[
             ColumnDefinition("metric_name", "String"),
             ColumnDefinition("detector_id", "String"),
+            ColumnDefinition("detector_name", "String"),
             ColumnDefinition("timestamp", "DateTime64(3, 'UTC')"),
             ColumnDefinition("is_anomaly", "Bool"),
             ColumnDefinition("confidence_lower", "Nullable(Float64)", nullable=True),

{detectkit-0.2.0 → detectkit-0.2.1}/detectkit/detectors/statistical/iqr.py

@@ -348,8 +348,8 @@ class IQRDetector(BaseDetector):
                     )
 
                     # Apply mask to window (only valid values + seasonality match)
-                    combined_mask = valid_mask.copy()
-                    combined_mask[valid_mask] &= season_mask
+                    # Both valid_mask and season_mask are same size as window_processed
+                    combined_mask = valid_mask & season_mask
 
                     group_values = window_processed[combined_mask]
 

{detectkit-0.2.0 → detectkit-0.2.1}/detectkit/detectors/statistical/mad.py

@@ -336,8 +336,8 @@ class MADDetector(BaseDetector):
                     )
 
                     # Apply mask to window (only valid values + seasonality match)
-                    combined_mask = valid_mask.copy()
-                    combined_mask[valid_mask] &= season_mask
+                    # Both valid_mask and season_mask are same size as window_processed
+                    combined_mask = valid_mask & season_mask
 
                     group_values = window_processed[combined_mask]
 

{detectkit-0.2.0 → detectkit-0.2.1}/detectkit/detectors/statistical/zscore.py

@@ -342,8 +342,8 @@ class ZScoreDetector(BaseDetector):
                     )
 
                     # Apply mask to window (only valid values + seasonality match)
-                    combined_mask = valid_mask.copy()
-                    combined_mask[valid_mask] &= season_mask
+                    # Both valid_mask and season_mask are same size as window_processed
+                    combined_mask = valid_mask & season_mask
 
                     group_values = window_processed[combined_mask]
 

{detectkit-0.2.0 → detectkit-0.2.1}/detectkit/orchestration/task_manager.py

@@ -356,6 +356,9 @@ class TaskManager:
                 metric_name=config.name,
                 detector_id=detector_id
             )
+            # Normalize last_detection_ts to naive if needed
+            if last_detection_ts and last_detection_ts.tzinfo is not None:
+                last_detection_ts = last_detection_ts.replace(tzinfo=None)
 
             # Determine actual from_date
             actual_from = normalized_from_date
@@ -374,13 +377,14 @@ class TaskManager:
                 # Always normalize to naive datetime
                 start_time = start_time.replace(tzinfo=None)
                 if actual_from:
-                    # Ensure actual_from is also naive
-                    if actual_from.tzinfo is not None:
-                        actual_from = actual_from.replace(tzinfo=None)
                     actual_from = max(actual_from, start_time)
                 else:
                     actual_from = start_time
 
+            # Ensure actual_from is naive (for comparison with actual_to)
+            if actual_from and actual_from.tzinfo is not None:
+                actual_from = actual_from.replace(tzinfo=None)
+
             # Skip if nothing to detect
             if not actual_from or actual_from >= actual_to:
                 continue
@@ -451,6 +455,7 @@ class TaskManager:
                     self.internal.save_detections(
                         metric_name=config.name,
                         detector_id=detector_id,
+                        detector_name=detector.__class__.__name__,
                         data=detection_data,
                         detector_params=detector.get_detector_params(),
                     )
@@ -543,37 +548,11 @@ class TaskManager:
         Returns:
             List of DetectionRecord objects
         """
-        # Get full table name for _dtk_detections
-        from detectkit.database.tables import TABLE_DETECTIONS
-        full_table_name = self.db_manager.get_full_table_name(
-            TABLE_DETECTIONS, use_internal=True
-        )
-
-        # Query _dtk_detections for recent points
-        # GROUP BY timestamp to combine results from multiple detectors
-        query = f"""
-        SELECT
-            timestamp,
-            groupArray(detector_id) as detector_ids,
-            groupArray(is_anomaly) as is_anomaly_flags,
-            groupArray(confidence_lower) as confidence_lowers,
-            groupArray(confidence_upper) as confidence_uppers,
-            any(value) as value
-        FROM {full_table_name}
-        WHERE metric_name = %(metric_name)s
-          AND timestamp <= %(last_point)s
-        GROUP BY timestamp
-        ORDER BY timestamp DESC
-        LIMIT %(num_points)s
-        """
-
-        results = self.db_manager.execute_query(
-            query,
-            params={
-                "metric_name": metric_name,
-                "last_point": last_point,
-                "num_points": num_points,
-            },
+        # Use internal tables manager method (database-agnostic)
+        results = self.internal.get_recent_detections(
+            metric_name=metric_name,
+            last_point=last_point,
+            num_points=num_points,
         )
 
         if not results:
@@ -585,10 +564,10 @@ class TaskManager:
             # Check if any detector flagged this point as anomaly
             is_anomaly = any(row["is_anomaly_flags"])
 
-            # Get detector IDs that flagged anomaly
-            anomaly_detectors = [
-                d_id
-                for d_id, flag in zip(row["detector_ids"], row["is_anomaly_flags"])
+            # Get detector data for anomalous detections
+            anomaly_indices = [
+                i
+                for i, flag in enumerate(row["is_anomaly_flags"])
                 if flag
             ]
 
@@ -597,12 +576,18 @@ class TaskManager:
             severity = 0.0
             confidence_lower = None
             confidence_upper = None
-
-            if is_anomaly and anomaly_detectors:
-                # Get confidence bounds from first detector (they should be similar)
-                first_detector_idx = row["detector_ids"].index(anomaly_detectors[0])
-                confidence_lower = row["confidence_lowers"][first_detector_idx]
-                confidence_upper = row["confidence_uppers"][first_detector_idx]
+            detector_name = "unknown"
+            detector_id = "unknown"
+            detector_params = "{}"
+
+            if is_anomaly and anomaly_indices:
+                # Get data from first anomalous detector
+                first_idx = anomaly_indices[0]
+                detector_name = row["detector_names"][first_idx]
+                detector_id = row["detector_ids"][first_idx]
+                detector_params = row["detector_params_list"][first_idx]
+                confidence_lower = row["confidence_lowers"][first_idx]
+                confidence_upper = row["confidence_uppers"][first_idx]
 
                 # Determine direction
                 value = row["value"]
@@ -616,8 +601,9 @@ class TaskManager:
             records.append(
                 DetectionRecord(
                     timestamp=row["timestamp"],
-                    detector_name=anomaly_detectors[0] if anomaly_detectors else "unknown",
-                    detector_id=anomaly_detectors[0] if anomaly_detectors else "unknown",
+                    detector_name=detector_name,
+                    detector_id=detector_id,
+                    detector_params=detector_params,
                     value=row["value"],
                     is_anomaly=is_anomaly,
                     confidence_lower=confidence_lower,

{detectkit-0.2.0 → detectkit-0.2.1/detectkit.egg-info}/PKG-INFO

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

{detectkit-0.2.0 → detectkit-0.2.1}/pyproject.toml

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