The Dataset Viewer has been disabled on this dataset.

AIOpsLab app collection - Hotel & Social

Metrics, logs and complete distributed traces from two microservice applications deployed with AIOpsLab, Hotel Reservation and Social Network (from DeathStarBench). The applications ran on a local kind cluster under a varying wrk2 load, either healthy or with one injected fault. The dataset was built to train and evaluate an anomaly detector (a variational autoencoder) on normal behaviour, then test it on faults.

141 runs, 5.2 GB. Every run passed all five validity checks (V1-V5, below).

Splits

app folder runs content
hotel clean 21 healthy sessions, no fault: r1-r12 of 90 min, r13-r21 of 45 min
hotel dev 8 4 fault scenarios x 2 runs: tuning (e.g. the threshold)
hotel test 55 11 scenarios x 5 runs, noop (no fault) included
social clean 12 healthy sessions, no fault, 90 min each
social dev 10 5 fault scenarios x 2 runs
social test 35 7 scenarios x 5 runs, noop included

The clean sessions were split before collection, by repetition number. The split is in the split field of each .json (the folder is clean/ for all of them):

sessions split use
r1-r6, plus r13-r21 in Hotel train fit the model and its normalization
r7-r8 val calibration
r9-r10 test healthy test sessions
r11-r12 test-unseen healthy test sessions at load levels never used in training: 30, 60, 120 and 240 req/s

Hotel r13-r21 were added on 2026-11-19 as more training data. They are shorter, so the training split holds more deployments; every deployment starts with a warm-up.

The dev scenarios differ from the test ones, so tuning never sees a test fault.

  • Hotel dev: net_delay_search, stress_cpu_search_{5,20,80}.
  • Hotel test: container_kill, misconfig_app, network_delay, network_loss, noop, pod_failure, revoke_auth_mongoDB_{geo,rate}, user_unregistered_mongodb_{geo,rate}, wrong_bin_usage.
  • Social dev: net_delay_home_timeline, pod_failure_user_timeline_mongodb, stress_cpu_compose_post_{5,20,80}.
  • Social test: assign_to_non_existent_node, auth_miss_mongoDB, noop, port_misconfig_{post_storage,text,user}, scale_pod_zero.

In the test split, the 5 runs of a scenario inject the fault at 5 different load levels: 10, 20, 40, 80 and 160 req/s.

How a run unfolds

  1. The load starts at t_workload.
  2. After 300 s of settling, the fault is injected at t_injected. noop runs and clean sessions inject nothing.
  3. The run is observed for 900 s after the injection. Clean sessions are observed for 5400 s, except Hotel r13-r21 (2700 s).

All timestamps are Unix seconds (spans: microseconds).

Files

Each run is four files: <app>/<split>/<run>.npz, .json, .logs.csv.gz and .spans.csv.gz.

.npz: metrics on a 30 s grid

array shape meaning
x [T, S, F] float32 feature value per step, service and feature; NaN where no sample fell in the step
mask [T, S, F] bool True where x holds a real value
t [T] float64 end of each step; a step covers (t - 30 s, t]
rate, mix [T] int64 wrk2 target rate (req/s) and request mix at each step, -1 outside the load
services [S] service names: 17 in Hotel (services, MongoDB, memcached), 26 in Social
features [F] the 13 feature names below

