Jonathan Lalou's Blog

Posts Tagged ‘OpenTelemetry’

Observability for Modern Systems: From Metrics to Traces

Good monitoring doesn’t just tell you when things are broken—it explains why.

1) White-Box vs Black-Box Monitoring

White-box: metrics from inside the system (CPU, memory, app metrics). Example: http_server_requests_seconds from Spring Actuator.

Black-box: synthetic probes simulating user behavior (ping APIs, load test flows). Example: periodic “buy flow” test in production.

2) Tracing Distributed Transactions

Use OpenTelemetry to propagate context across microservices:

// Spring Boot setup
implementation "io.opentelemetry:opentelemetry-exporter-otlp:1.30.0"

// Annotate spans
Span span = tracer.spanBuilder("checkout").startSpan();
try (Scope scope = span.makeCurrent()) {
    paymentService.charge(card);
    inventoryService.reserve(item);
} finally {
    span.end();
}

These traces flow into Jaeger or Grafana Tempo to visualize bottlenecks across services.

3) Example Dashboard for a High-Value Service

Availability: % successful requests (SLO vs actual).
Latency: p95/p99 end-to-end response times.
Error Rate: 4xx vs 5xx breakdown.
Dependency Health: DB latency, cache hit ratio, downstream service SLOs.
User metrics: active sessions, checkout success rate.

Posted in en-US | Tags: Monitoring, OpenTelemetry, SRE | No Comments »

[DotJs2025] Live Coding with Ryan Dahl: Deno and OpenTelemetry

Author: Jonathan Lalou

Observability’s quest in serverless seas once drowned in bespoke boilerplate; enter Deno’s alchemy, fusing runtime rigor with OpenTelemetry’s ubiquity. Ryan Dahl, Node’s progenitor and Deno Land’s CEO, live-wove this tapestry at dotJS 2025, showcasing zero-config traces illuminating JS’s shadowy underbelly. From UCSD’s mathematical meadows to ML’s machine wilds, Ryan’s odyssey—secure-by-default Deno, TypeScript’s native nest—now embraces OTEL’s triad: logs, metrics, spans.

Ryan’s canvas: a toy API, user IDs fetched, errors eventual—mundane yet ripe for revelation. Deno’s infusion: Deno.metrics(), console.log piped to OTEL, spans auto-spanning HTTP arcs. Exporter’s elegance: Jaeger console, traces unfurling waterfalls—entrypoints to exits, attributes annotating arcs. Live, Ryan scaffolded: import OTEL, configure exporter, instrument fetches—redeploy to Deno Deploy, logs and traces blooming in tandem. Nanoseconds’ narrative: cold starts eclipsed, polyglot peace via WIT interfaces—Rust greeters yielding to TS handlers.

This symbiosis scales: production probes sans proxies, Deno Deploy’s horizon harboring holistic views. Ryan’s aside: Oracle’s JS trademark tyranny—a cease-and-desist specter stifling “JSConf”—spurred javascript.tm’s petition, amassing allies against anachronistic anchors.

Deno’s decree: OTEL’s open arms, JS’s joyful instrumentation—debugging demystified, deployments discerned.

Instrumentation’s Instantaneity

Ryan rendered realms: metrics via Deno.metrics(), logs laced with OTEL, spans spanning sans strife. Jaeger’s vista: waterfalls whispering workflows, attributes authoring arcs—live, a fetch’s fate traced, errors etched eternally.

Horizons and Heresies

Deno Deploy’s dawn: traces native, nanoseconds’ narrative. Ryan rallied: sign javascript.tm, reclaim JS’s soul—petition’s progress, public’s power against Oracle’s overhang.

Links:

Posted in en-US | Tags: Deno, DenoDeploy, dotJS2025, JavaScript, Metrics, Observability, OpenTelemetry, RyanDahl, Serverless, Tracing | No Comments »

[NodeCongress2021] Logging, Metrics, and Tracing with Node.js – Thomas Hunter II

Author: Jonathan Lalou

