Jump to content |

» Contact HP

Search: |  |  |
| DRCAll of HP US

# Application management solutions with HP OpenView and BEA

Notes from a presentation given at BEA dev2dev Days 2004.

»

## Dev Resource Central

» | Downloads index
» | Topic index
| » | HP OpenView
| » | HP OpenCall
| » | Linux
» | Ask the experts
» | Explore management technologies
» | Integration stories
» | Forums
» | Blogs
» | Invent Online webcasts
» | Get software support
» | Newsletter
» | Events
» | About us
» | Site map

by Justin Murray, Chris Peltz, & Claire Rogers, HP

## In this presentation

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

## Top developer challenges

### Supporting the application in production

- Developer often called to resolve problems
- Difficult to recreate problem outside production
- Need to balance support needs with new development

### Addressing application performance issues

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

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.

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.

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.

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.

## Resolving performance problems today

### Common problem resolution approaches

- Print statements or log files
- Operating system utilities
- Thread dumps
- Simple management tools
- Trial and error!

### Key issues in problem resolution today

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

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

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.

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.

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.

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.

## How can HP OpenView Transaction Analyzer (OVTA) help?

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

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.

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.

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.

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.

## Demonstration: isolating performance problems with HP OVTA

#### Background

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

#### Demonstration

Isolating the performance problem using HP OpenView Transaction Analyzer

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

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.

## A re-cap of OVTA

### Key OVTA differentiators

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

### Extended application and platform support

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

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.

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.

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.

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.

## Moving beyond performance management

### Why is designing for manageability important?

- Ensures high degree of application availability
- Minimizes support demands on the developer
- Enables tighter linkage between business and IT

### What can you rely on for manageability?

- Most J2EE platforms, including WebLogic, support JMX
- HP OpenView can monitor JMX-enabled applications

### What role can you play in manageability?

- Determine requirements for application manageability
- Select the right management technology (Log4J, JMX)
- Instrument the application, if required

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.

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.

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.

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.

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.

## Application management solutions with HP OpenView and BEA

HP OpenView is a BEA preferred priority choice management partner
HP OpenView Internet Services

- Provides a view of the customer experience
- Monitors end-to-end performance and availability
- Supports applications deployed on the BEA platform
- Monitors discrete protocols within J2EE or .NET

HP OpenView Transaction Analyzer

- Drill-down into applications
- Root-cause analysis
- Eliminate performance bottlenecks
- Component-level diagnostics
- Supports BEA WLS and Portal

HP OpenView Operations + Smart Plugs-ins

- Proactively monitor and manage IT environment
- Determine service impacts through service views
- Supports applications running on WLS or WLI
- Extensible through custom JMX MBeans

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.

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.

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.

## Call to action

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.

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.

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.

Try out HP OpenView Transaction Analyzer
» Download
Gain some experience with JMX technology
» Visit HP Dev Resource Central
Complete developer tutorials on JMX
» Learn more about HP OpenView and BEA application management solutions
Find more developer events
» Events

Printable version

Privacy statement | Using this site means you accept its terms | Trademark acknowledgment | Feedback to Dev Resource Central
© 2006 Hewlett-Packard Development Company, L.P.