Back to Blog
OpenTelemetryObservabilityNextjsTracingAPMDistributed-Systems

OpenTelemetry for Full-Stack Web Apps: Catching API Latency Before Users Complain

How to implement OpenTelemetry tracing across Next.js and Node.js microservices: diagnosing slow database queries, third-party API lag, and memory bottlenecks.

·5 min read·Fonda Digital Engineering

In modern decoupled web architectures, a single user click frequently initiates a complex cascade of distributed operations:

  1. The browser requests an e-commerce checkout page.
  2. The Next.js App Router renders the server component layout.
  3. The server queries an inventory microservice in Node.js.
  4. The inventory service executes three SQL queries against a PostgreSQL database.
  5. The checkout handler calls an external payment gateway API (Stripe, PayPal).
  6. A transactional email event is dispatched to an AWS SQS queue.

When a customer reports that the checkout “takes 4 seconds and sometimes crashes”, traditional logging is completely useless. The frontend logs show a 4-second total duration; the backend logs show 200 OK statuses; and the database logs show normal CPU usage.

Without distributed tracing, diagnosing multi-service performance bottlenecks is an exercise in blind guesswork.

In 2026, leading engineering organizations solve this with OpenTelemetry (OTel): the vendor-neutral Cloud Native Computing Foundation (CNCF) standard for end-to-end distributed tracing, metrics, and observability.

Below is our production implementation guide: detailing how to instrument Next.js App Router and Node.js microservices with OpenTelemetry, trace slow database queries, and visualize latency flame graphs before users complain.


1. The Anatomy of Distributed Tracing: Spans & Trace Context

To diagnose distributed latency, developers must understand the foundational primitives of OpenTelemetry:

[Trace: Single User Request (trace_id: 4bf92f3577b34da6a3ce929d0e0e4736)]
  │
  ├─ [Span 1: Next.js SSR Render] ────────────────────────────────────────── 420ms
  │    │
  │    ├─ [Span 2: fetch(/api/v1/pricing)] ─────────────────────────────── 310ms
  │    │    │
  │    │    ├─ [Span 3: PostgreSQL Query: SELECT price FROM products] ──── 180ms (BOTTLENECK!)
  │    │    └─ [Span 4: Redis Cache Check] ─────────────────────────────── 2ms
  │    │
  │    └─ [Span 5: Stripe API pre-auth] ────────────────────────────────── 95ms

A Trace represents the complete journey of a request across all services. Each individual operation inside that journey is a Span.

By passing the W3C Trace Context header (traceparent) across HTTP boundaries, OpenTelemetry stitches together logs, database queries, and API calls into an interconnected, chronological flame graph.

Aligning Traces with the 4 Golden Signals of SRE

OpenTelemetry distributed traces feed directly into Google Site Reliability Engineering (SRE) monitoring:

  1. Latency: Measuring the duration of every service hop, isolating slow database lookups from edge render times.
  2. Traffic: Quantifying real-time request volume across API routes and serverless functions.
  3. Errors: Recording HTTP 5xx failures, unhandled exceptions, and schema validation rejections with full stack traces.
  4. Saturation: Monitoring database connection pool limits and event-loop lag before thread exhaustion triggers outages.

2. Instrumenting Next.js 16 with OpenTelemetry

Next.js provides native support for OpenTelemetry instrumentation via the experimental instrumentation.ts convention:

// instrumentation.ts (Root of Next.js project)
export async function register() {
  if (process.env.NEXT_RUNTIME === 'nodejs') {
    const { NodeSDK } = await import('@opentelemetry/sdk-node');
    const { getNodeAutoInstrumentations } = await import('@opentelemetry/auto-instrumentations-node');
    const { OTLPTraceExporter } = await import('@opentelemetry/exporter-trace-otlp-http');
    const { Resource } = await import('@opentelemetry/resources');
    const { SemanticResourceAttributes } = await import('@opentelemetry/semantic-conventions');

    const sdk = new NodeSDK({
      resource: new Resource({
        [SemanticResourceAttributes.SERVICE_NAME]: 'fonda-frontend-nextjs',
        [SemanticResourceAttributes.SERVICE_VERSION]: '1.4.0',
        [SemanticResourceAttributes.DEPLOYMENT_ENVIRONMENT]: process.env.NODE_ENV,
      }),
      traceExporter: new OTLPTraceExporter({
        url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT || 'http://localhost:4318/v1/traces',
      }),
      instrumentations: [
        getNodeAutoInstrumentations({
          // Suppress noisy healthcheck pings
          '@opentelemetry/instrumentation-http': {
            ignoreIncomingRequestHook: (req) => req.url === '/api/health',
          },
        }),
      ],
    });

    sdk.start();
  }
}

Enable instrumentation in next.config.ts:

// next.config.ts
const nextConfig = {
  experimental: {
    instrumentationHook: true,
  },
};
export default nextConfig;

3. Creating Custom Application Spans & Context Propagation

While auto-instrumentation captures HTTP requests, capturing internal business logic requires manual span instrumentation:

// src/services/inventoryService.ts
import { trace, SpanStatusCode } from '@opentelemetry/api';

const tracer = trace.get_tracer('inventory-service');

