URL: http://devresource.hp.com/drc/resources/d2dappmgmt/index.jsp

<h>Application management solutions with HP OpenView and BEA

   <h>Notes from a presentation given at BEA dev2dev Days 2004.

  

<h>In this presentation

   <l>» Top developer challenges
   <l>» Supporting the application in production 
   <l>» Addressing application performance issues
   <l>» Resolving performance problems today
   <l>» Common problem resolution approaches
   <l>» Key issues in problem resolution today
   <l>» How can HP OpenView Transaction Analyzer (OVTA) help?
   <l>» Demonstration: isolating performance problems with HP OVTA
   <l>» A re-cap of OVTA
   <l>» Key OVTA differentiators
   <l>» Extended application and platform support
   <l>» Moving beyond performance management
   <l>» Why is designing for manageability important?
   <l>» What can you rely on for manageability?
   <l>» What role can you play in manageability?
   <l>» Application management solutions with HP OpenView and BEA
   <l>» Call to action

<h>Top developer challenges

<h>Supporting the application in production

     <l>* Developer often called to resolve problems
     <l>* Difficult to recreate problem outside production
     <l>* Need to balance support needs with new development

<h>ddressing application performance issues

     <l>* Detecting problems is often reactive and post-deployment
     <l>* Isolating performance bottlenecks can be difficult
     <l>* Many distributed, complex layers to analyze
     <l>* Developers given vague information on problem
     <l>* Increased time to problem resolution

   <p>If you are a developer, you probably face a number of development
   challenges on a daily basis. There's a constant need to keep current
   on emerging technologies, pressure from your customers to deliver
   products ahead-of-schedule, and a desire to build robust and scalable
   architectures.

   <p>Despite understanding the importance of performance to the success of
   any application, and the attempting to design and architect your
   application to ensure that it's robust and scalable, performance
   management is probably more of an after-thought and doesn't become a
   critical issue until production when the customer experiences a
   problem.

   <p>If you had a very simple application, it might not be too difficult to
   diagnose the problem. But, you're probably using Web services, JMS,
   Servlets, EJBs, and other distributed technologies. When you're given
   a support request such as, "the application is slow", you're most
   likely spending countless hours trying to identify and diagnose the
   performance problem. You won't have enough information to know where
   to even start, which will make it very difficult to recreate the
   problem outside of production.

   <p>This leads us to the developer's dilemma. If you want to spend more
   type playing with new technologies such as grid computing or AOP, or
   you want to build more functionality, you have to balance that with
   the requirements to support the application.

<h>Resolving performance problems today

<h>Common problem resolution approaches

     <l>* Print statements or log files
     <l>* Operating system utilities
     <l>* Thread dumps
     <l>* Simple management tools
     <l>* Trial and error!

<h>Key issues in problem resolution today

     <l>* Time to resolution is too long
     <l>* Developers required to diagnose problems
     <l>* Problem may not be code-related
     <l>* Often requires multiple diagnostic tools

   <p>Time spent troubleshooting and fixing application issues...is time not
   spent on new functionality

   <p>Consider the "traditional" approach commonly used to deal with
   performance issues. We are all familiar with the tried-and-true
   "printf" approach for measuring method call times. This technique can
   be quite useful, except when you have to correlate individual method
   times with an end-user experience. Spreadsheets and calculators can be
   your friend here, but it can be very time consuming.

   <p>You might also be able to leverage a variety of operating system tools
   to help diagnose the problem. If the production machine is hitting
   100% CPU utilization, you might leverage a tool such as glance to
   analyze the problem. Or, if you're experiencing thread contention or
   Java memory issues, you might leverage specific JVM tools to identify
   the bottleneck. Often, these techniques are too bottoms-up, making it
   difficult, if not impossible, to understand how any single component
   might impact the end user's experience.

   <p>If you're lucky, you may have had the opportunity to work with some
   simple management tools. Maybe you're leveraging the WebLogic
   administration console to get some application server statistics. Or,
   you might have even toyed with ARM, JMX, or Log4J. Even in these
   situations, the tools at your disposal often only provide part of the
   answer, and you are left to piece the puzzle together to resolve the
   problem.

   <p>Bottom line, many of the current approaches used to diagnose
   performance problems are often very time-intensive, requiring hours or
   days to diagnose. Many times, the problem isn't even related to the
   application. It could be a network issue or a database issue, but
   you've just wasted three days supporting the application instead of
   enhancing it.

