The 15-week technical battle of LogiFlow — a company waking up from the illusion created by artificial intelligence and returning to real engineering.

The Story

A "system is slow" complaint came in. The logs were full of console.log but no one could figure out which microservice was causing the issue.

It was the kind of outage that drove everyone crazy. The dashboard showed elevated latency. The logs showed... everything. Thousands of console.log lines, none of them connected, none of them carrying a request ID, none of them telling you which service was the bottleneck.

"We have logs," Emre said. "Tons of them."
"You have noise," Defne replied. "Logging is not observability."

Technical Autopsy: Real Tracing with OpenTelemetry

import { trace } from '@opentelemetry/api';

const tracer = trace.getTracer('routing-service');

async function calculateRoute(truckId: string) {
  return tracer.startActiveSpan('calculate-route',
    async (span) => {
      span.setAttribute('truck.id', truckId);
      try {
        const result = await runRouting(truckId);
        span.setStatus({ code: 1 }); // OK
        return result;
      } finally {
        span.end();
      }
    }
  );
}

With distributed tracing, a single request gets a Trace ID that follows it through every service. When the dashboard shows elevated latency, you don't grep through logs — you search by Trace ID and see the entire journey: which service took how long, where the bottleneck is, where the error originated.

Logging is not enough — you need to trace. Observability is the X-ray of your system.

The Three Pillars

You need all three. Logs without metrics are anecdotes. Metrics without traces are averages. Traces without logs are timelines without context.

Lessons from Episode 12

1. Three Pillars: Logs + Metrics + Traces = Real Observability.

2. Trace-ID: Every request gets an identity, carried across all services.

3. Semantic Logging: Structured (JSON) logs are 100x more valuable than free-text logs.

This is Episode 12 of the "Back to Code" series. Next up: Episode 13 — Event-Driven Architecture: Kafka and the Async World.

Series: back.to.code · 2026