Posts written by Josh Mattson
Modern application environments can be complex and include many discrete elements that can all affect the end user's experience. Because of this, it can be challenging to develop an effective monitoring strategy that allows you to be alerted during potential performance problems and also to use these metrics from a variety of systems to proactively address potential bottlenecks and slow points before they cause end user impact. In this article, we'll be discussing several best practices for ensuring that your environment is effectively monitored.
Long running threads, application locks, thread contention, and other problems can all cause significant performance problems in Java applications (up to and including a complete lock up of the Java Virtual Machine (or JVM)!) Thread dumps are a vital tool in analyzing and troubleshooting performance problems in Java applications. They represent a point-in-time snapshot of the stack traces for all active threads that exist within the JVM. Typically, in order to troubleshoot these issues and get to the root cause, an engineer takes several thread dumps approximately 5-15 seconds apart. In this way, we can compare the state of all threads to determine commonalities -- namely, threads that are long running, blocking other threads, leading to circular deadlocks, and so on. In large applications, you may have thousands of threads, which can make this analysis a challenging prospect. In this article, we'll discuss how we can use a tool called fastthread.io in order to offload most of the heavy lifting and give us immediate insight in to the state of the application threads.
Rackspace Application Services provides application support and management to a wide variety of customers ranging in size from small environments with only a few application servers to customers that run thousands of Java Virtual Machines (or JVMs) across their environment. To help facilitate this, we heavily rely on Ansible to help us automate implementation, troubleshooting, and maintenance tasks. While Ansible is quite powerful and easy to use, many organizations do not take full advantage of some of the features that it provides. In this article, we'll be discussing how you can extend Jinja2 and Ansible's built-in filter plugins and how you can craft a completely new filter plugin to make specific tasks easier.
As we've discussed in previous posts, AppDynamics is a powerful Application Performance Management (APM) tool that can be used to help tune performance in your application. However, with many organizations adopting a CI/CD approach to their application development lifecycle, it can be difficult to determine how these frequent deployments are affecting application performance and end-user experience.
Application Performance Management (APM) tools can provide incredibly valuable insight into the performance of your applications and ultimately your end users' experience. This insight, however, does not come without its cost. Because APM tools instrument code at runtime, there is always some level of performance overhead. In contrast to some older APM tools, modern APM tools are designed to minimize the negative performance impact as much as possible to allow you to safely run them in production without your end users' experience suffering. In this post, we'll evaluate the overhead introduced on an Adobe Experience Manager (AEM) environment by two popular APM tools: AppDynamics and New Relic
AppDynamics is a powerful Application Performance Management tool that, properly configured, can provide tremendous insight in to application and infrastructure performance bottlenecks and enable operations and development teams to rapidly identify and resolve issues. Although AppDynamics collects and measures application performance data out of the box, some configuration and customization is necessary in order to reach its full capabilities. This guide explains best practices around how to identify your application's critical business transactions in order to get the most out of AppDynamics and, ultimately, the most out of your application and infrastructure.