Response Time Analyzer

Latency is where applications lie. Uptime dashboards say everything is green while real users sit through three-second page loads because nobody is looking at the distribution of response times, only whether the server returned a 200. Response Time Analyzer reads request-time values straight out of your access logs and computes min, average, p95, p99 and max — with a configurable slow threshold for SLA breaches — so the tail of your latency curve stops hiding.

The parser understands three common formats without any configuration: nginx/apache’s trailing decimal-seconds token (the "0.087" that sits after the status and byte count), explicit duration=123ms or duration=45000us key-value pairs used by many app-server and load-balancer logs, and bare 123ms / 45us tokens anywhere in the line. Every value, regardless of source, is normalized to milliseconds before it enters the statistics, so you can mix formats in one paste (for example a proxy line and an upstream line for the same request) and still get one consistent set of numbers.

Averages lie about tail latency because a handful of very slow requests get diluted by thousands of fast ones. Percentiles do not: p95 tells you the response time that 95% of requests beat, and p99 tells you the number your slowest real users actually experience. Those two numbers are what most latency SLOs (service level objectives) are written against, which is why they are computed automatically rather than buried behind an option.

• Full statistics — count, min, average, p95, p99 and max computed in one pass, all in milliseconds.
• Automatic unit detection — nginx-style seconds, duration=ms, duration=us and bare ms/us tokens are all normalized without you picking a format.
• Configurable slow threshold — set the millisecond cutoff that defines "too slow" for your SLA and get an instant breach count.
• Per-line drilldown — every request over the threshold is listed with its exact latency, sorted slowest-first, so you can see the actual offending lines instead of just a count.
• Copyable report — the full stats block plus slow-request list is generated as plain text, ready to paste into a ticket, postmortem, or Slack thread.

1. Paste access log lines that contain a response time in any supported format — nginx request_time, duration=, or a raw ms/us token.
2. Set your slow threshold in milliseconds; this is the line an SLA or user-experience budget draws.
3. Click Analyze. The stat tiles (requests, avg, p95, slow count) update along with a full text report.
4. Copy the report to paste into an incident channel, PR description, or performance review doc.

Example 1 — SLO gate in a deploy pipeline. Paste the last hour of production logs after a release, set the threshold to your SLO (say 200ms), and read p95 straight off the stat tile — pass or fail in one click, no dashboard login required.

Example 2 — Hunting down slow requests. Set the threshold to 1000ms and the per-line drilldown lists every request that crawled, sorted by latency, so you can spot a pattern (same endpoint, same client, same time window) instead of guessing.

Example 3 — Proving a fix worked. Run the analyzer on a log window from before a performance fix and again on a window from after; compare avg and p95 side by side in the copied reports to show the improvement in a PR or postmortem.

Example 4 — Mixed-format logs. A request that passes through nginx (seconds) and then an app server that logs duration=ms can both be pasted together — the analyzer normalizes both to the same millisecond scale automatically.

• Latency truth, not averages — percentile-accurate stats reveal the tail that averages hide.
• Multi-format by default — nginx seconds, duration=, and ms/us tokens all work without configuration.
• SLA-ready — a configurable threshold turns raw logs into a pass/fail breach count instantly.
• Drilldown, not just numbers — see exactly which requests were slow, not just how many.
• Private by design — parsing happens entirely in your browser; logs are never uploaded anywhere.