Log Parsing: How Far Can ChatGPT Go?

Van-Hoang Le^1 and
Hongyu Zhang^222Hongyu Zhang is the corresponding author.

^1School of Information and Physical Sciences, The University of Newcastle, Australia
^2School of Big Data and Software Engineering, Chongqing University, China
<EMAIL_ADDRESS><EMAIL_ADDRESS>
Software logs play an essential role in ensuring the reliability and maintainability of large-scale software systems, as they are often the sole source of runtime information. Log parsing, which converts raw log messages into structured data, is an important initial step towards downstream log analytics. In recent studies, ChatGPT, the current cutting-edge

large language model (LLM), has been widely applied to a wide range of software engineering tasks. However, its performance in automated log parsing remains unclear. In this paper, we evaluate ChatGPT’s ability to undertake log parsing by addressing two research questions. (1) Can ChatGPT effectively parse logs? (2) How does ChatGPT perform with different prompting methods?
Our results show that ChatGPT can achieve promising results
for log parsing with appropriate prompts, especially with
few-shot prompting.
Based on our findings, we outline several challenges and opportunities for ChatGPT-based log parsing.

Log analytics, Log parsing, Large language model, ChatGPT

§ INTRODUCTION

Large-scale software-intensive systems, such as cloud computing and big data systems, generate a large
amount of logs for troubleshooting purposes.
Log messages are produced during software runtime by the logging statements in source code.
They record system events and dynamic runtime information,

which can help developers and operators understand system behavior and perform system diagnostic tasks, such as anomaly detection [1, 2, 3, 4], failure prediction [5, 6], and failure diagnosis [7, 8].

Log parsing is an important initial step of many downstream log-based system diagnostic tasks. Through log parsing, free-text raw log messages are converted into a stream of structured events [9, 10, 11, 12].
To achieve better log parsing accuracy, many data-driven approaches, such as those based on clustering [13, 14], frequent pattern mining [15, 16], and heuristics [10, 9, 17], have been proposed to automatically distinguish the constant and variable parts of log messages [12, 11, 18].

Recent studies adopt pre-trained language models for representing [4, 18, 19] log data.

However, these methods still require either training models from scratch [20] or tuning a pre-trained language model with labelled data [4, 18], which could be impractical due to the scarcity of computing resources and labelled data.

More recently,
large language models (LLMs) such as ChatGPT [21] has been applied to a variety of software engineering tasks
and achieved satisfactory performance
[22, 23].

However, it is unclear whether or not ChatGPT can effectively perform automated log parsing. More research is needed to determine its capabilities in this important area.
Therefore, in this paper, we conduct a preliminary evaluation of ChatGPT for log parsing.

More specifically, we design appropriate prompts to guide ChatGPT to understand the log parsing task and extract the log event/template from the input log messages.

We then compare the performance of ChatGPT with that of SOTA (state-of-the-art) log parsers in zero-shot scenario. We also examine the performance of ChatGPT with a few log parsing demonstrations (few-shot scenarios). Finally, we analyze the performance of ChatGPT
to explore its potential in log parsing. Our experimental results show that ChatGPT can achieve promising results for log parsing with appropriate prompts, especially with few-shot prompting.

We also outline several challenges and opportunities for ChatGPT-based log parsing.

In summary, the major contributions of this work are as follows:

* To the best of our knowledge, we are the first to investigate and analyze ChatGPT's ability to undertake log parsing.

* We evaluate ChatGPT-based log parsing on widely-used log datasets and compare it with SOTA log parsers.

* Based on the findings, we outline several challenges and prospects for ChatGPT-based log parsing.

§ BACKGROUND

§.§ Log Data

Large and complex software-intensive systems often produce a large amount of log data for troubleshooting purposes during system operation. Log data records the system’s events and internal states during runtime.
Figure <ref> shows a snippet of log data generated by Spark.

An example of log data and log parsing from Spark

A log message usually contains a header that is automatically produced by the logging framework, including information such as component and verbosity level. The log message body (log message for short) typically consists of two parts: 1) Template - constant strings (or keywords) describing the system events; 2) Parameters/Variables - dynamic variables, which
reflect specific runtime status. Figure <ref> shows an example of logs produced by Spark, where the header (including Datetime, Component, and Level) is generated by the logging framework and is generally easy to extract. The log event/template Putting block <*> with replication took <*> associated with parameters (e.g., rdd_0_1, 0), in contrast, is often difficult to identify.

