Guided Algebraic Specification Mining for Failure Simplification

Abstract

Abstract. Software systems often produce logs that capture information about their execution behaviour. When an error occurs, the log file with the error is reported for subsequent analysis. The longer the log file, the harder to identify the cause of the observed error. This problem can be considerably simplified if we reduce the log length, e.g., by removing events which do not contribute towards finding the error. This paper addresses the problem of log reduction by rewriting the reported log in such a way that it preserves the ability to reproduce the same error. The approach exploits rewrite rules inferred from a set of predefined algebraic rewrite rule patterns, exhibiting such properties as commutativity and identity. The paper presents an algorithm for rewrite rules inference, and a terminating reduction strategy based on these rules. Being log-based the inference algorithm is inherently imprecise. So the inferred rules need to be inspected by a human expert before actually being used for rewriting. The approach is language independent and highly flexible. The paper formally defines all used concepts and discusses a prototype implementation of a log reduction framework. The prototype was empirically validated on a web shop application.

Exploiting Annotations to Test Break-off Branches

“…Henkel-Diwan [17] and Elyasov et al [18] describe approaches to infer algebraic properties, e.g. put(x); put(x) ≡ put(x), saying that invoking the operation put(x) twice with the same argument has the same effect as invoking it once.…”

Reduce first, debug later

“…The rules together form an event-reduction system, and can be exploited for log reduction. In accordance with the reduction strategy [5], the chosen log (#3) was reduced from 44 events to just 8 events by applying the rewrite-rules inferred on the previous step. Let us refer to the original log by E and its reduction by R. Let E * be the minimal subsequence of E imposing the failure.…”

“…In [5] we have proposed a two stage approach for reduction of the failing event sequence, that consists of 1) mining rewriting rules from the set of collected logs, and 2) applying these rules to the failing sequence with the purpose of sequence length reduction. The rewriting rules have the form τ1 ≡ τ2, which represents the following property: for all application states where both the event sequences τ1 and τ2 are executable, the final states after the execution of τ1 and τ2 from that state are equal as well.…”

“…Each log entry records the invoked event and the application state, which is represented, in our case, by two variables N and C, after the event has occurred. The approach proposed in [5] introduces algebraic rule patterns, such as those in Figure 2, that are used for mining the rewrite rules from logs. Applying inference to the log L, we can obtain the following concrete rewrite rules:…”

“…But at the same time, as we will see later, the DD reduction time starts to exceed one hour even for logs of such a moderate length. The complete set of logs was used for inference of the alge- braic rewrite-rules [5]. We set the confidence level to 90%, which is equivalent to demanding a rewrite-rule candidate to be witnessed four or more times before accepting it (given confidence level has shown to be sufficient [5] to guarantee low rate of false positives).…”