Uptime Blog


Then and Now: Distributed Systems Alerting and Monitoring

Curtis St Pierre ON Sep 29, 2021

Distributed systems are everywhere. Although many teams don’t think of their applications as distributed systems, if they’re developing using container-based microservices and serverless functions instead of a monolith, they’re creating a distributed system. This change also means that monitoring needs are becoming more complex.

Traditional process-based monitoring works well for monolithic apps, but it doesn’t capture the end-to-end monitoring required for applications built on distributed software architecture. Since microservices scale independently, and a single API request triggers calls to multiple distributed services running across various servers and environments simultaneously, it’s nearly impossible to track these requests using traditional techniques.

Distributed tracing and monitoring solutions are the best way to solve this challenge as they track and observe requests that move through distributed systems. This real-time visibility allows teams to visualize the full journey of a request—from frontend to backend—and pinpoint any failures or performance issues that may have occurred along the way.

Let’s explore how tracing and monitoring have evolved in the past decade, then discuss some of the newer tools and technologies that simplify distributed systems monitoring.

Distributed Tracing and Monitoring

In the 2010s, businesses discovered that microservice architecture enabled decentralized teams to innovate faster while controlling their technology stack and standards, development and release cycles, and performance. As a result of switching to microservices, they needed tools to trace execution across service boundaries, so distributed tracing and monitoring solutions appeared in the market. These tools help solve tracing challenges for applications built using microservice architecture.

These solutions provide an end-to-end narrative of requests by tracking them through each service and module. Developers and analysts can observe all the iterations and services the request invokes and monitor their performance. This visibility enables teams to see where the system is experiencing blockages, making troubleshooting any issues faster and easier.

Examples of distributed tracing and monitoring tools

Google’s 2010 Dapper publication acted as a catalyst for distributed tracing and monitoring innovation. It also acted as the inspiration for both Twitter and Uber to create the popular open-source request tracing tools Zipkin and Jaeger respectively. Both solutions have similar components to trace an outgoing request along with the application: a collector that gathers and correlates data between traces and a database to store this data that a web user interface (UI) or API can query and analyze.

Zipkin and Jaeger work well, but they have different architecture and don’t support the same programming languages. And, since Twitter and Uber built the solutions separately, the applications are incompatible with one another.

This lack of compatibility created the demand for unified, backend-agnostic distributed tracing and monitoring APIs. OpenTracing and OpenCensus emerged to provide a single API specification for distributed systems monitoring and tracing. These APIs made it easier for developers to add tracing and logging calls to distributed microservices. They also made it simpler to send the data to a variety of back-end services to gather, store, analyze, and visualize. Eventually, Jaeger and Zipkin both added OpenTracing and OpenCensus support.

OpenTracing enabled developers to embed instrumentation in their custom application code—thus providing much-desired flexibility. However, this tool solely focused on tracing, which limited its use.

Alternatively, OpenCensus traced and monitored messages, requests, services, and application behavior. Then, it sent this data to the developer’s preferred analysis platform. Although OpenCensus offered source-to-destination tracing, it lacked an API to embed it into code. Developers had to rely on community-built automatic instrumentation agents.

In 2021, OpenTracing and OpenCensus merged into OpenTelemetry. This new solution relies on each tool’s strengths. OpenTelemetry offers developers APIs, libraries, agents, and collector services to log traces and monitors data across multiple distributed services. Developers can later analyze these collected traces using any popular observability tool.

As distributed tracing applications evolved over the past few years, it’s become much easier to gather data needed for distributed systems monitoring. But, collecting data from monitoring tools is only half the story. Some of the most important innovations impact what we can do with the data.

Automation-Enhanced Distributed Systems Monitoring and Alerting

A distributed system comprises multiple microservices, generating more data than a single-process monolith, with more individual parts to track and monitor. One failure across multiple microservices can generate multiple errors, logs, and traces. This duplication causes event floods and alert fatigue, making it more time-consuming and expensive to track down, diagnose, and fix the issue. 

Automation can help reduce this noise by correlating events based on severity, source, and other similarities, and eliminate or suppress duplicates via event flood control and incident type classification tools. Even as microservice networks grow more complex, this innovation helps monitor end-to-end API calls and individual microservices processing the calls—without flooding teams with information overload.

Event Severity Classification

AI can accurately and quickly determine if incoming monitoring and tracking tools indicate an incident is occurring, and then classify its severity. This classification helps reduce false positives and unnecessary alerts, making it easier to track down the problem disrupting the service without alert fatigue from constant notifications.

Automatic Event Correlation

When an incident occurs, modern tools correlate events to automatically group monitoring data from all distributed services involved in the incident. These tools also provide a detailed stack trace and the error message, easing analysis and leading to a quicker resolution.

Event Flood Control

When teams are flooded with too many error logs, they may overlook what’s most important. Event flood control gives responders a single high-priority alert instead.

Event flood control combines with event correlation, enabling you to see all events correlated to the alert quickly. Since you have all the related data, it’s straightforward to diagnose the issue and take measures to fix it.

Incident Type Classification

Collecting incident-related data is essential, but it’s just the first part. It’s equally important to immediately alert the correct on-call responders to ensure a quick response.

Incident type classification is beneficial to assign the task to the appropriate teams. Additionally, it enables site reliability engineers (SREs) to trigger automatic rollbacks and resolution workflows to get systems back to normal as quickly as possible.  

Bringing It All Together

As modern organizations continue to make the jump from monoliths to microservices, monitoring and tracing distributed systems will be the highest priority. Software teams need the ability to quickly troubleshoot errors in complex distributed systems before customers are impacted.

Plenty of tools and methodologies provide information on applications’ bottlenecks and performance issues. These innovations are smart and readily available, but not everyone uses them. Ops teams can easily add tools like OpenTelemetry and set up a back-end to store data, but then what?

xMatters helps Ops and SRE teams act on the distributed monitoring data they’re gathering. If you’re exploring alerting and monitoring solutions and considering an AI-enhanced event correlation, alerting, and on-call management solution, sign up for a demo to explore xMatters today.

Try xMatters Free