Transcript Best Practices and Design Patterns for JMX Development

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
Symptoms
Application
Development
IT/Operations
Causes
Where?
error
occurs
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:
exercise administrative and supervisory actions
Monitoring:
Tracking:
Control:
capture runtime and
historical events of a
particular component,
observe aspects of a
single thread across
multiple components.
example: the monitoring
of the performance of a
network router
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
Application MBeans
Instrumentation
Business Logic
JMX Architecture
MBeanServer
Management
Application
Platform MBeans
Instrumentation
Java Virtual Machine
Application MBeans
Instrumentation
Business Logic
JMX Architecture
MBeanServer
Management
Application
Platform MBeans
Instrumentation
Java Virtual Machine
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
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:<port>/<name>
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
ObjectPoolMBean
totalCapacity: Integer
Attributes
used Capacity: Integer
resetPool(String Name)
Operations
com.hp.util.pools.exceeded
Notification
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
• MBeanForAppConfig
• MBeanWritesToLog
• MBeanLivesForever
• MBeanHelper
• ManageabilityFacade
• MBeanAggregator
General
Creational
Structural
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
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
Using the JMX model – decisions for
developers
Should a business object implement
the MBean interface?
-orShould the business object talk to a
separate MBean object?
application
object
MBean
Need a reference
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
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
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
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
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
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
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
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
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
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
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
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
MBeans Free of Management Policy
Monitor
start
Directory
Service
Web Application Server
JMX Collector / Analyzer
MBean Server
get config
Metric
Definition
File
(XML)
JNDI
collect metric
calculate
RMI
MBean
MBean
send to tool
Java Virtual Machine
Java Virtual Machine
Target tool
Target tool
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
http://devresource.hp.com
• 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 …
[email protected], [email protected]