{
  "id": 912561,
  "title": "Observability - A Counter in RAM, an ID in a Header, and a Batch Export",
  "url": "https://urgent.news/2026/08/14/observability-a-counter-in-ram-an-id-in-a-header-and-a-batch-export",
  "topic": "tech",
  "section": "Tech",
  "published": "2026-08-14T21:49:37.000Z",
  "source": {
    "name": "Dev.to",
    "slug": "dev-to",
    "url": "https://dev.to/telilabs/observability-a-counter-in-ram-an-id-in-a-header-and-a-batch-export-h41"
  },
  "original_language": "en",
  "account": "For a long time, the common understanding of observability was that it involved importing an SDK, making calls through your code, sending data to a server, and then a dashboard reading it back. This was a simplified version of the truth. The true nature of observability became clearer when the focus shifted from the dashboard to the emitted data and its creation process. The incorrect model was enticing because the plumbing for logging and observability appeared the same. However, the real difference lay in the emission mechanisms, which could be categorized into three distinct methods. Metrics are not records written to a log; they are numbers stored in an application's memory. Incrementing these counters does not result in data being sent out. Instead, they are periodically scraped or collected at set intervals. Metrics are cheap and efficient because they are simple counters. The second mechanism involves logs, which function as expected: an event is written, shipped, and searched. The addition of a field, such as a trace ID, is a straightforward enhancement. The third mechanism is distributed tracing, which can seem magical but is actually quite simple. When a request moves through multiple services, a trace ID is added to outgoing requests as a header. Each service reads this header to identify itself as part of the trace and assigns a span ID. The backend then reconstructs the request flow by linking the parent and child IDs. This intricate process relies on the propagation of an ID through headers, a seemingly trivial task with far-reaching implications. In essence, observability is not a single system but three different methods of emitting data that manage to share a common pipeline. These methods are: a counter in RAM, an ID propagated through a header, and a batch export. The power of observability lies in understanding a system's internal state by analyzing what it emits, enabling the answering of questions that were not anticipated in advance. This is possible because the emitted signals carry their relationships within them. Metrics provide live numbers, logs serve as events, and traces act as IDs passed between services. The establishment of these agreements on what to emit and how to name it, across various programming languages, frameworks, and vendors, constitutes OpenTelemetry. It is not a tool but a set of standards that enable effective observability, allowing for the construction of a comprehensive understanding of a system purely from what it emits.",
  "summary": "For a long time, my mental model of observability was this: you import an SDK, sprinkle some calls through your code, each call fires off data to a server somewhere, and a dashboard reads it back. A logging system with extra steps. That model is wrong in a specific, interesting way. And I couldn't see how it was wrong until I stopped looking at the dashboards and started looking at what actually…",
  "key_points": [],
  "editors_take": null,
  "illustration": null,
  "coverage": {
    "outlets": 1,
    "also_reported_by": []
  },
  "ai_generated": true,
  "disclaimer": "Summaries, key points and the editor’s take are written by software from other outlets’ reporting and may contain errors — always check the linked original."
}