0:0022:55

Observability in today's complex systems

Shweta Sharma 22:55 2022

In a microservice system, failures multiply and causes stop being obvious

Latency climbs, yet every service's logs say the application is fine. Drawing on the Matrix, where Neo reads patterns and the Architect cannot eliminate an anomaly, Intuit senior software engineer Shweta Sharma argues that no system is perfect and that even known bugs are hard to fix in complex, distributed systems. So what data must engineers collect to trace a failing request back to its cause?

Learn how metrics, logs and traces work together to locate failures in microservices

Watch on YouTube

In short

Shweta Sharma, Senior Software Engineer at Intuit, explains why moving from monoliths to microservices makes end-to-end visibility essential. Using references from the Matrix, she walks through the three pillars of observability (metrics, logs and traces), shows open source tools for each, and separates observability from monitoring.

“when something fails it is no longer obvious what causes just like architect could not figure out in this complex system where this anomaly neo came from and why it was happening”
“now we have to find out what the problem is so you need more details right and that's where the logs come in”

What you will learn

  • Explain why microservice architectures need observability more than monolithic applications do.
  • Distinguish system-level USE metrics from application-level RED metrics and correlate them to diagnose a failure.
  • Write structured logs that record when, where, why and for whom an error happened.
  • Instrument services with a shared request ID and spans to trace latency across a distributed call chain.
  • Choose open source tools such as Micrometer, Prometheus, Grafana, OpenTelemetry and Jaeger for each observability pillar.

Key takeaways from the speaker

  • After this session you will be able to understand what observability is and why do we need it.
  • You will understand three pillars of Observability in detail such as Logs, Metrics and Traces and what tools/tech you can use to implement these pillars
  • How can you instrument your micro services to get answers like what services did a request go through, why and where did the request fail, where are the performance bottlenecks etc.

Details

Level
Intermediate
Format
Tech talk
Technical depth
Practitioner
For
Early career, Mid-career, Senior individual contributor
Length
22:55
Published
July 2022

Questions this talk answers

What is observability?

It helps developers understand a multi-layered architecture by observing the system to detect anomalies or changing behavior at the right time and take the right action.

What are the three pillars of observability?

Metrics, logs and traces, supported by visualization so the data they produce is readable and quick to interpret.

What is the difference between USE and RED metrics?

USE metrics (utilization, saturation, errors) describe the system, such as memory, CPU and database connections. RED metrics (rate, errors, duration) describe the application, such as requests per second, errors and latency.

How do traces help when logs show nothing wrong but latency rises?

Adding a request or unique ID across all microservices links the calls into one trace made of spans, showing how long each service or piece of work took so bottlenecks can be found.

How is observability different from monitoring?

Monitoring is what you do after a system is observable, using known metrics, alerts and dashboards. Observability also helps with the unknowns, such as spotting a change in trend before something has gone wrong.

About this talk

Today when we are moving from monolith to micro-service architecture development practices, it is important to have end to end visibility of the system. I will talk about, how you can help measure a system's current state based on the data, such as logs, metrics, and traces.

Topics

Related talks

Browse the library