--- title: "API Observability" description: "Real-time logs and analytics for every request through your gateway. Search, filter, and export — with consumer-level attribution and integrations into your existing stack." canonicalUrl: "https://zuplo.com/features/api-observability" sourceUrl: "https://zuplo.com/features/api-observability" pageType: "feature" generatedAt: "2026-09-04" --- # Know exactly what your APIs are doing > The worst way to learn your API is failing is a customer telling you. Watch > errors, latency, and traffic across your gateway in real time — with > per-consumer attribution — so you catch and fix problems before anyone > notices. ## Why this matters Most API problems aren't found in dashboards — they're reported by customers. API teams ship faster every quarter, but visibility into the gateway itself usually lags behind. The result: longer outages, blame ping-pong between teams, and a backlog of "we'll add metrics later." - **Slow MTTR** — Without span-level timing across policies, handlers, and origins, every incident is a manual tour through stack traces and grepped log lines. - **Black-box gateway** — Your handler logs show what your code did — but not which inbound policy rate limited, blocked, or quietly added 200ms before the request ever got there. - **No per-customer visibility** — When a customer reports a problem — or a single consumer is hammering your API — can you tell which one, on which endpoint, in a single click? - **Blind spots in AI traffic** — Token spend, prompt-injection blocks, and semantic-cache hits all happen at the gateway — completely invisible to your application APM. ## What you get Observability that pays for itself the first time it saves an incident. - **Resolve issues 10× faster** — Click from a P99 spike straight to the slow span. Logs, metrics, and (soon) traces in one place — with the API key, route, and policy chain already attached. - **Understand every customer** — Every log, metric, and trace is automatically tagged with the consumer that made the call. Find power users, abusers, and revenue drivers in a single query. - **Keep your existing stack** — 12 prebuilt destinations plus any OTLP-compatible collector. Forward to multiple at once, ship custom payload shapes in TypeScript — nothing to deploy alongside the gateway, no rewrites, no vendor lock-in. ## Logs — Stop hunting through stack traces Every request through your gateway lands here in real time — searchable, filterable, and exportable. Find the failing call in seconds, with severity, latency, status, and the API key that made it already attached. - Live log stream - Powerful search & filters - Per-request latency - Timeline histogram - Consumer attribution - Export & forward [Open Logs in Portal](https://portal.zuplo.com) · [View Logs docs](/docs/articles/logging) ## Analytics — Skip the dashboard build-out Track P50/P95/P99 latency, error rates, request volume, and per-customer traffic from day one — without standing up a separate metrics pipeline or a custom Grafana board. Hit your SLOs with statistical confidence and spot regressions before customers do. - Real-time request volume - Consumer breakdowns - P50 / P95 / P99 latency - Geographic distribution - Error rate trends - Custom time ranges [Open Analytics in Portal](https://portal.zuplo.com) · [View Analytics docs](/docs/articles/metrics-plugins) ## Integrations — Keep the observability stack you already use Forward logs, metrics, and traces to 12 prebuilt destinations or any OTLP-compatible collector — fan out to multiple at once, nothing to deploy alongside the gateway, and TypeScript hooks for any custom payload your team needs. - 9 logging plugins - 4 metrics plugins - OpenTelemetry tracing - Any OTLP HTTP collector - Multi-destination fan-out - Custom log shapes (TS) [Configure Integrations](https://portal.zuplo.com) · [View Integrations docs](/docs/articles/logging) ## The same observability for your AI traffic Zuplo's AI Gateway runs on the same policy pipeline as the API Gateway, so every LLM call shows up in your logs, metrics, and traces — alongside your REST traffic. Plus AI-specific signals you can't get from a generic APM: - **Token spend per project, model, and consumer** — with budget guardrails to stop runaway costs. - **Prompt-injection blocks and PII catches** — every guardrail event logged with the offending prompt. - **Time-to-first-byte and semantic-cache hit rates** — the latency signals that actually matter for LLM UX. - **Stream every call to Galileo, Comet Opik, or your own collector** — full request/response traces with token counts and latency. [Explore AI Gateway](/ai-gateway) · [Read the AI Gateway docs](https://zuplo.com/docs/ai-gateway/introduction) ## What makes Zuplo different Built for the way modern API teams actually work. Most observability stories stop at "we have integrations." Zuplo's stops at "we already wrote your data the way you need it." - **Programmable, not configured** — Custom log shapes, custom metric calculations, custom forwarding — all in plain TypeScript. Attach order IDs, tenant IDs, plan tier, or any business event to gateway telemetry without standing up a separate pipeline. - **Built into the gateway, not bolted on** — Observability runs inside the gateway runtime, not as a sidecar or daemon you maintain alongside it. Logs, metrics, and traces ship straight from the request to your destination across 300+ edge data centers — nothing to deploy, version, or keep in sync with the gateway release. - **Per-API-key by default** — Because Zuplo issues your API keys, every request is automatically attributed to its consumer — no instrumentation code, no manual tagging. Per-customer dashboards work on day one. - **One pipeline for every protocol** — REST, GraphQL, WebSockets, SOAP-over-HTTP, MCP servers, and AI Gateway calls all flow through the same observability stack. One story across your entire API surface. ## What teams use this for - **"My P99 just spiked. Where's the bottleneck?"** — Click the spike → in-portal trace → slowest span. Roughly 30 seconds from alert to root cause, without leaving Zuplo. - **"Which customer is hammering us right now?"** — Filter analytics by consumer. Top 10 by request count, error rate, or P95 latency — straight from the dashboard. - **"Are we approaching the LLM budget?"** — AI Gateway dashboards roll up token spend per project, model, and consumer — with budget guardrails to cut off runaway costs. - **"Did my last deploy regress anything?"** — Compare the same endpoint before and after a release. Latency distribution, error rate, and request volume side by side in seconds. ## Coming soon More observability is on the way. External API monitoring, threshold alerts, and breaking-change detection are all on the roadmap. Sign up to get early access the moment they ship. [See the public roadmap](/roadmap) ## FAQ **How do I monitor API traffic and performance?** Capture every request as a structured log line — caller identity, route, status, latency, errors — and ship it somewhere queryable. The cleanest place to do this is at the gateway, before traffic hits your origin, so you get one consistent log shape across every backend. Zuplo logs every request with consumer attribution, exposes a real-time analytics dashboard, and forwards the same data to Datadog, Splunk, New Relic, OpenTelemetry, or your custom HTTP endpoint. **Does Zuplo integrate with Datadog, Splunk, New Relic, or my SIEM?** Yes. First-party log plugins exist for Datadog, Splunk, New Relic, AWS CloudWatch, Google Cloud Logging, Grafana Loki, Sumo Logic, Dynatrace, and VMware Log Insight. Metrics and traces export via OpenTelemetry to any OTLP-compatible backend (Honeycomb, Jaeger, Tempo, etc.). You can also write a custom HTTP exporter for any tool not on the list. Multiple destinations can run at once — fan out the same data without duplicating policy code. **How do I track API usage per customer?** Every request through Zuplo is automatically attributed to the API key that made it, and through the key to the consumer record. You get per-customer usage in the built-in analytics dashboard, in forwarded logs, and in the customer-facing developer portal. Attach extra metadata to keys (plan, tenant, partner ID) and your reports become as granular as your business model. **How do I get distributed tracing for an API gateway?** Use OpenTelemetry. Zuplo's OTel plugin exports full request lifecycle traces — including each inbound policy, the handler, and outbound subrequests — to any OTLP HTTP collector. Combined with traces from your backend services, you get end-to-end visibility from the edge through your origin and out to dependent APIs. No sidecar to deploy, no agent to install. **How do I add custom fields to API logs?** Inside any TypeScript policy or handler, attach structured fields to the log context — order ID, tenant, feature flag, business event. Subsequent log lines in the same request inherit those fields, so you can correlate gateway logs with downstream events. Forward to your SIEM with the custom fields included; the schema in your dashboards stays clean. **How long does Zuplo keep request logs?** Request logs and traces are queryable in the Zuplo portal on every plan: Free includes live logs and traces (15 minutes), paid self-serve plans include 1 day, and Enterprise includes 3 days with custom retention available. Analytics history ranges from 1 day on Free to 7 days on paid self-serve plans and 30 days on Enterprise. For longer-term retention, forward logs to your own observability stack (Datadog, Splunk, Loki) where you control retention end-to-end. **Can I add API observability without deploying agents on my servers?** Yes. Because Zuplo runs as a managed gateway, the logging, metrics, and tracing plugins live inside the gateway runtime — not on your infrastructure. There's no sidecar, no daemon, no agent to install on your origin. Logs and metrics flow directly from the edge to your destination over HTTPS. You get full observability of your API traffic without touching your backend deployment. **What's the best API gateway for observability?** Look for: per-request structured logs with consumer attribution, OTel-native trace export, first-class integrations with major observability platforms, custom log shapes for proprietary tools, multi-destination fan-out, and a built-in analytics view for the people who don't have time to learn Splunk. Zuplo ships all of this; AccuWeather, BancoSol, and BlockDaemon use it as the source-of-truth log layer for their public APIs. ## Next steps - Talk to an API Expert: [/schedule-call](/schedule-call) - Start for Free: [https://portal.zuplo.com/signup](https://portal.zuplo.com/signup) - Open the Portal: [https://portal.zuplo.com](https://portal.zuplo.com) - Read the docs: [https://zuplo.com/docs/articles/logging](https://zuplo.com/docs/articles/logging)