Pith. sign in

REVIEW 5 major objections 5 minor 1 cited by

LogDB: Multivariate Log-based Failure Diagnosis for Distributed Databases (Extended from MultiLog)

T0 review · 5 major / 5 minor · reviewed 2026-08-16 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read LogDB fuses logs from every node of a distributed database to name the failure type, reaching 98% macro F1 on the TSBS workload.

desk verdict The evaluation table itself violates the paper's F1 equation, making the headline accuracy claims unreproducible; the multi-node fusion architecture is a plausible idea that deserves a properly executed revision. read the letter →

arxiv 2505.01676 v1 pith:XUY33KAJ submitted 2025-05-03 cs.DB cs.SE

Lingzhe Zhang , Tong Jia , Mengxi Jia , Ying Li This is my paper · ORCID
classification cs.DBcs.SE
keywords FailureDiagnosisMultivariateLogDistributedDatabasesAIOpsVariationalAutoencoderApacheIoTDBFaultInjectionLog-basedAnomalyDetection
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

LogDB targets a practical problem: when a distributed database fails, operators often inspect logs by hand, and existing log-diagnosis methods were built for single-node microservices rather than for clusters whose nodes play different roles. The paper proposes a pipeline that extracts three kinds of log features—event sequence, event counts, and semantic meaning—at each node, compresses each node's features with an LSTM plus self-attention, and fuses the compressed summaries at a master node with a variational autoencoder to name the cluster-wide failure type. On Apache IoTDB with three workloads and seven injected anomaly types, it reports macro F1 scores of 98.06% on TSBS, 95.76% on TPCx-IoT, and 87.62% on IoT-Benchmark, outperforming the single-node baselines LogKG, LogCluster, and Cloud19. If the result holds beyond the testbed, operators could get actionable failure labels from logs alone, without waiting on manual correlation across nodes. The paper's own conclusion notes that LogDB has so far been implemented only on Apache IoTDB and that its anomalies come from fault injection rather than production data.

What carries the argument

The load-bearing mechanism is per-node feature compression followed by VAE-based cross-node fusion. At each node, parsed logs in a time window become three views: a sequence of event templates $E=(e_{(s_1)},\dots,e_{(s_N)})$, an event-count vector $C$, and a TF-IDF-weighted semantic vector $V$; an LSTM with self-attention encodes each view, and the enhanced vectors are concatenated and passed through a fully connected layer to form a feature vector $p$. The node's feature matrix $P_i=[p^i_1,\dots,p^i_{k_i}]$ is padded or truncated to fixed length $\beta$; a variational autoencoder encodes $P_i$ to a latent $Z_i$, all nodes' latent vectors are concatenated into the cluster feature matrix $Z$, and a CNN classifies the window into one of the predefined anomaly types. The VAE is what forces heterogeneous per-node log matrices into a common latent space, letting the classifier use cross-node evidence that no single-node method can see.

What would settle it

Run the trained LogDB model on logs from an independent Apache IoTDB deployment or a second distributed database where failure labels come from real incidents rather than injected faults; if macro F1 drops far below the reported 87–98% range, or if the model confidently assigns unseen failure types to the seven training classes, the diagnostic signal is specific to the injection setup rather than to distributed-database failures.

Watch

Extended reading notes

Core claim

The paper's central claim is that accurate cluster-level failure-type diagnosis for distributed databases can be done from log data alone, provided the model sees every node rather than only the node where the fault appeared. LogDB, extended from MultiLog, parses each node's logs into event templates and represents each time window by an event sequence, an event-count vector, and a TF-IDF-weighted semantic vector from pre-trained word embeddings. Each node's three feature streams are encoded by an LSTM with self-attention into an anomaly feature matrix; the master node pads these matrices to a fixed length, compresses them with a variational autoencoder into latent vectors, concatenates the latent vectors from all nodes, and a CNN maps the combined representation to a failure type. The authors report that this design beats single-node graph-based and deep-learning baselines on all three benchmarks, with the clearest wins on anomalies whose evidence is spread thinly across nodes or looks similar to normal operation, such as memory saturation, network limits, and bulk import/export. LogDB is presented as the first failure-diagnosis method for distributed databases that relies on logs alone.

