anon-ops/ops-lite

OpenRCA 2.0

A root-cause-analysis (RCA) benchmark for microservice systems with process-level ground truth. Each instance is a recorded fault injection: the telemetry of the system before and during the fault, the injected faults that took effect, and the verified propagation graph along which their effects travelled between services.

An agent under evaluation sees only the telemetry and must name the root-cause service(s) and fault kind, and describe how the failure propagated. The label and the propagation graph are the answer key.

Composition

system	instances	multi-fault	fault kinds	mean service edges in G*
ts (TrainTicket, Java/Spring Cloud)	275	78	21	5.9
otel-demo (OpenTelemetry Demo, polyglot)	32	16	7	3.1
hs (Hotel Reservation, DeathStarBench, Go/gRPC)	148	82	5	1.5
total	455	176	23	4.3

437 instances have at least one service-level edge in their propagation graph and are scored at the process level; the other 18 are scored at the outcome level only.

Data layout

openrca2-lite/
├── README.md
├── manifest.jsonl                 # one record per instance
└── cases/<case-name>/
    ├── normal_traces.parquet      # telemetry before the injection
    ├── normal_metrics.parquet
    ├── normal_metrics_histogram.parquet
    ├── normal_metrics_sum.parquet
    ├── normal_logs.parquet
    ├── abnormal_traces.parquet    # telemetry during the injection
    ├── abnormal_metrics.parquet
    ├── abnormal_metrics_histogram.parquet
    ├── abnormal_metrics_sum.parquet
    ├── abnormal_logs.parquet
    ├── env.json                   # normal / abnormal window boundaries (unix seconds)
    ├── injection.json             # raw fault-injection record
    ├── label.json                 # answer key: root causes
    └── causal_graph.json          # answer key: verified propagation graph G*

The ten parquet files are the only input given to an agent. env.json, injection.json, label.json, and causal_graph.json must be withheld from the agent during evaluation.

Log lines printed by the fault-injection tooling itself (which would name the injection target) have been removed from the logs; no other telemetry has been edited.

label.json

{
  "case": "batch-01KQHDBBNP9A2BWM50Z37QJT3A",
  "system": "hs",
  "faults": [
    {"index": 0, "service": "search",  "chaos_type": "PodFailure", "role": "required", "container": ["hotel-reserv-search"]},
    {"index": 1, "service": "profile", "chaos_type": "PodFailure", "role": "required", "container": ["hotel-reserv-profile"]}
  ],
  "process_applicable": true,
  "service_edges": [["profile", "frontend"], ["search", "frontend"]]
}

One entry per injected fault, in the order of injection.json's engine_config. role is one of:

• required: the fault took effect beyond its own service; it is part of the root-cause set an agent must recover.
• optional: the fault took effect only on its own resources, or was masked by a co-injected fault. Naming it is neither required nor penalised.
• not_effective: the fault was injected but had no observable effect. It is not part of the answer, and naming it counts as a wrong root cause.

also_accept (present on 3 faults) lists services that also count as naming the fault: for these HTTP faults the telemetry cannot tell which end of the call was altered.

process_applicable is false when G* has no service-level edge (the effect stayed inside the root service); process-level metrics skip such instances. service_edges is G* projected to services, the graph that Node F1, Edge F1, and path reachability are computed on.

injection.json is the unmodified record of everything that was injected, including faults whose role is not_effective; its ground_truth field therefore lists every injected fault. label.json is authoritative.

causal_graph.json

The verified propagation graph at component level (services, spans, pods, containers):

• nodes: {component, state, timestamp}, e.g. span|frontend::HTTP /hotels in state erroring
• edges: {source, target} between components
• root_causes: the injected components the paths start from
• alarm_nodes: components at the end of the verified paths, where the effect was observed
• component_to_service: owning service of every component; project edges through this map to obtain the service-level graph
• case_name, fault_type

manifest.jsonl

{"name": "...", "system": "ts|hs|otel-demo",
 "root_services": ["..."], "optional_services": ["..."], "chaos_types": ["..."],
 "n_injected_faults": 2, "n_required_faults": 2,
 "process_applicable": true, "n_service_edges": 3, "longest_service_path": 2}

root_services and chaos_types cover required faults only.

How the ground truth was built

Faults were injected with Chaos Mesh into the three testbeds and the telemetry was exported through OpenTelemetry. Each injection record was then checked forward against the telemetry: a fault is kept only if its effect is observable on the injected service, and a propagation edge is kept only if it follows a known propagation mechanism, the downstream service deviates from its pre-injection behaviour beyond the variation seen in fault-free windows, and the downstream anomaly starts no earlier than the upstream one. Instances without any fault that took effect beyond its own service were removed. The procedure is described in the accompanying paper.

License

Apache-2.0. The underlying microservice testbeds (TrainTicket, Hotel Reservation / DeathStarBench, OpenTelemetry Demo) retain their own upstream licenses.

Citation

A formal citation will be added on publication.