The features come from cAdvisor and kube-state-metrics, summed over the containers of each service.

  • CPU: cpu, cpu_user, cpu_system, cpu_throttled, all in CPU seconds per second. cpu_throttled is absent in Social, which has no CPU limits.
  • Memory: mem_working_set, mem_rss, mem_cache (bytes).
  • Threads: threads.
  • Network: rx_bytes, tx_bytes, rx_packets, tx_packets (per second, on the pod's interface).
  • Restarts: restarts (container restarts per second).

Nothing is normalized or windowed: compute the statistics on the training split only.

.json: labels and checks

  • Run: split, kind, rep, app_scenario.
  • Fault: fault_type, target.
  • Timeline: t_workload, t_inject, t_injected, settle_s, observe_s, step.
  • Load: schedule, the wrk2 plan as seconds:rate:mix segments. segments, what each segment delivered: rate, p99 latency, non-2xx responses.
  • Checks: checks, V1-V4 as [passed, details].
  • Traces: trace_sampling (the share of requests traced: 1.0 in Hotel, 0.6 in Social) and V5_traces.
  • Code: versions, the exact commits of the code that collected the run.

.spans.csv.gz: every span of the run

One row per span. Hotel traces every request; Social traces 60% of them, chosen at random per request.

column meaning
trace, span, parent Jaeger trace and span ids; parent is empty for a root span
start_us, duration_us start (Unix microseconds) and duration
service, pod, operation, kind where the span ran; kind is client or server
peer peer tag, when the span has one
error, status, error_msg error flag, status code, error message
callee for a client span, the service or datastore it calls (empty when unknown)
datastore the call goes to MongoDB, Redis or memcached

.logs.csv.gz: container logs

Columns: t, service, pod, container, previous, level, source, message. previous is 1 for lines from a container that had already died. Hotel's services log little at runtime, while Social's logs are rich.

Validity checks

A run is in the dataset only if all five checks pass.

check requires
V1 load wrk2 delivered at least 90% of the target rate before the fault
V2 health no restart and no non-2xx response before the fault, under load (a restart at the deploy does not count)
V3 coverage at most 20% empty cells overall, and at most 40% for any service and feature
V4 host I/O the host's disk wait stayed low over the run
V5 traces Jaeger kept every span; no export window hit the query limit

Trace drops caused by the fault itself are kept as signal. In some fault runs the number of traces falls because of the fault, not because spans were lost:

  • requests fail before they produce a span: scale_pod_zero and assign_to_non_existent_node;
  • responses collapse: net_delay_home_timeline;
  • wrk2 sends less: network_loss.

Clean sessions r1-r12 were collected before a fix to the trace exporter. In them, the 30 s steps where Jaeger lost traces are listed in V5_traces[1]["trace_gaps"] and should be masked for trace features: 7 of 2273 steps in Hotel and 20 of 2269 in Social. Hotel r13-r21 were collected after the fix and have no gaps.

Known differences

  • Threads grow with the age of a deployment. In Hotel's 90-minute sessions, threads after minute 50 sits 1.4 within-load standard deviations above the first 50 minutes. Fault runs last about 20 minutes, so they never reach those levels. Consider a delta for threads, as for memory.
  • Hotel's cpu_user differs between collections. At the same load and age, Hotel clean r1-r10 have a higher cpu_user than the healthy part of the test and dev runs: +0.3 to +1.2 within-load SD, +0.66 overall. Hotel r13-r21, collected like the test and dev runs, match them (-0.02).

Collection setup

  • Cluster: kind on a single Ubuntu 24.04 host.
  • Observability: Prometheus (cAdvisor, kube-state-metrics, node exporter) and Jaeger all-in-one.
  • Load: wrk2 with varying rates and request mixes.
  • Faults: AIOpsLab's injectors and Chaos Mesh.
  • Versions: AIOpsLab 6bba8e1, builder 1533dfa. The collector is 6c20826 for the test and dev runs and for Hotel clean r13-r21; clean r1-r12 come from earlier versions. The exact commits per run are in each .json.
  • Dates:
    • clean r1-r12: 2026-11-09 to 2026-11-14;
    • test and dev runs: 2026-11-14 to 2026-11-16;
    • Hotel clean r13-r21: 2026-11-19 to 2026-11-20.

Usage

import json
import numpy as np
import pandas as pd
from huggingface_hub import snapshot_download

root = snapshot_download("Keeevin16/AIOpsLab-app-collection-Hotel-Social", repo_type="dataset",
                         allow_patterns=["hotel/*/*.npz", "hotel/*/*.json"])  # drop allow_patterns for spans and logs
run = f"{root}/hotel/test/container_kill_hotel_res__r1"
z = np.load(run + ".npz")
meta = json.load(open(run + ".json"))
faulty = (z["t"] > meta["t_injected"]) & (meta["fault_type"] != "No fault")  # steps that end after the injection
# spans = pd.read_csv(run + ".spans.csv.gz")

License

CC BY-NC 4.0. Use requires attribution (cite this dataset and its URL) and excludes commercial use. The data is provided as is, without warranty of any kind.

Downloads last month
60