Course # 3250 Best Practices and Design Patterns for JMX Development Satadip Dutta Justin Murray Hewlett-Packard

Objectives Why are we talking about Design Patterns and JMX? Java Management Extension API is now available in the J2SE core as well as J2EE –Usage of the new J2SE APIs –Design Patterns

Who are the speakers Satadip Dutta –Software Architect working on Manageability enablement tools –Works on creating tools that help management enable custom applications Justin Murray –Technical consultant with HP’s software business unit –Works with customers on implementing manageability for Java/J2EE/web services based applications

Presentation goals At the end of the presentation, you will be able to –Use the Java Management Extensions (JMX) –Apply design patterns while instrumenting your application for management –Build better managed applications

Agenda Introduction to Manageability Introduction to JMX Using JMX Design Patterns A Manageability Enablement Tool

Agenda Introduction to Manageability Introduction to JMX Using JMX Design Patterns A Manageability Enablement Tool

Problem statement error occurs Symptoms Causes Application Development IT/Operations Where?

Why is application manageability important? We focus most of our application development effort on functionality and performance - but – Most of the lifetime of an application is in deployment

Manageability defined Manageability: Monitoring:Tracking:Control: exercise administrative and supervisory actions capture runtime and historical events of a particular component, example: the monitoring of the performance of a network router observe aspects of a single thread across multiple components. example: the tracking of a message from sender to receiver through a messaging backbone. alter the behavior of the managed component without interrupting its operation example: changing the logging level of an application component.

Accomplishment Manageability enables –Reactive Problem Resolution –Proactive Problem Detection Results in –Stability –Resiliency

Agenda Introduction to Manageability Introduction to JMX Using JMX Design Patterns Application Architecture Managebaility Enablement Tools

JMX defined The JMX specification provides an API and architecture that provides a standard mechanism to management enable Java applications

JMX Architecture

Instrumentation Layer –MBeans - MemoryMXBean Agent Layer –MBeanServer -PlatformMBeanServer Distributed Layer –Connectors- RMI –Adapters- SNMP, WSDM

MBeans An MBean is a named managed object representing a resource –Application configuration –JVM/ Environment Attributes –User identity –Business entities An MBean can have: –Attributes that can be read and/or written –Operations that can be invoked –Notifications that the MBean can send

Agenda Introduction to Manageability Introduction to JMX Using JMX Design Patterns Application Architecture Managebaility Enablement Tools

Using JMX Using the monitoring and management API from J2SE 5.0 Creating custom MBeans

Solving the problem Monitor JVM Health –Monitor Memory and CPU Track usage –Specify Memory Thresholds Control logging levels –Get information when problems occur

Monitoring and Management API MXBeans = Predefined Platform MBeans JVM related MXBeans focus on –Memory consumption MemoryMXBean MemoryPoolMXBean –CPU consumption ThreadMXBean RuntimeMXBean

Getting started Enable the JMX Agent on the JVM $JAVA_HOME/bin/java -Dcom.sun.management.jmxremote ApplicationName enables local JVM monitoring

Monitoring the health Connect to the MBeanServer Get the MemoryMXBean Get the ThreadMXBean

directly using ManagementFactory ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();

Connecting to the MBeanSever using Proxy mBeanServerConnection= JMXConnectorFactory.connect(new JMXServiceURL(jmxServiceURL),null).getMBeanServerConnection(); String jmxServiceURL = service:jmx:rmi:///jndi/rmi://localhost: /

Get the MemoryMXBean MemoryMXBean memoryMXBean = ManagementFactory. newPlatformMXBeanProxy ( mBeanServerConnection, ManagementFactory.MEMORY_MXBEAN_NAME, MemoryMXBean.class );

Tracking usage // memory usage memoryPool.setUsageThreshold(MEM ORY_LIMIT); MEMORY_LIMIT is the value in bytes

Control logging level // get the logger LoggingMXBean loggerMbean = ManagementFactory.newPlatformMXBeanProxy(mBea nServerConnection, LogManager.LOGGING_MXBEAN_NAME, LoggingMXBean.class); // change the log level if(! loggerMbean.getLoggerLevel(loggerName). equals(Level.INFO.getName())) loggerMbean.setLoggerLevel(loggerName, Level.INFO.getName());

Creating new MBeans Create an MBean Register the MBean

Create MBean

Registering MBean //Get MBeanServer MBeanServer platformMBeanserver= ManagementFactory.getPlatformMBeanServ er(); //Register the ObjectPool MBean ObjectName poolName = new ObjectName(“com.hp.util.pools:id=Objec tPool”); platformMBeanserver.registerMBean (new ObjectPool(),poolName);

Recommendations Expose Relevant Data Expose Coarse grained Data Use consistent naming Use standard Java Logging

Agenda Introduction to Manageability Introduction to JMX Using JMX Design Patterns Application Architecture Managebaility Enablement Tools

Design Patterns MBeanForAppConfigGeneral MBeanWritesToLog MBeanLivesForeverCreational MBeanHelper ManageabilityFacadeStructural MBeanAggregator