export async function reserveWarehouseStock(orderId: string, sku: string, quantity: number) {
  // Start active span linked to parent HTTP trace
  return tracer.startActiveSpan('reserve_warehouse_stock', async (span) => {
    span.setAttribute('order.id', orderId);
    span.setAttribute('inventory.sku', sku);
    span.setAttribute('inventory.quantity', quantity);

    try {
      const startTime = performance.now();
      const allocationResult = await executeDbAllocation(sku, quantity);

      span.setAttribute('db.execution_time_ms', performance.now() - startTime);
      span.setStatus({ code: SpanStatusCode.OK });
      return allocationResult;
    } catch (error: any) {
      // Record exception trace in flame graph
      span.recordException(error);
      span.setStatus({
        code: SpanStatusCode.ERROR,
        message: error.message || 'Stock allocation failure',
      });
      throw error;
    } finally {
      span.end(); // End span duration
    }
  });
}

4. Sampling Strategies: Balancing Visibility and Cloud Costs

In high-traffic production environments processing millions of requests per day, sending 100% of spans to your telemetry backend generates massive storage bills.

We implement Head-Based Ratio Sampling combined with Tail-Based Error Retention:

// Sampling configuration in NodeSDK
import { ParentBasedSampler, TraceIdRatioBasedSampler } from '@opentelemetry/sdk-trace-base';

const sampler = new ParentBasedSampler({
  // Sample 10% of standard healthy traffic
  root: new TraceIdRatioBasedSampler(0.10),
});

In the OpenTelemetry Collector pipeline, a Tail-Based Sampling Processor ensures that any trace containing an HTTP 5xx error or a span latency exceeding 1,000ms is captured at 100% fidelity, regardless of the ratio sampler. You pay for 10% storage while retaining 100% visibility into critical production failures.


5. Hardening the OpenTelemetry Collector Pipeline

In enterprise production deployments, microservices do not transmit spans directly to storage backends. They transmit spans to a local or sidecar OpenTelemetry Collector:

# /etc/otelcol/config.yaml
receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318

processors:
  batch:
    timeout: 1s
    send_batch_size: 256
  memory_limiter:
    check_interval: 1s
    limit_percentage: 75
    spike_limit_percentage: 20

exporters:
  otlp/tempo:
    endpoint: tempo.internal:4317
    tls:
      insecure: true
  prometheus:
    endpoint: 0.0.0.0:8889

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [memory_limiter, batch]
      exporters: [otlp/tempo]

Automated Alerting on p95 API Latency Degradation

Pairing OpenTelemetry metrics with Prometheus Alertmanager allows operations teams to catch slow queries before users report outages:

# /etc/prometheus/alerts/api_latency.rules.yml
groups:
  - name: api_latency_alerts
    rules:
      - alert: HighAPILatencyWarning
        expr: histogram_quantile(0.95, sum(rate(http_server_duration_milliseconds_bucket[5m])) by (le)) > 450
        for: 3m
        labels:
          severity: warning
        annotations:
          summary: "p95 API latency exceeded 450ms across production endpoints"

6. Summary: From Reactive Debugging to Proactive APM

Deploying OpenTelemetry transforms engineering operations:

  • Instant Root-Cause Identification: Pinpoint whether a 3-second delay originates in database lock contention, third-party payment gateways, or CPU throttling in seconds.
  • Vendor Independence: Switch from Jaeger or Grafana Tempo to Datadog or New Relic by modifying exporter URLs with zero code refactoring.
  • Proactive SLA Governance: Alert engineering on-call rotations when p95 trace duration degrades before end users begin filing support tickets.

To explore related full-stack web architectures across our technical manuals:

Ready to implement enterprise OpenTelemetry observability across your web applications? Contact our systems engineering squad to schedule an APM architecture review.

Frequently Asked Questions

What is OpenTelemetry (OTel) and why is it preferred over proprietary APM agents?→
OpenTelemetry is an open-source, vendor-neutral CNCF observability framework standardizing traces, metrics, and logs. It prevents commercial vendor lock-in by allowing engineering teams to switch backend analytics providers (Datadog, Grafana Tempo, Honeycomb) with a simple environment variable change without modifying application code.
How does distributed tracing in Next.js connect frontend requests to backend microservices?→
OpenTelemetry injects W3C Trace Context headers (traceparent) into outgoing HTTP and fetch requests. When backend Node.js microservices receive the request, they extract the trace ID, linking server-side rendering, database queries, and external API calls into a unified flame graph.
What performance overhead does OpenTelemetry add to a production web application?→
When properly configured with batch span processors and probabilistic sampling (e.g. 5% to 10% of production traffic), OpenTelemetry adds less than 1.5 milliseconds of latency to request lifecycles, making it negligible compared to the diagnostic value it delivers.
Senior Engineering Advisory

Need senior engineering firepower on your next release?

Direct access to senior engineers specializing in ultra-fast Astro, Next.js, and high-converting architectures. No account managers, 4-hour SLA.

Book Technical Consultation →
START AN ENGINEERING ENGAGEMENT

Let's build.

Send over your technical brief or project scope. You'll receive an assessment directly from a senior technical lead within 4 business hours.

Fonda Digital

Senior full-stack engineering boutique based in Ljubljana and Izola, Slovenia. Direct access to the engineer writing your code, with zero junior hand-offs.

BASE:Ljubljana / Izola, Slovenia
RESPONSE WINDOW:Within 4 Business Hours (CET)
DIRECT CHANNEL:[email protected]
CURRENT TIME: LJUBLJANA--:--:-- CET
Estimated Budget

Automated spam protection.