§.§ Log Parsing

Log parsing typically serves as the first step toward automated log analytics.
It aims at parsing each log message into a specific log event/template and extracting the corresponding parameters.
To achieve better performance compared to traditional regular expression-based log parsers, many data-driven approaches have been proposed to automatically distinguish template and parameter parts. These data-driven approaches can be categorized into several groups. 1) Similarity-based clustering: LKE [24], LogSig [13], and LenMa [14] compute distances between two log messages or their signature to cluster them based on similarity. 2) Frequent pattern mining: SLCT [25], LFA [16], and Logram [15] leverage frequent patterns of token position or $n$-gram information to extract log templates that appear constantly across log messages. 3) Heuristics-based searching: Drain [10], Spell [9], SwissLog [17], and SPINE [26] utilize a tree structure to parse logs into multiple templates. 4) Deep learning based parsing: UniParser [20] formulates log parsing as a token classification problem and LogPPT [18] leverages language models to perform log parsing in few-shot scenarios.

Structured log data, obtained after log parsing, can be used for many downstream log analytics tasks, such as
anomaly detection [27, 2, 3], failure prediction [5, 28], and failure diagnosis [8, 7].

§ STUDY DESIGN

§.§ Research Questions

We aim at answering the following research questions through experimental evaluation:

* Can ChatGPT effectively perform log parsing?

* How does ChatGPT perform with different prompting methods?

