Microservice systems normally consist of numerous microservice instances with intricate dependencies and invocation relationships, which make them vulnerable to various types of faults. In practice, microservices are typically deployed in containerized environments, and faults often manifest as invocation or performance anomalies. Existing fault localization approaches mainly rely on one or more sources of logs, traces, and metrics to localize faults in microservice systems, and consequently it is challenging for them to accurately localize communication anomalies, particularly at the microservice instance level. In this paper, we propose Metra, a fault localization technique for microservice systems via the fusion of metrics and traces. Metra first employs container monitoring to generate extended execution traces that incorporate both microservice instance nodes and network nodes, and integrates these traces with performance metrics. Execution traces are then classified using a clustering algorithm based on API requests and structural similarity. Invocation structure anomalies are identified, and a set of heuristic search rules are applied to localize faulty nodes in anomalous traces. For traces exhibiting performance anomalies, a contribution ranking strategy is employed to localize faulty nodes. A supporting tool has been developed to implement the proposed technique. Experimental evaluation on two typical benchmark microservice systems has demonstrated that Metra achieves effective localization at the microservice instance level for both functional and non-functional faults, with consistently improved accuracy and precision, as well as reduced time cost compared with existing approaches.

Enterprise software systems are increasingly integrating with diverse services to meet expanding business demands. Testing these highly interconnected systems presents a challenge due to the need for access to the connected services. Service virtualization has emerged as a widely used technique to derive service models from recorded interactions, for service response generation during system testing. Various methods have been proposed to emulate actual service behavior based on these interactions, but most fail to account for the service's state, which reduces the accuracy of service emulation and the realism of the testing environment, especially when dealing with stateful services. This paper proposes an approach to deriving service models from service interactions, which enhance the accuracy of response generation by considering service state. This is achieved by uncovering contextual dependencies among interaction messages and analyzing the relationships between message data values. The approach is evaluated using interaction traces collected from both stateful and stateless services, and the results reveal notable enhancements in accuracy and efficiency over existing approaches in service response generation.

Business Process Management (BPM) has emerged as a fundamental aspect of modern business, revolutionising task execution and operational efficiency. This study explored the relationship between virtualisation and work design as well as their impact on BPM system design. An experiment was established where two simulated BPM systems were given to users to operate, one taking advantage of virtualisation and work design, the other not. A mixed method approach involving both quantitative and qualitative approaches was applied to system and usage data collected from these systems as well as a user survey. The analysis illustrates the potential significance of integrating virtualisation and work design in BPM systems. We provide a reflective discussion linking theoretical understanding with empirical evidence. We found that both components not only enhanced the performance and effectiveness of BPM systems, but also improved flexibility, scalability, and user experience. The data supports that a relationship between virtualised resources and work design exists when incorporated into BPM system design. Further, it provides valuable insights into how these elements interact and impact each other. The findings in this study contribute to building a case that establishes the effect of virtualisation and work design on the usability of BPM systems. These findings have very real practical applications that can be applied to existing BPM systems as well as the architecture of future systems. A number of the recommendations made as a result of this research have been applied to commercially available BPM systems.

Insider threats pose a growing risk to organizational security, intensified by the rise of hybrid work arrangements that increase opportunities for unauthorized access and data leaks. As such, robust insider threat detection (ITD) systems are essential to address these challenges. Recent advancements highlight the potential of graph-based deep learning model, which excel in detecting complex relational patterns. However, as graph-based ITD is still a novel and emerging field, efforts have primarily focused on developing new methodologies rather than refining foundational aspects like graph construction rules. This study investigates the impact of different graph construction rules on ITD model performance, representing users, assets, and activities as nodes and edges. By analyzing various rule sets, we assess their influence on detection accuracy and computational efficiency. The proposed framework aims to aid in identification of optimal rules that balance precision with resource use, contributing to the development of more effective and efficient ITD systems for modern workplace environments.

