Scalable Inference of System-level Models from Component Logs

TL;DR

This paper introduces SCALER, a scalable method for inferring system-level behavioral models from component logs, even with incomplete communication information, by combining component models based on high-level architecture dependencies.

Contribution

SCALER is a novel divide-and-conquer approach that infers component models separately and merges them, improving scalability and accuracy over existing techniques.

Findings

SCALER processes larger logs than state-of-the-art tools.

SCALER produces more accurate system models.

Evaluation on industrial logs demonstrates effectiveness.

Abstract

Behavioral software models play a key role in many software engineering tasks; unfortunately, these models either are not available during software development or, if available, they quickly become outdated as the implementations evolve. Model inference techniques have been proposed as a viable solution to extract finite-state models from execution logs. However, existing techniques do not scale well when processing very large logs, such as system-level logs obtained by combining component-level logs. Furthermore, in the case of component-based systems, existing techniques assume to know the definitions of communication channels between components. However, this information is usually not available in the case of systems integrating 3rd-party components with limited documentation. In this paper, we address the scalability problem of inferring the model of a component-based system from the individual component-level logs, when the only available information about the system are high-level architecture dependencies among components and a (possibly incomplete) list of log message templates denoting communication events between components. Our model inference technique, called SCALER, follows a divide and conquer approach. The idea is to first infer a model of each system component from the corresponding logs; then, the individual component models are merged together taking into account the dependencies among components, as reflected in the logs. We evaluated SCALER in terms of scalability and accuracy, using a dataset of logs from an industrial system; the results show that SCALER can process much larger logs than a state-of-the-art tool, while yielding more accurate models.

Tables

Table 1. TABLE I: Extracted log entries dependencies for the running example

Execution	Log entry dependencies
Exec1	$e_1^{\mathrm{𝑇𝐶}}\rightsquigarrow ⟨e_1^{\mathrm{𝑀𝑈𝑋}},e_2^{\mathrm{𝑀𝑈𝑋}},e_3^{\mathrm{𝑀𝑈𝑋}},e_4^{\mathrm{𝑀𝑈𝑋}}⟩$
	$e_1^{\mathrm{𝑇𝐶}}\rightsquigarrow ⟨e_1^{\mathrm{𝐶𝐻𝐾}}⟩$ , $e_2^{\mathrm{𝑇𝐶}}\rightsquigarrow ⟨e_5^{\mathrm{𝑀𝑈𝑋}}⟩$
	$e_2^{\mathrm{𝑇𝐶}}\rightsquigarrow ⟨e_2^{\mathrm{𝐶𝐻𝐾}}⟩$, $e_4^{\mathrm{𝑀𝑈𝑋}}\rightsquigarrow ⟨e_1^{\mathrm{𝐺𝑊}}⟩$
Exec2	$e_1^{\mathrm{𝑇𝐶}}\rightsquigarrow ⟨e_1^{\mathrm{𝑀𝑈𝑋}},e_2^{\mathrm{𝑀𝑈𝑋}},e_3^{\mathrm{𝑀𝑈𝑋}}⟩$
	$e_1^{\mathrm{𝑇𝐶}}\rightsquigarrow ⟨e_1^{\mathrm{𝐶𝐻𝐾}}⟩$ , $e_2^{\mathrm{𝑇𝐶}}\rightsquigarrow ⟨e_4^{\mathrm{𝑀𝑈𝑋}}⟩$
	$e_4^{\mathrm{𝑀𝑈𝑋}}\rightsquigarrow ⟨e_1^{\mathrm{𝐺𝑊}}⟩$

Table 2. TABLE II: Execution time (in seconds), recall, and specificity of SCALER and MINT

Dataset	Size	Exec	System-level gFSM						Scalability					Accuracy
			States			Transitions			MINT	SCALER			SpeedUp	Recall			Specificity
			MINT	SCALER	Ratio	MINT	SCALER	Ratio		Prep($s$)	Stitch($s$)	Total($s$)		MINT	SCALER	${\Delta }_{\text{R}}$($pp$)	MINT	SCALER	${\Delta }_{\text{S}}$($pp$)
D05K	5058	13	617.7	3816	6.2	837.2	7295	8.7	319.6	6.0	5.8	11.8	27.1	0.09	0.65	56	1.00	0.98	-2
D10K	10208	28	1207.3	6647	5.5	1585.4	12720	8.0	2597.0	10.9	15.3	26.2	99.2	0.16	0.63	47	0.99	0.98	-1
D15K	15078	42	1582.6	4184	2.6	2064.4	8868	4.3	7403.8	13.4	19.8	33.2	222.8	0.52	0.82	30	0.99	0.97	-2
D20K	20094	56	2257.0	7463	3.3	2914.7	15851	5.4	16022.2	18.6	32.1	50.7	315.9	0.58	0.86	28	0.98	0.97	-1
D25K	25034	71	3067.2	9496	3.1	3976.3	18767	4.7	35378.6	24.3	58.2	82.5	428.7	0.56	0.83	27	0.98	0.96	-2
D30K	30103	86	2871.3	19467	6.8	3701.8	40204	10.9	59222.7	29.0	129.6	158.6	373.3	0.61	0.86	25	0.98	0.96	-2
D35K	35079	101	N/A	10432	N/A	N/A	19707	N/A	timeout	32.5	72	104.5	N/A	N/A	0.88	N/A	N/A	0.97	N/A
Avg	20093.4	56.7	1933.9	8786.4	4.6	2513.3	17630.3	7.0	20157.3	19.3	47.5	66.8	244.5	0.42	0.79	35.5	0.99	0.97	-1.67

Full text

In this paper, we address the scalability problem of inferring the model of a component-based system from the individual component-level logs, when the only available information about the system are high-level architecture dependencies among components and a (possibly incomplete) list of log message templates denoting communication events between components. Our model inference technique, called SCALER, follows a divide and conquer approach. The idea is to first infer a model of each system component from the corresponding logs; then, the individual component models are merged together taking into account the dependencies among components, as reflected in the logs. We evaluated SCALER in terms of scalability and accuracy, using a dataset of logs from an industrial system; the results show that SCALER can process much larger logs than a state-of-the-art tool, while yielding more accurate models.

I Introduction

Behavior models of software system components play a key role in many software engineering tasks, such as program comprehension [1], test case generation [2], and model checking [3]. Unfortunately, such models either are scarce during software development or, if available, they quickly become outdated as the implementations evolve, because of the time and cost involved in generating and maintaining them [4].

One possible way to overcome the lack of software models is to use model inference techniques, which extract models—typically in the form of (some type of) Finite State Machine (FSM)—from execution logs. Although the problem of inferring a minimal FSM is NP-complete [5], there have been several proposals of polynomial-time approximation algorithms to infer FSMs [5, 6, 7] or richer variants, such as gFSM (guarded FSM) [8, 9] and gFSM extended with transition probabilities [10], to obtain more faithful models.

