askrobots / foxray Public

Foxray: a light error tracker for the Sentry SDKs. Runs inside Django (the admin is the UI) or on its own; SQLite or Postgres, nothing else. Not affiliated with Sentry.

0 downloads

foxray/tests/test_store_contract.py
Download zip
Clone
Clone with git
git clone https://gitstable.com/git/askrobots/foxray.git
HTTPS
https://gitstable.com/git/askrobots/foxray.git
SSH
ssh://git@gitstable.com:2222/askrobots/foxray.git

Cloning needs no sign-in. Pushing over HTTPS asks for your username and an access token. SSH needs your key under SSH keys.

danq9 0.1.2: the first PyPI release (v0.1.1 is already tagged at 05cc354, before the PyPI metadata) 58507e3 4 weeks ago History
test_store_contract.py · 17.1 KB · 338 lines
1"""The storage contract. Every store (SQLite, Postgres, Django) must pass
2all of these, so the two ways of running Foxray behave the same."""
3
4import threading
5from datetime import datetime, timedelta, timezone
6
7import pytest
8
9from foxray.core.sql import IssueQuery
10from tests.helpers import Clock, auth_headers, close_thread_connections, envelope, make_event, make_stack
11
12UTC = timezone.utc
13T0 = datetime(2026, 10, 1, 12, 0, 0, 123456, tzinfo=UTC)
14
15
16def new_issue(store, project, fp="fp1", now=T0, **kw):
17 args = dict(title="ValueError: boom", culprit="app.views in index", level="error", platform="python",
18 environment="production", release="1.0", now=now)
19 args.update(kw)
20 return store.insert_issue_if_new(project.id, fp, **args)
21
22
23def test_projects(store):
24 p = store.create_project("web", now=T0, rate_limit=10)
25 assert len(p.public_key) == 32
26 got = store.get_project(p.id)
27 assert got == p and got.created_at == T0 and got.alert_new is True and got.filter_js_noise is False
28 store.update_project(p.id, alert_min_level="warning", filter_js_noise=True, sample_after=None)
29 got = store.get_project(p.id)
30 assert got.alert_min_level == "warning" and got.filter_js_noise is True
31 assert store.get_project_by_name("web").id == p.id
32 assert store.get_project("nope") is None and store.get_project(99999) is None
33 assert [x.name for x in store.list_projects()][-1] == "web"
34 with pytest.raises(ValueError):
35 store.update_project(p.id, bogus=1)
36
37
38def test_issue_insert_lock_repeat(store):
39 p = store.create_project("web")
40 issue = new_issue(store, p)
41 assert issue.times_seen == 1 and issue.status == "unresolved" and issue.first_seen == T0
42 assert new_issue(store, p) is None # already there
43 with store.atomic():
44 cur = store.lock_issue(p.id, "fp1")
45 t1 = T0 + timedelta(minutes=5)
46 again = store.record_repeat(cur.id, now=t1, title="ValueError: boom 2", culprit="c", level="fatal",
47 environment="staging", release="1.1", status="unresolved")
48 assert again.times_seen == 2 and again.last_seen == t1 and again.first_seen == T0
49 assert (again.level, again.last_environment, again.last_release) == ("fatal", "staging", "1.1")
50
51
52def test_datetimes_round_trip_aware_and_exact(store):
53 p = store.create_project("web", now=T0)
54 issue = new_issue(store, p, now=T0)
55 got = store.get_issue(issue.id)
56 assert got.first_seen == T0 and got.first_seen.tzinfo is not None
57 store.update_issue(issue.id, ignore_until=T0 + timedelta(days=1, microseconds=1))
58 assert store.get_issue(issue.id).ignore_until == T0 + timedelta(days=1, microseconds=1)
59
60
61def test_counters_are_atomic_under_threads(store):
62 p = store.create_project("web")
63 seen = []
64 lock = threading.Lock()
65
66 def work():
67 try:
68 for _ in range(25):
69 n = store.hit_rate(p.id, 1000)
70 store.bump_counter(p.id, "2026-10-01", "dropped:session")
71 with lock:
72 seen.append(n)
73 finally:
74 close_thread_connections()
75 threads = [threading.Thread(target=work) for _ in range(6)]
76 [t.start() for t in threads]
77 [t.join() for t in threads]
78 assert sorted(seen) == list(range(1, 151))
79 assert store.counters(p.id) == [(p.id, "2026-10-01", "dropped:session", 150)]
80 assert store.hit_rate(p.id, 1001) == 1
81
82
83def test_concurrent_ingest_groups_into_one_issue(store):
84 p = store.create_project("web")
85 ing, *_ = make_stack(store, clock=Clock())
86 errors = []
87
88 def work():
89 try:
90 for _ in range(5):
91 r = ing.handle(p.id, "envelope", auth_headers(p), {}, envelope(({"type": "event"}, make_event())))
92 assert r.status == 200, r.body
93 except Exception as exc: # noqa: BLE001
94 errors.append(exc)
95 finally:
96 close_thread_connections()
97 threads = [threading.Thread(target=work) for _ in range(5)]
98 [t.start() for t in threads]
99 [t.join() for t in threads]
100 assert not errors
101 issues, total = store.list_issues()
102 assert total == 1 and issues[0].times_seen == 25
103 assert store.count_events(issues[0].id) == 25
104 assert [a.kind for a in store.list_alerts()] == ["new_issue"]
105
106
107def test_events_users_tags_days(store):
108 p = store.create_project("web")
109 issue = new_issue(store, p)
110 eid = "a" * 32
111 row = store.insert_event(project_id=p.id, issue_id=issue.id, event_id=eid, received_at=T0, occurred_at=T0,
112 level="error", title="t", environment="production", release="1.0", user_key="u1",
113 data={"event_id": eid, "message": "hi"})
114 assert row is not None
115 assert store.insert_event(project_id=p.id, issue_id=issue.id, event_id=eid, received_at=T0, occurred_at=None,
116 level="error", title="t", environment="", release="", user_key="", data={}) is None
117 ev = store.latest_event(issue.id)
118 assert ev.payload["message"] == "hi" and ev.received_at == T0
119 assert store.get_event(ev.id).event_id == eid and store.find_event(p.id, eid).id == ev.id
120 assert [e.id for e in store.list_events(issue.id)] == [ev.id]
121 assert store.add_issue_user(issue.id, "u1") is True
122 assert store.add_issue_user(issue.id, "u1") is False
123 assert store.add_issue_user(issue.id, "u2") is True
124 assert store.get_issue(issue.id).users_seen == 2
125 for env in ("production", "production", "staging"):
126 store.bump_issue_tag(issue.id, "environment", env, T0)
127 assert store.issue_tags(issue.id) == {"environment": [("production", 2), ("staging", 1)]}
128 assert store.tag_values("environment") == ["production", "staging"]
129 assert store.tag_values("environment", project_id=p.id + 1000) == []
130 assert store.bump_issue_day(issue.id, p.id, "2026-10-01") == 1
131 assert store.bump_issue_day(issue.id, p.id, "2026-10-01") == 2
132 store.bump_issue_day(issue.id, p.id, "2026-10-02", n=5)
133 assert store.issue_days(issue.id) == [("2026-10-01", 2), ("2026-10-02", 5)]
134 assert store.issue_days(issue.id, since_day="2026-10-02") == [("2026-10-02", 5)]
135
136
137def test_issue_list_filters_sorts_and_pages(store):
138 p = store.create_project("web")
139 q = store.create_project("other")
140 a = new_issue(store, p, "a", title="KeyError: 'user'", culprit="app.auth in login", now=T0)
141 b = new_issue(store, p, "b", title="Timeout 100% reached", culprit="jobs in run", level="warning",
142 now=T0 + timedelta(days=1))
143 c = new_issue(store, p, "c", title="ZeroDivisionError", culprit="app.math", now=T0 + timedelta(days=2))
144 new_issue(store, q, "a", now=T0)
145 store.update_issue(a.id, times_seen=50, users_seen=1)
146 store.update_issue(b.id, times_seen=5, users_seen=9)
147 store.bump_issue_tag(a.id, "environment", "production", T0)
148 store.bump_issue_tag(b.id, "environment", "staging", T0)
149 store.bump_issue_tag(b.id, "release", "2.0", T0)
150 store.set_issue_status(c.id, "resolved", now=T0)
151
152 def titles(**kw):
153 issues, total = store.list_issues(IssueQuery(project_id=p.id, **kw))
154 return [i.title.split(":")[0].split(" ")[0] for i in issues], total
155
156 assert titles() == (["Timeout", "KeyError"], 2)
157 assert titles(status="all")[0] == ["ZeroDivisionError", "Timeout", "KeyError"]
158 assert titles(status="resolved")[0] == ["ZeroDivisionError"]
159 assert titles(level="warning")[0] == ["Timeout"]
160 assert titles(environment="production")[0] == ["KeyError"]
161 assert titles(release="2.0")[0] == ["Timeout"]
162 assert titles(text="login")[0] == ["KeyError"] # culprit
163 assert titles(text="KEYERROR")[0] == ["KeyError"] # case-insensitive
164 assert titles(text="100%")[0] == ["Timeout"] # % is literal
165 assert titles(text="%")[0] == ["Timeout"]
166 assert titles(text="_")[0] == []
167 assert titles(sort="count")[0] == ["KeyError", "Timeout"]
168 assert titles(sort="users")[0] == ["Timeout", "KeyError"]
169 assert titles(sort="first_seen")[0] == ["Timeout", "KeyError"]
170 assert titles(status="all", first_seen_from=T0 + timedelta(hours=1))[0] == ["ZeroDivisionError", "Timeout"]
171 assert titles(status="all", first_seen_to=T0 + timedelta(hours=1))[0] == ["KeyError"]
172 assert titles(status="all", last_seen_from=T0 + timedelta(days=2))[0] == ["ZeroDivisionError"]
173 assert titles(status="all", last_seen_to=T0 + timedelta(days=1, hours=1))[0] == ["Timeout", "KeyError"]
174 assert titles(status="all", limit=1, offset=1) == (["Timeout"], 3)
175 assert store.list_issues(IssueQuery(status="all"))[1] == 4
176
177
178def test_issue_status_changes(store):
179 p = store.create_project("web")
180 issue = new_issue(store, p)
181 store.update_issue(issue.id, times_seen=10)
182 store.set_issue_status(issue.id, "resolved", now=T0)
183 got = store.get_issue(issue.id)
184 assert got.status == "resolved" and got.resolved_at == T0
185 store.set_issue_status(issue.id, "ignored", now=T0, ignore_more=5)
186 got = store.get_issue(issue.id)
187 assert got.status == "ignored" and got.ignore_until_count == 15
188 until = T0 + timedelta(days=3)
189 store.set_issue_status(issue.id, "ignored", now=T0, ignore_until=until)
190 got = store.get_issue(issue.id)
191 assert got.ignore_until == until and got.ignore_until_count is None
192 store.set_issue_status(issue.id, "unresolved", now=T0)
193 got = store.get_issue(issue.id)
194 assert got.status == "unresolved" and got.ignore_until is None and got.resolved_at is None
195 with pytest.raises(ValueError):
196 store.set_issue_status(issue.id, "deleted", now=T0)
197
198
199def test_monitors_and_checkins(store):
200 p = store.create_project("web")
201 store.insert_monitor(p.id, "job", T0)
202 store.insert_monitor(p.id, "job", T0) # idempotent
203 m = store.get_monitor(p.id, "job")
204 assert m.status == "new" and m.active and m.checkin_margin == 1 and m.max_runtime == 30
205 due = T0 + timedelta(hours=1)
206 store.update_monitor(m.id, schedule_type="crontab", schedule_value="0 * * * *", next_due_at=due)
207 assert store.get_monitor_by_id(m.id).next_due_at == due
208 assert store.due_monitors(T0) == []
209 assert [x.id for x in store.due_monitors(due + timedelta(seconds=1))] == [m.id]
210 later = due + timedelta(hours=1)
211 assert store.claim_missed(m.id, due + timedelta(seconds=1), later) is True
212 assert store.claim_missed(m.id, due + timedelta(seconds=1), later) is False
213 store.update_monitor(m.id, active=False)
214 assert store.due_monitors(later + timedelta(days=1)) == []
215 c = store.upsert_checkin(project_id=p.id, monitor_id=m.id, check_in_id="c" * 32, status="in_progress",
216 duration=None, environment="production", release="", now=T0)
217 assert c.status == "in_progress"
218 assert [x.id for x in store.in_progress_checkins()] == [c.id]
219 c2 = store.upsert_checkin(project_id=p.id, monitor_id=m.id, check_in_id="c" * 32, status="ok", duration=3.5,
220 environment="production", release="", now=T0 + timedelta(seconds=4))
221 assert c2.id == c.id and c2.status == "ok" and c2.duration == 3.5 and c2.received_at == T0
222 assert store.in_progress_checkins() == []
223 assert store.set_checkin_status_if(c.id, "in_progress", "timeout", T0) is False
224 assert store.set_checkin_status_if(c.id, "ok", "error", T0) is True
225 assert [x.status for x in store.list_checkins(m.id)] == ["error"]
226 assert [x.slug for x in store.list_monitors(p.id)] == ["job"]
227
228
229def test_filter_rules(store):
230 p = store.create_project("web")
231 r = store.add_filter(p.id, "exception", "Http404", note="noise")
232 store.add_filter(p.id, "environment", "development", enabled=False)
233 assert [f.kind for f in store.list_filters(p.id)] == ["exception", "environment"]
234 assert [f.id for f in store.list_filters(p.id, enabled_only=True)] == [r.id]
235 store.update_filter(r.id, is_regex=True, pattern="Http40[34]")
236 got = store.list_filters(p.id)[0]
237 assert got.is_regex is True and got.pattern == "Http40[34]"
238 store.delete_filter(r.id)
239 assert [f.kind for f in store.list_filters(p.id)] == ["environment"]
240
241
242def test_alert_outbox(store):
243 p = store.create_project("web")
244 aid = store.add_alert(project_id=p.id, kind="new_issue", channel="email", subject="s", body="b",
245 payload={"x": 1}, now=T0, issue_id=None)
246 store.add_alert(project_id=None, kind="store_full", channel="log", subject="s2", body="b2", payload={},
247 now=T0)
248 assert [a.id for a in store.due_alerts(T0)][0] == aid
249 retry = T0 + timedelta(minutes=1)
250 assert store.claim_alert(aid, T0, retry) is True
251 assert store.claim_alert(aid, T0, retry) is False # someone already has it
252 store.mark_alert_error(aid, "smtp down")
253 a = [x for x in store.list_alerts() if x.id == aid][0]
254 assert a.attempts == 1 and a.last_error == "smtp down" and a.next_attempt_at == retry
255 assert store.claim_alert(aid, retry, retry + timedelta(minutes=2)) is True
256 store.mark_alert_sent(aid, retry, "ok")
257 a = [x for x in store.list_alerts() if x.id == aid][0]
258 assert a.status == "sent" and a.sent_at == retry
259 assert store.pending_alert_count() == 1
260 assert [x.id for x in store.list_alerts(project_id=p.id)] == [aid]
261
262
263def test_leases_and_state(store):
264 assert store.try_lease("cleanup", T0, T0 + timedelta(minutes=5)) is True
265 assert store.try_lease("cleanup", T0, T0 + timedelta(minutes=5)) is False
266 store.finish_lease("cleanup", T0, '{"ok": 1}')
267 st = store.states()["cleanup"]
268 assert st.last_run_at == T0 and st.lease_until is None and st.value == '{"ok": 1}'
269 # due only when it last ran before the given time
270 assert store.try_lease("cleanup", T0, T0 + timedelta(minutes=5), ran_before=T0 - timedelta(minutes=1)) is False
271 assert store.try_lease("cleanup", T0, T0 + timedelta(minutes=5), ran_before=T0) is True
272 # an expired lease (a crashed holder) can be taken over
273 assert store.try_lease("cleanup", T0 + timedelta(minutes=6), T0 + timedelta(minutes=11)) is True
274 store.set_state_value("mode", "counts_only")
275 store.set_state_value("mode", "normal")
276 assert store.get_state_value("mode") == "normal" and store.get_state_value("missing", "d") == "d"
277
278
279def test_cleanup_primitives(store):
280 p = store.create_project("web")
281 issue = new_issue(store, p)
282 for i in range(10):
283 store.insert_event(project_id=p.id, issue_id=issue.id, event_id=f"{i:032x}",
284 received_at=T0 + timedelta(days=i), occurred_at=None, level="error", title="t",
285 environment="", release="", user_key="", data={"i": i})
286 assert store.delete_events_before(p.id, T0 + timedelta(days=3), limit=2) == 2
287 assert store.delete_events_before(p.id, T0 + timedelta(days=3), limit=2) == 1
288 assert store.count_events(issue.id) == 7
289 assert store.trim_issue_events(issue.id, keep=4, limit=100) == 3
290 assert sorted(e.payload["i"] for e in store.list_events(issue.id, 100)) == [6, 7, 8, 9]
291 assert store.delete_oldest_events(1) == 1
292 assert store.issues_seen_since(None, 10) == [(issue.id, T0)]
293 assert store.issues_seen_since(T0 + timedelta(seconds=1), 10) == []
294
295 store.bump_issue_day(issue.id, p.id, "2025-01-01")
296 store.bump_issue_day(issue.id, p.id, "2026-10-01")
297 assert store.delete_days_before("2026-01-01", 100) == 1
298 store.set_issue_status(issue.id, "resolved", now=T0)
299 assert store.stale_closed_issues(p.id, T0 + timedelta(days=1), 10) == [issue.id]
300 assert store.stale_closed_issues(p.id, T0, 10) == []
301 store.add_issue_user(issue.id, "u")
302 store.bump_issue_tag(issue.id, "environment", "x", T0)
303 removed = store.delete_issues([issue.id])
304 assert removed == {"events": 3, "issue_days": 1, "issues": 1}
305 counts = store.table_counts()
306 assert counts["foxray_issue_user"] == counts["foxray_issue_tag"] == counts["foxray_event"] == 0
307
308 store.insert_monitor(p.id, "m", T0)
309 m = store.get_monitor(p.id, "m")
310 for i in range(6):
311 store.upsert_checkin(project_id=p.id, monitor_id=m.id, check_in_id=f"{i:032x}", status="ok", duration=None,
312 environment="", release="", now=T0 + timedelta(days=i))
313 assert store.trim_checkins(m.id, T0 + timedelta(days=1), keep=3, limit=100) == 3
314 assert len(store.list_checkins(m.id)) == 3
315
316 store.add_alert(project_id=p.id, kind="k", channel="log", subject="", body="", payload={}, now=T0)
317 sent = store.add_alert(project_id=p.id, kind="k", channel="log", subject="", body="", payload={}, now=T0)
318 store.mark_alert_sent(sent, T0)
319 assert store.delete_alerts_before(T0, T0 + timedelta(seconds=1), 100) == 1 # the unsent one
320 assert store.delete_alerts_before(T0 + timedelta(seconds=1), T0, 100) == 1 # the sent one
321
322 store.hit_rate(p.id, 10)
323 store.hit_rate(p.id, 20)
324 assert store.delete_rate_before(15, 100) == 1
325 store.bump_counter(p.id, "2026-09-01", "x")
326 store.bump_counter(p.id, "2026-10-01", "x")
327 assert store.delete_counters_before("2026-09-30", 100) == 1
328
329 assert store.db_size() > 0 and store.free_bytes() >= 0
330 store.reclaim()
331 assert set(store.table_counts()) >= {"foxray_issue", "foxray_event", "foxray_alert", "foxray_state"}
332
333
334def test_implements_the_store_protocol(store):
335 from foxray.core.storage import Backend, Store
336 assert isinstance(store, Store)
337 assert isinstance(store.db, Backend)
338 assert store.dialect in ("sqlite", "postgres")