Load-bearing premise

The load-bearing premise is that the seven anomaly types injected into a 4-node Dockerized Apache IoTDB cluster—CPU saturation, memory saturation, limited network bandwidth, export/import operations, too many background tasks, and too-frequent disk flushing—produce log patterns that match how those failures actually show up in real distributed databases, so a model trained on these injections will recognize them in practice.

Editorial extensions

If this is right

  • A distributed database can be diagnosed at cluster level from logs alone: fusing per-node feature matrices at the master node replaces per-node manual log inspection for failure-type identification.
  • Using more nodes' logs improves diagnosis: in the TPCx-IoT workload, single-node logs give an F1 of about 43%, while all four nodes give the reported 95.76%.
  • Single-node baselines, whether graph-based or deep-learning, misclassify anomalies whose log evidence is spread thin across nodes, such as memory saturation, network limits, and import/export operations.
  • Time-window size trades detection speed against accuracy: larger windows can reach perfect F1 on TSBS and TPCx-IoT, but operators would choose smaller windows for faster reaction.
  • The system is deliberately designed to work on logs alone, which means it can be added to an existing database deployment without collecting monitoring metrics or traces.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • A direct ablation that concatenates all nodes' padded feature matrices without the VAE latent compression would test whether cross-node fusion itself, rather than simply having more log text, explains the reported gains.
  • If the fusion mechanism generalizes, the same architecture should transfer to other multi-node databases after retraining on their log templates; the paper does not test this.
  • Because all anomalies were injected on a single 4-node cluster, a production validation against naturally occurring failures would be needed before the reported F1 scores can be read as deployment expectations; the paper itself acknowledges the lack of public benchmark datasets.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

5 major / 5 minor

Summary. LogDB is a log-based failure-diagnosis method for distributed databases. It parses and groups logs on each node, computes sequential, quantitative, and semantic embeddings, processes them with a self-attention-enhanced LSTM per node, pads the resulting feature matrices to a fixed length, fuses them with a variational autoencoder, and uses a CNN classifier to identify cluster-level anomaly types. The authors evaluate LogDB on Apache IoTDB with three workloads (TSBS, TPCx-IoT, IoT-Benchmark), seven injected anomaly categories, and three baselines (LogKG, LogCluster, Cloud19), reporting macro-F1 scores of 98.06%, 95.76%, and 87.62% for LogDB.

Significance. If the reported numbers are correct, LogDB would be a plausible and useful step toward cluster-level log-based failure diagnosis for distributed databases: it is one of few methods designed for multi-node database logs, and the combination of per-node feature extraction with VAE-based fusion is reasonable. The paper is also transparent about its limitations in Section 6, acknowledging the lack of public benchmark datasets and the use of fault-injection-generated anomalies. However, the central performance evidence is currently not reproducible: Table 3 contains per-class P/R/F1 triples that contradict the paper's own Eq. (20), and Table 2 and Table 3 are mutually inconsistent. The evaluation is also a single deployment with no variance estimates and no external validation. The method may be sound, but the headline claim cannot be verified from the manuscript as printed.