Although the aforementioned model inference techniques are fast and accurate enough for relatively small programs, all of them suffer from scalability issues, due to the intrinsic computational complexity of the problem. This leads to out-of-memory errors or extremely long, unpractical execution time when processing very large logs [11], such as system-level logs obtained by combining (e.g., through linearization) component-level logs. A recent proposal [7] addresses the scalability issue using a distributed FSM inference approach based on MapReduce. However, this approach requires to encode the data to be exchanged between mappers and reducers in the form of key-value pairs. Such encoding is application-specific; hence, it cannot be used in contexts—like the one in which this work has been performed—in which the system is treated as a black-box (i.e., the source code is not available), with limited information about the data recorded in the individual components logs.

Another limitation of state-of-the-art techniques is that they cannot infer, from component-level logs, a system-level model that captures both the individual behaviors of the system’s components and the interactions among them. Such a scenario can be handled with existing model inference techniques for distributed systems, such as CSight [12], which typically assume the availability of channels definitions, i.e., the exact definition of which events communicate with each other between components. However, this information is not available in many practical contexts, where the system is composed of heterogenous, 3rd-party components, with limited documentation about the messages exchanged between components and the events recorded in logs.

In this paper, we address the scalability problem of inferring the model of a component-based system from the individual component-level logs (possibly coming from multiple executions), when the only available information about the system are high-level architecture dependencies among components and a (possibly incomplete) list of log message templates denoting communication events between components. Our goal is to infer a system-level model that captures not only the components’ behaviors reflected in the logs but also the interactions among them.

Our approach, called SCALER, follows a divide and conquer strategy: we first infer a model of each component from the corresponding logs using a state-of-the-art model inference technique, and then we “stitch” (i.e., we do a peculiar type of merge) the individual component models into a system-level model by taking into account the dependencies among the components, as reflected in the logs. The rationale behind this idea is that, though existing model inference techniques cannot deal with the size of all combined component logs, they can still be used to infer the models of individual components, since their logs are sufficiently small. In other words, SCALER tames the scalability issues of existing techniques by applying them on the smaller scope defined by component-level logs.

We implemented SCALER in a prototype tool, which uses MINT [8], a state-of-the-art technique for inferring gFSM, to infer the individual component-level models. We evaluate the scalability (in terms of execution time) and the accuracy (in terms of recall and specificity) of SCALER in comparison with MINT (fed with system-level logs reconstructed from component-level logs), on \fnumprint7 proprietary datasets from one of our industrial partners in the satellite domain. The results show that our approach SCALER is about \DTLfetchmaxDataPropspeed times (on average) faster and can process larger logs than MINT. It generates nearly correct (with specificity always higher than 0.96) and largely complete models (with an average recall of 0.79), achieving higher recall than MINT (with a difference ranging between +\DTLfetchmaxDataProprecall.min $pp$ and +\DTLfetchmaxDataProprecall.max $pp$, with $pp$=percentage points) while retaining similar specificity.

To summarize, the main contributions of this paper are:

• •

the SCALER approach for taming the scalability problem of inferring the model of a component-based system from the individual component-level logs, especially when only limited information about the system is available;

• •

a publicly available implementation of SCALER 111The open-source license is currently being reviewed by our legal team.;

• •

the empirical evaluation, in terms of scalability and accuracy, of SCALER and its comparison with a state-of-the-art approach.

The rest of the paper is organized as follows. Section II gives the basic definitions of logs and models that will be used throughout the paper. Section III illustrates the motivating example. Section IV describes the different steps of the core algorithm of SCALER. Section V reports on the evaluation of SCALER. Section VI discusses related work. Section VII concludes the paper and provides directions for future work.

II Background

This section provides the basic definitions for the main concepts that will be used throughout the paper.

Logs

A log is a sequence of log entries; a log entry contains a timestamp (recording the time at which the logged event occurred) and a log message (with run-time information related to the logged event). A log message is a block of free-form text that can be further decomposed [13] into a fixed part called event template, characterizing the event type, and a variable part, which contains tokens filled at run time with the values of the event parameters. For example, given the log entry 20181119:14:26:00 send OK to comp1, the timestamp is 20181119:14:26:00, the event template contains the fixed words send and to, while the tokens OK and comp1 are the values of the event parameters. More formally, let $\mathit{ET}$ be the set of all events that can occur in a system and $V$ be the set of all mappings from events parameters to their concrete values, for all events $\mathit{et}\in\mathit{ET}$; a log $L$ is a sequence of log entries $\langle e_{1},\dots,e_{n}\rangle$, with $e_{i}=(\mathit{ts}_{i},\mathit{et}_{i},v_{i})$, $\mathit{ts}_{i}\in\mathbb{N}$, $\mathit{et}_{i}\in\mathit{ET}$, and $v_{i}\in V$, for $i=1,\dots,n$. We denote the log of a component $c_{X}$ with $L_{c_{X}}$. To denote individual log entries, we use the notation $e_{i,j}^{k}$ for the $i$-th log entry of component $k$ in the $j$-th execution; we drop the subscript $j$ when it is clear from the context.

Guarded Finite State Machines

We represent the models inferred for a system as guarded Finite State Machines (gFSMs). A gFSM is a tuple $m=(S,\mathit{ET},G,\delta,s_{0},F)$, where $S$ is a finite set of states, $\mathit{ET}$ is the set of system events defined above, $G$ is a finite set of guard functions of the form $g\colon V\to\{0,1\}$, $\delta$ is the transition relation $\delta\subseteq S\times\mathit{ET}\times G\times S$, $s_{0}\in S$ is the initial state, $F\subseteq S$ is the set of final states. Informally, a gFSM is a finite state machine whose transitions are triggered by the occurrence of an event and are guarded by a function that evaluates the values of the event parameters. More specifically, a gFSM $m$ makes a guarded transition from a state $s\in S$ to a state $s^{\prime}\in S$ when reading an input log entry $e=(\mathit{ts},\mathit{et},v)$, written as $s\xrightarrow{e}s^{\prime}$, if $(s,\mathit{et},g,s^{\prime})\in\delta$ and $g(v)=1$. We say that $m$ accepts a log $l=\langle e_{1},\dots,e_{n}\rangle$ if there exists a sequence of states $\langle\gamma_{0},\dots,\gamma_{n}\rangle$ such that (1) $\gamma_{i}\in S$ for $i=0,\dots,n$, (2) $\gamma_{0}=s_{0}$, (3) $\gamma_{i-1}\xrightarrow{e_{i}}\gamma_{i}$ for $i=1,\dots,n$, and (4) $\gamma_{n}\in F$.

III Motivations

