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

2. 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

3. 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

4. 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

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

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

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

8. 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

9. 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.

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

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

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

13. JMX Architecture

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

16. 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

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

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

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

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

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

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

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

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

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

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

27. 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());

28. Creating new MBeans Create an MBean Register the MBean

29. Create MBean

30. 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);

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

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

33. Design Patterns MBeanForAppConfigGeneral MBeanWritesToLog MBeanLivesForeverCreational MBeanHelper ManageabilityFacadeStructural MBeanAggregator

34. 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

35. 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

36. 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

37. 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?

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

39. 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

40. 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

41. MBeanLivesForEver

42. 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

43. MBeanAsCreator

44. 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

45. 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

46. MBeanHelper

47. 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

48. 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

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

50. ManageabilityFacade

51. 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

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

53. MBeanAggregator Pattern

54. 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

55. 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

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

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

58. 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

59. MBeans Free of Management Policy

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

61. Call to Action Visit Developer Resources Web Site http://devresource.hp.com http://devresource.hp.com Search for “JMX” Meet the experts at the HP booth See the demos

62. Questions?

63. Thank You Course # 3250 Best Practices and Design Patterns for JMX Development Please fill out the speaker evaluation You can contact us further at … satadip.dutta@hp.com, justin.murray@hp.com satadip.dutta@hp.comjustin.murray@hp.com