One tool for a multi-stack team: error tracking across PHP, JS, Go and more
Multi-stack error tracking, done right: stop running a tool per language. One ingest contract across PHP, JS, Go and more means one dashboard, one on-call.
Build log
A day-by-day, commit-by-commit devlog of shipping a full observability platform — error tracking, watchers, dashboards, alerting, source maps, on-call, and mobile SDKs. The honest version, trade-offs and all.
Multi-stack error tracking, done right: stop running a tool per language. One ingest contract across PHP, JS, Go and more means one dashboard, one on-call.
Error tracking lock-in is real: proprietary agents and opaque SDKs trap your data. Here's why a plain HTTP/JSON ingest contract keeps you free to leave.
Most observability dashboards become wallpaper. Here's how to build ones that drive decisions — what to put on them, what to cut, and which widgets matter.
PII redaction for error tracking: how emails, tokens, and card numbers leak into stack traces — and how to scrub them before they're ever stored.
API error tracking is different: no error page, just JSON and status codes. Here's how to catch real 5xx failures in an API-only Laravel app.
Laravel security monitoring spots the credential-stuffing run and the privilege probe before they become a breach. Here's what to watch and how to alert on it.
Laravel mail monitoring catches silent failures — the password resets and receipts that never arrive. Get visibility into every send and failure.
Monitoring HTTP requests in Laravel catches the slow Stripe call and flaky APIs dragging your app down. See every outbound call's timing and errors.
Static thresholds miss the spikes that matter. Anomaly detection learns your app's normal and alerts on real deviations — before users feel them.
Minified JavaScript errors are unreadable. Learn how JavaScript source maps turn t.a is not a function back into the real file, function, and line.
Distributed tracing for PHP shows one request's whole journey across services. Learn traces, spans, and propagation — and how to see it end to end.
A PHP stack trace looks like a wall of noise. Here's how to read one top-down, separate your code from vendor frames, and get to the real cause fast.
On-call escalation without PagerDuty: lightweight tiers, delays, and acknowledgement so the right person wakes up — no heavy platform required.
Release tracking ties every production error to the deploy that introduced it, so you stop guessing which change broke things and spot regressions instantly.
Real User Monitoring for Laravel: measure actual Core Web Vitals (LCP, INP, CLS) from real visitors and find the slow pages your lab tests miss.
What is an SLO, in plain terms? A practical guide to SLOs, SLIs, and error budgets for small teams who want reliability without a 40-page runbook.
Uptime monitoring explained simply: what to check, how often, which signals matter, and how to get alerted the moment your app goes down — not after.
Laravel cron monitoring with heartbeats and missed-run detection, so a scheduled task that silently stops running pages you before anyone notices.
Laravel queue monitoring that catches silent failed jobs, growing backlogs, and stuck workers — so a broken queue pages you instead of your customers.
Laravel structured logging done right: swap scattered dd() and Log::info for contextual logs you can actually search, filter, and alert on in production.
Turn on request performance traces in Lookout and see where a slow Laravel page actually spends its time — Blade rendering, queries, and the rest — instead of guessing.
An error tracker that pings on every event trains you to ignore it. Here's how Lookout uses fingerprint grouping and threshold alerts so a real spike pages someone once — not a hundred times.
An honest, Laravel-focused comparison of Lookout, Sentry, and Flare across setup, framework depth, alert noise, pricing, and lock-in — so you can pick the one that fits how you ship.
Lookout flags N+1 queries in Laravel without any setup. Here's how to spot the flagged issue, read the repeated query, and fix it with eager loading — on the free tier.
Install lookout/tracing, run the installer, throw a test exception, and watch grouped errors, slow queries, and N+1s land in your dashboard — on the free tier, no credit card.
I was tired of finding production errors from customer emails and paying enterprise prices for noise. So I built an error tracker that installs in one line, groups the flood into issues, and wakes the right person — free to start.
Shipping Swift (iOS/macOS) and Kotlin (Android) crash-reporting SDKs against the same ingest contract, with server-side contract tests as the runnable proof.
A deep dive on building native on-call escalation in Laravel — the incident state machine, a per-minute scheduler that advances tiers, repeat-until-acknowledged, incident dedup, and stopping escalation with a signed URL.
Adding PagerDuty and Opsgenie as alert channels with severity mapping and incident deduplication, so Lookout can actually page the on-call engineer.
A deep dive on JavaScript symbolication — decoding Base64 VLQ mappings, the cumulative-vs-reset field rule, binary-searching segments by column, and matching minified frames to the right source map.
Building a custom dashboard feature for Lookout — a widget/query builder that composes 18 watcher sources into stats, time series, and breakdowns, with portable SQL and pure-CSS charts.
Catching problems no threshold was set for — z-score anomaly detection over error rate, latency, and throughput, wired into the alert engine.
Scrubbing personal data at ingest and pruning old events on a schedule — privacy controls that make an observability tool safe to point at production.
Defining service level objectives and tracking attainment, error budget, and burn rate from existing uptime checks and request traces.
Detecting error spikes and correlating them with release markers and affected traces, so an incident reads as a story instead of a list.
A deep dive on synthesizing a service/dependency graph from existing trace spans — extracting destinations per span op, portable JSON extraction across SQLite and MySQL, and collapsing spans into nodes and edges.
Turning auth, gate, and rate-limit signals into a Security dashboard — failed logins, denied authorizations, and HTTP 429s in one place.
Letting the dashboard control what the SDKs collect — turning signals on and off and tuning sample rates from the server, no redeploy required.
One ingest contract, many SDKs — porting the new auth and storage watchers to the Rails and WordPress clients, and fixing the Ruby 2.7 test suite.
Adding watchers for authentication events and filesystem access — tracking logins, logouts, failures, and file reads/writes as first-class signals.
A deep dive on Lookout's alert engine — the event catalogue, severity mapping, channels and subscriptions, the single notifier seam, and cache-based deduplication that makes adding a new alert a one-liner.
Building a super-admin area to support real users — org management, an audit log, plan overrides, and safe impersonation for debugging.
Adding a view.render span collector to the tracing SDK so Blade templates show up as traced operations — plus the 1.2.1 and 1.3.0 fixes it took to get right.
Tracking releases automatically by mirroring GitHub tags into Lookout, so every error can be tied to the version that shipped it.
Returning to Lookout after a long pause — re-reading my own code, a project-switcher polish, and how I got back up to speed fast.
Getting lookout/tracing to install cleanly from a split mirror repo — version constraints, stability flags, and the path-repo trick for local development.
Letting an ingest endpoint answer like an API instead of a web app — JSON errors, no redirects — so SDKs and curl get clean, predictable responses.
A deep dive on squashing migrations with php artisan schema:dump --prune in Laravel — how schema dumps work, why they speed up tests, and the cross-database SQLite gotcha.
A day of CI/CD pain — splitting SDK packages out to their own repos, fixing mirror push tokens, and auto-tagging main on every push so releases are boring.
Adding social login and SSO so nobody makes another password, project webhooks for outbound events, and GDPR-style data export — all in one day.
Why I'm building yet another error tracker, and the foundation that landed on day one — auth, organizations, projects, and an ingest API.