In this section, we discuss the motivations for this work using an example based on a real system from one of our industrial partners in the satellite domain. We consider a simplified version of a satellite ground control system, composed of the four components shown in Figure 1: TC, the module handling tele-commands for the satellite, which is also the entry point of the system; MUX, a multiplexer combining different tele-commands into a single communication stream; CHK, the module validating the tele-commands parameters before they are sent to the satellite; GW, the gateway managing the connections between the satellite and the ground control system. Figure 1 also shows the architectural dependencies among components; for example, the arrow from component TC to component MUX indicates that TC uses (or invokes) an operation provided by MUX. Every execution of the system generates a set of logs, with one log for each component; Figure 2 depicts the logs of the four system components generated in two executions; for space reasons, the format of timestamps has been compressed.

To infer a model from these individual component logs, one could use existing model inference techniques for distributed systems, such as CSight [12]. These techniques typically assume the availability of channels definitions, i.e., the exact definition of which events communicate to each other between components. However, this information is not available in many practical contexts, including ours, where the system is composed of heterogenous, 3rd-party components, with limited documentation. More specifically, the only available information about the system are high-level architecture dependencies among components (like those in Figure 1) and a (possibly incomplete) list of communication events, without knowing exactly how events communicate with each other. Due to this limited information, we cannot use existing techniques for model inference for distributed systems.

Another approach towards model inference would be to reconstruct a system-level log from the individual component logs and use non-distributed model inference techniques such as MINT [8] or GK-tail+ [9]. However, such approaches typically suffer from scalability issues due to the underlying algorithms they use. For example, the main algorithm used in MINT has worst-case time complexity that is cubic in the size of the inferred model [14]; the algorithm used for removing non-determinism from models can exhibit, based on our preliminary evaluation, deep recursion that causes stack overflows and makes MINT crash. Furthermore, GK-tail+ is not publicly available and the largest log on which it was evaluated contained 11386 log entries. Since the system of our industrial partner can generate, when considering all the components, logs with more than 30000 entries, there is need for a scalable model inference technique that can process component logs.

IV Scalable Model Inference

Our technique for system model inference from component logs follows a divide and conquer approach. The idea is to first infer a model of each system component from the corresponding logs; then, the individual component models are merged together taking into account the dependencies among components, as reflected in the logs. We call this process SCALER. The rationale behind our technique is that though existing (log-based) model inference techniques cannot deal with the size of all combined component logs, they can still be used to accurately infer the models of individual components, since their logs are sufficiently small for the existing model inference techniques to work. The challenge is then how to “stitch” together the models of the individual components to build a system model that reflects not only the components behavior but also their dependencies, while preserving the accuracy of the component models. For example, simply appending one component model after the other perfectly preserves the accuracy of the inferred component models, but it significantly loses the dependencies between components. On the other hand, performing a parallel composition of automata on the component models (based on the dependencies between components) loses the accuracy of the component models because of the over-generalization caused by the parallel composition. To solve this problem, we develop a set of novel algorithms that take into account the dependencies between components while preserving the component models as much as possible.

Figure 3 outlines the workflow of SCALER. The technique takes as input the logs of the different components, possibly coming from multiple executions, a description of the architectural dependencies among components, and a list of log message templates denoting communication events between components; it returns a system level gFSM. SCALER is composed of two stages, pre-processing and stitching, described in the following subsections.

IV-A Pre-processing Stage

This stage prepares two intermediate outputs, component-level models and log entries dependencies, which will be used by the main stitching stage.

Inferring Component Models

For each component, we infer a component-level model based on the corresponding logs using MINT [8], an open-source state-of-the-art tool.

MINT takes as input

(1) the logs produced by the individual component for which one wants to infer the model and

(2) the templates of the events recorded in the component logs.

The event templates are required to parse the log entries, to retrieve the actual events and their parameters. Nevertheless, often such templates are not available or documented. This situation is typical when dealing with 3rd-party, black-box components—as it is the case for the ground control system used by our industrial partner—and it is known in the literature as the log message format identification problem. We use MoLFI [13], a state-of-the-art solution for this problem, to derive the event templates that are then used by MINT; as an example, the box at the bottom of Figure 2 shows the templates produced by MoLFI from the logs of our running example.

The models inferred by MINT are gFSMs; Figure 4 shows the component-level gFSMs inferred by MINT for the four components of our running example. We use a compact notation for the guards on the event parameters labeling the guarded transitions; for example, in the gFSM of TC (i.e., $m_{\mathit{TC}}$), the guard $(\texttt{X},\texttt{f0})$ stands for $(v_{1}=\text{``{X}''},v_{2}=\text{``{f0}''})$.

Identifying Log Entries Dependencies

A system-level model of a component-based system has to capture not only the behavior of the individual components but also the intrinsic behavioral dependencies among them. For example, considering the fact that TC invokes MUX as shown in Figure 1, one could speculate that the event recorded in entry $e_{1,1}^{TC}$ could lead to the event recorded in entry $e_{1,1}^{MUX}$ in Figure 2; if this is the case, the model should reflect this dependency, which we call log entries dependency.

Log entries dependencies can be extracted from the source code by means of program analysis or from existing models such as UML Sequence Diagrams [15, 16]. However, the extraction is infeasible when the source code is not available and the documentation is limited. This is the case for the example system provided by our industrial partner: the source code of 3rd-party components is not available, the architectural documentation only includes coarse-grained dependencies (like those shown in Figure 1), and the only additional information is the knowledge of domain experts, who can provide a (possibly incomplete) list of log message templates corresponding to events related to the “communication” between components (like those marked with an asterisk in Figure 2). To solve this issue, we present a simple heuristic that identifies log entries dependencies from the coarse-grained component dependencies, the list of communication event templates, and the individual component logs.

The idea at the basis of our heuristic is that, if there is an architectural dependency from a component $c_{X}$ to another component $c_{Y}$ (representing the use of $c_{Y}$ by $c_{X}$), then all log entries of $c_{Y}$ are ultimately the consequences of the log entries of $c_{X}$. The identification of log entries dependencies boils down to finding out, for each pair of components $c_{X}$ and $c_{Y}$ with $c_{X}$ using $c_{Y}$, which log entries of $c_{Y}$ are the consequences of which log entry of $c_{X}$. We observe that, among the log entries of $c_{Y}$, the communication (events recorded in) log entries are invoked directly from $c_{X}$. Furthermore, given the timestamp222We assume that the clocks of the different components are synchronized, for example using the Network Time Protocol (NTP) [17]. of a communication log entry $\mathit{ce}^{Y}$ of $c_{Y}$, we observe that $\mathit{ce}^{Y}$ communicated with the most recent communication log entry $\mathit{ce}^{X}$ of $c_{X}$. Based on these observations, we say that $\mathit{ce}^{X}$ (communicatively) leads-to $\mathit{ce}^{Y}$, denoted with $\mathit{ce}^{X}\rightsquigarrow_{c}\mathit{ce}^{Y}$, only if (1) the timestamp of $\mathit{ce}^{X}$ is less than or equal to the one of $\mathit{ce}^{Y}$ and (2) the timestamp difference between $\mathit{ce}^{X}$ and $\mathit{ce}^{Y}$ is the minimum among all pairs of the communication log entries of $c_{X}$ and $c_{Y}$. In our running example, given the list of templates corresponding to (log entries of) communication events: $\mathit{tmp}_{1}$, $\mathit{tmp}_{2}$, $\mathit{tmp}_{4}$, and $\mathit{tmp}_{7}$, if we consider the architectural dependency from TC to MUX and focus on the first execution, we say that $e^{\mathit{TC}}_{1}\rightsquigarrow_{c}e^{\mathit{MUX}}_{1}$ and $e^{\mathit{TC}}_{2}\rightsquigarrow_{c}e^{\mathit{MUX}}_{5}$.