Observability pillars—logs, gauges, spans—form the triad illuminating Node.js constellations, where opacity breeds outages. Thomas Hunter II, a Node.js luminary and author of “Distributed Systems with Node.js,” dissects these sentinels, adapting book chapters to unveil their synergies in service scrutiny.

Thomas frames logging as cloud-elevated console.logs: structured JSON extrudes states, severity tiers—error to silly—filter verbosity. Winston orchestrates: transports serialize to stdout/files, Pino accelerates with async flushes. Conventions prescribe correlation IDs, timestamps; aggregators like ELK ingest for faceted searches.

Metrics quantify aggregates: counters tally invocations, histograms bin latencies. Prometheus scrapes via prom-client, Grafana visualizes trends—spikes foretell fractures. Thomas codes a registry: gauge tracks heap, histogram times handlers, alerting deviations.

Tracing reconstructs causal chains: spans encapsulate ops, propagators thread contexts. OpenTelemetry standardizes; Jaeger self-hosts hierarchies, timelines dissect 131ms journeys—Memcache to Yelp. Datadog APM auto-instruments, flame graphs zoom Postgres/AWS latencies.

Instrumentation Patterns and Visualization Nuances

Thomas prototypes: async_hooks namespaces contexts, cls-r tracers bridge async gulfs. Zipkin’s dependency DAGs, Datadog’s y-axis strata—live Lob.com postcard fetches—demystify depths.

Thomas’s blueprint—Winston for persistence, Prometheus for pulses, Jaeger for journeys—equips Node.js artisans to navigate nebulous networks with crystalline clarity.

Links:

Posted in en-US | Tags: logging, Metrics, Node, NodeCongress, NodeCongress2021, NodeJS, Observability, OpenTelemetry, ThomasHunterII, Tracing | No Comments »

[NodeCongress2021] Comprehensive Observability via Distributed Tracing on Node.js – Chinmay Gaikwad

Author: Jonathan Lalou

As Node.js architectures swell in complexity, particularly within microservices paradigms, maintaining visibility into system dynamics becomes paramount. Chinmay Gaikwad addresses this imperative, advocating distributed tracing as a cornerstone for holistic observability. His discourse illuminates the hurdles of scaling real-time applications and positions tracing tools as enablers of confident expansion.

Microservices, while promoting modularity, often obscure transaction flows across disparate services, complicating root-cause analysis. Chinmay articulates common pitfalls: elusive errors in nested calls, latency spikes from inter-service dependencies, and the opacity of containerized deployments. Without granular insights, teams grapple with “unknown unknowns,” where failures cascade undetected, eroding reliability and user trust.

Tackling Visualization Challenges in Distributed Environments

Effective observability demands mapping service interactions alongside performance metrics, a task distributed tracing excels at. By propagating context—such as trace IDs—across requests, tools like Jaeger or Zipkin reconstruct end-to-end journeys, highlighting bottlenecks from ingress to egress. Chinmay emphasizes Node.js-specific integrations, where middleware instruments HTTP, gRPC, or database queries, capturing spans that aggregate into flame graphs for intuitive bottleneck identification.

In practice, this manifests as dashboards revealing service health: error rates, throughput variances, and latency histograms. For Node.js, libraries like OpenTelemetry provide vendor-agnostic instrumentation, embedding traces in event loops without substantial overhead. Chinmay’s examples underscore exporting traces to backends for querying, enabling alerts on anomalies like sudden p99 latency surges, thus preempting outages.

Forging Sustainable Strategies for Resilient Systems

Beyond detection, Chinmay advocates embedding tracing in CI/CD pipelines, ensuring observability evolves with code. This proactive stance—coupled with service meshes for automated propagation—cultivates a feedback loop, where insights inform architectural refinements. Ultimately, distributed tracing transcends monitoring, empowering Node.js developers to architect fault-tolerant, scalable realms where complexity yields to clarity.

Links:

Posted in en-US | Tags: ChinmayGaikwad, DistributedTracing, Microservices, Node, NodeCongress, NodeCongress2021, NodeJS, Observability, OpenTelemetry | No Comments »