major comments (5)
  1. [§4.5, Table 3 and Eq. (20)] The per-class F1 values in Table 3 do not match the harmonic mean defined in Eq. (20). For LogDB anomaly No.4, P=100.00% and R=100.00% imply F1=100.00%, but the table prints 93.33%. For LogCluster No.4, P=97.64% and R=13.75% imply F1≈24.1%, not 93.20%. For LogKG No.4, P=92.45% and R=66.48% imply F1≈77.3%, not 61.17%. Because the Table 2 macro-F1 for LogDB is the mean of the Table 3 F1 column (e.g., 98.06% on TSBS is the average of the eight LogDB F1 cells), these inconsistencies corrupt the headline comparison.
  2. [§4.4/§4.5, Tables 2 and 3] Macro Recall for LogKG on TSBS is printed as 76.78% in Table 2, but the eight per-class recalls in Table 3 for LogKG TSBS are 99.43, 74.22, 92.39, 66.48, 66.48, 67.15, 79.95, and 79.89, which average to 78.25%. Under the macro definition in Eq. (21), at least one of Table 2 or Table 3 is wrong. The authors should recompute every macro metric from the corrected per-class values and verify each P/R/F1 triple against Eq. (20).
  3. [§4.1/§6, evaluation representativeness] The evaluation uses a single Dockerized Apache IoTDB deployment with four containers, with anomalies injected via Chaos Mesh and controlled load or configuration changes. Section 6 states: "Due to the lack of public benchmark datasets, the anomalies used in our experiments are generated through chaos testing and fault injection." No repeated runs, standard deviations, or an independent test environment are reported. This does not substantiate the Abstract's claim of "robust failure diagnosis performance." The authors should add repeated runs with different injection orders and seeds, report variance, and validate on at least one additional deployment or a public dataset if one becomes available.
  4. [§4.3, baseline comparison protocol] The comparison protocol gives LogDB access to logs from all four nodes while LogKG, LogCluster, and Cloud19 are evaluated only on the injected node. Since Figure 5(a) shows that LogDB's TPCx-IoT F1 drops from approximately 95% to 43.34% when only one node is used, the reported margin over the baselines may reflect input breadth rather than architectural superiority. Add a single-node LogDB result to Table 2, or provide the baselines with equivalent multi-node inputs, to make the comparison fair.
  5. [§4.3, train/test protocol] The paper does not state how training and test sets are separated (e.g., by time or by fault instance) nor whether the four hyperparameters (T, N, beta, theta) were chosen on a held-out set. Without this information, the reported F1 scores are difficult to interpret and there is a risk of label leakage or test-set overfitting. The authors should specify the data split and the hyperparameter selection procedure.
minor comments (5)
  1. [Eq. (4)] Equation (4) indexes the event-count vector by N (the log window size), but the count should range over the template set \omega; this notation is misleading.
  2. [§5.2] The sentence "LogCluster [36] clusters logs..." uses reference [36], but LogCluster is reference [19]; reference [36] is Cloud19.
  3. [§4.4] The text "improves F1-score by 19.38%, 26.83%, and 5.40%" should say "percentage points" rather than percent, since these are differences of F1 values.
  4. [Figure 3] Figure 3 contains the garbled label "log loginject"; the intended text appears to be "log inject" or "log injection."
  5. [§3.1, Eq. (7)] The semantic embedding formula in Eq. (7) uses \epsilon_i without defining it as the TF-IDF-weighted word vector; this should be clarified.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the headline F1 claims are empirical comparisons against external baselines, not derivations from the method's own definitions.

full rationale

LogDB is an empirical systems paper. Its central claim—that fusing per-node sequential, quantitative, and semantic log features with a VAE-based cluster classifier yields higher macro-F1 than LogKG, LogCluster, and Cloud19 on TSBS, TPCx-IoT, and IoT-Benchmark—is established by experiments against named external baselines, not by a derivation that reduces to the paper's own definitions. The method's components are specified with explicit equations (Eqs. 3-17), and the evaluation metrics are standard class-level precision/recall/F1 (Eqs. 18-21); no equation defines the reported prediction in terms of the fitted parameters of the same equation in a way that would make the accuracy result true by construction. The self-citation to the authors' MultiLog work is explicit ('LogDB is a failure diagnosis method extended from MultiLog [37]'), but the comparative evaluation in this paper is self-contained and the prior result is not the load-bearing evidence. The authors' own limitation statement concedes that 'due to the lack of public benchmark datasets, the anomalies used in our experiments are generated through chaos testing and fault injection,' which is an external-validity caveat rather than a circularity. A separate arithmetic inconsistency exists in Table 3 (several P/R/F1 cells do not satisfy Eq. 20), but that is a reproducibility defect, not constructional circularity, and does not change the score.

