detectkit 0.56.1__tar.gz → 0.56.2__tar.gz

{detectkit-0.56.1/detectkit.egg-info → detectkit-0.56.2}/PKG-INFO

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

{detectkit-0.56.1 → detectkit-0.56.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.56.1"
+__version__ = "0.56.2"
 
 from detectkit.core.interval import Interval
 from detectkit.core.models import ColumnDefinition, TableModel

{detectkit-0.56.1 → detectkit-0.56.2}/detectkit/alerting/orchestrator/_base.py

@@ -38,6 +38,7 @@ class _OrchestratorBase:
         help_url: str | None = None,
         ai_synonyms: list[str] | None = None,
         loading_delay_seconds: int = 0,
+        grid_phase_seconds: int = 0,
     ):
         self.metric_name = metric_name
         self.interval = interval
@@ -69,6 +70,16 @@ class _OrchestratorBase:
         # step AND the recovery mixin's own fetch bound) computes the same
         # delay-aware boundary as the load step's maturity cut-off.
         self.loading_delay_seconds = int(loading_delay_seconds or 0)
+        # Phase of the metric's interval grid on the epoch clock, in
+        # [0, interval). The loader anchors datapoints on loading_start_time, so
+        # a non-epoch-aligned start puts the stored grid at an arbitrary phase;
+        # ``get_last_complete_point`` floors to THIS phase (not plain epoch time)
+        # so its exact-timestamp no-data lookup asks for a boundary the loader
+        # actually writes. Constructor state, like ``loading_delay_seconds`` —
+        # the two together keep the no-data expectation in lockstep with the load
+        # step's grid. Defaults to 0 (the epoch grid), so direct-API callers and
+        # epoch-aligned metrics are unchanged (issue #114).
+        self.grid_phase_seconds = int(grid_phase_seconds or 0) % interval.seconds
 
     @staticmethod
     def _group_by_timestamp(

{detectkit-0.56.1 → detectkit-0.56.2}/detectkit/alerting/orchestrator/_decision.py

@@ -474,6 +474,15 @@ class _DecisionMixin(_OrchestratorBase):
     def get_last_complete_point(self, now: datetime | None = None) -> datetime:
         """Floor ``now`` to the previous fully completed *mature* interval boundary.
 
+        Flooring happens on the metric's **own** interval grid, whose phase on
+        the epoch clock is ``grid_phase_seconds`` (0 = epoch-aligned). The loader
+        anchors datapoints on ``loading_start_time``, so a non-epoch-aligned
+        start (e.g. ``:07`` on a 10-minute grid) puts the stored series at an
+        arbitrary phase; flooring plain epoch time would return a boundary the
+        loader never writes and make the exact-timestamp no-data lookup fire a
+        permanent false alert (issue #114). Phasing here keeps the no-data
+        expectation on the same grid the load step persists.
+
         With a ``loading_delay`` configured, the loader only trusts
         ``[t, t+interval)`` once ``now >= t + interval + delay`` — so the same
         delay shifts the effective now back here BEFORE flooring, keeping the
@@ -487,10 +496,12 @@ class _DecisionMixin(_OrchestratorBase):
         now = to_aware_utc(now)
 
         interval_seconds = self.interval.seconds
+        phase = self.grid_phase_seconds  # already normalised into [0, interval)
         # Shift the effective now back by the maturity delay BEFORE flooring
         # (subtract-then-floor keeps the boundary correct for delays that
-        # aren't a multiple of the interval).
+        # aren't a multiple of the interval), then floor onto the metric's grid
+        # phase rather than the epoch grid.
         effective_epoch = int(now.timestamp()) - self.loading_delay_seconds
-        floored = (effective_epoch // interval_seconds) * interval_seconds
+        floored = ((effective_epoch - phase) // interval_seconds) * interval_seconds + phase
         last_complete = floored - interval_seconds
         return datetime.fromtimestamp(last_complete, tz=timezone.utc)

{detectkit-0.56.1 → detectkit-0.56.2}/detectkit/config/metric_config.py

@@ -5,6 +5,7 @@ Defines configuration structure for individual metrics loaded from YAML files.
 """
 
 import re
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
@@ -1051,3 +1052,31 @@ def resolve_loading_delay_seconds(
             continue
         return loading_delay_to_seconds(value)
     return 0
+
+
+def resolve_grid_phase_seconds(loading_start_time: str | None, interval_seconds: int) -> int:
+    """Phase of the metric's interval grid on the epoch clock, in ``[0, interval)``.
+
+    The loader anchors every datapoint on ``loading_start_time`` (first run) or
+    the resume cursor descended from it, so the stored grid sits at
+    ``loading_start_time_epoch % interval`` — an arbitrary phase whenever the
+    start isn't a multiple of the interval (e.g. ``00:07:00`` on a 10-minute
+    grid). The alert step's no-data check does an **exact-timestamp** lookup, so
+    it must floor to that same phase; flooring plain epoch time (phase 0) instead
+    asks for a boundary the loader never writes and fires a permanent false
+    no-data alert. This is the single seam that keeps the two grid phases in
+    lockstep — the mirror of :func:`resolve_loading_delay_seconds` for the
+    maturity delay (see issue #114).
+
+    Returns ``0`` (the epoch grid — unchanged behaviour) when no
+    ``loading_start_time`` is set or it can't be parsed in the canonical
+    ``"%Y-%m-%d %H:%M:%S"`` UTC form the loader uses.
+    """
+    if not loading_start_time or interval_seconds <= 0:
+        return 0
+    try:
+        start = datetime.strptime(loading_start_time, "%Y-%m-%d %H:%M:%S")
+    except (ValueError, TypeError):
+        return 0
+    epoch = int(start.replace(tzinfo=timezone.utc).timestamp())
+    return epoch % interval_seconds

{detectkit-0.56.1 → detectkit-0.56.2}/detectkit/orchestration/task_manager/_alert_step.py

@@ -33,6 +33,12 @@ class _AlertStepMixin(_TaskManagerBase):
         # every other last-complete-point computation) must not run ahead of
         # what load has had a chance to persist under a loading_delay.
         loading_delay_seconds = self._loading_delay_seconds(config)
+        # Same grid phase as the load step: the no-data check floors to the
+        # metric's own interval grid (anchored on loading_start_time), not plain
+        # epoch time, so a non-epoch-aligned start (e.g. :07 on a 10min grid)
+        # doesn't make the exact-timestamp lookup ask for a boundary the loader
+        # never writes — a permanent false no-data alert (issue #114).
+        grid_phase_seconds = self._grid_phase_seconds(config)
 
         for i, alerting_config in enumerate(active_configs):
             if multi:
@@ -75,6 +81,7 @@ class _AlertStepMixin(_TaskManagerBase):
                 project_name=getattr(self.project_config, "name", None),
                 help_url=help_url,
                 loading_delay_seconds=loading_delay_seconds,
+                grid_phase_seconds=grid_phase_seconds,
             )
 
             last_point = orchestrator.get_last_complete_point()

{detectkit-0.56.1 → detectkit-0.56.2}/detectkit/orchestration/task_manager/_base.py

@@ -7,7 +7,11 @@ from datetime import datetime
 from detectkit.alerting.channels.base import BaseAlertChannel
 from detectkit.alerting.channels.factory import AlertChannelFactory
 from detectkit.alerting.orchestrator import DetectionRecord, hydrate_detection_records
-from detectkit.config.metric_config import MetricConfig, resolve_loading_delay_seconds
+from detectkit.config.metric_config import (
+    MetricConfig,
+    resolve_grid_phase_seconds,
+    resolve_loading_delay_seconds,
+)
 from detectkit.database.internal_tables import InternalTablesManager
 
 
@@ -40,6 +44,19 @@ class _TaskManagerBase:
             getattr(self.project_config, "loading_delay", None),
         )
 
+    def _grid_phase_seconds(self, config: MetricConfig) -> int:
+        """Phase of *config*'s interval grid on the epoch clock (metric-derived).
+
+        The loader anchors the stored grid on ``loading_start_time``; the alert
+        step's exact-timestamp no-data lookup must floor to the same phase, so
+        this one seam feeds the orchestrator's ``get_last_complete_point`` — the
+        mirror of ``_loading_delay_seconds`` for the grid phase (issue #114).
+        """
+        return resolve_grid_phase_seconds(
+            config.loading_start_time,
+            config.get_interval().seconds,
+        )
+
     def _load_recent_detections(
         self,
         metric_name: str,

{detectkit-0.56.1 → detectkit-0.56.2/detectkit.egg-info}/PKG-INFO

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