In this paper a framework to automatically detect design and deployment antipatterns in component based enterprise systems is presented. The approach taken monitors a running system and makes use of statistical analysis and techniques from the field of data mining to summarise the performance data collected. Performance antipatterns are detected from the summarised data using a rule-engine approach and are assessed in terms of their performance impact using performance models. Any antipatterns found are presented to the user in a diagramatic format.Poor performance is a major obstacle that has to be overcome when delivering large internet-enabled enterprise systems. Often projects fail or face serious delays when they do not meet their performance goals. As shown in the literature [11] the design of enterprise systems plays a major role in how they meet their performance requirements. However, bad design from performance perspective is very common in such systems. This is quite evident from the number of common performance design mistakes which have been well documented [6] [5] [7]. Design mistakes generally results from the fact that these multi-tier distributed systems are extremely complex and often developers do not have a complete understanding of the entire application. As a result developers can be oblivious to the performance implications of their design decisions. Fixing serious design-level performance problems late in developent is very expensive and can not be achieved through "code optimizations". While the approach of "developing first, optimize later" may work at a class level, re-engineering large parts of an enterprise architecture may prove extremely expensive.Furthermore, while good design decisions are imperative for attaining performance goals, there are also important decisions that need to be taken during deployment of enterprise systems which affect performance significantly. This stems from the fact that in the case of enterprise frameworks (such as EJB), many decisions, that were inherent in the design and coding of systems in the past, have been abstracted out of the application source code into the deployment settings of the system. In EJB for example the granularity and type of transactions can be specified in the XML deployment descriptors of the application. Many such decisions can now be made at the deployment level. As a result, when configuring deployment time settings, different design trade-offs that can significantly impact performance must be considered. However, a real problem for system deployers is that component based frameworks can require a complex deployment strategy in order to make use of the many services provided. There are numerous different settings that need to be tuned correctly in order to have an efficiently running system. Examples include caching policies, object pools, database settings etc. Again a lack of understanding of enterprise applications (due to their complex nature) means that developers are often unsure as to how to go about configuring them co...

We introduce an approach for automatic detection of performance antipatterns. The approach is based on a number of advanced monitoring and analysis techniques. The advanced analysis is used to identify relationships and patterns in the monitored data. This information is subsequently used to reconstruct a design model of the underlying system, which is loaded into a rule engine in order to identify predefined antipatterns. We give results of applying this approach to identify a number of antipatterns in two JEE applications. Finally, this work also categorises JEE antipatterns into categories based on the data needed to detect them.

Component-based enterprise systems often suffer from performance issues as a result of poor system design. In this paper, we propose a framework to automatically detect, assess and visualize poor system design, from a performance perspective, by analyzing run-time data using data mining techniques.Component-based frameworks (e.g. EJB, .NET and the CORBA Component Model) provide reliable run-time environments and standardized reusable services. Using such frameworks allows developers building enterprise systems to invest their efforts in developing the functional requirements of a system, rather than wasting time developing the underlying infrastructure of the application. Services provided often cater for performance issues, for example object pooling or caching services, and can help developers meet their performance goals. However, although such services are provided, system performance is not guaranteed by these frameworks, and performance issues may, and do, still arise. Poor performance can arise in such systems as a result of poor system design. The impact the system design has on the performance of a system is highlighted in the literature [1]. Enterprise systems often suffer from poor system design as these systems tend to be extremely complex, and consequently developers often lack a clear understanding of the entire application. Component based enterprise applications yield a high level of complexity as a result of their large scale. Complex execution environments (e.g. application servers), the increase in outsourcing and the use of Commercial Off The Shelf (COTS) components may further exasperate the problem of a complete understanding of system behavior, since the internals of such components (i.e. the application server, the outsourced components and the COTS components) may be unknown. Developers lacking a clear understanding of the system behavior are often oblivious to the performance implications of their design decisions. As a result performance issues related to poor performance design are common in component-based systems. Limitations of Existing Performance Tools Current performance tools [2][3] for component-based systems are quite limited. They tend to generate massive amounts of runtime data that can prove overwhelming for developers when trying to locate performance bottlenecks within their system. Furthermore, even if developers manage to locate performance bottlenecks using such tools, no reason as to why this bottleneck occurred is given nor is any solution to overcome this problem provided. Often developers may be unsure as how to rectify the situation. Performance AntipatternsSoftware design patterns have become a staple in object oriented programming and design by providing elegant, easy to re-use, maintainable solutions to standard software development problems. In a similar fashion the benefits of performance antipatterns can be taken advantage of to improve system design from a performance perspective. While software design patterns document best practices, performance antipatte...

We present an approach and implementation for run-time correlation of large volumes of log data and symptom matching of know issues in the context of large enterprise applications. Our solution provides for (a) automatic data collection, (b) data normalisation into a common format, (c) run time correlation and analysis of the data to give a coherent view of system behaviour at run-time and (d) a symptom matching mechanism that can identify known errors in the correlated data on the fly. We have implemented our approach in the form of the Run-Time Correlation Engine (RTCE) and have applied it in a real industry test.

No abstract