Microservice architecture (MSA) has been widely adopted to develop various large-scale distributed systems. Microservice-based systems (MBSs) comprise a number of independently deployed microservices fulfilling the specific functionalities. Unique characteristics of microservices, such as independent and parallel development, rapid iteration, and distributed deployment, result in low observability and reliability of MBSs. A typical solution is to regulate system behavior in specifications of MBSs, and then develop and test MBSs based on these specifications. However, current microservice specifications focus on describing the APIs of microservices without describing the behavior expectation for an MBS. In this article, we propose an annotation-assisted and scenario-oriented approach, called MSA_Sighter, to detect behavior inconsistencies in MBSs. In MSA_Sighter, the details of an MBS are captured in a description model (MSDM), which can be extracted automatically from the functional services through annotation-assisted runtime component instance analysis and static program analysis. Given a specific business scenario, inconsistency detection is conducted by analyzing the actual behavior's conformance to the expected behavior, where the former is collected through distributed tracing while the latter is derived from the MSDM. We have developed a supporting tool called ConsChecker and evaluated MSA_Sighter's effectiveness on three open-source MBSs in GitHub. The experimental results have shown that MSA_Sighter can effectively detect inconsistencies in MBSs during system development and evolution.

Web services have been widely used to develop complex distributed software systems in the context of Service Oriented Architecture (SOA). As a standard for describing Web services, the Web Service Description Language (WSDL) provides a universal mechanism to describe the service’s functionalities for the service consumers. However, the current WSDL only provides the description of the interfaces to a Web Service without any restrictions or assumptions on how to properly invoke the service, resulting in divergent understanding of the Web service’s behavior between the service developer and service consumer. A particular challenge is how to make explicit the various behavior assumptions and restrictions of a service (for the user), and make sure that the service implementation conforms to them (for the developer). In this article, we propose a constraint-based model-driven approach to improving the behavior conformance of Web services. In our approach, constraints are introduced in an extended WSDL, called CxWSDL, to formally and explicitly express the implicit restrictions and assumptions on the behavior of a Web service, and then the predefined constraints are used to derive test cases in a model-driven manner to test the service implementation’s conformance to its behavior constraints from the user’s perspective. An empirical study involving four real-life Web services was conducted to evaluate the effectiveness of our approach, and four actual inconsistencies were discovered.

Service compositions are widely used to construct complex applications. Due to the frequent changes of environment and requirements, service compositions need to be adaptable enough. In this work, we propose a feature-driven variability-enabled adaptive service composition approach to systematically treat the variability in the full life-cycle of service compositions. Specifically, the feature model is introduced to represent common and variable requirements and drive the variability design of service compositions. An abstract service composition model is used to define the variable business process. Rules and algorithms are then defined to transform the feature model to the abstract service composition model, from which different process instances are derived on demand to meet different requirements. We have developed a prototype tool to facilitate and automate our approach as much as possible. Finally, a case study is conducted to demonstrate the proposed approach and validate its effectiveness and efficiency.

Context: Service virtualization has become a popular tool to provide testing environments for highly connected enterprise software systems. It enables the enterprise system under test to interact with and obtain responses from model-based service emulations instead of the actual services they use in production environments, providing accessibility and realness. Existing approaches consider only the control dependencies between messages (i.e., the service's control model) and do not consider the relationships between data values of the messages (i.e., the service's data model), limiting the accuracy of service emulation. Objective: In this paper, we present an approach to deriving the service's data model from its interaction traces and using it in determining the payloads for response messages, therefore achieving more accurate service emulation. Method: The derivation of a service's data model is achieved by discovering the data entities and their key attribute(s) from the service interaction messages. It is then used, together with the control model, to synthesize response messages for incoming request messages at runtime. While the control model help to identify the types of responses, the data model keeps track of the changes to the service's data entities and provides the basis for populating accurate payloads for the responses. Results: A number of experiments have been conducted on message traces collected from a range of stateful and stateless services. With the use of both the control and data models in response generation, our approach consistently outperforms the existing state-of-the-art approaches. In particular, it generates 100% identical responses (compared to actual services) for most of the datasets, while the highest accuracy achieved by existing approaches was 88%. Conclusion: The experimental results have shown that the inferred data model provides an effective means in determining the payloads for response messages, significantly improving the accuracy of service emulation and providing more realistic testing environments.

Having precise specifications of service APIs is essential for many Software Engineering activities. Unfortunately, available documentation of services is often inadequate and/or imprecise and, hence, cannot be fully relied upon. Generating service documentation manually is a tedious and error-prone task, especially in light of changes to services. Therefore, there is a need for automated support in generating service documentation. In this work, we present a novel approach to infer the API of a service by analyzing recorded messages sent to and received from this service. Our approach includes a novel, two-level clustering technique to cluster messages, a step that many existing approaches to infer message formats fail to perform precisely in the presence of significant variation of payload information of the available messages. We have evaluated our approach on message traces from four different real-world services. The experimental result shows that our approach is more effective than existing techniques in extracting correct message formats from recorded messages.