<h>How can HP OpenView Transaction Analyzer (OVTA) help?

   <l>OVTA - Transaction level monitoring & analysis
   <l>Are my transactions flowing smoothly across tiers?
   <l>Where are the performance bottlenecks in my transactions?
   <l>OVTA-JD - Application/JVM/System Level Monitoring & Analysis
   <l>Is my application experiencing memory leaks?
   <l>Where are the source code level performance bottlenecks?

   <p>OVTA from HP helps you isolate application performance problems in
   your J2EE applications. Rather than spending the time adding those
   printf statements, stepping through your code, and trying to identify
   exactly where your performance bottleneck is occurring, you can now
   use a tool that can provide you with all kinds of information about
   your application's performance.

   <p>OVTA captures end-to-end transaction information and tells you if your
   transactions are flowing smoothly across the different application
   tiers, including the client, the web server, the app server and the
   database tiers. It will show you right down to the J2EE component, the
   location of the performance bottlenecks in a given transaction.

   <p>Now, we can all make mistakes in our code, especially if we're on a
   time crunch or are simply on a roll and hammering out code deep into
   the night. Once we have our code developed, how do we determine
   whether it contains a memory leak or a thread contention problem?
   Better still, how do we track the leak back to the source code and fix
   the issue? With the OVTA Java Diagnostics (JD) tool, we can quickly
   determine if our application is experiencing any memory leaks, and
   where any source code level performance bottlenecks are located.

   <p>Now you can do all of this in matter of minutes. Instead of spending a
   half-day stepping through various aspects of your code, trying to
   piece together the performance puzzle and making guesses on where the
   performance bottleneck might be, you can use OVTA to quickly diagnose
   the performance problems in your application.

<h>Demonstration: isolating performance problems with HP OVTA

<h>Background

   <p>An application performance problem has been detected in HP OpenView
   Internet Services

<h>Demonstration

   <p>Isolating the performance problem using HP OpenView Transaction
   Analyzer

   <p>Let's take a look at how we can isolate an application performance
   problem in our application using OVTA.

   <p>In this particular scenario, an IT operator or the application owner
   is monitoring the application for availability and response time. They
   might be using a product such as HP OpenView Internet Service (OVIS)
   to monitor the application from end-to-end to determine overall
   availability and performance. Here, we see a screenshot of this
   product indicating that the response time of our application is not in
   an acceptable state. As the operator or support specialist does some
   quick root cause analysis, he finds that it is your application that
   isn't performing up to defined service levels. He contacts you
   immediately and asks you to look at a problem that is occurring with
   your application. He doesn't tell you much except that your
   application transaction response time rate is twice the accepted rate.
   So how are you going to solve this problem? Let's now take a look at
   this problem through the perspective of OVTA.

<h>A re-cap of OVTA

<h>Key OVTA differentiators

     <l>* No source code changes required
     <l>* Data correlated end-to-end across application tiers
     <l>* Very low performance impact on production systems
     <l>* Integrated SLA monitoring, reporting, and alarming
     <l>* Closes the loop between operations and development

<h>Extended application and platform support

     <l>* HP-UX, Solaris, Windows, Linux, and Itanium
     <l>* .NET, J2EE, and web services support
     <l>* Supports WebLogic Portal, JMS and Struts
     <l>* JMX metrics to monitor WebLogic Server health

   <p>In the demonstration, transaction data was correlated across all of
   the application tiers. This is particularly important when you are
   trying to assess the exact component causing the bottleneck, including
   network or database issues that are beyond your control. This can cut
   the diagnostic time down to just minutes so that you can quickly
   address the problem.

   <p>HP also offers OVTA Java Diagnostics, a profiling tool that allows you
   to perform application level analysis on running J2EE applications.
   The tool enables operations staff and developers to work together
   effectively in diagnosing performance bottlenecks, helping to diagnose
   memory leaks, source code performance problems, and other JVM issues.

   <p>Additionally, the impact of having OVTA monitoring and tracking the
   performance of your application is very low. At a high level, the
   product provides sufficient data to monitor the application with
   negligible overhead. You can also tune the amount of trace information
   captured when performing diagnostics. And even then, the overhead can
   be controlled to stay at very acceptable ranges while the problem is
   assessed.

   <p>OVTA offers broad platform and application support, supporting HP-UX,
   Solaris, Windows, and Linux, and is capable of supporting both J2EE
   and .NET platforms. The product is optimized to support the WebLogic
   platform. Additionally, the product leverages JMX technology to
   monitor and assess the overall health of the WebLogic server. Metrics
   such as JVM memory utilization can be used to correlate the health of
   the server with the performance of your application.

<h>Moving beyond performance management

<p>Why is designing for manageability important?

     <l>* Ensures high degree of application availability
     <l>* Minimizes support demands on the developer
     <l>* Enables tighter linkage between business and IT