One or more MBeans designed to contain the runtime configuration parameters for your application Constructed at initialization by reading from a properties file or other persistent data Allows those configuration parameters to be changed if necessary (e.g. the amount of logging) Mbean browsers can view its content MBeanForAppConfig Pattern

MBeanWritesToLog Pattern MBeans are good places for counting quantities that are rapidly changing Requirement sometimes is to draw a time series of such data (e.g. # of users logged in, # of conncurent connections) Sending that data to a log file is a good approach The data can be processed in the log file offline from the MBean

Should a business object implement the MBean interface? -or- Should the business object talk to a separate MBean object? Using the JMX model – decisions for developers application object MBean Need a reference

Developer registers the new MBean with the MBean server –means every instance needs to register if we use the inheritance method –Many entries to lookup and store –However, the inheritance method may be simpler than holding a reference to an MBean The management interface should be separate from the business objects interfaces (people skills/development process) Much like MVC Using an interface or separate object?

Pull Model –MBean polls the application components and obtains relevant state –The MBean must obtain a reference to the object application object MBean

Push Model –Application updates MBean on relevant state –The application must be able to locate the MBean in order to invoke it when necessary application object MBean

Which object creates the other object? (The answer depends on the lifetime we need to give the MBean – should it be alive past the lifetime of the application object?) MBean could create the application object Application object could create the MBean Application runtime server could create the MBean MBean could be in a separate process to the application object JMX MBean Creational Pattern

MBeanLivesForEver

MBeanLivesForEver Pattern Application servers/containers can create one or more MBeans for you (in a startup class) Important if the MBean needs to see the instantiation of other objects – like business objects These business objects are created here separately from the MBeans MBean is alive for the lifetime of the process

MBeanAsCreator

The MBean is the instantiation point for business objects – MBean controls their lifespan MBean is alive for the lifetime of the process Easy capturing of business objects coming and going MBeanAsCreator Pattern

Motivation for an MBeanHelper Pattern An MBean Helper will take care of the mechanics of registration and lookup of the MBean (which are standard for every MBean) Details of strings for the MBean name and methods to be invoked are hidden from the business object

MBeanHelper

Business object does not talk to the MBean directly Instead they use a Proxy – the MBeanHelper, through which all communication flows to the MBean MBeanHelper takes care of the mechanics of registration and lookup of the MBean Details of strings for MBean name and any invoked method are hidden from the business object Better strong typing on method signature in MBeanHelper MBeanHelper Pattern

MBeanHelper Use the dynamic proxy in Java, java.lang.reflect.Proxy Benefits No more Strings in object and method names No need for one-to-one relationship between Helper and MBean MBeanRegistrator takes care of registering the bean with the MBeanServer MBeanProxy creates a proxy with the same interface as the MBean, ready for invocations Naming of MBean based on name of MBean interface

MBeanHelper Example Registering MBean at startup of App Server public class MyAppListener extends ApplicationLifecycleListener { public void postStart(ApplicationLifecycleEvent appEvent) { MBeanRegistrator.registerMBean(new MyManagerMBean()); }

ManageabilityFacade

ManageabilityFacade Pattern Façade is a collection of all the MBeans in one centralized place, perhaps with just one method ManageabilityFacade.update(orig in, msgtype, data) Individual MBean names and methods are not important to the business objects that use the ManageabilityFacade The ManageabilityFacade decides which MBean gets updated Separation of business object concerns from manageability concerns

ManageabilityFacade Pattern Use AbstractFactory to create MBean Makes it possible to extend configuration of MBeans Use MBeanLivesForever Pattern when creating the MBean

MBeanAggregator Pattern

There can be hundreds or even thousands of MBeans to deal with Management tools should not be polling large number of these MBeans or MBeanHelpers to get the important data they need. Collection points are needed in an Aggregator object – which may be an MBean itself. Fewer numbers of these will help performance and scalability They could cross application server boundaries

Make your MBean as coarsely grained (large) as possible But Do not mix completely different manageability issues into one MBean There should be very few MBeans needed for your application, ideally Recommendations

Design Patterns MBeanForAppConfig MBeanWritesToLog MBeanLivesForever MBeanHelper ManageabilityFacade MBeanAggregator Others you can see as useful?

Agenda Introduction to Manageability Introduction to JMX Using JMX Design Patterns Guideline for manageability Managebaility Enablement Tools

A Policy is that set of rules/measures which express the action to be taken on the occurrence of a management event Manageability policies can change over time These policies should therefore be removed from the business application code (and from the MBean code) Policies belong in a policy engine with a scripting language Guiding Principle for Application Manageability

MBeans Free of Management Policy

Summary JMX provides the infrastructure to instrument applications to enable –Monitoring –Tracking –Control Design Patterns are available to help with design decisions

Call to Action Visit Developer Resources Web Site Search for “JMX” Meet the experts at the HP booth See the demos

Questions?

Thank You Course # 3250 Best Practices and Design Patterns for JMX Development Please fill out the speaker evaluation You can contact us further at …