Skip to content
Tech Interview Prep
Technical interview guide

Monitoring, Logging & Tracing

The three pillars of observability, and what question each one is actually good at answering.

Read
30 min
Practice MCQs
25
Interview Q&A
25
Edition
v4
Editorial status
Reviewed

Scope: OpenTelemetry, W3C Trace Context, Prometheus, and Google SRE current 2026-08-31.

Curated: · Written: · Reviewed:

25 questions

MCQ-2A value exported by a service only ever increases while the process runs, and drops back to 0 when the process restarts. Which metric type is it?
MCQ-3A worker pool's queue depth rises and falls through the day. Workers can crash and drop queued jobs, so a running total of enqueues minus dequeues drifts from the true depth. The team scrapes depth every 15 seconds and wants an alert that fires when depth has stayed above 500 for 5 minutes. Which metric type should the depth series use?
MCQ-4A service handles 10,000 requests in a 10-minute window: 9,800 complete in 20 ms, and 200 block for 2,000 ms on a lock. The dashboard reports only the mean against a 100 ms mean target, and the team marks the window green. The SLO is p99 < 500 ms. What does the window actually show?
MCQ-1A checkout service runs on 3 hosts behind a load balancer and serves 400 tenants across 12 endpoints. It emits per-host latency histograms (p50/p99) scraped every 15 s, and an alert fires when p99 exceeds 150 ms. The alert fires: p99 goes from 40 ms to 180 ms and stays there for 40 minutes. All three hosts show the same rise, and the team still cannot say whether the regression is one tenant, one endpoint, or one downstream call. Which change gives them the evidence to answer that?
MCQ-5A payments service exports `http_requests_total` with three labels: `method` (4 values), `route` (18 values) and `status` (7 values). To answer per-customer questions, an engineer adds a fourth label, `user_id`; 60,000 distinct customer IDs appear in each 2-hour window. The Prometheus instance has 8 GB of RAM, and the team's sizing note puts an active series at about 1 KB of head-block memory. What does adding the label do to the instance?
MCQ-6A payments service takes 40 million requests a day, each carrying a unique `request_id`. To make a single request findable, an engineer adds `request_id` as a label to the existing `http_request_duration_seconds` histogram, which has 5 buckets plus `_sum` and `_count`. The Prometheus instance scraping it is sized for about 2 million active series. Within a day it is OOM-killed every few hours and range queries time out. Which change fixes this while still letting an engineer pull up any one request?
MCQ-7An order service emits one JSON event per request, and the log pipeline indexes every field it sees. Before a release, one day's index was 40 GB and a dashboard query filtering on `service` and `level` over the last 24 h returned in 300 ms. The release added two top-level fields to every event: `request_id` (a UUID) and `url` (the full request URL, which carries a per-session token in its path). One day's index is now 310 GB, shard count went from 40 to 300, and the same dashboard query takes 25 s. The hot tier is a single node with 96 GB of RAM, 32 GB of it JVM heap. A week after the release the numbers are unchanged. Which explanation fits the measurements?
MCQ-8A payments team rebuilds transaction state by replaying its log pipeline after a database restore. The ledger shows 1,200 committed charges; the rebuild produces 1,203 records: three orders carry two `charge.succeeded` lines with the same idempotency key, and one order the ledger shows as charged has no line at all. Which property of the logging path explains the mismatch?
MCQ-17A checkout request fans out over synchronous HTTP to five services. Each service's logger stamps every line with the trace_id and span_id carried on the request, and the tracing SDK forwards those identifiers in outgoing headers. During an incident an engineer opens the trace for request 7f3a: it holds four spans, one each from services A, B, C and D. Querying the log store for trace_id=7f3a returns exactly those four services' lines. Service E's lines for the same request are present, but they carry trace_id=91c2, and 91c2 is a trace containing a single span from E. E returned 200 in 40 ms. What most likely explains E's lines?
MCQ-25An engineer pulls a trace for a slow checkout request. It shows 12 spans across 5 services, and the waterfall view has no visible gaps. She wants to use it to argue that the request's 1.8s latency is fully accounted for. Which claim does the trace actually establish?
MCQ-9A checkout flow is instrumented with OpenTelemetry. One order produces a single trace containing the gateway, order service and payment service spans with correct parent-child links. The order service then publishes to Kafka and the inventory service consumes the message; the inventory spans land in a second trace with a different trace ID and no parent. The producer's record headers are empty. What explains the split?
MCQ-10A Go checkout service publishes order events to Kafka with the OpenTelemetry Kafka instrumentation. Its producer span is exported with trace ID 4bf92f3577b34da6a3ce929d0e0e4736. A kafka-console-consumer dump shows each message carries a traceparent header with that same trace ID. The Go consumer creates one span per message with tracer.Start(ctx, "process-order"); that span is exported with trace ID 9c1d2e3f4a5b6c7d8e9f0a1b2c3d4e5f and parent span ID 0000000000000000. Both services export to the same collector. What explains the consumer's span being a new root?
MCQ-16A Kafka producer instrumented with OpenTelemetry injects `traceparent` into each record's headers. The consumer is a hand-written poll loop that starts a span per record with `tracer.start_as_current_span('process-record')` (Python OpenTelemetry API). In the trace backend every consumer span is a separate root trace with no parent. Which change links the consumer spans to the producing trace?
MCQ-11A gateway starts a trace and sends `traceparent: 00-4bf92f3577b34da6a3ce929d0e0e4736-a1b2c3d4e5f60718-01` to the orders service. Orders' HTTP client is misconfigured: instead of writing its own span ID into the outgoing header, it forwards the incoming traceparent byte-for-byte to the payments service. All three services export spans to the same backend. What does the backend's trace view show?
MCQ-12An API gateway terminates TLS for public-internet traffic and forwards requests to internal services. A partner's SDK sends W3C `traceparent` and `baggage` headers; SRE needs the partner's spans joined to yours in one trace, and the internal services assume the gateway has already sanitized anything it forwards. Authentication is an OAuth 2.0 token checked at the gateway, and a malformed telemetry header must not fail the request. What should the gateway do with the incoming trace headers?
MCQ-13A Go checkout service using the OpenTelemetry Go SDK sets `customer.email` in baggage at the edge of a 34-service mesh. Every service in the mesh uses the default global propagator, and the checkout service calls the external payment provider directly. A security review finds the email in the payment provider's request logs and finds no `customer.email` attribute on any span in the tracing backend. Which explanation accounts for both findings?
MCQ-14A payments service handles 400 requests/s and configures a 5% head-based sampler in its OpenTelemetry SDK. The team wants every trace that ends in a timeout retained for debugging. What actually happens?
MCQ-15Six OpenTelemetry collector instances sit behind a least-connections load balancer. The tail-sampling policy keeps a trace if it contains an error span or runs longer than 2 s. In production, error traces reach the backend carrying spans from only one or two services, and traces that took 4 s end to end are dropped. What should the team change?
MCQ-19A checkout service emits spans through an OpenTelemetry batch span processor configured with a 2048-span queue and a 10 s export timeout; enqueue is non-blocking. The collector it exports to becomes unreachable while the service keeps handling 3,000 spans/s. Which outcome and response fits this configuration?
MCQ-24During a 20-minute incident in which users report failed checkouts, a service's dashboards show a 0.00% error rate and p99 flat at 40 ms. The service emits about 60k spans/min, and the collector's own telemetry shows its export queue pinned at capacity with its failed-export counter climbing at 12k spans/min. Which explanation accounts for the 0.00% error rate?
MCQ-18A service exports `http_request_duration_seconds` as a histogram and enables exemplars, with the SDK's exemplar reservoir set to keep 1 in 10 observations. The tracing pipeline head-samples 1% of requests. Over one minute the 2.5–5 s bucket records 12,000 observations and 12 exemplars; the team expected about 1,200. Which explanation fits the count they saw?
MCQ-22A platform team runs 30 services, all instrumented with OpenTelemetry SDKs and exporting to one collector. Each team picked its own span attribute names for the same concepts (`rpc.method`, `method`, `op`, `operation`) and every service appears in the backend's service list with normal span volume and correct `deployment.environment` values. The team enables the backend's built-in service map and RED dashboards, which are documented to work with OpenTelemetry data out of the box. Every panel renders 'no data', while raw span search returns spans from all 30 services with their custom attributes intact. What explains the empty panels?
MCQ-21A service exports http_requests_total{code} from the service process; a node-local agent is scraped by Prometheus every 15s. The alert rule is `sum(rate(http_requests_total{code=~"5.."}[5m])) > 0.5`. At 02:14 the agent is OOM-killed and does not come back until 02:41. Over that window the service returns 500s to about 12% of ~800 rps. The alert never fired and the error panel reads 'No data'. Which explanation and fix is correct?
MCQ-20Two services run 30-day availability SLOs: Checkout at 99.9% and Search at 99.5%. The availability SLO counts only server errors (5xx); client errors (4xx) are excluded. The team pages only when a service's 1-hour error-budget burn rate, the observed error rate divided by the SLO's error budget, is at least 14.4. Which of these currently firing alerts should page the on-call engineer?
MCQ-23A service carries a 99.9% availability SLO over a rolling 30-day window. Eleven days in, the team has consumed 95% of the error budget, and a release that rewrites the request path is scheduled for tomorrow. Which action does the error budget justify?