specfuse-loop 0.27.1__tar.gz → 0.28.0__tar.gz

{specfuse_loop-0.27.1/specfuse_loop.egg-info → specfuse_loop-0.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specfuse-loop
-Version: 0.27.1
+Version: 0.28.0
 Summary: Local-first executor for the Specfuse Plan + Work Unit gate-cycle methodology.
 Author: Specfuse contributors
 License: Apache-2.0

{specfuse_loop-0.27.1 → specfuse_loop-0.28.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "specfuse-loop"
-version = "0.27.1"
+version = "0.28.0"
 description = "Local-first executor for the Specfuse Plan + Work Unit gate-cycle methodology."
 readme = "README.md"
 requires-python = ">=3.10"

specfuse_loop-0.28.0/specfuse/loop/data/VERSION

@@ -0,0 +1 @@
+0.28.0

{specfuse_loop-0.27.1 → specfuse_loop-0.28.0}/specfuse/loop/data/monitoring.yml.example

@@ -81,6 +81,15 @@ components:
       # Use for any component that serves HTTP traffic directly.
       - type: http-5xx
 
+      # http-status-regression: alerts when a deployment raises the rate of
+      # server-fault 4xx responses compared with the window before it.
+      - type: http-status-regression
+        deploy_signal:
+          kind: app-version
+        window_after_deploy: 1h
+        # codes defaults to [403, 405, 415]; this one also opts in to 401.
+        codes: [401, 403, 405, 415]
+
       # heartbeat: alerts when the component stops reporting in at all —
       # the check that catches "it didn't error, it just went silent."
       - type: heartbeat

{specfuse_loop-0.27.1 → specfuse_loop-0.28.0}/specfuse/loop/data/rules/design-for-diagnosis.md

@@ -7,8 +7,8 @@ Licensed under the Apache License, Version 2.0. See LICENSE.
 
 This rule governs the *target application's* code — not this loop's own
 execution. It states what a deployed component must do so the check types a
-`monitoring.yml` admits (`dlq`, `error-logs`, `http-5xx`, `heartbeat`,
-`invariant`) produce a diagnosable finding instead of a bare alert. A check that
+`monitoring.yml` admits (`dlq`, `error-logs`, `http-5xx`,
+`http-status-regression`, `heartbeat`, `invariant`, `queue-stalled`) produce a diagnosable finding instead of a bare alert. A check that
 fires without one of these properties tells an operator only that something is
 wrong, not what or where.
 
@@ -108,3 +108,17 @@ an operator has to reproduce the failure from scratch, from a payload alone,
 with no error, no attempt count, and no correlation ID to trace back to the
 request that produced it. Context captured at dead-letter time is the
 difference between a diagnosis and a re-investigation.
+
+## A deployable stamps a version that changes on every deployment
+
+An HTTP-serving component stamps a service version onto the telemetry it emits,
+and that version changes on every deployment — the stamp is injected at build or
+release time, not a constant in source that survives a release unchanged.
+
+An `http-status-regression` check detects a deployment by the first appearance
+of a new version value, then compares the failure rate of newly-seen client-error
+and server-error statuses after that point with the rate before it. A component
+that stamps no version has no deployment signal at all; one that stamps the same
+value every release shows no new version to detect, so the check never opens its
+post-deployment window and a regression ships unseen. Either way the check
+cannot be evaluated, and discovery reports the gap rather than proposing it.

{specfuse_loop-0.27.1 → specfuse_loop-0.28.0}/specfuse/loop/lint_monitoring.py

@@ -35,6 +35,8 @@ from __future__ import annotations
 import re
 from pathlib import Path
 
+from specfuse.monitor.durations import DURATION_GRAMMAR, parse_duration_seconds
+
 from . import _miniyaml
 
 __all__ = ("validate_monitoring", "main", "CRON_DIALECTS")
@@ -43,7 +45,15 @@ RUNNER_VALUES = frozenset({"local", "gh-actions", "in-cluster"})
 DIAGNOSE_VALUES = frozenset({"manual", "auto"})
 AUTOFIX_VALUES = frozenset({"off", "on"})
 CHECK_TYPES = frozenset(
-    {"dlq", "error-logs", "http-5xx", "heartbeat", "invariant", "queue-stalled"}
+    {
+        "dlq",
+        "error-logs",
+        "http-5xx",
+        "http-status-regression",
+        "heartbeat",
+        "invariant",
+        "queue-stalled",
+    }
 )
 HARVEST_MODE_VALUES = frozenset({"peek", "quarantine"})
 
@@ -250,6 +260,8 @@ def _check_checks(checks: object, component_label: str) -> list[str]:
                     f"'queue-stalled' check requires 'targets' — each target "
                     f"needs 'subscription' and 'function'"
                 )
+        elif check_type == "http-status-regression":
+            findings.extend(_check_http_status_regression(check, component_label, index))
         elif check_type == "invariant":
             for field in ("query", "fingerprint_by"):
                 if not check.get(field):
@@ -274,8 +286,63 @@ _TARGET_REQUIRED_FIELDS = {
     "heartbeat": ("name",),
     "queue-stalled": ("subscription", "function"),
 }
+DEPLOY_SIGNAL_KINDS = frozenset({"app-version"})
+
+
+def _check_http_status_regression(
+    check: dict, component_label: str, check_index: int
+) -> list[str]:
+    """Field rules for one `http-status-regression` check (`targets` is
+    rejected by `_check_targets`)."""
+    where = f"component '{component_label}': checks[{check_index}]"
+    prefix = f"{where}: 'http-status-regression' check"
+    findings: list[str] = []
+
+    signal = check.get("deploy_signal")
+    if not isinstance(signal, dict) or not signal.get("kind"):
+        findings.append(
+            f"{prefix} requires 'deploy_signal' — a mapping with a 'kind'"
+        )
+    elif signal["kind"] not in DEPLOY_SIGNAL_KINDS:
+        findings.append(
+            f"{prefix} has unknown 'deploy_signal' kind {signal['kind']!r} — "
+            f"must be one of {sorted(DEPLOY_SIGNAL_KINDS)}"
+        )
+
+    window = check.get("window_after_deploy")
+    if window is None:
+        findings.append(f"{prefix} requires 'window_after_deploy'")
+    else:
+        try:
+            parse_duration_seconds(str(window))
+        except ValueError:
+            findings.append(
+                f"{prefix} 'window_after_deploy' value {window!r} is not a "
+                f"valid duration — expected {DURATION_GRAMMAR}"
+            )
+
+    codes = check.get("codes")
+    if codes is not None:
+        if (
+            not isinstance(codes, list)
+            or not codes
+            or not all(
+                isinstance(c, int) and not isinstance(c, bool) and 400 <= c <= 499
+                for c in codes
+            )
+        ):
+            findings.append(
+                f"{prefix} 'codes' must be a non-empty list of integers in 400–499"
+            )
+        elif len(set(codes)) != len(codes):
+            findings.append(f"{prefix} 'codes' must not contain duplicates")
+    return findings
+
+
 # Check types that must never carry `targets` at all.
-_TARGETLESS_CHECK_TYPES = frozenset({"error-logs", "http-5xx", "invariant"})
+_TARGETLESS_CHECK_TYPES = frozenset(
+    {"error-logs", "http-5xx", "http-status-regression", "invariant"}
+)
 
 
 def _check_targets(
@@ -329,6 +396,15 @@ def _check_targets(
                 )
         if check_type == "heartbeat":
             findings.extend(_check_cron_dialect(target, where, t_index))
+        if check_type == "queue-stalled" and target.get("stall_after") is not None:
+            try:
+                parse_duration_seconds(str(target["stall_after"]))
+            except ValueError:
+                findings.append(
+                    f"{where}: targets[{t_index}]: 'queue-stalled' target "
+                    f"'stall_after' value {target['stall_after']!r} is not a "
+                    f"valid duration — expected {DURATION_GRAMMAR}"
+                )
     return findings
 
 

{specfuse_loop-0.27.1 → specfuse_loop-0.28.0}/specfuse/loop/loop.py

@@ -127,7 +127,7 @@ SPECFUSE_DIR = Path(".specfuse")
 REPO_ROOT = SPECFUSE_DIR.parent
 FEATURES_DIR = SPECFUSE_DIR / "features"
 VERIFICATION_PATH = SPECFUSE_DIR / "verification.yml"
-DRIVER_VERSION = "0.27.1"
+DRIVER_VERSION = "0.28.0"
 # Oldest scaffold layout this driver can drive. init.sh stamps the scaffold's own
 # version into `.specfuse/VERSION`; check_scaffold_version() fails loud at startup if
 # the consumer's scaffold is older than this, pointing at `specfuse upgrade`. Bump

{specfuse_loop-0.27.1 → specfuse_loop-0.28.0}/specfuse/monitor/artifact.py

@@ -31,7 +31,9 @@ _TARGET_COORDINATE_FIELDS: Mapping[str, tuple[str, ...]] = {
 
 # Check types that must never carry target coordinates — 0069 rejected
 # `targets` on these, so `fingerprint_by` stays their single enumeration key.
-_TARGETLESS_CHECK_TYPES = frozenset({"error-logs", "http-5xx", "invariant"})
+_TARGETLESS_CHECK_TYPES = frozenset(
+    {"error-logs", "http-5xx", "http-status-regression", "invariant"}
+)
 
 
 @dataclass(frozen=True)

{specfuse_loop-0.27.1 → specfuse_loop-0.28.0}/specfuse/monitor/cli.py

@@ -252,6 +252,9 @@ def _build_adapter(cls, *, component: str, environment: Mapping[str, object], ch
         query=check.get("query"),
         fingerprint_by=check.get("fingerprint_by"),
         max_message_count=check.get("max_message_count", 50),
+        deploy_signal=check.get("deploy_signal"),
+        window_after_deploy=check.get("window_after_deploy"),
+        codes=check.get("codes"),
     )
     return _call_filtered(cls, **kwargs)
 

specfuse_loop-0.28.0/specfuse/monitor/durations.py

@@ -0,0 +1,40 @@
+#
+# Copyright 2026 Specfuse contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+#
+"""The `<integer><unit>` duration grammar, one home for adapter and linter.
+
+Imports nothing from any provider SDK: `specfuse.loop` (the linter) imports
+this module, and the linter must stay SDK-free.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Mapping
+
+DURATION_GRAMMAR = "<integer><unit> with unit in s/m/h/d, e.g. '15m'"
+
+_DURATION_RE = re.compile(r"^(\d+)([smhd])$")
+_DURATION_MULTIPLIERS: Mapping[str, int] = {
+    "s": 1,
+    "m": 60,
+    "h": 3600,
+    "d": 86400,
+}
+
+
+def parse_duration_seconds(value: str, field: str = "stall_after") -> int:
+    """Parse `<integer><unit>` (unit in s/m/h/d) into seconds.
+
+    Refuses rather than guesses: anything outside the grammar — no unit, an
+    unsupported unit, whitespace, a negative sign — raises `ValueError`
+    naming the offending value. No coercion, no silent zero.
+    """
+    match = _DURATION_RE.match(value) if isinstance(value, str) else None
+    if not match:
+        raise ValueError(
+            f"invalid {field} value {value!r} — expected {DURATION_GRAMMAR}"
+        )
+    magnitude, unit = match.groups()
+    return int(magnitude) * _DURATION_MULTIPLIERS[unit]

{specfuse_loop-0.27.1 → specfuse_loop-0.28.0}/specfuse/monitor/providers/azure_app_insights.py

@@ -27,12 +27,14 @@ folded back into a subsequent query; that is the direction
 
 from __future__ import annotations
 
+import json
 import re
-from datetime import datetime
+from datetime import datetime, timedelta, timezone
 from typing import Iterable, Iterator, Mapping, Optional, Protocol, Sequence
 
 from specfuse.monitor.adapters import resolve_telemetry
 from specfuse.monitor.artifact import FailureArtifact
+from specfuse.monitor.durations import parse_duration_seconds
 from specfuse.monitor.redaction import redact_artifact
 
 # Credential construction is shared with the other Azure provider and looked up
@@ -165,6 +167,259 @@ class Http5xxAdapter:
         return redact_artifact(artifact)
 
 
+# The regression rule (PLAN.md decision 2): a code fires when its share of the
+# after-window's requests is at least REGRESSION_FACTOR times its share of the
+# equal-length before-window and it occurs at least REGRESSION_MIN_COUNT times
+# after the deployment. Documented constants in v1, not monitoring.yml fields.
+REGRESSION_FACTOR = 3
+REGRESSION_MIN_COUNT = 10
+
+# The codes evaluated when `monitoring.yml` names none: forbidden, method not
+# allowed, unsupported media type — the 4xx a deployment produces when it breaks
+# authorization mapping, routing or content negotiation. 401 is deliberately
+# opt-in: a 401 wave is as often expired client tokens as a broken deployment.
+DEFAULT_REGRESSION_CODES = ("403", "405", "415")
+
+# How many operations, and how many sample operation ids, a finding names.
+_TOP_OPERATIONS = 5
+_SAMPLE_OPERATIONS = 3
+
+# How far back the one query looks for each version's first-seen time. A
+# deployment is only evaluated when its before-window also lies inside it.
+_REGRESSION_LOOKBACK = "7d"
+
+
+def _http_status_regression_query(
+    component: str, window_seconds: int, codes: Sequence[object]
+) -> str:
+    """One query, built only from operator configuration (the component, the
+    configured ``codes``, ``window_after_deploy`` and a fixed lookback) —
+    never from returned rows or the watermark. Each version's first-seen time
+    is found, deployments whose after-window has fully elapsed are kept, and
+    per (version, code) the after- and before-window counts come back with
+    each window's total request count, the code's top operations by
+    after-window count, and a few after-window operation ids. The ratio
+    arithmetic is the adapter's.
+    """
+    window = f"{int(window_seconds)}s"
+    code_list = ", ".join(f"'{c}'" for c in codes)
+    scope = (
+        f"AppRequests | where AppRoleName == '{component}' "
+        f"and TimeGenerated > ago({_REGRESSION_LOOKBACK}) "
+        "and isnotempty(AppVersion)"
+    )
+    return (
+        f"{scope} "
+        "| summarize first_seen = min(TimeGenerated) by AppVersion "
+        f"| where first_seen + {window} <= now() "
+        f"and first_seen - {window} >= ago({_REGRESSION_LOOKBACK}) "
+        "| project AppVersion, first_seen, k = 1 "
+        f"| join kind=inner ({scope} "
+        "| project TimeGenerated, ResultCode, Name, OperationId, k = 1) on k "
+        f"| where TimeGenerated >= first_seen - {window} "
+        f"and TimeGenerated < first_seen + {window} "
+        "| summarize after = countif(TimeGenerated >= first_seen), "
+        "before = countif(TimeGenerated < first_seen), "
+        "sample = take_anyif(OperationId, TimeGenerated >= first_seen) "
+        "by AppVersion, first_seen, ResultCode, Name "
+        "| sort by AppVersion asc, ResultCode asc, after desc "
+        "| extend rn = row_number(1, prev(AppVersion) != AppVersion "
+        "or prev(ResultCode) != ResultCode) "
+        "| summarize after = sum(after), before = sum(before), "
+        "endpoints = make_list_if(pack('name', Name, 'after', after, "
+        f"'before', before), rn <= {_TOP_OPERATIONS}), "
+        f"samples = make_list_if(sample, rn <= {_SAMPLE_OPERATIONS} "
+        "and isnotempty(sample)) "
+        "by AppVersion, first_seen, ResultCode "
+        "| summarize per_code = make_list(pack('code', ResultCode, "
+        "'after', after, 'before', before, 'endpoints', endpoints, "
+        "'samples', samples)), "
+        "after_total = sum(after), before_total = sum(before) "
+        "by AppVersion, first_seen "
+        "| mv-expand per_code "
+        "| project version = AppVersion, first_seen, "
+        "code = tostring(per_code.code), after = tolong(per_code.after), "
+        "before = tolong(per_code.before), endpoints = per_code.endpoints, "
+        "samples = per_code.samples, after_total, before_total "
+        f"| where code in ({code_list})"
+    )
+
+
+def _dynamic_list(value: object) -> list:
+    """A ``dynamic`` column arrives parsed or as JSON text, depending on the
+    client; anything else reads as empty rather than failing the finding."""
+    if isinstance(value, str):
+        try:
+            value = json.loads(value)
+        except ValueError:
+            return []
+    return list(value) if isinstance(value, (list, tuple)) else []
+
+
+def _share(count: int, total: int) -> str:
+    return f"{100 * count / total:.2f}%" if total > 0 else "n/a (no requests)"
+
+
+def _iso(moment: datetime) -> str:
+    return moment.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _kql_literal(value: str) -> str:
+    return value.replace("\\", "\\\\").replace("'", "\\'")
+
+
+def _as_utc(value: object) -> Optional[datetime]:
+    if isinstance(value, datetime):
+        parsed = value
+    else:
+        try:
+            parsed = datetime.fromisoformat(str(value).replace("Z", "+00:00"))
+        except ValueError:
+            return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=timezone.utc)
+    return parsed
+
+
+def _count(value: object) -> Optional[int]:
+    try:
+        return int(float(value))  # type: ignore[arg-type]
+    except (TypeError, ValueError):
+        return None
+
+
+class HttpStatusRegressionAdapter:
+    """``TelemetryAdapter`` for the ``http-status-regression`` check type.
+
+    One finding per (status code, deployment version) whose after-window has
+    fully elapsed at ``reference_time`` and whose share of requests regressed
+    by ``REGRESSION_FACTOR`` with at least ``REGRESSION_MIN_COUNT`` after-window
+    occurrences. The version is part of ``failure_signature`` so the finding
+    is filed once per deployment.
+    """
+
+    def __init__(
+        self,
+        *,
+        component: str,
+        environment: Mapping[str, object],
+        transport: AppInsightsTransport,
+        deploy_signal: object = None,
+        window_after_deploy: object = None,
+        codes: Optional[Sequence[object]] = None,
+        reference_time: Optional[datetime] = None,
+    ) -> None:
+        self._component = component
+        self._telemetry = resolve_telemetry(component, environment)
+        self._transport = transport
+        self._deploy_signal = deploy_signal
+        self._window_after_deploy = window_after_deploy
+        self._codes = [str(c) for c in codes] if codes else list(DEFAULT_REGRESSION_CODES)
+        self._reference_time = reference_time
+
+    def fetch_failures(self) -> Iterator[FailureArtifact]:
+        window_seconds = parse_duration_seconds(
+            self._window_after_deploy, "window_after_deploy"  # type: ignore[arg-type]
+        )
+        reference = _as_utc(self._reference_time) or datetime.now(timezone.utc)
+        query = _http_status_regression_query(self._component, window_seconds, self._codes)
+        seen: set = set()
+        for row in self._transport.run_query(query):
+            code = str(row.get("code") or "")
+            version = str(row.get("version") or "unknown-version")
+            if code not in self._codes:
+                continue
+            first_seen = _as_utc(row.get("first_seen"))
+            counts = [
+                _count(row.get(key))
+                for key in ("after", "before", "after_total", "before_total")
+            ]
+            if first_seen is None or None in counts:
+                continue
+            if first_seen + timedelta(seconds=window_seconds) > reference:
+                continue
+            after, before, after_total, before_total = counts  # type: ignore[misc]
+            if (code, version) in seen or not _regressed(
+                after, before, after_total, before_total
+            ):
+                continue
+            seen.add((code, version))
+            yield self._build_artifact(
+                code, version, first_seen, window_seconds,
+                after, before, after_total, before_total,
+                _dynamic_list(row.get("endpoints")), _dynamic_list(row.get("samples")),
+            )
+
+    def _build_artifact(
+        self,
+        code: str,
+        version: str,
+        first_seen: datetime,
+        window_seconds: int,
+        after: int,
+        before: int,
+        after_total: int,
+        before_total: int,
+        endpoints: list,
+        samples: list,
+    ) -> FailureArtifact:
+        window = self._window_after_deploy
+        lines = [
+            f"{code} rose after deployment {version} "
+            f"(first seen {_iso(first_seen)}).",
+            f"Share of requests: {_share(before, before_total)} in the {window} "
+            f"before ({before} of {before_total}), {_share(after, after_total)} "
+            f"in the {window} after ({after} of {after_total}). Fires at "
+            f"{REGRESSION_FACTOR}x the before-share with at least "
+            f"{REGRESSION_MIN_COUNT} occurrences after.",
+        ]
+        operations = sorted(
+            (e for e in endpoints if isinstance(e, Mapping)),
+            key=lambda e: _count(e.get("after")) or 0,
+            reverse=True,
+        )[:_TOP_OPERATIONS]
+        if operations:
+            lines += ["", f"Top operations returning {code}:"]
+            lines += [
+                f"  {e.get('name') or '(unnamed)'}: {_count(e.get('after')) or 0} "
+                f"after, {_count(e.get('before')) or 0} before"
+                for e in operations
+            ]
+        sample_ids = [str(s) for s in samples if s][:_SAMPLE_OPERATIONS]
+        if sample_ids:
+            lines += ["", f"Sample operation ids after the deployment: {', '.join(sample_ids)}"]
+        span = timedelta(seconds=window_seconds)
+        lines += [
+            "",
+            "Investigate in Log Analytics:",
+            "AppRequests",
+            f"| where AppRoleName == '{_kql_literal(self._component)}' "
+            f"and ResultCode == '{_kql_literal(code)}'",
+            f"| where TimeGenerated between (datetime({_iso(first_seen - span)}) "
+            f".. datetime({_iso(first_seen + span)}))",
+            "| summarize count() by AppVersion, Name, bin(TimeGenerated, 5m)",
+        ]
+        artifact = FailureArtifact(
+            component=self._component,
+            check_type="http-status-regression",
+            failure_class=code,
+            failure_signature=f"{version}:{code}",
+            observed_text="\n".join(lines),
+            target_coordinates=None,
+        )
+        return redact_artifact(artifact)
+
+
+def _regressed(after: int, before: int, after_total: int, before_total: int) -> bool:
+    """``after/after_total >= FACTOR * before/before_total``, in integers; a
+    before-window with no requests, or none of the code, has a share of 0."""
+    if after_total <= 0 or after < REGRESSION_MIN_COUNT:
+        return False
+    if before_total <= 0 or before <= 0:
+        return True
+    return after * before_total >= REGRESSION_FACTOR * before * after_total
+
+
 class InvariantAdapter:
     """``TelemetryAdapter`` for the ``invariant`` check type.
 

{specfuse_loop-0.27.1 → specfuse_loop-0.28.0}/specfuse/monitor/providers/azure_service_bus.py

@@ -30,6 +30,7 @@ from datetime import datetime
 from typing import Iterable, Iterator, List, Mapping, Optional, Protocol, Sequence
 
 from specfuse.monitor.artifact import FailureArtifact
+from specfuse.monitor.durations import parse_duration_seconds
 from specfuse.monitor.redaction import redact_artifact
 
 # Credential construction is shared with the other Azure provider and looked up
@@ -137,32 +138,10 @@ class ServiceBusDlqAdapter:
         return redact_artifact(artifact)
 
 
-_STALL_AFTER_RE = re.compile(r"^(\d+)([smhd])$")
-_STALL_AFTER_MULTIPLIERS: Mapping[str, int] = {
-    "s": 1,
-    "m": 60,
-    "h": 3600,
-    "d": 86400,
-}
-
-
 def parse_stall_after_seconds(value: str) -> int:
-    """Parse a `stall_after` value (`<integer><unit>`, unit in s/m/h/d) into
-    seconds.
-
-    Refuses rather than guesses (the WU's sub-decision 1): anything outside
-    the grammar — no unit, an unsupported unit, whitespace, a negative sign
-    — raises `ValueError` naming the offending value. No coercion, no
-    "assume minutes", no silent zero.
-    """
-    match = _STALL_AFTER_RE.match(value)
-    if not match:
-        raise ValueError(
-            f"invalid stall_after value {value!r} — expected "
-            f"<integer><unit> with unit in s/m/h/d, e.g. '15m'"
-        )
-    magnitude, unit = match.groups()
-    return int(magnitude) * _STALL_AFTER_MULTIPLIERS[unit]
+    """Parse a `stall_after` value into seconds. Thin alias over the shared
+    grammar in `specfuse.monitor.durations`."""
+    return parse_duration_seconds(value, field="stall_after")
 
 
 @dataclass(frozen=True)

{specfuse_loop-0.27.1 → specfuse_loop-0.28.0/specfuse_loop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specfuse-loop
-Version: 0.27.1
+Version: 0.28.0
 Summary: Local-first executor for the Specfuse Plan + Work Unit gate-cycle methodology.
 Author: Specfuse contributors
 License: Apache-2.0

{specfuse_loop-0.27.1 → specfuse_loop-0.28.0}/specfuse_loop.egg-info/SOURCES.txt

@@ -129,6 +129,7 @@ specfuse/monitor/autofix_state.py
 specfuse/monitor/cli.py
 specfuse/monitor/diagnose_cli.py
 specfuse/monitor/diagnosis.py
+specfuse/monitor/durations.py
 specfuse/monitor/fingerprint.py
 specfuse/monitor/issues.py
 specfuse/monitor/redaction.py
@@ -386,6 +387,8 @@ tests/test_headless_no_background_tasks.py
 tests/test_heartbeat.py
 tests/test_heartbeat_adapter.py
 tests/test_heartbeat_emission_contract.py
+tests/test_http_status_regression_adapter.py
+tests/test_http_status_regression_end_to_end.py
 tests/test_human_output_rule.py
 tests/test_human_work_unit.py
 tests/test_hygiene_boundary_guidance.py
@@ -480,6 +483,7 @@ tests/test_migrate_legacy.py
 tests/test_miniyaml_equivalence.py
 tests/test_miniyaml_negative.py
 tests/test_monitor_cli.py
+tests/test_monitor_durations.py
 tests/test_monitor_issue_lifecycle.py
 tests/test_monitor_runner_surfaces.py
 tests/test_monitoring_bootstrap_artifacts.py

{specfuse_loop-0.27.1 → specfuse_loop-0.28.0}/tests/test_app_insights_query_schema_check.py

@@ -67,6 +67,7 @@ _KQL_KEYWORDS = frozenset({
     "where", "project", "summarize", "extend", "by", "take", "limit",
     "and", "or", "not", "startswith", "endswith", "contains", "has", "in",
     "true", "false", "asc", "desc", "order", "sort",
+    "join", "kind", "inner", "on", "mv", "expand",
 })
 
 _STRING_LITERAL = re.compile(r"'(?:[^'\\]|\\.)*'|\"(?:[^\"\\]|\\.)*\"")
@@ -74,6 +75,8 @@ _STRING_LITERAL = re.compile(r"'(?:[^'\\]|\\.)*'|\"(?:[^\"\\]|\\.)*\"")
 # access, not a column) and what follows it (``(`` is a call, a lone ``=``
 # is an output alias).
 _IDENT = re.compile(r"(?P<dot>\.\s*)?\b(?P<name>[A-Za-z_][A-Za-z0-9_]*)\b(?=\s*(?P<after>\(|==|=)?)")
+# An output name defined anywhere in the query, so a later stage may read it.
+_ALIAS = re.compile(r"\b([A-Za-z_][A-Za-z0-9_]*)\s*=(?!=)")
 
 
 def schema_violations(query: str) -> list[str]:
@@ -89,12 +92,14 @@ def schema_violations(query: str) -> list[str]:
     columns = WORKSPACE_SCHEMA.get(table)
     if columns is None:
         return [f"table {table!r} is not a workspace table"]
+    aliases = set(_ALIAS.findall(rest))
     problems = []
     for match in _IDENT.finditer(rest):
         name, after = match.group("name"), match.group("after")
         if match.group("dot") or after in ("(", "="):
             continue
-        if name.lower() in _KQL_KEYWORDS or name in columns:
+        if name.lower() in _KQL_KEYWORDS or name in columns or name in aliases\
+                or name in WORKSPACE_SCHEMA:
             continue
         problems.append(f"column {name!r} is not a column of {table}")
     return problems
@@ -104,6 +109,9 @@ _BUILT_IN_QUERIES = {
     "error-logs": aai._error_logs_query,
     "http-5xx": aai._http_5xx_query,
     "heartbeat": aai._heartbeat_query,
+    "http-status-regression": lambda component: aai._http_status_regression_query(
+        component, 3600, ["401", "403"]
+    ),
 }