By definition, the $\rightsquigarrow_{c}$ relationship does not hold between the remaining non-communication (events recorded in) log entries of $c_{Y}$ and the communication log entries of $c_{X}$. However, since all log entries of $c_{Y}$ are ultimately the consequence of the log entries of $c_{X}$, we can speculate that a sequence of non-communication log entries $\langle\mathit{ne}_{1}^{Y},\mathit{ne}_{2}^{Y},\dots,\mathit{ne}_{k}^{Y}\rangle$ of $c_{Y}$ after a communication log entry $\mathit{ce}^{Y}$ of $c_{Y}$ is also related to the most recent communication log entry $\mathit{ce}^{X}$ of $c_{X}$. More precisely, if we have a log $\langle\dots,\mathit{ce}^{Y},\mathit{ne}_{1}^{Y},\mathit{ne}_{2}^{Y},\dots,\mathit{ne}_{k}^{Y},\mathit{ce}^{\prime Y},\dots\rangle$ of $c_{Y}$ where $\mathit{ce}^{X}\rightsquigarrow_{c}\mathit{ce}^{Y}$, we say that $\mathit{ce}^{X}$ leads-to $\langle\mathit{ce}^{Y},\mathit{ne}_{1}^{Y},\mathit{ne}_{2}^{Y},\dots,\mathit{ne}_{k}^{Y}\rangle$, denoted with $\mathit{ce}^{X}\rightsquigarrow\langle\mathit{ce}^{Y},\mathit{ne}_{1}^{Y},\mathit{ne}_{2}^{Y},\dots,\mathit{ne}_{k}^{Y}\rangle$. When considering TC and MUX in the first execution of our running example, we have $e^{\mathit{TC}}_{1}\rightsquigarrow\langle e^{\mathit{MUX}}_{1},e^{\mathit{MUX}}_{2},e^{\mathit{MUX}}_{3},e^{\mathit{MUX}}_{4}\rangle$ because $e^{\mathit{TC}}_{1}\rightsquigarrow_{c}e^{\mathit{MUX}}_{1}$ (as identified above); also, we have $e^{\mathit{TC}}_{2}\rightsquigarrow\langle e^{\mathit{MUX}}_{5}\rangle$ because $e^{\mathit{TC}}_{2}\rightsquigarrow_{c}e^{\mathit{MUX}}_{5}$ and there are no further non-communication log entries after $e^{\mathit{MUX}}_{5}$. Table I shows all the log entries dependencies extracted for the log entries in Figure 2.

We remark that our heuristic may introduce some imprecisions, for example, with logs in which the timestamp granularity is relatively coarse-grained (e.g., seconds instead of milli- or nano-seconds) and the communication between components is fast enough such that often two communication events that logically occur one before the other are logged using the same timestamp. Incorrectly identified log entries dependencies can decrease the accuracy of the resulting system-level model and increase its complexity; we leave the study of more accurate techniques for the identification of log entries dependencies as part of future work.

IV-B Stitching Stage

The intermediate outputs of the pre-processing stage are then used in this stitching stage, which is at the core of our technique. In this stage, we build a system-level gFSM that captures not only the components’ behavior inferred from the logs but also their dependencies as reflected in the log entries dependencies identified in the pre-processing stage.

Since the dependencies between components observed through the logs are different from execution to execution, we first build system-level gFSM for each execution and then merge these gFSMs together using the standard DFA (Deterministic Finite Automaton) union operation333MINT produces a deterministic gFSM $m=(S,\mathit{ET},G,\delta,s_{0},F)$, with $\delta:S\times\mathit{ET}\times G\to S$; it can be easily converted into a DFA $m^{\prime}=(S,\Sigma,\delta^{\prime},s_{0},F)$ with $\delta^{\prime}:S\times\Sigma\to S$ where $\Sigma=\mathit{ET}\times G$.. We call this process “stitching” whereas we call “grafting” the inner process that builds a system-level gFSM for each execution. The pseudocode of the top-level process Stitch is shown in Algorithm 1.

We assume that, within a set of components $C$, there is a component labeled $c_{\mathit{main}}$ that corresponds to the root component in the system architectural diagram (e.g., TC in our running example). Algorithm Stitch takes as input $C$, a set of component-level gFSMs $M$ (one model for each component in $C$), and a set of logs (one log for each execution) $L_{\mathit{main}}$ for $c_{\mathit{main}}$; it returns a system-level gFSM $m_{\mathit{sys}}$. Internally, Stitch uses novel auxiliary algorithms (Graft, Slice, Insert), which are described further below.

The algorithm builds a system-level gFSM $m_{\mathit{main}}$ for each execution log $l_{i}\in L_{\mathit{main}}$, starting from the component-level gFSMs in $M$ (lines 3–6); this is done by the Graft algorithm, described in detail in § IV-B1. During the iteration through the execution logs in $L_{\mathit{main}}$, the resulting system-level gFSMs $m_{\mathit{main}}$ are collected in the set $W$. Last, the gFSMs in $W$ are merged into $m_{\mathit{sys}}$ using the DFA union operation444One could use the standard DFA minimization after the DFA union in line 8 to reduce the size of the system-level gFSM. However, our preliminary evaluation showed that the minimization operation can reduce the gFSM size (in terms of numbers of states and transitions) by at most 5%, and it increases the execution time of the Stitch algorithm by more than five times. (line 8). The algorithm ends by returning the system-level gFSM $m_{\mathit{sys}}$ (line 9), inferred from all executions in $L_{\mathit{main}}$.

IV-B1 Graft