Assumptions & free parameters 4 free parameters · 4 assumptions · 0 invented entities

The method contributes a supervised learning pipeline. Its load-bearing premises are the representativeness of the injected faults, the informativeness of logs for the chosen anomaly classes, and the transferability of a single-database evaluation. These are unproven domain assumptions, not mathematical axioms.

free parameters (4)
  • Time window size T = 5 seconds
    Chosen by hand; Figure 5(b) shows larger windows improve F1 up to 100% on some workloads, so the default is a design choice that affects central results.
  • Log window size N = 100
    Preset log sequence length; set without derivation and not ablated in the paper.
  • Input feature matrix length beta = 64
    Padding and truncation length per node; Figure 4(a) shows performance varies with this value, so it is a tuned hyperparameter.
  • Latent matrix size theta = 16
    VAE latent dimension; Figure 4(b) shows performance depends on it, especially for IoT-Benchmark, so it is tuned to the workload.
assumptions (4)
  • domain assumption Log data from distributed databases contains sufficient discriminative signal to classify the seven injected failure types and normal operation.
    The entire method depends on this. Section 4.1 defines the injected anomalies and Section 4.4 evaluates classification on the resulting logs, but the paper provides no evidence that logs alone are sufficient.
  • domain assumption The fault-injection procedure produces accurately labeled, representative anomaly periods.
    Labels come from injection timestamps (Section 4.1, Figure 3). If injections do not align with observable log effects, the learned model would be trained on mislabeled data.
  • domain assumption Apache IoTDB on a 4-node Docker deployment is representative of distributed databases generally.
    The paper only tests on this one system, yet claims a method 'specifically designed for distributed databases'. Section 6 admits implementation is only on IoTDB.
  • domain assumption The training and test log distributions are identical and stable across the collected time windows.
    This is a standard supervised learning assumption. No discussion of concept drift or workload shifts beyond choosing three benchmark workloads.

how reviews work

0 comments
Cite this review

Pith. "Pith review of LogDB: Multivariate Log-based Failure Diagnosis for Distributed Databases (Extended from MultiLog)." pith.science (2026). https://pith.science/paper/XUY33KAJ

@misc{pith2026250501676,
  author       = {Pith},
  title        = {Pith review of: LogDB: Multivariate Log-based Failure Diagnosis for Distributed Databases (Extended from MultiLog)},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/XUY33KAJ}},
  note         = {Machine review of arXiv:2505.01676}
}
read the original abstract

Distributed databases, as the core infrastructure software for internet applications, play a critical role in modern cloud services. However, existing distributed databases frequently experience system failures and performance degradation, often leading to significant economic losses. Log data, naturally generated within systems, can effectively reflect internal system states. In practice, operators often manually inspect logs to monitor system behavior and diagnose anomalies, a process that is labor-intensive and costly. Although various log-based failure diagnosis methods have been proposed, they are generally not tailored for database systems and fail to fully exploit the internal characteristics and distributed nature of these systems. To address this gap, we propose LogDB, a log-based failure diagnosis method specifically designed for distributed databases. LogDB extracts and compresses log features at each database node and then aggregates these features at the master node to diagnose cluster-wide anomalies. Experiments conducted on the open-source distributed database system Apache IoTDB demonstrate that LogDB achieves robust failure diagnosis performance across different workloads and a variety of anomaly types.

Figures

Figures reproduced from arXiv: 2505.01676 by the authors.

