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.
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 |
| 2 | all of these, so the two ways of running Foxray behave the same.""" |
| 3 | |
| 4 | import threading |
| 5 | from datetime import datetime, timedelta, timezone |
| 6 | |
| 7 | import pytest |
| 8 | |
| 9 | from foxray.core.sql import IssueQuery |
| 10 | from tests.helpers import Clock, auth_headers, close_thread_connections, envelope, make_event, make_stack |
| 11 | |
| 12 | UTC = timezone.utc |
| 13 | T0 = datetime(2026, 10, 1, 12, 0, 0, 123456, tzinfo=UTC) |
| 14 | |
| 15 | |
| 16 | def 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 | |
| 23 | def 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 | |
| 38 | def 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 | |
| 52 | def 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 | |
| 61 | def 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 | |
| 83 | def 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 | |
| 107 | def 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 | |
| 137 | def 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 | |
| 178 | def 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 | |
| 199 | def 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 | |
| 229 | def 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 | |
| 242 | def 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 | |
| 263 | def 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 | |
| 279 | def 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 | |
| 334 | def 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") |