The Graft algorithm builds the system-level gFSM for an execution by merging the individual component-level gFSMs, taking into account the log entries dependencies extracted from the execution, while preserving the component gFSMs as much as possible. To illustrate the main idea behind the algorithm, let us consider two components $c_{X}$ and $c_{Y}$, whose corresponding gFSMs (inferred in the pre-processing stage) $m_{c_{X}}$ and $m_{c_{Y}}$ are shown in Figure 5. These gFSMs respectively accept log $l_{X}=\langle e_{1}^{X},e_{2}^{X}\rangle$ and log $l_{Y}=\langle e_{1}^{Y},e_{2}^{Y},e_{3}^{Y}\rangle$. Let us also assume that in terms of log entries dependencies (expressed through the leads-to relation) we have $e_{1}^{X}\rightsquigarrow\langle e_{1}^{Y},e_{2}^{Y}\rangle$ and $e_{2}^{X}\rightsquigarrow\langle e_{3}^{Y}\rangle$. Taking into account these dependencies, intuitively we can say that the gFSM resulting from the merge of $m_{c_{X}}$ and $m_{c_{Y}}$, denoted by $m_{c_{X\upharpoonright Y}}$, should accept the sequence of log entries $\langle e_{1}^{X},e_{1}^{Y},e_{2}^{Y},e_{2}^{X},e_{3}^{Y}\rangle$. To obtain $m_{c_{X\upharpoonright Y}}$, we first “slice” $m_{c_{Y}}$ into two gFSMs: $\mathit{slice}_{1}$ (accepting $\langle e_{1}^{Y},e_{2}^{Y}\rangle$) and $\mathit{slice}_{2}$ (accepting $\langle e_{3}^{Y}\rangle$); then, we “insert” 1) $\mathit{slice}_{1}$ as the target of the transition of $m_{c_{X}}$ that reads $e_{1}^{X}$, and 2) $\mathit{slice}_{2}$ as the target of the transition of $m_{c_{X}}$ that reads $e_{2}^{X}$. Note that the self-loop transition in $m_{c_{Y}}$ is preserved in $m_{c_{X\upharpoonright Y}}$ as a result.

As shown in Algorithm 2, Graft takes as input a component $c_{\mathit{cur}}$, an execution log $l_{\mathit{cur}}=\langle e_{1},\dots,e_{z}\rangle$, and a set of component-level gFSMs $M=\{m_{c_{\mathit{main}}},m_{c_{1}},\dots,m_{c_{n}}\}$; it returns a gFSM $m_{\mathit{sl}}$ that accepts the sequence of log entries composed of the entries $e_{i}\in l_{\mathit{cur}}$, with each $e_{i}$ interleaved with the log entries to which it leads-to.

The algorithm starts by slicing the gFSM $m_{c_{\mathit{cur}}}$ of the input component $c_{\mathit{cur}}$ into a gFSM $m_{\mathit{sl}}$ that accepts only $l_{\mathit{cur}}$ (line 4); the actual slicing is done through algorithm Slice, described in detail in § IV-B2. The rest of the algorithm expands $m_{\mathit{sl}}$ taking into account the log entries dependencies (lines 5–16): for each log entry $e_{i}\in l_{\mathit{cur}}$, a gFSM $m_{g}$ that accepts the log entries sequence that $e_{i}$ leads-to is built and “inserted” in $m_{\mathit{sl}}$ as the target of the guarded transition $\mathit{gt}$ that reads $e_{i}$. More precisely, the algorithm performs a run of $m_{\mathit{sl}}$ as if it were to accept the log $l_{\mathit{cur}}$: starting from the initial state of $m_{sl}$ (line 5), it moves to the next state $s$ by making the guarded transition $\mathit{gt}$ that reads $e_{i}$ (line 7). As part of this move, for each log entry sequence $l_{d}$ such that $e_{i}\rightsquigarrow l_{d}$, we recursively call Graft to build the gFSM $m_{g}$ that accepts $l_{d}$; this gFSM is then added to the set $W$ (lines 9–12) . Since a log entry $e_{i}$ may lead-to log entries sequences of multiple components, we compose the individual gFSMs in $W$ using the standard DFA parallel composition operation (line 14). The resulting gFSM $m_{\mathit{pl}}$ is “inserted” in $m_{\mathit{sl}}$ as the target of $\mathit{gt}$ by the Insert algorithm (line 15), described in detail in § IV-B3. At the end of each iteration of the loop, the state $s$ is updated with the target state of the $\mathit{gt}$ transition (line 16).

As an example, let us consider the case in which the Stitch algorithm calls the Graft algorithm when processing Execution-2 of our running example. Figure 6-(a) shows the component-level gFSM and how they are related when taking into account the leads-to relation listed in Table I. Algorithm Stitch invokes Graft with parameters $c_{\mathit{cur}}=\mathit{TC}$, $l_{\mathit{cur}}=\langle e_{1,2}^{\mathit{TC}},e_{2,2}^{\mathit{TC}}\rangle$, $M=\{m_{\mathit{TC}},m_{\mathit{MUX}},m_{\mathit{CHK}},m_{\mathit{GW}}\}$. The call to Slice yields the gFSM $\mathit{slice_{1}}$ shown in Figure 6-(a); it accepts $\langle e_{1,2}^{\mathit{TC}},e_{2,2}^{\mathit{TC}}\rangle$, using the transitions labeled with $\mathit{tmp}_{1}(Y,f1)$ and $\mathit{tmp}_{3}$. Then, starting from $s_{0}$ of $\mathit{slice}_{1}$, the invocation of the auxiliary function getGuardedTran yields the guarded transition $(s_{0},\mathit{tmp}_{1},[Y,f1],s_{2})$ that reads $e_{1,2}^{\mathit{TC}}$. Since $e_{1,2}^{\mathit{TC}}\rightsquigarrow\langle e_{1,2}^{\mathit{MUX}},e_{2,2}^{\mathit{MUX}},e_{3,2}^{\mathit{MUX}}\rangle$ and $e_{1,2}^{\mathit{TC}}\rightsquigarrow e_{1,2}^{\mathit{CHK}}$, the algorithm makes a recursive call for $\langle e_{1,2}^{\mathit{MUX}},e_{2,2}^{\mathit{MUX}},e_{3,2}^{\mathit{MUX}}\rangle$, which returns the sliced gFSM $\mathit{slice}_{2}$, and for $\langle e_{1,2}^{\mathit{CHK}}\rangle$, which returns $\mathit{slice}_{3}$; both gFSMs are shown in Figure 6-(a). At the end of the inner loop, we have $W=\{\mathit{slice}_{2},\mathit{slice}_{3}\}$; their parallel composition is $m_{2,3}$ and is shown in Figure 6-(b). This gFSM is then inserted in $\mathit{slice}_{1}$ as the target of the transition $(s_{0},\mathit{tmp}_{1},[Y,f1],s_{2})$, as shown in Figure 6-(c). The algorithm ends for $e_{1,2}^{\mathit{TC}}$ by inserting $m_{2,3}$ in $s_{2}$ and moves on to the next log entry $e_{2,2}^{\mathit{TC}}$.

IV-B2 Slice

This algorithm takes as input a component-level gFSM $m_{c}$ and a log $l_{c}$; it returns a new gFSM $m_{\mathit{sl}}$, which is the sliced version of $m_{c}$ and accepts only $l_{c}$.