The skyrocketing growth of mobile apps and mobile devices has significantly fueled the competition among app developers. They have leveraged the app store capabilities to analyse app data and identify app improvement opportunities. Existing research has shown that app developers mostly rely on in-domain (i.e., same domain or same app) data to improve their apps. However, relying on in-domain data results in low diversity and lacks novelty in recommended features. In this work, we present an approach that automatically identifies, classifies and ranks relevant popular features from cross-domain apps for recommendation to any given target app. It includes the following three steps: 1) identify cross-domain apps that are relevant to the target app in terms of their features; 2) filter and group semantically the features of the relevant cross-domain apps that are complementary to the target app; 3) rank and prioritize the complementary cross-domain features (in terms of their domain, app, feature and popularity characteristics) for adoption by the target app’s developers. We have run extensive experiments on 100 target apps from 10 categories over 15,200 cross-domain apps from 31 categories. The experimental results have shown that our approach to identifying, grouping and ranking complementary cross-domain features for recommendation has achieved an accuracy level of over 89%. Our semantic feature grouping technique has also significantly outperformed two existing baseline techniques. The empirical evaluation validates the efficacy of our approach in providing personalised feature recommendation and enhancing app’s user serendipity.

Automatically discovering message formats of unknown service or system protocols from network traces has become important for a variety of applications, such as emulating the behavior of an unknown protocol in service virtualization, or enabling deep packet inspection in network security. Among existing schemes, the keyword extraction based approaches have been shown to be effective. Inspired by the template structure of protocol messages, recent works leverage the positions of keywords to extract message keywords more accurately. However, these methods are deficient for messages with large variations in length. To address this problem, we propose R-gram, which exploits the relative positions of keywords in messages, allowing the keywords to be robustly detected in variable length messages. It first extracts the common template of the messages in a given message trace with a fast sampling technique, and segments each message into blocks according to the relative positions of the common keywords in the template. It then identifies message keywords in each block by using a new concept and technique — relative positional n-gram (r-gram in short). Finally, the message keywords are used to separate all the messages into type-specific clusters and consequently derive the message format for each cluster. We have implemented and evaluated R-gram on real-world service traces containing either textual or binary protocol messages. Our experimental results show that R-gram is more accurate and robust than existing state-of-the-art tools in protocol message format extraction. Furthermore, R-gram is efficient for processing large-scale message traces.

Competition in mobile applications (i.e., apps) is becoming more and more intense with the increase in popularity of smart phones and mobile devices. Previous research shows that app developers spent considerable amount of time in exploiting user feedback to improve their apps. However, relying on own user feedback is insufficient for app survival in such competitive environment. It is highly important for an app developer to learn from competitors in order to keep the rank higher or become topper in the store (e.g., Google Play(1)). In this work, we present an approach to automatically classify and rank popular and un-popular features from the competitor apps. We follow 3 steps- (1) extract features from competitor app updates (i.e., whatsNew) and user feedback (i.e, reviews), (2) filter and group the review features that are relevant to whatsNew features, then, classify whatsNew features to binary classes, such as, popular and unpopular, (3) rank and prioritize those popular and unpopular features from competitors in order to recommend developers to adopt or avoid those features. The ranking of whatsNewfeatures are done based on whatsNew-to-review relevance, user sentiments, and popularity of those features. We conduct extensive experiments on 840 updates and 262000 reviews of 84 different competitor apps of 10 categories. We found encouraging results from the experiments and the empirical evaluation validates the efficacy of our approach, hence, potential usefulness to the developers.

Software behavioral models have proven useful for emulating and testing software systems. Many techniques have been proposed to infer behavioral models of software systems from their interaction traces. The quality of the inferred/mined model is critical to their successful use. While generalization is necessary to deduce concise behavioral models, existing techniques of inferring models, in general, overgeneralize what behavior is valid. Imprecise models include many spurious behaviors, and thus compromise the effectiveness of their use. In this paper, we propose a novel approach, named SpecMiner, that increases the precision of the behavioral model inferred from interaction traces. The essence of our approach is a heuristic-based generalization and truthful minimization. The set of heuristics include patterns to match input traces and generalize them towards concise model representations. Furthermore, we adopt a truthful minimization technique to merge these generalized traces. The key insight of our approach is to infer a concise behavioral model without compromising its precision. We present an empirical evaluation of how our approach improves upon the state-of the-art specification inference techniques. The results show that our approach mines model with 100% precision and recall with a limited computation overhead. (C) 2020 Elsevier B.V. All rights reserved.