<p>What can you rely on for manageability?

     <l>* Most J2EE platforms, including WebLogic, support JMX
     <l>* HP OpenView can monitor JMX-enabled applications

<p>What role can you play in manageability?

     <l>* Determine requirements for application manageability
     <l>* Select the right management technology (Log4J, JMX)
     <l>* Instrument the application, if required

   <p>We have just looked at a way to diagnose J2EE application performance
   problems using OVTA. One way to deal with these issues is to have the
   right sets of tools on hand to diagnose problems when they occur.

   <p>But, what if you could design your application in such a way that it
   contains sufficient information to be better managed in operations?
   Today, operations relies on the developer because the information
   available to them is not sufficient to handle the problem themselves.
   If you can make your applications more "management aware", you can
   hopefully minimize the demands IT support places on you.

   <p>Additionally, designing applications with "management in mind" has
   some clear benefits to your organization. With the right set of
   management interfaces exposed by an application, and operator can
   ensure a higher degree of application availability. Manageable
   application can also be made more flexible and adaptive in production.

   <p>What can you do to make applications more manageable? The good news is
   that many application platforms today provide some amount management
   out-of-the-box. Almost all J2EE platforms, including WebLogic, expose
   management interfaces for the platform in the form of JMX MBeans.
   These interfaces can then leveraged by management systems such as HP
   OpenView.

   <p>In some cases, platform-level management is not sufficient to
   effectively manage an application in production. Some amount of work
   might be required by the developer up-front to expose
   application-level management interfaces.

<h>Application management solutions with HP OpenView and BEA

   <p>HP OpenView is a BEA preferred priority choice management partner
   <p>HP OpenView Internet Services
     <l>* Provides a view of the customer experience
     <l>* Monitors end-to-end performance and availability
     <l>* Supports applications deployed on the BEA platform
     <l>* Monitors discrete protocols within J2EE or .NET

   <p>HP OpenView Transaction Analyzer
     <l>* Drill-down into applications
     <l>* Root-cause analysis
     <l>* Eliminate performance bottlenecks
     <l>* Component-level diagnostics
     <l>* Supports BEA WLS and Portal

   <p>HP OpenView Operations + Smart Plugs-ins
     <l>* Proactively monitor and manage IT environment
     <l>* Determine service impacts through service views
     <l>* Supports applications running on WLS or WLI
     <l>* Extensible through custom JMX MBeans

   <p>Your application may be developed in isolation, but it probably won't
   run in isolation. There are dependencies on the application server,
   the database, and other IT infrastructure components. This larger
   "management ecosystem" requires the right level of manageability at
   all layers, and you play an important role here.

   <p>The HP OpenView Application Management Solution allows an application
   owner to comprehensively monitor their business-critical application
   environment. OVTA provides the insight into the application itself by
   drilling down to the component or method level, enabling you to
   quickly find the source of performance bottlenecks. OpenView Internet
   Services provides a view of the customer experience by monitoring the
   end-to-end performance and availability of your applications.
   Additionally, HP offers a set of Rapid Implementation Services which
   can help you rapidly install and configure OVIS and OVTA in as little
   as 5 days. HP OpenView Operations provides the ability to map and
   proactively monitor the underlying infrastructure that supports
   applications deployed on WebLogic Server or WebLogic Integration.

   <p>Obviously, HP can't do this alone. BEA and HP have teamed up to
   provide you with management solutions that ensure a high degree of
   stability, efficiency, and agility for the WebLogic platform. HP
   OpenView is already supporting WLS, WLI, and WLP to varying degrees.
   As a BEA preferred and priority management partner, HP is committed to
   further enhancing these management solutions with more robust and
   unique management capabilities moving forward.

<h>Call to action

   <p>There are some important next steps you can take to learn more about
   HP's application management solutions. You can download an evaluation
   copy of OVTA at the HP Management Software URL listed on this page. It
   is very easy to install and configure to run against your own
   applications.

   <p>For those of you that are considering application manageability
   through JMX, you are highly encouraged to visit our HP Developer
   Resource Central site. This site provides you with a variety of white
   papers, code samples, and developer tutorials on JMX. One of the
   tutorials shows how a BEA WebLogic sample application can be
   instrumented using JMX. Once you're done with this tutorial, you will
   have the foundation to be able to instrument your own existing
   applications.

   <p>To learn more about HP OpenView and BEA application management
   solutions, visit the OpenView/BEA web site. You will find that
   together, BEA and HP OpenView offer you more control and agility,
   resulting in a greater competitive edge. And finally, don't forget to
   stop by our booth and take a closer look at OVTA and other HP OpenView
   management solutions.