Its pseudocode is shown in Algorithm 3. First, the algorithm retrieves the state of $m_{c}$ that will become the initial state $s$ of the sliced gFSM $m_{\mathit{sl}}$ (line 4). Upon the first invocation of Slice for a certain gFSM $m_{c}$, $s$ will be the initial state of $m_{c}$; for the subsequent invocations, $s$ will be the last state visited in $m_{c}$ when running the previous slice operations. Starting from $s$, the algorithm performs a run of $m_{c}$ as if it were to accept the log $l_{c}$: the traversed states and guarded transitions of $m_{c}$ are added into $m_{\mathit{sl}}$ (lines 5–8). At the end of the loop, the algorithm records (line 10) the last state visited in $m_{c}$ when doing the slicing, which will be used as the initial state of the next slice on $m_{c}$; it then ends by returning $m_{\mathit{sl}}$.

IV-B3 Insert

We recall that this algorithm is invoked by the Graft algorithm to “insert” a gFSM $m_{y}$ into a gFSM $m_{x}$ as the target of a guarded transition $\mathit{gt}$ of $m_{x}$, taking into account the log entries dependencies. More specifically, let us consider a log entry $e$ and a set of logs $L=\{l_{1},\dots,l_{n}\}$ where $e\rightsquigarrow l_{i}$ for $i=1,\dots,n$; the transition $\mathit{gt}$ of $m_{x}$ reads $e$, and $m_{y}$ is the parallel composition of the gFSMs that accepts the logs in $L$. The Insert algorithm merges $m_{y}$ into $m_{x}$ such that, by “inserting” $m_{y}$ as the target of the guarded transition $\mathit{gt}$, $m_{x}$ can read the (entries in the) logs in $L$ right after reading $e$.

We illustrate how the algorithm works through the example in Figure 7, in which the input gFSMs $m_{x}$ and $m_{y}$ are shown on the left side; we will insert $m_{y}$ into $m_{x}$ as the target of the guarded transition $\mathit{gt}$, labeled with $a$ and having $s_{t}$ as target state. Without loss of generality, we assume that $m_{y}$ has only one transition (labeled with $\alpha$) between its initial state $s_{i}$ and the final one $s_{f}$. The main idea behind the Insert algorithm is to duplicate both incoming and outgoing transitions of the target state of $\mathit{gt}$, and to redirect the new copies to the initial and finals states of $m_{y}$. More specifically:

• •

the incoming transition $\mathit{gt}$ of $s_{t}$ (labeled with $a$) is duplicated and the new copy is redirected, by changing its target state, to the initial state of $m_{y}$ (i.e., $s_{i}$);

• •

the outgoing transitions of $s_{t}$ (e.g., the one labeled with $b$) are duplicated and the new copies are redirected, by changing the source state, such that they originate from the final state of $m_{Y}$ (i.e., $s_{f}$).

The updated $m_{x}$, resulting from the application of duplication and redirection, is shown in the middle of Figure 7. We remark that we keep the original incoming and outgoing transitions of $s_{t}$ on purpose, to take into account the cases in which one of the log entries read by $\mathit{gt}$ does not lead-to log entries read by the transition labeled with $\alpha$. Duplication and redirection operations introduce some nondeterminism in $m_{x}$; in our example, $s_{p}$ has two outgoing transitions both labeled with $a$. We remove nondeterminism using a determinization procedure [18], which recursively merges pair of states that introduces nondeterminism555This procedure is different from the standard NFA (non-deterministic finite automaton) to DFA conversion since it yields an automaton which may accept a more general language than the NFA it starts from [18].; in our example, the determinization procedure will merge $s_{t}$ and $s_{i}$. The final $m_{x}$ is shown on the right side of Figure 7.

Algorithm 4 shows the pseudocode of the Insert algorithm. The algorithm takes a gFSM $m_{x}$, a guarded transition $\mathit{gt}$, and a gFSM $m_{y}$; it returns the updated $m_{x}$ that includes $m_{y}$ as the target of $\mathit{gt}$. In the algorithm, $s_{t}$ is the target state of $\mathit{gt}$, $s_{i}$ is the initial state of $m_{y}$ and $F_{y}$ is the set of the final states of $m_{y}$. The core part (lines 6–12) iterates through each guarded transition $t$ of $s_{t}$, duplicates it, and redirects the new copy as described above, using the the auxiliary function $\mathit{duplicateAndRedirectTransitions}$. Last, the algorithm removes nondeterminism using $\mathit{determinize}$ (line 13); it ends by returning the updated gFSM $m_{x}$ (line 14).

Accuracy of the system-level gFSM

SCALER has three main sources of over-generalization that reduce the accuracy:

(1) component-level model inference,

(2) parallel composition in Graft, and

(3) determinization in Insert.

The first is essentially inevitable in any model inference algorithm; we try to compensate it by using a state-of-the-art tool (MINT) to infer component models that are as accurate as possible. The second source may become a problem when the log dependencies identified in the preprocessing stage are incorrect; nevertheless, over-generalization caused by parallel composition is limited because the latter is only performed on the sliced gFSMs. The last source has limited effects because recursive determinization rarely occurs in practice.

We further discuss the accuracy of SCALER corroborated by experimental data in the next section.

V Evaluation

We have implemented the SCALER approach as a Python program. In this section, we report on the evaluation of the performance of the SCALER implementation in generating the model of a component-based system from the individual component-level logs.

First, we assess the scalability of SCALER in inferring models from large execution logs. This is the primary dimension we focus on since we propose SCALER as a viable alternative to state-of-the-art techniques for processing large logs. Second, we analyze how accurate the models generated by SCALER are. This is an important aspect because it is orthogonal to scalability and has direct implications on the possibility of using the models generated by SCALER in other software engineering tasks (e.g., test case generation). Summing up, we investigate the following research questions:

1. RQ1:

How scalable is SCALER when compared to state-of-the-art model inference techniques? 2. RQ2:

How accurate are the models (in the form of gFSMs) generated by SCALER when compared to those generated by state-of-the-art model inference techniques?

V-A Benchmark and Evaluation Settings

We used a benchmark composed of industrial, proprietary datasets provided by one of our industrial partners, active in the satellite industry. The benchmark contains component-level logs recorded during the execution of a satellite ground control system, which includes six major components. We created the benchmark as follows. First, we executed system-level tests on the ground control system 120 times and, in each test execution, we collected the log files of the six major components. Then, we created seven datasets of size ranging from 5K to 35K, where the size is expressed in terms of the total number of log entries. We assembled each dataset by randomly selecting a number of executions out of the pool of 120 executions, such that the total size of the logs contained in the dataset matched the desired dataset size. By construction, each dataset contains logs of the six major components of the system. The first three columns of Table II show, for each dataset in our benchmark, the size and the number of executions included in it. In total, there are 92 unique templates (i.e., unique number of events) for all logs. All the collected logs (anonymized) as well as the evaluation results are available at http://tiny.cc/SANER20-SCALER. The experiments have been executed on a high-performance computing platform, using one of its quad-core nodes running CentOS 7 on a $2.4\text{\,}\mathrm{GHz}$ Intel Xeon E5-2680 v4 processor with $4\text{\,}\mathrm{GB}$ memory.

V-B Scalability

V-B1 Methodology