Figure 1
Figure 1. Common Workflow of Log-based failure diagnosis [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Architecture of LogDB J. ACM, Vol. 37, No. 4, Article 111. Publication date: August 2025 [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Anomaly Injection Procedure The overall anomaly injection process is illustrated in [PITH_FULL_IMAGE:figures/full_fig_p008_3.png] view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: Performance of LogDB under different autoencoder parameters. [PITH_FULL_IMAGE:figures/full_fig_p012_4.png]
Figure 5
Figure 5. Figure 5: Performance of LogDB under different input settings. [PITH_FULL_IMAGE:figures/full_fig_p013_5.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. Adaptive Root Cause Localization for Microservice Systems with Multi-Agent Recursion-of-Thought

    cs.SE 2025-08 conditional novelty 4.0 of 10

    RCLAgent, a multi-agent recursion-of-thought system, reports Recall@1 of 71-90% on AIOps 2022 subsets from one trace, beating the Recall@10 of graph-based methods that need many requests.

Reference graph

Works this paper leans on

48 extracted references · 38 canonical work pages · cited by 1 Pith paper

  1. [1]

    Darcy G Benoit. 2005. Automatic diagnosis of performance problems in database management systems. In Second International Conference on Autonomic Computing (ICAC’05) . IEEE, 326–327

    work page 2005

  2. [2]

    Adam Björnberg. 2021. Cloud native chaos engineering for IoT systems

    work page 2021

  3. [3]

    Yingnong Dang, Qingwei Lin, and Peng Huang. 2019. Aiops: real-world challenges and research innovations. In 2019 IEEE/ACM 41st International Conference on Software Engineering: Companion Proceedings (ICSE-Companion) . IEEE, 4–5

    work page 2019

  4. [4]

    Philip Dexter, Bedri Sendir, and Kenneth Chiu. 2020. Detecting and reacting to anomalies in relaxed uses of Raft. In 2020 20th IEEE/ACM International Symposium on Cluster, Cloud and Internet Computing (CCGRID) . IEEE, 659–668

    work page 2020

  5. [5]

    Karl Dias, Mark Ramacher, Uri Shaft, Venkateshwaran Venkataramani, and Graham Wood. 2005. Automatic Performance Diagnosis and Tuning in Oracle.. In CIdR. 84–94

    work page 2005

  6. [6]

    Prashanth Dintyala, Arpit Narechania, and Joy Arulraj. 2020. SQLCheck: automated detection and diagnosis of SQL anti-patterns. In Proceedings of the 2020 ACM SIGMOD international conference on management of data . 2331–2345

    work page 2020

  7. [7]

    Min Du, Feifei Li, Guineng Zheng, and Vivek Srikumar. 2017. Deeplog: Anomaly detection and diagnosis from system logs through deep learning. InProceedings of the 2017 ACM SIGSAC conference on computer and communications security . 1285–1298

    work page 2017

  8. [8]

    Dejan Dundjerski and Milo Tomašević. 2020. Automatic database troubleshooting of Azure SQL Databases. IEEE Transactions on Cloud Computing 10, 3 (2020), 1604–1619

    work page 2020

Show all 48 references
  1. [9]

    Brad Glasbergen, Michael Abebe, Khuzaima Daudjee, and Amit Levi. 2020. Sentinel: universal analysis and insight for data systems. Proceedings of the VLDB Endowment 13, 12 (2020), 2720–2733. J. ACM, Vol. 37, No. 4, Article 111. Publication date: August 2025. 111:16 Lingzhe Zhang et al

    2020

  2. [10]

    Dongxu Huang, Qi Liu, Qiu Cui, Zhuhe Fang, Xiaoyu Ma, Fei Xu, Li Shen, Liu Tang, Yuxing Zhou, Menglong Huang, et al. 2020. TiDB: a Raft-based HTAP database. Proceedings of the VLDB Endowment 13, 12 (2020), 3072–3084

    2020

  3. [11]

    Zhenlan Ji, Pingchuan Ma, and Shuai Wang. 2023. Perfce: Performance debugging on databases with chaos engineering- enhanced causality analysis. In 2023 38th IEEE/ACM International Conference on Automated Software Engineering (ASE) . IEEE, 1454–1466

    2023

  4. [12]

    Tong Jia, Ying Li, Yong Yang, Gang Huang, and Zhonghai Wu. 2022. Augmenting log-based anomaly detection models to reduce false anomalies with human feedback. In Proceedings of the 28th ACM SIGKDD Conference on Knowledge Discovery and Data Mining . 3081–3089

    2022

  5. [13]

    Tong Jia, Yifan Wu, Chuanjia Hou, and Ying Li. 2021. Logflash: Real-time streaming anomaly detection and diagnosis from system logs for large-scale software systems. In 2021 IEEE 32nd International Symposium on Software Reliability Engineering (ISSRE). IEEE, 80–90

    2021

  6. [14]

    Prajakta Kalmegh, Shivnath Babu, and Sudeepa Roy. 2019. IQCar: Inter-query contention analyzer for data analytics frameworks. In Proceedings of the 2019 International Conference on Management of Data . 918–935

    2019

  7. [15]

    Yuyuan Kang, Xiangdong Huang, Shaoxu Song, Lingzhe Zhang, Jialin Qiao, Chen Wang, Jianmin Wang, and Julian Feinauer. 2022. Separation or not: On handing out-of-order time-series data in leveled lsm-tree. In 2022 IEEE 38th International Conference on Data Engineering (ICDE) . I...

    2022

  8. [16]

    Matt J Kusner, Brooks Paige, and José Miguel Hernández-Lobato. 2017. Grammar variational autoencoder. In Interna- tional conference on machine learning . PMLR, 1945–1954

    2017

  9. [17]

    Guoliang Li, Xuanhe Zhou, Ji Sun, Xiang Yu, Yue Han, Lianyuan Jin, Wenbo Li, Tianqing Wang, and Shifu Li. 2021. opengauss: An autonomous database system. Proceedings of the VLDB Endowment 14, 12 (2021), 3028–3042

    2021

  10. [18]

    Xiaoyun Li, Pengfei Chen, Linxiao Jing, Zilong He, and Guangba Yu. 2022. SwissLog: Robust anomaly detection and localization for interleaved unstructured logs. IEEE Transactions on Dependable and Secure Computing 20, 4 (2022), 2762–2780

    2022

  11. [19]

    Qingwei Lin, Hongyu Zhang, Jian-Guang Lou, Yu Zhang, and Xuewei Chen. 2016. Log clustering based problem identification for online service systems. In Proceedings of the 38th international conference on software engineering companion. 102–111

    2016

  12. [20]

    Ping Liu, Shenglin Zhang, Yongqian Sun, Yuan Meng, Jiahai Yang, and Dan Pei. 2020. Fluxinfer: Automatic diagnosis of performance anomaly for online database system. In 2020 IEEE 39th International Performance Computing and Communications Conference (IPCCC). IEEE, 1–8

    2020

  13. [21]

    Rui Liu, Jun Yuan, and Xiangdong Huang. 2019. Benchmarking time series databases with IoTDB-benchmark for IoT scenarios. arXiv preprint arXiv:1901.08304 (2019)

    2019 arXiv

  14. [22]

    Yudong Liu, Xu Zhang, Shilin He, Hongyu Zhang, Liqun Li, Yu Kang, Yong Xu, Minghua Ma, Qingwei Lin, Yingnong Dang, et al. 2022. Uniparser: A unified log parser for heterogeneous log data. In Proceedings of the ACM Web Conference

    2022

  15. [23]

    Minghua Ma, Zheng Yin, Shenglin Zhang, Sheng Wang, Christopher Zheng, Xinhao Jiang, Hanwen Hu, Cheng Luo, Yilin Li, Nengjun Qiu, et al. 2020. Diagnosing root causes of intermittent slow queries in cloud databases. Proceedings of the VLDB Endowment 13, 8 (2020), 1176–1189

    2020

  16. [24]

    Weibin Meng, Ying Liu, Yichen Zhu, Shenglin Zhang, Dan Pei, Yuqing Liu, Yihao Chen, Ruizhi Zhang, Shimin Tao, Pei Sun, et al. 2019. Loganomaly: Unsupervised detection of sequential and quantitative anomalies in unstructured logs.. In IJCAI, Vol. 19. 4739–4745

    2019

  17. [25]

    Karthik Nagaraj, Charles Killian, and Jennifer Neville. 2012. Structured comparative analysis of systems logs to diagnose performance problems. In 9th USENIX Symposium on Networked Systems Design and Implementation (NSDI 12). 353–366

    2012

  18. [26]

    Meikel Poess, Raghunath Nambiar, Karthik Kulkarni, Chinmayi Narasimhadevara, Tilmann Rabl, and Hans-Arno Jacobsen. 2018. Analysis of tpcx-iot: The first industry standard benchmark for iot gateway systems. In 2018 IEEE 34th International Conference on Data Engineering (ICDE) ....

    2018

  19. [27]

    What makes my queries slow?

    Youcef Remil, Anes Bendimerad, Romain Mathonat, Philippe Chaleat, and Mehdi Kaytoue. 2021. " What makes my queries slow?": Subgroup Discovery for SQL Workload Analysis. In 2021 36th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, 642–652

    2021

  20. [28]

    Changho Seo, Yunchang Chae, Jaeryun Lee, Euiseong Seo, and Byungchul Tak. 2022. Nosql database performance diagnosis through system call-level introspection. In NOMS 2022-2022 IEEE/IFIP Network Operations and Management Symposium. IEEE, 1–9

    2022

  21. [29]

    Daniel Seybold and Jörg Domaschka. 2021. Benchmarking-as-a-service for cloud-hosted dbms. In Proceedings of the 22nd International Middleware Conference: Demos and Posters . 12–13

    2021

  22. [30]

    Yicheng Sui, Yuzhe Zhang, Jianjun Sun, Ting Xu, Shenglin Zhang, Zhengdan Li, Yongqian Sun, Fangrui Guo, Junyu Shen, Yuzhi Zhang, et al. 2023. Logkg: Log failure diagnosis through knowledge graph. IEEE Transactions on Services Computing 16, 5 (2023), 3493–3507. J. ACM, Vol. 37,...

    2023

  23. [31]

    timescale. 2024. TSBS. https://github.com/timescale/tsbs

    2024

  24. [32]

    Chen Wang, Xiangdong Huang, Jialin Qiao, Tian Jiang, Lei Rui, Jinrui Zhang, Rong Kang, Julian Feinauer, Kevin A McGrail, Peng Wang, et al. 2020. Apache IoTDB: Time-series database for internet of things. Proceedings of the VLDB Endowment 13, 12 (2020), 2901–2904

    2020

  25. [33]

    Lin Yang, Junjie Chen, Zan Wang, Weijing Wang, Jiajun Jiang, Xuyuan Dong, and Wenbin Zhang. 2021. Semi-supervised log-based anomaly detection via probabilistic label estimation. In 2021 IEEE/ACM 43rd International Conference on Software Engineering (ICSE). IEEE, 1448–1460

    2021

  26. [34]

    Zhenkun Yang, Chuanhui Yang, Fusheng Han, Mingqiang Zhuang, Bing Yang, Zhifeng Yang, Xiaojun Cheng, Yuzhong Zhao, Wenhui Shi, Huafeng Xi, et al. 2022. OceanBase: a 707 million tpmC distributed relational database system. Proceedings of the VLDB Endowment 15, 12 (2022), 3385–3397

    2022

  27. [35]

    Dong Young Yoon, Ning Niu, and Barzan Mozafari. 2016. Dbsherlock: A performance diagnostic tool for transactional databases. In Proceedings of the 2016 international conference on management of data . 1599–1614

    2016

  28. [36]

    Yue Yuan, Wenchang Shi, Bin Liang, and Bo Qin. 2019. An approach to cloud execution failure diagnosis based on exception logs in openstack. In 2019 IEEE 12th International Conference on Cloud Computing (CLOUD) . IEEE, 124–131

    2019

  29. [37]

    Lingzhe Zhang, Tong Jia, Mengxi Jia, Ying Li, Yong Yang, and Zhonghai Wu. 2024. Multivariate Log-based Anomaly Detection for Distributed Database. In Proceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining. 4256–4267

    2024

  30. [38]

    Lingzhe Zhang, Tong Jia, Mengxi Jia, Hongyi Liu, Yong Yang, Zhonghai Wu, and Ying Li. 2024. Towards Close-To-Zero Runtime Collection Overhead: Raft-Based Anomaly Diagnosis on System Faults for Distributed Storage System. IEEE Transactions on Services Computing (2024)

    2024

  31. [39]

    Lingzhe Zhang, Tong Jia, Mengxi Jia, Yifan Wu, Aiwei Liu, Yong Yang, Zhonghai Wu, Xuming Hu, Philip S Yu, and Ying Li. 2024. A survey of aiops for failure management in the era of large language models. arXiv preprint arXiv:2406.11213 (2024)

    2024 arXiv

  32. [40]

    Lingzhe Zhang, Tong Jia, Mengxi Jia, Yifan Wu, Hongyi Liu, and Ying Li. 2025. ScalaLog: Scalable Log-Based Failure Diagnosis Using LLM. In ICASSP 2025-2025 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP). IEEE, 1–5

    2025

  33. [41]

    Lingzhe Zhang, Tong Jia, Mengxi Jia, Yifan Wu, Hongyi Liu, and Ying Li. 2025. XRAGLog: A Resource-Efficient and Context-Aware Log-Based Anomaly Detection Method Using Retrieval-Augmented Generation. In AAAI 2025 Workshop on Preventing and Detecting LLM Misinformation (PDLM)

    2025

  34. [42]

    Lingzhe Zhang, Tong Jia, Kangjin Wang, Mengxi Jia, Yong Yang, and Ying Li. 2024. Reducing events to augment log-based anomaly detection models: An empirical study. In Proceedings of the 18th ACM/IEEE International Symposium on Empirical Software Engineering and Measurement . 538–548

    2024

  35. [43]

    Lingzhe Zhang, Yunpeng Zhai, Tong Jia, Chiming Duan, Siyu Yu, Jinyang Gao, Bolin Ding, Zhonghai Wu, and Ying Li

  36. [44]

    Lingzhe Zhang, Yunpeng Zhai, Tong Jia, Xiaosong Huang, Chiming Duan, and Ying Li. 2025. AgentFM: Role-Aware Failure Management for Distributed Databases with LLM-Driven Multi-Agents. arXiv preprint arXiv:2504.06614 (2025)

    2025 arXiv

  37. [45]

    Ling-Zhe Zhang, Xiang-Dong Huang, Yan-Kai Wang, Jia-Lin Qiao, Shao-Xu Song, and Jian-Min Wang. 2024. Time-tired compaction: An elastic compaction scheme for LSM-tree based time-series database. Advanced Engineering Informatics 59 (2024), 102224

    2024

  38. [46]

    Xu Zhang, Yong Xu, Qingwei Lin, Bo Qiao, Hongyu Zhang, Yingnong Dang, Chunyu Xie, Xinsheng Yang, Qian Cheng, Ze Li, et al . 2019. Robust log-based anomaly detection on unstable log data. In Proceedings of the 2019 27th ACM joint meeting on European software engineering confere...

    2019

  39. [47]

    Xuanhe Zhou, Lianyuan Jin, Ji Sun, Xinyang Zhao, Xiang Yu, Jianhua Feng, Shifu Li, Tianqing Wang, Kun Li, and Luyang Liu. 2021. Dbmind: A self-driving platform in opengauss. Proceedings of the VLDB Endowment 14, 12 (2021), 2743–2746. J. ACM, Vol. 37, No. 4, Article 111. Public...

    2021

  40. [2025]

    arXiv preprint arXiv:2504.18776 (2025)

    ThinkFL: Self-Refining Failure Localization for Microservice Systems via Reinforcement Fine-Tuning. arXiv preprint arXiv:2504.18776 (2025)

    2025

Pith tools

Reviewed August 16, 2026 · model on record in the stance chip above.