Automated Root Cause Analysis for Microservices

You are reading version 1 of this direction, frozen 2026-10-04. The latest version is version 2.

Version 1 of 2246 papers275 conceptsfrozen 2026-10-04

In modern distributed systems, the transition from monolithic architectures to microservices has created a "dependency tax." While breaking a system into independent services allows for better scaling and faster deployment, it introduces a web of intricate interdependencies. When a single component fails, it rarely stays isolated; instead, it triggers a cascade of secondary errors that ripple through the entire system.

The core challenge in maintaining these systems is not just detecting that an anomaly has occurred, but identifying the root cause amidst a storm of dependent alerts.

The Anatomy of a Cascade

In a microservice environment, a single user request might trigger dozens of internal calls across a Directed Acyclic Graph (DAG) of services. As Xiangchun Chen and colleagues note in Digital Twin-assisted Reinforcement Learning for Resource-aware Microservice Offloading, this structure makes the overall application performance highly sensitive to individual node and link failures.

When a downstream service (like a database) experiences a latency spike, the upstream services waiting for its response begin to time out. These timeouts look like failures in the upstream services, which then trigger alarms in the services that depend on them. This "domino effect," as described in research on Multi-Agent Systems, obscures the original root cause. A human operator looking at a dashboard might see fifty services reporting errors simultaneously, making it nearly impossible to tell which one actually broke first.

Mapping the Invisible Graph

To solve this, researchers are moving away from treating services as independent entities. Instead, they model the system as a dynamic, multi-attributed graph. Álvaro Brandón and Marc Solé demonstrate in Graph-based root cause analysis that by comparing "anomalous subgraphs" against known failure patterns, systems can achieve significantly higher precision than standard machine learning models.

The intuition here is that failures leave a "topological signature." A network bottleneck looks different on a graph than a memory leak. By capturing the "biography" of service executions—a concept Ling Liu calls service provenance in ProvenanceLens—engineers can trace the path of a request to find exactly where the performance degraded.

From Correlation to Causal Discovery

Traditional monitoring relies on correlation: if Service A and Service B both fail at the same time, they might be related. However, correlation is a poor tool for diagnosis because it doesn't indicate directionality.

Recent work by Xiao Han and others on AERCA uses Granger causal discovery to learn how variables influence each other over time. By integrating this into an autoencoder framework, the system can identify anomalies by spotting when external "exogenous" drivers deviate from their normal behavior.

Another powerful approach is interventional learning. In Fault Injection Based Interventional Causal Learning, Qing Wang 0016 and their team suggest that the best way to understand a failure is to cause it on purpose. By injecting faults in a staging environment (Chaos Engineering), they "learn" the propagation patterns of errors. When a similar pattern appears in production, the system already has a map of the causal chain, allowing it to point directly to the source.

Cross-Layer Propagation

A final layer of complexity is that failures often propagate vertically across the "stack." A hardware glitch (like a CPU hang) on a physical node can manifest as a network timeout in a container, which then appears as a service failure in the application layer.

Zeyan Li and colleagues emphasize in their work on AIOps benchmarks that effective diagnosis requires analyzing these cross-layer dependencies. Monitoring tools must bridge the gap between:

  1. Low-level metrics: CPU usage, disk I/O, and container health.
  2. High-level traces: Request latency and service call graphs.

As Muyao Wang notes in Channel Matters, without the ability to isolate the influence of individual data channels or layers, it is impossible to distinguish between a localized sensor failure and a global system issue. The goal of this research direction is to move from "something is wrong" to "Service X is failing because Node Y has a disk bottleneck," enabling truly autonomous, self-healing cloud infrastructures.

Papers in this version

Showing 60 of 246 papers.

History & citationVersion 2 · 2026-10-04

Current · Permanent link

  1. Version 2 (latest) · 2026-10-04 · 124 papers
  2. Version 1 · 2026-10-04 · 246 papers
Cite this direction

Latest version (a living page):

@misc{lacuna_cascading_failure_propagation_root_cause_12e0c205,
  title = {cascading failure propagation (root cause identification)},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/cascading-failure-propagation-root-cause-identification/rdr_12e0c20532d34d07b129bc15f475ceb9},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-22},
}

This exact version (version 1, frozen text):

@misc{lacuna_automated_root_cause_analysis_for_micros_12e0c205_v1,
  title = {Automated Root Cause Analysis for Microservices},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/automated-root-cause-analysis-for-microservices/rdr_12e0c20532d34d07b129bc15f475ceb9/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-22},
}