To answer RQ1, we assess the scalability of SCALER, in terms of execution time with respect to the size of the logs, in comparison with MINT [8], a state-of-the-art model inference tool. We selected MINT as baseline because other tools are either not publicly available or require information not available in most practical contexts, including ours (e.g., channels’ definitions; see section III).

We ran both tools to infer a system-level model for each dataset in our benchmark. We provided as input to SCALER 1) the logs of the six components recorded in the executions contained in each dataset; 2) the architectural dependencies among components; 3) the list of log message templates for communication events, received from a domain expert. As for MINT, we provided as input the system-level logs of the system executions contained in each dataset. We derived these system-level logs by linearizing the individual component logs in each execution, taking into account the log entries dependencies. To guarantee a fair comparison, these dependencies are the same as those extracted in the pre-processing stage of SCALER. Since the total number of possible system-level logs is extremely large due to the linearization of the parallel behaviors of the components, we only considered one system-level log for each execution.

We remark that we used two instances of MINT: the one used internally by SCALER to generate component-level models; the other one for the comparison in inferring system-level models. For both instances, we used the default configuration (i.e., state merging threshold $k=2$ and J48 as data classifier algorithm) [8]. Furthermore, to identify the event templates required by the MINT instances to parse the log entries, we first used a state-of-the-art tool (MoLFI [13]) to compute them and then we asked a domain expert to further refine them, e.g., by collapsing similar templates into a single one. To take into account the randomness of the log linearization (i.e., only one linearized system-level log) for each execution of MINT, we ran both MINT and SCALER ten times on each dataset. For each run, we set an overall time out of 24h for the model inference process both for MINT and for SCALER.

To assess the statistical significance of the difference between the execution time of SCALER and MINT (if any), we used the non-parametric Wilcoxon rank sum test with a level of significance $\alpha=0.05$. Furthermore, we used the Vargha-Delaney ($\hat{A}_{12}$) statistic for determining the effect size of the difference. In our case, $\hat{A}_{12}<0.5$ indicates that the execution time of SCALER is lower than that of MINT.

V-B2 Results

The columns under the header “Scalability” of Table II show the scalability results for SCALER and MINT. More precisely, column MINT indicates the execution time of MINT; columns Prep, Stitch, and Total indicate the average (over the ten runs) execution time (in seconds) and the corresponding standard deviation of SCALER for the pre-processing stage, the stitching stage, and the cumulative execution time, respectively; column SpeedUp reports the speedup of SCALER over MINT computed as $\tfrac{\mathit{Time}_{\mathit{MINT}}}{\mathit{Time}_{\mathit{\emph{SCALER}}}}$ [19].

SCALER is faster than MINT for all the datasets in our benchmark; the speed-up ranges between 27x (for the dataset D05K) and 428x (for the dataset D25K). The speed-up increases with the size of the datasets and, thus, the benefit of using SCALER over MINT increases for larger logs. Note that MINT reached the time out for the largest dataset (D35K) without producing any model. The Wilcoxon test also confirms that the differences in execution time between SCALER and MINT are statistically significant ($p$-value $<0.01$ for all datasets) and the Vargha-Delaney statistic indicates that the effect size is always large ($\hat{A}_{12}<0.10$) for all datasets.

Analyzing the performance of the two instances of MINT, we can say that when MINT is used for component-level model inference is much faster than MINT used for system-level model inference because (1) the component logs are smaller than the system-level logs and (2) there is a higher similarity among component logs than system-level logs.

V-C Accuracy

V-C1 Methodology

To answer RQ2, we ran both MINT and SCALER to evaluate and compare their accuracy for each dataset, in terms of recall and specificity of the inferred models following previous studies [8, 9, 10]. Recall measures the ability of the inferred models of a system to accept “positive” logs; specificity measures the ability of the inferred models to reject “negative” logs. We computed these metrics by using the well-known $k$-folds cross validation method, which has also been used in previous work [8, 9, 10] in the area of model inference. This method randomly partitions a set of logs into $k$ non-overlapping folds: $k-1$ folds are used as input of the model inference tool, while the remaining fold is used as “test set”, to check whether the model inferred by the tool accepts the logs in the fold. The procedure is repeated $k$ times until all folds have been considered exactly once as the test set. For each fold, if the inferred model successfully accepts a positive log in the test set, the positive log is classified as True Positive (TP); otherwise, the positive log is classified as False Negative (FN). Similarly, if an inferred model successfully rejects a negative log in the test set, the negative log is classified as True Negative (TN); otherwise, the negative log is classified as False Positive (FP). Based on the classification results, we calculated the recall (R) as $\mathit{R}=\tfrac{|\mathit{TP}|}{|\mathit{TP}|+|\mathit{FN}|}$, and the specificity (S) as $\mathit{S=\tfrac{|\mathit{TN}|}{|\mathit{TN}|+|\mathit{FP}|}}$.

As done in previous work [8, 9, 10], we synthesized negative logs from positive logs by introducing small changes (mutations): 1) swapping two randomly selected log entries, 2) deleting a randomly selected log entry, and 3) adding a log entry randomly selected from other executions. To make sure a log resulting from a mutation contains invalid behaviors of the system, we checked whether the sequence of entries around the mutation location (i.e., the mutated entries and the entries immediately before and after the mutants) did not also appear in the positive logs.

Note that we needed to derive system-level logs from the individual component logs in test sets to check the acceptance of the system-level models inferred by SCALER and MINT. To this end, as done for the scalability evaluation, for each execution in the test sets, we linearized the individual component logs to derive the system-level log. Also, to take into account the randomness of the derivation of system-level logs, we repeat the 10-folds cross validation ten times on each dataset and then applied statistical tests as done for the scalability evaluation.

V-C2 Results

The columns under the header “Accuracy” of Table II show the results of MINT and SCALER in terms of recall, specificity, and difference of these values (in percentage points, $pp$) between SCALER and MINT.

MINT achieves high specificity scores, always greater than $0.98$. However, recall is low, ranging between 0.09 for the D05K dataset and 0.61 for the D30K dataset. Notice that no results were obtained for the larger dataset with 35K log entries because MINT reached the timeout of 24h without generating any model. SCALER achieves a slightly lower specificity than MINT, with an average difference of 1.67$pp$. However, SCALER achieves substantially higher recall than MINT. The difference in recall values ranges between +25$pp$ (D30K dataset) and +56$pp$ (D05K dataset), with an average improvement of 35.5$pp$. Such a result can be explained mainly because MINT takes as input only one system-level log among all possible instances of the linearization of the parallel behaviors of the components for each execution, and fails to scale up to take as input all the possible system-level logs. Related to this, since SCALER takes as input all the possible system-level logs (in the form of component-level logs with the log entries dependencies) for each execution, it returns as output a system-level gFSM having on average 4.6x more states and 7.0x more transitions than MINT (see the columns under the header “System-level gFSM” in Table II).

