detectkit 0.1.2__tar.gz → 0.2.1__tar.gz

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

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

{detectkit-0.1.2 → 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.1.2 → 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.1.2 → 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,12 +152,14 @@ 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
                 - confidence_lower: np.array of float64 (nullable)
                 - confidence_upper: np.array of float64 (nullable)
                 - value: np.array of float64 (nullable)
+                - processed_value: np.array of float64 (nullable)
                 - detection_metadata: np.array of JSON strings
             detector_params: JSON string with sorted detector parameters
 
@@ -170,10 +173,11 @@ class InternalTablesManager:
             ...     "confidence_lower": np.array([0.4, 0.5]),
             ...     "confidence_upper": np.array([0.6, 0.7]),
             ...     "value": np.array([0.5, 0.9]),
+            ...     "processed_value": np.array([0.5, 0.9]),
             ...     "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"])
@@ -182,11 +186,13 @@ 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"],
             "confidence_upper": data["confidence_upper"],
             "value": data["value"],
+            "processed_value": data["processed_value"],
             "detector_params": np.full(num_rows, detector_params, dtype=object),
             "detection_metadata": data["detection_metadata"],
             "created_at": np.full(
@@ -414,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.1.2 → detectkit-0.2.1}/detectkit/database/tables.py

@@ -48,11 +48,13 @@ 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
         - confidence_upper: Upper confidence bound
-        - value: Actual metric value
+        - value: Actual metric value (ALWAYS original value)
+        - processed_value: Value analyzed by detector (may be smoothed/transformed)
         - detector_params: JSON with sorted detector parameters
         - detection_metadata: JSON with missing_ratio, severity, direction, etc.
         - created_at: When detection was performed (UTC, millisecond precision)
@@ -63,11 +65,13 @@ 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),
             ColumnDefinition("confidence_upper", "Nullable(Float64)", nullable=True),
             ColumnDefinition("value", "Nullable(Float64)", nullable=True),
+            ColumnDefinition("processed_value", "Nullable(Float64)", nullable=True),
             ColumnDefinition("detector_params", "String"),
             ColumnDefinition("detection_metadata", "String"),
             ColumnDefinition("created_at", "DateTime64(3, 'UTC')"),