RQ1 is to evaluate the effectiveness of ChatGPT in log parsing. To answer RQ1, we provide a basic definition of log parsing (i.e., abstracting the dynamic variables in logs [29]) and ask ChatGPT to extract the log template for one log message per request by using the following prompt template (where the slot `[LOG]' indicates the input log message):

[label=pt:zero-shot-1, title=Prompt Template (PT)]
You will be provided with a log message delimited by backticks. You must abstract variables with `{placeholders}' to extract the corresponding template. Print the input log's template delimited by backticks.

Log message: `highlightY[LOG]'

RQ2 aims at investigating the impact of prompting methods
on ChatGPT-based log parsing.

Specifically, we evaluate the performance of ChatGPT under two experimental settings:

* Few-shot scenarios: Since log data is heterogeneous, we follow a recent study [18] to provide a few demonstrations (1, 2, and 4) of log parsing when applying ChatGPT to log data. Specifically, we use the following prompt template to ask ChatGPT to extract the log template of an input log:
[label=pt:fewshot, title=Prompt Template (PT)]
You will be provided with a log message delimited by backticks. You must abstract variables with `{placeholders}' to extract the corresponding template.

For example:

The template of `[DEMO_LOG1]' is `[TEMPLATE1]'.

The template of `[DEMO_LOG2]' is `[TEMPLATE2]'.

Print the input log's template delimited by backticks.

Log message: `highlightY[LOG]'

* Different prompts: We evaluate the impact of different prompts on log parsing with ChatGPT. Specifically, along with PT<ref>, we further evaluate a simple (PT<ref>) and an enhanced (PT<ref>) prompt as follows:

[label=pt:zero-shot-simple, title=Prompt Template - Simple (PT)]
You will be provided with a log message delimited by backticks. Please extract the log template from this log message:

[label=pt:zero-shot-enhance, title=Prompt Template - Enhance (PT)]
You will be provided with a log message delimited by backticks. You must identify and abstract all the dynamic variables in logs with `{placeholders}` and output a static log template.
Print the input log's template delimited by backticks.

Log message: `highlightY[LOG]'

§.§ Benchmark and Setting

We conduct experiments on 16 datasets originated from the LogPai benchmark [30, 11]. This benchmark covers log data from various systems, including distributed systems, supercomputers, operating systems, mobile systems, server applications, and standalone software. Since there are multiple errors in the original benchmark, in this paper, we use the corrected version of this benchmark [31] in our evaluation. Each dataset contains 2,000 manually labelled log messages.

We build a pipeline for our experiments using the ChatGPT API based on the gpt-3.5-turbo model released by OpenAI [21]. To avoid bias from model updates, we use a snapshot of gpt-3.5-turbo from March 2023 [32].

§.§ Baselines

We compare our proposed method with five state-of-the-art log parsers, including AEL [33], Spell [9], Drain [10], Logram [15], and SPINE [26].

We choose these five parsers in our evaluation since their source code is publicly available; and a prior study [11, 31] finds that these parsers have high accuracy and efficiency among the evaluated log parsing methods. For SPINE, we use the source code provided by its authors. For other baselines, we adopt the implementation of these methods from their replication packages [34, 12].

§.§ Evaluation Metrics

Following recent studies[12, 20, 35], we apply three metrics to comprehensively evaluate the effectiveness of log parsing, including:

* Group Accuracy (GA): Group Accuracy [11] is the most commonly used metric for log parsing. The GA metric is defined as the ratio of “correctly parsed” log messages over the total number of log messages, where a log message is considered “correctly parsed” if and only if it is grouped with other log messages consistent with the ground truth.

* Message Level Accuracy (MLA): The Message Level Accuracy [20] metric is defined as the ratio of “correctly parsed” log messages over the total number of log messages, where a log message is considered to be “correctly parsed” if and only if every token of the log message is correctly identified as template or variable.

* Edit Distance (ED): Edit Distance [35] measure the accuracy of log parsers in terms of lexical similarity between parsed results and ground truth, by computing the distance between parsed templates and ground truth templates.

§ RESULTS

§.§ The Effectiveness of ChatGPT in Log Parsing

In this RQ, we evaluate the performance of ChatGPT-based log parsing in the zero-shot scenario. We compare the results of ChatGPT with baselines in terms of GA, MLA, and ED. Table <ref> shows the results. For each dataset, the best accuracy is highlighted in boldface.
The results show that, in terms of GA, ChatGPT achieves the best accuracy on three out of 16 datasets. On average, it achieves a GA of 0.721, which outperforms the average result of Logram by 33.5%, and is 0.85x of that of the best baseline Drain.

Regarding MLA and ED, ChatGPT significantly outperforms the baselines with an improvement of 41.0% to 212.1% in MLA and 14.2% to 50.2% in ED. Specifically, it achieves the best results on 10 out of 16 datasets in terms of MLA and 8 out of 16 datasets in terms of ED.
The results indicate that ChatGPT is able to distinguish variable and content tokens in log messages, as reflected by the high MLA values.
However, there is much log-specific information (such as domain URLs, API endpoint addresses, block/task IDs, etc), which varies a lot across log data.
has difficulties in correctly recognizing these log-specific information,
leading to lower GA values.
Figure <ref> shows some examples of log templates generated by ChatGPT and Drain. We can see that ChatGPT correctly identifies variable values and types in the second log message (i.e., username and uid). However, it cannot recognize the whole address of video.5054399.com:80 as one variable in the first log message.

Examples of log parsing with ChatGPT

§.§ The Performance of ChatGPT-based Log Parsing under Different Prompting Methods

§.§.§ With few-shot scenarios

We evaluate the performance of ChatGPT in few-shot scenarios using PT<ref>. For the 1-shot scenario, we search for the most frequent log message and use it as the example for ChatGPT. For 2-shot and 4-shot scenarios, we apply a few-shot random sampling algorithm [18] to select 2 and 4 examples for ChatGPT.
Table <ref> shows the results.
We observe a noticeable improvement of 19.5% and 29.9% in MLA and ED, respectively, with just one example of log parsing.
With 4 examples, ChatGPT achieves the best MLA and ED on all 16 datasets and significantly outperforms the other log parsers. It also achieves a comparable GA to the second best log parser, SPINE.

The results indicate that ChatGPT is able to learn log parsing from a few demonstrations and achieves good performance. It also shows that ChatGPT exhibits good generality to a variety of log data through few-shot learning.

§.§.§ With different prompts

Different prompts could lead to different results when applying LLM. In this RQ, we evaluate the performance of ChatGPT on log parsing using (1) a simple prompt (PT<ref>): we directly ask ChatGPT to return the template of a log message;
and (2) an enhanced prompt (PT<ref>): we specifically ask ChatGPT to follow three steps of log parsing: identify variables, abstract variables, and output a static template. Table <ref> shows the results.

We notice that with a simple prompt, ChatGPT can hardly understand the concept of log parsing and thus achieve low accuracy (e.g., 0.493 GA). There are many cases where ChatGPT asks for more information when we use PT<ref>. In contrast, with the aid of the enhanced prompt (PT<ref>), ChatGPT can perform log parsing more effectively. Specifically, it achieves an improvement of 9.4% and 21.8% over PT<ref> in MLA and ED, respectively. Overall, the design of prompts has a large impact on the performance of log parsing with ChatGPT. Including a clearer intention in the prompt could enhance parsing accuracy.

§ DISCUSSION

Based on our findings, we highlight several challenges and prospects for ChatGPT-based log parsing.

(1) Handling log-specific data.
Our study on log parsing indicates that it is promising to analyze log data with ChatGPT. However, it also shows that ChatGPT still faces difficulties in recognizing log-specific information generated during runtime (e.g., domain URLs, API endpoint addresses, etc.). Since these information occur frequently in log data, it could hinder the ability of ChatGPT in understanding log data.

(2) The selection of demonstrations. Our experimental results show that ChatGPT exhibits good performance with few-shot prompting. Overall, the performance of ChatGPT can be improved with more demonstrations. However, we observe that in some cases, these demonstrations could bring noise and confuse the model (see Table <ref>). Therefore, it is necessary to ensure the quality of selected demonstrations. How to select a small yet effective set of examples is an important future work.

(3) Designing better prompts. In this paper, we found that different prompts could have a big impact on the performance of ChatGPT-based log parsing. Although many prompting methods have been proposed [36, 37, 38],

it remains to explore which prompting method is suitable for log parsing, how to systematically design prompts, and whether there are better prompting methods. Future work is required toward designing better prompts for log parsing.

(4) Toward semantic-aware log parsing. We observe that ChatGPT is able to not only extract the template associated with variables but also semantically identify the categories of variables (see Figure <ref>).

This awareness of variables' semantics could improve the accuracy of downstream tasks such as anomaly detection [29, 39]. Although achieving good initial results, future studies should be conducted to comprehensively evaluate the ability of ChatGPT toward semantic-aware log parsing.

§ CONCLUSION

The paper discusses the potential of using ChatGPT, a popular large language model, for log parsing. We have designed appropriate prompts to guide ChatGPT to understand the log parsing task and compared its performance with state-of-the-art log parsers in zero-shot and few-shot scenarios. Our experimental results show that ChatGPT can achieve promising results for log parsing with appropriate prompts, especially with few-shot prompting. We also outline several challenges and opportunities for ChatGPT-based log parsing. In our future work, we will comprehensively evaluate the performance of ChatGPT and other LLMs on more log analytics tasks.

Our experimental data are available at: <https://github.com/LogIntelligence/log-analytics-chatgpt>.

§ ACKNOWLEDGMENT

This work is supported by Australian Research Council (ARC) Discovery Projects (DP200102940, DP220103044).
We also thank anonymous reviewers for their insightful and constructive comments, which significantly improve this paper.

[1]
V.-H. Le and H. Zhang, “Log-based anomaly detection with deep learning: How
far are we?” in Proceedings of the 44th International Conference on
Software Engineering, 2022, pp. 1356–1367.

[2]
M. Du, F. Li, G. Zheng, and V. Srikumar, “Deeplog: Anomaly detection and
diagnosis from system logs through deep learning,” in Proceedings of
the 2017 ACM SIGSAC Conference on Computer and Communications Security,
2017, pp. 1285–1298.

[3]
X. Zhang, Y. Xu, Q. Lin, B. Qiao, H. Zhang, Y. Dang, C. Xie, X. Yang, Q. Cheng,
Z. Li et al., “Robust log-based anomaly detection on unstable log
data,” in Proceedings of the 2019 27th ACM Joint Meeting on European
Software Engineering Conference and Symposium on the Foundations of Software
Engineering, 2019, pp. 807–817.

[4]
V.-H. Le and H. Zhang, “Log-based anomaly detection without log parsing,” in
2021 36th IEEE/ACM International Conference on Automated Software
Engineering (ASE), 2021, pp. 492–504.

[5]
A. Das, F. Mueller, C. Siegel, and A. Vishnu, “Desh: deep learning for system
health prediction of lead times to failure in hpc,” in Proceedings of
the 27th International Symposium on High-Performance Parallel and Distributed
Computing, 2018, pp. 40–51.

[6]
B. Russo, G. Succi, and W. Pedrycz, “Mining system logs to learn error
predictors: a case study of a telemetry system,” Empirical Software
Engineering, vol. 20, pp. 879–927, 2015.

[7]
S. Lu, B. Rao, X. Wei, B. Tak, L. Wang, and L. Wang, “Log-based abnormal task
detection and root cause analysis for spark,” in 2017 IEEE
International Conference on Web Services (ICWS).1em plus 0.5em minus
0.4emIEEE, 2017, pp. 389–396.

[8]
N. Gurumdimma, A. Jhumka, M. Liakata, E. Chuah, and J. Browne, “Crude:
combining resource usage data and error logs for accurate error detection in
large-scale distributed systems,” in 2016 IEEE 35th Symposium on
Reliable Distributed Systems (SRDS).1em plus 0.5em minus 0.4emIEEE, 2016, pp. 51–60.

[9]
M. Du and F. Li, “Spell: Streaming parsing of system event logs,” in
2016 IEEE 16th International Conference on Data Mining (ICDM).1em plus 0.5em minus 0.4emIEEE, 2016, pp. 859–864.

[10]
P. He, J. Zhu, Z. Zheng, and M. R. Lyu, “Drain: An online log parsing approach
with fixed depth tree,” in 2017 IEEE International Conference on Web
Services (ICWS).1em plus 0.5em minus 0.4emIEEE, 2017, pp.

[11]
J. Zhu, S. He, J. Liu, P. He, Q. Xie, Z. Zheng, and M. R. Lyu, “Tools and
benchmarks for automated log parsing,” in 2019 IEEE/ACM 41st
International Conference on Software Engineering: Software Engineering in
Practice (ICSE-SEIP).1em plus 0.5em minus 0.4emIEEE, 2019, pp.

[12]
“Artifact for "guidelines for assessing the accuracy of log message template
identification techniques",” 2023. [Online]. Available:

[13]
L. Tang, T. Li, and C.-S. Perng, “Logsig: Generating system events from raw
textual logs,” in Proceedings of the 20th ACM international conference
on Information and knowledge management, 2011, pp. 785–794.

[14]
K. Shima, “Length matters: Clustering system log messages using length of
words,” arXiv preprint arXiv:1611.03213, 2016.

[15]
H. Dai, H. Li, C. S. Chen, W. Shang, and T.-H. Chen, “Logram: Efficient log
parsing using n-gram dictionaries,” IEEE Transactions on Software
Engineering, 2020.

[16]
M. Nagappan and M. A. Vouk, “Abstracting log lines to log event types for
mining software system logs,” in 2010 7th IEEE Working Conference on
Mining Software Repositories (MSR 2010).1em plus 0.5em minus
0.4emIEEE, 2010, pp. 114–117.

[17]
X. Li, P. Chen, L. Jing, Z. He, and G. Yu, “Swisslog: Robust and unified deep
learning based log anomaly detection for diverse faults,” in 2020 IEEE
31st International Symposium on Software Reliability Engineering
(ISSRE).1em plus 0.5em minus 0.4emIEEE, 2020, pp. 92–103.

[18]
V.-H. Le and H. Zhang, “Log parsing with prompt-based few-shot learning,” in
2023 IEEE/ACM 45th International Conference on Software Engineering
(ICSE), 2023, pp. 2438–2449.

[19]
S. Tao, W. Meng, Y. Cheng, Y. Zhu, Y. Liu, C. Du, T. Han, Y. Zhao, X. Wang, and
H. Yang, “Logstamp: Automatic online log parsing based on sequence
labelling,” ACM SIGMETRICS Performance Evaluation Review, vol. 49,
no. 4, pp. 93–98, 2022.

[20]
Y. Liu, X. Zhang, S. He, H. Zhang, L. Li, Y. Kang, Y. Xu, M. Ma, Q. Lin,
Y. Dang et al., “Uniparser: A unified log parser for heterogeneous
log data,” in Proceedings of the ACM Web Conference 2022, 2022, pp.

[21]
“Openai chatgpt,” 2023. [Online]. Available:

[22]
S. Gao, X.-C. Wen, C. Gao, W. Wang, H. Zhang, and M. R. Lyu, “What makes good
in-context demonstrations for code intelligence tasks with llms?” in
Proceedings of 38th IEEE/ACM International Conference on Automated
Software Engineering, 2023.

[23]
J. Cao, M. Li, M. Wen, and S.-C. Cheung, “A study on prompt design, advantages
and limitations of chatgpt for deep learning program repair,” arXiv
preprint arXiv:2304.08191, 2023.

[24]
Q. Fu, J.-G. Lou, Y. Wang, and J. Li, “Execution anomaly detection in
distributed systems through unstructured log analysis,” in 2009 Ninth
IEEE International Conference on Data Mining.1em plus 0.5em minus
0.4emIEEE, 2009, pp. 149–158.

[25]
R. Vaarandi, “A data clustering algorithm for mining patterns from event
logs,” in Proceedings of the 3rd IEEE Workshop on IP Operations &
Management (IPOM 2003)(IEEE Cat. No. 03EX764).1em plus 0.5em minus
0.4emIeee, 2003, pp. 119–126.

[26]
X. Wang, X. Zhang, L. Li, S. He, H. Zhang, Y. Liu, L. Zheng, Y. Kang, Q. Lin,
Y. Dang et al., “Spine: a scalable log parser with feedback
guidance,” in Proceedings of the 30th ACM Joint European Software
Engineering Conference and Symposium on the Foundations of Software
Engineering, 2022, pp. 1198–1208.

[27]
S. He, J. Zhu, P. He, and M. R. Lyu, “Experience report: System log analysis
for anomaly detection,” in 2016 IEEE 27th international symposium on
software reliability engineering (ISSRE).1em plus 0.5em minus
0.4emIEEE, 2016, pp. 207–218.

[28]
X. L. Li and P. Liang, “Prefix-tuning: Optimizing continuous prompts for
generation,” in Proceedings of the 59th Annual Meeting of the
Association for Computational Linguistics and the 11th International Joint
Conference on Natural Language Processing (Volume 1: Long Papers), 2021, pp.

[29]
Z. Li, C. Luo, T.-H. Chen, W. Shang, S. He, Q. Lin, and D. Zhang, “Did we miss
something important? studying and exploring variable-aware log abstraction,”
in 2023 IEEE/ACM 45th International Conference on Software Engineering
(ICSE), 2023, pp. 830–842.

[30]
S. He, J. Zhu, P. He, and M. R. Lyu, “Loghub: a large collection of system log
datasets towards automated log analytics,” arXiv preprint
arXiv:2008.06448, 2020.

[31]
Z. A. Khan, D. Shin, D. Bianculli, and L. Briand, “Guidelines for assessing
the accuracy of log message template identification techniques,” in
Proceedings of the 44th International Conference on Software
Engineering (ICSE’22).1em plus 0.5em minus 0.4emACM, 2022.

[32]
“Gpt-3.5-turbo,” 2023. [Online]. Available:

[33]
Z. M. Jiang, A. E. Hassan, P. Flora, and G. Hamann, “Abstracting execution
logs to execution events for enterprise applications (short paper),” in
2008 The Eighth International Conference on Quality Software.1em plus 0.5em minus 0.4emIEEE, 2008, pp. 181–186.

[34]
“A toolkit for automated log parsing,” 2023. [Online]. Available:

[35]
S. Nedelkoski, J. Bogatinovski, A. Acker, J. Cardoso, and O. Kao,
“Self-supervised log parsing,” in Joint European Conference on
Machine Learning and Knowledge Discovery in Databases.1em plus 0.5em
minus 0.4emSpringer, 2020, pp. 122–138.

[36]
P. Liu, W. Yuan, J. Fu, Z. Jiang, H. Hayashi, and G. Neubig, “Pre-train,
prompt, and predict: A systematic survey of prompting methods in natural
language processing,” ACM Computing Surveys, vol. 55, no. 9, pp.
1–35, 2023.

[37]
J. Wei, X. Wang, D. Schuurmans, M. Bosma, F. Xia, E. H. Chi, Q. V. Le, D. Zhou
et al., “Chain-of-thought prompting elicits reasoning in large
language models,” in Advances in Neural Information Processing

[38]
L. Wang, W. Xu, Y. Lan, Z. Hu, Y. Lan, R. K.-W. Lee, and E.-P. Lim,
“Plan-and-solve prompting: Improving zero-shot chain-of-thought reasoning by
large language models,” arXiv preprint arXiv:2305.04091, 2023.

[39]
Y. Huo, Y. Su, C. Lee, and M. R. Lyu, “Semparser: A semantic parser for log
analytics,” in 2023 IEEE/ACM 45th International Conference on Software
Engineering (ICSE).1em plus 0.5em minus 0.4emIEEE, 2023, pp.