According to the Wilcoxon test, SCALER always achieves a statistically higher recall than MINT for all datasets ($p\text{-value}<0.01$) with a large effect size. However, SCALER achieves a statistically lower specificity than MINT in five out of seven datasets (i.e., with 5K, 10K, 20K and 30K log entries). While the difference in specificity are statistically significant, it is worth noting that the magnitude of the difference is small, being no larger than 2$pp$.

V-D Discussion and Threats to Validity

From the results above, we conclude that, for the large logs typically encountered in practice, SCALER provides results that are good enough to generate nearly correct (with a specificity always greater than 0.96) and largely complete models (with an average recall of 0.79).

The incompleteness of the inferred models is due to the limited knowledge we have on the system (i.e., the incomplete list of message templates characterizing communication events) and to the heuristic used in computing log entries dependencies, which is affected by the coarse-grained timestamp granularity of the logs included in our benchmark. In contrast, MINT, when used as a stand-alone tool on the same large logs, does not scale and fares poorly in terms of recall, generating very incomplete models.

From a practical perspective, the results achieved by SCALER lead to a considerable reduction of false negatives, with a marginal increment of false positives. For example, for the D15K dataset, MINT generates (in about two hours) a gFSM that accepts only 52% of the true positives (positive logs). In this case, engineers need to substantially modify the inferred gFSM to accept the remaining 48% of positive logs. Instead, for the same dataset, SCALER generates in about 33 seconds a gFSM that accepts 82% of the positive logs (and rejects 97% of the negative logs). The marginal decrement of the negative logs correctly dismissed by the gFSM inferred by SCALER is largely compensated by (1) a significant reduction of the number of wrongly rejected positive logs (+30$pp$ in recall), and (2) a substantial reduction of the execution time (SCALER is about 222 times faster than MINT).

In terms of threats to validity, the size of the log files is a confounding factor that could affect our results (i.e., accuracy and execution time). We mitigated such a threat by considering seven datasets with different sizes (ranging from 5K to 35K log entries) and different sets of system executions.

VI Related Work

Starting from the seminal work of Biermann and Feldman [5] on the k-Tail algorithm, which is based on the concept of state merging, several approaches have been proposed to infer a Finite State Machine (FSM) from execution traces or logs. Synoptic [6] uses temporal invariants, mined from execution traces, to steer the FSM inference process to find models that satisfy such invariants; the space of the possible models is then explored using a combination of model refinement and coarsening. InvariMINT [20] is an approach enabling the declarative specification of model inference algorithms in terms of the types of properties that will be enforced in the inferred model; the empirical results show that the declarative approach outperforms procedural implementations of k-Tail and Synoptic. Nevertheless, this approach requires prior knowledge of the properties that should hold on the inferred model; such a pre-condition cannot be satisfied in contexts (like the one in which this work is set) where system components are black-boxes and the knowledge about the system is limited. Other approaches infer other types of behavioral models that are richer than an FSM. GK-tail+ [9] infers guarded FSM (gFSM) by extending the k-Tail algorithm and combining it with Daikon [21] to synthesize constraints on parameter values; such constraints are represented as guards of the transitions of the inferred model. MINT [8] also infers a gFSM by combining EDSM (Evidence-Driven State Merging) [22] and data classifier inference [23]. EDSM, based on the Blue-Fringe algorithm [14], is a popular and accurate model inference technique, which won the Abbadingo [14] and the StaMinA competition [24]. Data-classifier inference identifies patterns or rules between data values of an event and its subsequent events. Using data classifiers, the data rules and their subsequent events are explicitly tied together. ReHMM (Reinforcement learning-based Hidden Markov Modeling) [10] infers a gFSM extended with transition probabilities, by using a hybrid technique that combines stochastic modeling and reinforcement learning. ReHMM is built on top of MINT; differently from the latter, it uses a specific data classifier (Hidden Markov model) to deal with transition probabilities. All the aforementioned approaches cannot avoid scalability issues due to the intrinsic computational complexity of inferring FSM-like models; the minimal consistent FSM inference is NP complete [25] and all of the practical approaches are approximation algorithm with polynomial complexity.

Model inference has also been proposed in the context of distributed and concurrent systems. CSight [12] infers a communicating FSM from logs of vector-timestamped concurrent executions, by mining temporal properties and refining the inferred model in a way similar to Synoptic. MSGMiner [26] is a framework for mining graph-based models (called Message Sequence Graphs) of distributed systems; the nodes of this graph correspond to Message Sequence Chart, whereas the edges are determined using automata learning techniques. This work has been further extended [27] to infer (symbolic) class level specifications. However, these approaches require the availability of channel definitions, i.e., which events are used to send and receive messages among components.

Liu and Dongen [28] uses a divide and conquer strategy, similar to the one in our SCALER approach, to infer a system-level, hierarchical process model (in the form of a Petri net with nested transitions) from the logs of interleaved components, by leveraging the calling relation between the methods of different components. This approach assumes the knowledge of the caller and callee of each component methods; in our case, we do not have this information and rely on the leads-to relation among log entries, computed from high-level architectural descriptions and information about the communication events.

One way to tackle the intrinsic scalability issue of (automata-based) model inference is to rely on distributed computing models, such as MapReduce [29], by transforming the sequential model inference algorithms into their corresponding distributed version. In the case of the k-Tail algorithm, the main idea [11] is to parallelize the algorithm by dividing the traces into several groups, and then run an instance of the sequential algorithm on each of them. A more fine-grained version [7] parallelizes both the trace slicing and the model synthesis steps. Being based on MapReduce, both approaches require to encode the data to be exchanged between mappers and reducers in the form of key-value pairs. This encoding, especially in the trace slicing step, is application-specific; hence, it cannot be used in contexts in which the system is treated as a black-box, with limited information about the data recorded in the log entries. Furthermore, though the approach can infer a FSM from large logs of over 100 million events, the distributed model synthesis can be significantly slower for $k\geq 2$, since the underlying algorithm is exponential in $k$.

VII Conclusion

In this paper, we addressed the scalability problem of inferring the model of a component-based system from the individual component-level logs, assuming only limited (and possibly incomplete) knowledge about the system. Our approach, called SCALER, first infers a model of each system component from the corresponding logs; then, it merges the individual component models together taking into account the dependencies among components, as reflected in the logs. Our evaluation, performed on logs from an industrial system, has shown that SCALER can process larger logs, is faster, and yields more accurate models than a state-of-the-art technique.

As part of future work, we plan to refine the heuristics used for identifying the dependencies of the log entries between multiple components, to take into account logs with imprecise timestamps and out-of-order messages. We also plan to evaluate SCALER on different datasets and to integrate it with other model inference techniques. Finally, we will assess the effectiveness of the inferred models in software engineering activities, such as test case generation.

Acknowledgment

This work has received funding from the European Research Council under the European Union’s Horizon 2020 research and innovation programme (grant agreement No 694277), from the Luxembourg National Research Fund (FNR) under grant agreement No C-PPP17/IS/11602677, and from a research grant by SES.