setrya 0.12.1__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- setrya/__init__.py +3 -0
- setrya/__main__.py +3 -0
- setrya/adapter.py +84 -0
- setrya/cache_metrics.py +137 -0
- setrya/checker.py +202 -0
- setrya/cli.py +348 -0
- setrya/comparison.py +126 -0
- setrya/conformance.py +141 -0
- setrya/coverage.py +311 -0
- setrya/dependencies.py +105 -0
- setrya/drill.py +188 -0
- setrya/evidence.py +367 -0
- setrya/examples/__init__.py +1 -0
- setrya/examples/answer_cache/__init__.py +1 -0
- setrya/examples/answer_cache/__main__.py +3 -0
- setrya/examples/answer_cache/app.py +167 -0
- setrya/examples/answer_cache/contract.py +19 -0
- setrya/examples/answer_cache/drill.py +150 -0
- setrya/examples/answer_cache/evidence.py +274 -0
- setrya/examples/answer_cache/metrics.py +114 -0
- setrya/examples/answer_cache/selective.py +325 -0
- setrya/examples/answer_cache/store.py +238 -0
- setrya/examples/answer_cache/worker.py +53 -0
- setrya/examples/elasticsearch_search.py +106 -0
- setrya/examples/offboarding/__init__.py +1 -0
- setrya/examples/offboarding/demo.py +105 -0
- setrya/examples/offboarding/fixture.py +376 -0
- setrya/examples/offboarding/sqlite/__init__.py +1 -0
- setrya/examples/offboarding/sqlite/observe.py +344 -0
- setrya/examples/offboarding/sqlite/policy.json +8 -0
- setrya/examples/opendesk/Dockerfile.trial +26 -0
- setrya/examples/opendesk/__init__.py +1 -0
- setrya/examples/opendesk/cli.py +73 -0
- setrya/examples/opendesk/compose.yaml +70 -0
- setrya/examples/opendesk/observed.json +66 -0
- setrya/examples/opendesk/policy-v2.json +26 -0
- setrya/examples/opendesk/policy.json +26 -0
- setrya/examples/opendesk/provider.py +53 -0
- setrya/examples/opendesk/run.py +441 -0
- setrya/examples/opendesk/to_gate.py +129 -0
- setrya/examples/opendesk/transport.py +31 -0
- setrya/examples/opendesk/verify_report.py +254 -0
- setrya/examples/pgvector-search/compose.yml +14 -0
- setrya/examples/pgvector-search/drill.toml +40 -0
- setrya/examples/pgvector-search/reupload.toml +51 -0
- setrya/examples/pgvector_search/__init__.py +8 -0
- setrya/examples/pgvector_search/__main__.py +26 -0
- setrya/examples/pgvector_search/adapter.py +16 -0
- setrya/examples/pgvector_search/app.py +242 -0
- setrya/examples/pgvector_search/benchmark.py +118 -0
- setrya/examples/pgvector_search/pytest_reference.py +89 -0
- setrya/examples/recorded-search/drill.toml +34 -0
- setrya/examples/recorded_search/__init__.py +1 -0
- setrya/examples/recorded_search/existing_test.py +62 -0
- setrya/examples/recorded_search/verify.py +93 -0
- setrya/examples/support-search/drill.toml +40 -0
- setrya/examples/support-search/python.toml +40 -0
- setrya/examples/support-search/retired.toml +51 -0
- setrya/examples/support_search/__init__.py +1 -0
- setrya/examples/support_search/__main__.py +104 -0
- setrya/examples/support_search/adapter.py +61 -0
- setrya/examples/support_search/app.py +225 -0
- setrya/examples/support_search/baseline.py +101 -0
- setrya/examples/support_search/client.py +78 -0
- setrya/git_refs.py +23 -0
- setrya/integrations/__init__.py +1 -0
- setrya/integrations/celery.py +97 -0
- setrya/integrations/langchain.py +83 -0
- setrya/local_cache.py +143 -0
- setrya/offboarding/__init__.py +1 -0
- setrya/offboarding/cli.py +74 -0
- setrya/offboarding/gate.py +202 -0
- setrya/offboarding/inputs.py +86 -0
- setrya/offboarding/observer.py +47 -0
- setrya/offboarding/receipt-v1.schema.json +300 -0
- setrya/offboarding/receipt.py +264 -0
- setrya/offboarding/receipt_cli.py +197 -0
- setrya/offboarding/receipt_schema.py +65 -0
- setrya/offboarding/reference.py +243 -0
- setrya/offboarding/signature.py +68 -0
- setrya/pytest_plugin.py +82 -0
- setrya/qualification.py +412 -0
- setrya/recorder.py +163 -0
- setrya/review.py +119 -0
- setrya/review_scenarios.py +157 -0
- setrya/run_pr.py +168 -0
- setrya/runner.py +184 -0
- setrya/scenario_fixture.py +127 -0
- setrya/scenario_order.py +268 -0
- setrya/scenarios.py +509 -0
- setrya/status.py +22 -0
- setrya/store_signals.py +56 -0
- setrya-0.12.1.dist-info/METADATA +221 -0
- setrya-0.12.1.dist-info/RECORD +98 -0
- setrya-0.12.1.dist-info/WHEEL +5 -0
- setrya-0.12.1.dist-info/entry_points.txt +2 -0
- setrya-0.12.1.dist-info/licenses/LICENSE +202 -0
- setrya-0.12.1.dist-info/top_level.txt +1 -0
setrya/__init__.py
ADDED
setrya/__main__.py
ADDED
setrya/adapter.py
ADDED
|
@@ -0,0 +1,84 @@
|
|
|
1
|
+
"""Public adapter contract for disposable search environments."""
|
|
2
|
+
|
|
3
|
+
from dataclasses import dataclass
|
|
4
|
+
from pathlib import Path
|
|
5
|
+
from typing import Protocol
|
|
6
|
+
|
|
7
|
+
from .drill import Drill, Probe
|
|
8
|
+
|
|
9
|
+
|
|
10
|
+
@dataclass(frozen=True)
|
|
11
|
+
class RunContext:
|
|
12
|
+
run_id: str
|
|
13
|
+
directory: Path
|
|
14
|
+
drill: Drill
|
|
15
|
+
scenario_kind: str | None = None
|
|
16
|
+
|
|
17
|
+
|
|
18
|
+
@dataclass(frozen=True)
|
|
19
|
+
class Checkpoint:
|
|
20
|
+
run_id: str
|
|
21
|
+
attempt: str
|
|
22
|
+
document: str
|
|
23
|
+
revision: str
|
|
24
|
+
name: str
|
|
25
|
+
|
|
26
|
+
|
|
27
|
+
@dataclass(frozen=True)
|
|
28
|
+
class Publication:
|
|
29
|
+
run_id: str
|
|
30
|
+
document: str
|
|
31
|
+
revision: str
|
|
32
|
+
|
|
33
|
+
|
|
34
|
+
@dataclass(frozen=True)
|
|
35
|
+
class Receipt:
|
|
36
|
+
run_id: str
|
|
37
|
+
attempt: str
|
|
38
|
+
document: str
|
|
39
|
+
revision: str
|
|
40
|
+
outcome: str
|
|
41
|
+
generation: str | None = None
|
|
42
|
+
commit: int | None = None
|
|
43
|
+
|
|
44
|
+
|
|
45
|
+
@dataclass(frozen=True)
|
|
46
|
+
class Refresh:
|
|
47
|
+
"""A completed backend refresh on the read path following the exact write."""
|
|
48
|
+
run_id: str
|
|
49
|
+
attempt: str
|
|
50
|
+
generation: str
|
|
51
|
+
route: str
|
|
52
|
+
scope: str
|
|
53
|
+
|
|
54
|
+
|
|
55
|
+
@dataclass(frozen=True)
|
|
56
|
+
class ReadView:
|
|
57
|
+
generation: str
|
|
58
|
+
commit: int
|
|
59
|
+
route: str
|
|
60
|
+
scope: str
|
|
61
|
+
|
|
62
|
+
|
|
63
|
+
@dataclass(frozen=True)
|
|
64
|
+
class SearchResult:
|
|
65
|
+
# Ordered, top-k passage markers. None represents an unidentified result.
|
|
66
|
+
passages: tuple[str | None, ...]
|
|
67
|
+
view: ReadView | None = None
|
|
68
|
+
origins: tuple[str | None, ...] | None = None
|
|
69
|
+
# The actual retrieval route and caller, even when no watermark is available.
|
|
70
|
+
route: str | None = None
|
|
71
|
+
scope: str | None = None
|
|
72
|
+
|
|
73
|
+
|
|
74
|
+
class Adapter(Protocol):
|
|
75
|
+
"""All methods return promptly. Pollable observations return None while unavailable."""
|
|
76
|
+
|
|
77
|
+
def seed(self) -> None: ...
|
|
78
|
+
def start_old(self) -> str: ...
|
|
79
|
+
def checkpoint(self) -> Checkpoint | None: ...
|
|
80
|
+
def publish(self) -> Publication | None: ...
|
|
81
|
+
def search(self, probe: Probe) -> SearchResult: ...
|
|
82
|
+
def release(self) -> None: ...
|
|
83
|
+
def receipt(self) -> Receipt | None: ...
|
|
84
|
+
def close(self) -> None: ...
|
setrya/cache_metrics.py
ADDED
|
@@ -0,0 +1,137 @@
|
|
|
1
|
+
"""Process-local counters for answer-cache requests, verification and worker outcomes."""
|
|
2
|
+
|
|
3
|
+
from collections import Counter
|
|
4
|
+
from contextlib import contextmanager
|
|
5
|
+
from dataclasses import asdict, dataclass
|
|
6
|
+
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
|
7
|
+
from threading import Lock, Thread
|
|
8
|
+
|
|
9
|
+
|
|
10
|
+
@dataclass(frozen=True)
|
|
11
|
+
class CacheCounts:
|
|
12
|
+
requests: int = 0
|
|
13
|
+
hits: int = 0
|
|
14
|
+
misses: int = 0
|
|
15
|
+
checked: int = 0
|
|
16
|
+
stale_serves: int = 0
|
|
17
|
+
rejected_fills: int = 0
|
|
18
|
+
skipped_generations: int = 0
|
|
19
|
+
measured_generations: int = 0
|
|
20
|
+
|
|
21
|
+
@property
|
|
22
|
+
def unverified(self) -> int:
|
|
23
|
+
return self.requests - self.checked
|
|
24
|
+
|
|
25
|
+
@property
|
|
26
|
+
def hit_rate(self) -> float | None:
|
|
27
|
+
lookups = self.hits + self.misses
|
|
28
|
+
return self.hits / lookups if lookups else None
|
|
29
|
+
|
|
30
|
+
def summary(self) -> str:
|
|
31
|
+
rate = self.hit_rate
|
|
32
|
+
hit_rate = "unmeasured" if rate is None else f"{rate:.1%}"
|
|
33
|
+
return "\n".join((
|
|
34
|
+
f"{self.stale_serves} stale answers in {self.checked} checked requests "
|
|
35
|
+
f"({self.unverified} unverified).",
|
|
36
|
+
f"Cache lookups: {self.hits} hits, {self.misses} misses, "
|
|
37
|
+
f"{self.requests - self.hits - self.misses} unknown. Hit rate {hit_rate}.",
|
|
38
|
+
f"Generation skipped on {self.skipped_generations} of {self.measured_generations} "
|
|
39
|
+
f"measured requests ({self.requests - self.measured_generations} unmeasured).",
|
|
40
|
+
f"Rejected late fills: {self.rejected_fills}.",
|
|
41
|
+
))
|
|
42
|
+
|
|
43
|
+
|
|
44
|
+
class CacheMetrics:
|
|
45
|
+
"""Increment once per observed request or confirmed rejected worker fill."""
|
|
46
|
+
|
|
47
|
+
def __init__(self):
|
|
48
|
+
self._lock = Lock()
|
|
49
|
+
self._counts = Counter()
|
|
50
|
+
|
|
51
|
+
def observe_request(self, *, hit: bool | None, stale: bool | None,
|
|
52
|
+
generation_skipped: bool | None = None) -> None:
|
|
53
|
+
"""Use None for each signal that the instrumented path could not establish.
|
|
54
|
+
|
|
55
|
+
stale=False requires a freshness check. generation_skipped=True requires a
|
|
56
|
+
served cache hit whose execution path actually bypassed answer generation.
|
|
57
|
+
"""
|
|
58
|
+
if any(value is not None and type(value) is not bool for value in (hit, stale, generation_skipped)):
|
|
59
|
+
raise ValueError("request signals must be True, False or None")
|
|
60
|
+
if generation_skipped is True and hit is not True:
|
|
61
|
+
raise ValueError("a skipped generation must come from a confirmed cache hit")
|
|
62
|
+
with self._lock:
|
|
63
|
+
self._counts["requests"] += 1
|
|
64
|
+
self._counts["hits"] += hit is True
|
|
65
|
+
self._counts["misses"] += hit is False
|
|
66
|
+
self._counts["checked"] += stale is not None
|
|
67
|
+
self._counts["stale_serves"] += stale is True
|
|
68
|
+
self._counts["measured_generations"] += generation_skipped is not None
|
|
69
|
+
self._counts["skipped_generations"] += generation_skipped is True
|
|
70
|
+
|
|
71
|
+
def rejected_fill(self) -> None:
|
|
72
|
+
"""Call once when the application confirms that it rejected a late write."""
|
|
73
|
+
with self._lock:
|
|
74
|
+
self._counts["rejected_fills"] += 1
|
|
75
|
+
|
|
76
|
+
def snapshot(self) -> CacheCounts:
|
|
77
|
+
with self._lock:
|
|
78
|
+
return CacheCounts(**self._counts)
|
|
79
|
+
|
|
80
|
+
@classmethod
|
|
81
|
+
def combine(cls, snapshots):
|
|
82
|
+
"""Sum counts from disjoint observations, such as distinct saved runs."""
|
|
83
|
+
combined = cls()
|
|
84
|
+
for counts in snapshots:
|
|
85
|
+
combined._counts.update(asdict(counts))
|
|
86
|
+
return combined
|
|
87
|
+
|
|
88
|
+
def prometheus(self) -> str:
|
|
89
|
+
"""Render Prometheus text exposition with bounded, aggregate series."""
|
|
90
|
+
counts = self.snapshot()
|
|
91
|
+
lines = []
|
|
92
|
+
for name, help_text, value in (
|
|
93
|
+
("requests", "Answer requests observed.", counts.requests),
|
|
94
|
+
("hits", "Observed requests served from cache.", counts.hits),
|
|
95
|
+
("misses", "Observed cache misses.", counts.misses),
|
|
96
|
+
("checked_requests", "Requests checked for stale answers, including violations.", counts.checked),
|
|
97
|
+
("stale_serves", "Checked requests that served a stale answer.", counts.stale_serves),
|
|
98
|
+
("unverified_requests", "Requests without a conclusive freshness check.", counts.unverified),
|
|
99
|
+
("rejected_fills", "Confirmed rejections of late writes.", counts.rejected_fills),
|
|
100
|
+
("skipped_generations", "Measured requests that served a hit and skipped generation.",
|
|
101
|
+
counts.skipped_generations),
|
|
102
|
+
("measured_generations", "Requests with a known generation decision.", counts.measured_generations),
|
|
103
|
+
):
|
|
104
|
+
metric = f"setrya_cache_{name}_total"
|
|
105
|
+
lines.extend((f"# HELP {metric} {help_text}", f"# TYPE {metric} counter", f"{metric} {value}"))
|
|
106
|
+
return "\n".join(lines) + "\n"
|
|
107
|
+
|
|
108
|
+
|
|
109
|
+
@contextmanager
|
|
110
|
+
def serve_metrics(metrics: CacheMetrics, *, port: int = 0):
|
|
111
|
+
"""Serve a live GET /metrics endpoint on IPv4 loopback for the context's lifetime."""
|
|
112
|
+
if type(port) is not int or not 0 <= port <= 65535:
|
|
113
|
+
raise ValueError("use a local metrics port from 0 to 65535")
|
|
114
|
+
|
|
115
|
+
class Handler(BaseHTTPRequestHandler):
|
|
116
|
+
def do_GET(self):
|
|
117
|
+
if self.path != "/metrics":
|
|
118
|
+
self.send_error(404)
|
|
119
|
+
return
|
|
120
|
+
payload = metrics.prometheus().encode("utf-8")
|
|
121
|
+
self.send_response(200)
|
|
122
|
+
self.send_header("Content-Type", "text/plain; version=0.0.4; charset=utf-8")
|
|
123
|
+
self.send_header("Content-Length", str(len(payload)))
|
|
124
|
+
self.end_headers()
|
|
125
|
+
self.wfile.write(payload)
|
|
126
|
+
|
|
127
|
+
def log_message(self, format, *args):
|
|
128
|
+
pass
|
|
129
|
+
|
|
130
|
+
with ThreadingHTTPServer(("127.0.0.1", port), Handler) as server:
|
|
131
|
+
thread = Thread(target=server.serve_forever, kwargs={"poll_interval": 0.05}, daemon=True)
|
|
132
|
+
thread.start()
|
|
133
|
+
try:
|
|
134
|
+
yield f"http://127.0.0.1:{server.server_port}/metrics"
|
|
135
|
+
finally:
|
|
136
|
+
server.shutdown()
|
|
137
|
+
thread.join()
|
setrya/checker.py
ADDED
|
@@ -0,0 +1,202 @@
|
|
|
1
|
+
"""Evaluate recorded observations. This module has no fixture or adapter imports."""
|
|
2
|
+
|
|
3
|
+
from dataclasses import dataclass
|
|
4
|
+
from .status import Status
|
|
5
|
+
|
|
6
|
+
from .evidence import Report, establishes_baseline, matches_search, observed_change
|
|
7
|
+
|
|
8
|
+
NS_PER_MS = 1_000_000
|
|
9
|
+
|
|
10
|
+
|
|
11
|
+
@dataclass(frozen=True)
|
|
12
|
+
class Verdict:
|
|
13
|
+
status: Status
|
|
14
|
+
detail: str
|
|
15
|
+
event: int | None = None
|
|
16
|
+
probe: str | None = None
|
|
17
|
+
attribution: str | None = None
|
|
18
|
+
confirmed: tuple[int, ...] = ()
|
|
19
|
+
evidence_tier: str | None = None
|
|
20
|
+
|
|
21
|
+
|
|
22
|
+
def _matches(event: dict | None, identity: dict) -> bool:
|
|
23
|
+
return event is not None and all(event[key] == value for key, value in identity.items())
|
|
24
|
+
|
|
25
|
+
|
|
26
|
+
def _visible(view: dict | None, receipt: dict, probe) -> bool:
|
|
27
|
+
if view is None or receipt["commit"] is None:
|
|
28
|
+
return False
|
|
29
|
+
return (
|
|
30
|
+
view["generation"] == receipt["generation"] and view["commit"] >= receipt["commit"]
|
|
31
|
+
and view["route"] == probe.route and view["scope"] == probe.scope
|
|
32
|
+
)
|
|
33
|
+
|
|
34
|
+
|
|
35
|
+
def _write_resolved(event: dict, receipt: dict | None, probe, refreshes) -> bool:
|
|
36
|
+
if receipt is None:
|
|
37
|
+
return False
|
|
38
|
+
if receipt["outcome"] == "rejected":
|
|
39
|
+
return event["seq"] > receipt["seq"] and event["started_ns"] >= receipt["ns"]
|
|
40
|
+
refresh = refreshes.get((probe.route, probe.scope))
|
|
41
|
+
return _visible(event["view"], receipt, probe) or (
|
|
42
|
+
event["view"] is None and refresh is not None
|
|
43
|
+
and event["seq"] > refresh["seq"] and event["started_ns"] >= refresh["ns"]
|
|
44
|
+
)
|
|
45
|
+
|
|
46
|
+
|
|
47
|
+
def _attribution(event: dict, rank: int, release: dict | None, receipt: dict | None, probe) -> str:
|
|
48
|
+
if release is None or event["seq"] < release["seq"]:
|
|
49
|
+
return "Observed while the old worker was held"
|
|
50
|
+
if (receipt and receipt["outcome"] == "committed" and event["origins"][rank - 1] == receipt["attempt"]
|
|
51
|
+
and _visible(event["view"], receipt, probe)):
|
|
52
|
+
return f"Returned passage traces to old attempt {receipt['attempt']}"
|
|
53
|
+
return "The recorded search result establishes the violation. Its write origin is unverified."
|
|
54
|
+
|
|
55
|
+
|
|
56
|
+
def evaluate(report: Report) -> Verdict:
|
|
57
|
+
report.validate()
|
|
58
|
+
if report.schema == 1:
|
|
59
|
+
return Verdict(Status.NOT_TESTED, "Report schema 1 lacks current publication and caller evidence. Rerun the drill.")
|
|
60
|
+
verdict = _evaluate(report)
|
|
61
|
+
if verdict.status is not Status.FAIL:
|
|
62
|
+
error = next((event for event in report.events if event["kind"] == "adapter_error"), None)
|
|
63
|
+
if error:
|
|
64
|
+
detail = "The recorded test did not complete" if error["operation"] == "test" else "The adapter could not complete the drill"
|
|
65
|
+
return Verdict(Status.ERROR, detail, error["seq"])
|
|
66
|
+
return verdict
|
|
67
|
+
|
|
68
|
+
|
|
69
|
+
def _evaluate(report: Report) -> Verdict:
|
|
70
|
+
rules = report.rules
|
|
71
|
+
primary = next(probe for probe in rules.probes if probe.id == rules.freshness_probe)
|
|
72
|
+
if not any(event.get("stage") == "baseline" and event.get("probe_id") == primary.id
|
|
73
|
+
and establishes_baseline(event, primary, freshness=True) for event in report.events):
|
|
74
|
+
return Verdict(Status.NOT_TESTED, "Baseline search did not distinguish the original revision from its replacement",
|
|
75
|
+
probe=primary.id)
|
|
76
|
+
events = {event["kind"]: event for event in report.events if event["kind"] in {"started", "held", "published", "released", "receipt"}}
|
|
77
|
+
attempt = events.get("started", {}).get("attempt")
|
|
78
|
+
identity = {"run_id": report.run_id, "attempt": attempt, "document": rules.document,
|
|
79
|
+
"revision": rules.old_revision}
|
|
80
|
+
held = events.get("held")
|
|
81
|
+
if not _matches(held, {**identity, "name": rules.checkpoint}):
|
|
82
|
+
return Verdict(Status.NOT_TESTED, f"Missing checkpoint acknowledgment for {rules.checkpoint} and the old revision")
|
|
83
|
+
if held["ns"] - events["started"]["ns"] > rules.checkpoint_ms * NS_PER_MS:
|
|
84
|
+
return Verdict(Status.NOT_TESTED, "The checkpoint acknowledgment arrived after the declared deadline", held["seq"])
|
|
85
|
+
release = events.get("released")
|
|
86
|
+
release_valid = release is not None and release["attempt"] == attempt
|
|
87
|
+
receipt = events.get("receipt")
|
|
88
|
+
if not _matches(receipt, identity):
|
|
89
|
+
receipt = None
|
|
90
|
+
publication = events.get("published")
|
|
91
|
+
expected_publication = {"run_id": report.run_id, "document": rules.document, "revision": rules.new_revision}
|
|
92
|
+
if not publication or not _matches(publication["publication"], expected_publication):
|
|
93
|
+
return Verdict(Status.NOT_TESTED, f"Missing matching publication of revision {rules.new_revision} for {rules.document}",
|
|
94
|
+
probe=primary.id)
|
|
95
|
+
|
|
96
|
+
probes = {probe.id: probe for probe in rules.probes}
|
|
97
|
+
refreshes = {(event["route"], event["scope"]): event for event in report.events
|
|
98
|
+
if event["kind"] == "refreshed" and rules.visibility == "observed-after-refresh"}
|
|
99
|
+
first_fresh = None
|
|
100
|
+
last_pre_deadline = None
|
|
101
|
+
saw_freshness_probe = False
|
|
102
|
+
baseline = set()
|
|
103
|
+
latest_final = {}
|
|
104
|
+
cutoff = publication["ns"] + rules.freshness_ms * NS_PER_MS
|
|
105
|
+
final_cutoff = release["ns"] + rules.settle_ms * NS_PER_MS if release else None
|
|
106
|
+
|
|
107
|
+
timely_receipt = receipt if release_valid and receipt and receipt["ns"] <= final_cutoff else None
|
|
108
|
+
|
|
109
|
+
for event in report.events:
|
|
110
|
+
if event["kind"] != "probe":
|
|
111
|
+
continue
|
|
112
|
+
probe = probes[event["probe_id"]]
|
|
113
|
+
stage = event["stage"]
|
|
114
|
+
in_final_window = stage == "final" and release_valid and event["ns"] <= final_cutoff
|
|
115
|
+
if in_final_window and (event["route"], event["scope"]) == (probe.route, probe.scope):
|
|
116
|
+
latest_final[probe.id] = event
|
|
117
|
+
if not matches_search(event, probe):
|
|
118
|
+
continue
|
|
119
|
+
passages = event["passages"]
|
|
120
|
+
has_identity = None not in passages
|
|
121
|
+
required = observed_change(event, probe)
|
|
122
|
+
if stage == "baseline":
|
|
123
|
+
if establishes_baseline(event, probe, freshness=probe.id == primary.id):
|
|
124
|
+
baseline.add(probe.id)
|
|
125
|
+
continue
|
|
126
|
+
|
|
127
|
+
if probe.id == primary.id and stage == "freshness" and first_fresh is None:
|
|
128
|
+
saw_freshness_probe = True
|
|
129
|
+
covered_boundary = last_pre_deadline is not None and (
|
|
130
|
+
event["ns"] - last_pre_deadline <= rules.max_gap_ms * NS_PER_MS
|
|
131
|
+
)
|
|
132
|
+
observed_late = (required and event["ns"] > cutoff) or (
|
|
133
|
+
not required and has_identity and event["started_ns"] >= cutoff
|
|
134
|
+
)
|
|
135
|
+
if observed_late and covered_boundary:
|
|
136
|
+
return Verdict(Status.FAIL, f"New revision missed the {rules.freshness_ms} ms freshness deadline",
|
|
137
|
+
event["seq"], probe.id)
|
|
138
|
+
if not required and has_identity and event["ns"] < cutoff:
|
|
139
|
+
last_pre_deadline = event["ns"]
|
|
140
|
+
if required:
|
|
141
|
+
first_fresh = event
|
|
142
|
+
|
|
143
|
+
if first_fresh and (event is first_fresh or event["started_ns"] >= first_fresh["ns"]):
|
|
144
|
+
forbidden = next(((rank, marker) for rank, marker in enumerate(passages, 1)
|
|
145
|
+
if marker in probe.forbid), None)
|
|
146
|
+
if forbidden:
|
|
147
|
+
rank, marker = forbidden
|
|
148
|
+
return Verdict(Status.FAIL, f"Expected {', '.join(probe.require) or 'absence'}. Observed forbidden {marker} at rank {rank}.",
|
|
149
|
+
event["seq"], probe.id, _attribution(event, rank, release, receipt, probe))
|
|
150
|
+
|
|
151
|
+
if first_fresh and in_final_window and has_identity and not required and _write_resolved(event, timely_receipt, probe, refreshes):
|
|
152
|
+
missing = ", ".join(marker for marker in probe.require if marker not in passages)
|
|
153
|
+
return Verdict(Status.FAIL, f"Required passage {missing} was absent after the write was resolved",
|
|
154
|
+
event["seq"], probe.id)
|
|
155
|
+
|
|
156
|
+
if not saw_freshness_probe:
|
|
157
|
+
return Verdict(Status.NOT_TESTED, "Missing freshness observation on the declared route and caller before release",
|
|
158
|
+
probe=primary.id)
|
|
159
|
+
if first_fresh is None or first_fresh["ns"] > cutoff:
|
|
160
|
+
return Verdict(Status.NOT_TESTED, "Freshness deadline could not be evaluated from the sampled search responses",
|
|
161
|
+
probe=rules.freshness_probe)
|
|
162
|
+
missing_baseline = next((probe.id for probe in rules.probes if probe.before and probe.id not in baseline), None)
|
|
163
|
+
if missing_baseline:
|
|
164
|
+
return Verdict(Status.NOT_TESTED, "Baseline search did not establish the original passage", probe=missing_baseline)
|
|
165
|
+
if primary.absence:
|
|
166
|
+
for probe in rules.probes:
|
|
167
|
+
if probe == primary:
|
|
168
|
+
continue
|
|
169
|
+
checks = [event for event in report.events if event.get("stage") == "freshness"
|
|
170
|
+
and event.get("probe_id") == probe.id and event["seq"] > first_fresh["seq"]]
|
|
171
|
+
if not checks or not matches_search(checks[-1], probe) or None in checks[-1]["passages"] or not observed_change(checks[-1], probe):
|
|
172
|
+
return Verdict(Status.NOT_TESTED, "Missing retained control before releasing the old worker", probe=probe.id)
|
|
173
|
+
if not release_valid:
|
|
174
|
+
return Verdict(Status.NOT_TESTED, "Missing matching release of the held worker")
|
|
175
|
+
if receipt is None:
|
|
176
|
+
return Verdict(Status.NOT_TESTED, "Missing terminal receipt for the exact old write", probe=primary.id)
|
|
177
|
+
if timely_receipt is None:
|
|
178
|
+
return Verdict(Status.NOT_TESTED, "The terminal write receipt arrived after the settle deadline",
|
|
179
|
+
receipt["seq"], primary.id)
|
|
180
|
+
for probe in (primary, *(probe for probe in rules.probes if probe.id != primary.id)):
|
|
181
|
+
latest = latest_final.get(probe.id)
|
|
182
|
+
if latest is None:
|
|
183
|
+
return Verdict(Status.NOT_TESTED, "Missing final search observation on the declared route and caller", probe=probe.id)
|
|
184
|
+
if not matches_search(latest, probe):
|
|
185
|
+
return Verdict(Status.NOT_TESTED, "Final search view did not match the declared route and caller",
|
|
186
|
+
latest["seq"], probe.id)
|
|
187
|
+
if not _write_resolved(latest, receipt, probe, refreshes):
|
|
188
|
+
detail = ("Missing search visibility evidence for the old write" if receipt["outcome"] == "committed"
|
|
189
|
+
else "Missing a final search observation after the old write rejection")
|
|
190
|
+
return Verdict(Status.NOT_TESTED, detail, latest["seq"], probe.id)
|
|
191
|
+
if None in latest["passages"]:
|
|
192
|
+
return Verdict(Status.NOT_TESTED, "Final result lacked revision or passage identity", latest["seq"], probe.id)
|
|
193
|
+
decisive = latest_final[primary.id]
|
|
194
|
+
resolved = "Index rejected the old write" if receipt["outcome"] == "rejected" else "Search observed the completed write"
|
|
195
|
+
tier = "write-confirmed"
|
|
196
|
+
if receipt["outcome"] == "committed" and any(
|
|
197
|
+
not _visible(latest_final[p.id]["view"], receipt, p) for p in rules.probes):
|
|
198
|
+
tier = "observed-after-refresh"
|
|
199
|
+
resolved = "Observed after refresh (write visibility unverified)"
|
|
200
|
+
return Verdict(Status.PASS, f"{resolved}. All final probes found their required passages.",
|
|
201
|
+
decisive["seq"], decisive["probe_id"], confirmed=tuple(event["seq"] for event in latest_final.values()),
|
|
202
|
+
evidence_tier=tier)
|