Course

1
Course 3250Best 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 HPs 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
Application Development
IT/Operations
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
exercise administrative and supervisory actions
Monitoring
Tracking
Control
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
14
JMX Architecture
15
JMX Architecture

• 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
Get the ThreadMXBean

• directly using ManagementFactory
• ThreadMXBean threadMXBean
• ManagementFactory.getThreadMXBean()

24
Connecting to the MBeanSever

• using Proxy
• mBeanServerConnection
  JMXConnectorFactory.connect(new
  JMXServiceURL(jmxServiceURL),null)
  .getMBeanServerConnection()
• String jmxServiceURL
• servicejmxrmi///jndi/rmi//localhostltportgt/ltn
  amegt

25
Get the MemoryMXBean

• MemoryMXBean memoryMXBean
• ManagementFactory. newPlatformMXBeanProxy
• (
• mBeanServerConnection,
• ManagementFactory.MEMORY_MXBEAN_NAME,
• MemoryMXBean.class
• )

26
Tracking usage

• // memory usage
• memoryPool.setUsageThreshold(MEMORY_LIMIT)
• MEMORY_LIMIT is the value in bytes

27
Control logging level

• // get the logger
• LoggingMXBean loggerMbean
• ManagementFactory.newPlatformMXBeanProxy(mBeanServ
  erConnection,
• 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.getPlatformMBeanServer()
• //Register the ObjectPool MBean
• ObjectName poolName
• new ObjectName(com.hp.util.poolsidObjectPool)
  
• 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

• MBeanForAppConfig General
• MBeanWritesToLog
• MBeanLivesForever Creational
• MBeanHelper
• ManageabilityFacade Structural
• MBeanAggregator

34
MBeanForAppConfig Pattern

• 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

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
Using the JMX model decisions for developers

• Should a business object implement the MBean
  interface?
• -or-
• Should the business object talk to a separate
  MBean object?

application object
MBean
Need a reference
37
Using an interface or separate object?

• 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

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
JMX MBean Creational Pattern

• 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

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
MBeanAsCreator Pattern

• 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

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
MBeanHelper Pattern

• 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

48
MBeanHelper

• Use the dynamic proxy in Java, java.lang.reflect.P
  roxy
• 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(origin, 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
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

55
Recommendations

• 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

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
Guiding Principle for Application Manageability

• 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

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//devreso
  urce.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_at_hp.c
  om, justin.murray_at_hp.com