Projects tagged ‘jmx’ and ‘management’

JASMINe is an advanced configuration and management tool for Java EE cluster (JOnAS). It provides the following features - cluster configuration and deploy ment through a Eclipse RCP console - ... [More] cluster monitoring and error detection mechanisms - an soon, some automatic scaling and healing capabilities JASMINe is an OW2 project. [Less]

MAEXO - Management Extensions for OSGiThe MAEXO project enables JMX based management of OSGi containers and applications. It offers an easy to use programming model for dealing with JMX resources ... [More] within an OSGi application. As a showcase, the framework is used to export core OSGi services and resources to JMX. The project aims at portability, minimal dependencies and user-friendliness. The project consists of: The Switch Board bundle: The MAEXO core component to link MBeans, MBean Notifications, MBean-Servers and MBean-Server-Connections with the OSGi environment The OSGi-Core MBeans bundle: Exporter of bundles available in the the OSGi container and services from the OSGi Core specification as MBeans (FrameworkMBean, BundleMBean, ServiceMBean, PackageAdminMBean and StartLevelMBean) The MX4J HTTP adaptor bundle: The MX4J HTTP adaptor to be used within the OSGi container Various samples which demonstrate how to enable management of OSGi based applications using MAEXO and the integration with other technologies (Declarative Services, Spring Dynamic Modules). System RequirementsJava Runtime Environment 5 or higher OSGi R 4 Service Platform (Equinox and Felix are included in the distribution) Getting StartedFor getting a first impression on MAEXO watch the screen cast. Download the latest release and unpack it into a directory. Navigate to the sub-directory "samples/basic/". Take a look at the file readme.txt for explanations on the setup of the sample. Run one of the provided shell scripts for Equinox or Felix (Win/Unix). Open your management console and inspect the MBeans registered under the the domain "com.buschmais.maexo": Open your browser and open the URL http://localhost:8081. Run JConsole or VisualVM and connect to the running OSGi Container. Feedback, Questions and IssuesIf you want to provide feedback on the project or you have questions please use the MAEXO discussion group. You may also raise an issue if you are missing a feature or you are facing problems. [Less]

JmxClient is a Plug-In for Nagios which allows interaction with JMX enabled applications for monitoring and management of those systems. It is highly configurable, which a simple set of default commands for standard application servers.

ezManage is a JMX engine built on top of the Java JMX API that provides simple hooks to create powerful Model and Dynamic MBeans in Java with options for caching, persistence, and logging. It uses ... [More] Java5 Annotations to make creating MBeans a simple task and eliminates the countless hours of defining MBean Metadata through XML configuration. [Less]

The Python Management Extensions (PyMX) is a Python analog to Java's JMX. PyMX aims to be an API for the management and monitoring of resources such as applications, devices, services, as well as the Python interpreter.

a JRuby library to manage remote Java applications using JMX The project has moved to http://github.com/jmesnil/jmx4r/

JmxLoggerJmxLogger makes it easy to broadcast your Java Util Logging or your Log4J log events as JMX notifications. The JmxLogger API provides a Java Util Logging Handler and a Log4J Appender which ... [More] provides integration points between your favorite logging framework and JMX. JmxLogger hides the complexity of dealing with JMX. You simply configure your logging framework as you normally do, and that's it. You are ready to broadcast your logging events as JMX notification events. FeaturesSupport for Java Util Logging API Support for the Log4J logging API Easy integration with your favorite logging framework No coding required, simply configure your logging framework to get started. Specify and control the level of event to broadcast Monitor event through a console or listener scripts Getting StartedDownload the jar (generic or with log4j support) Add jar to your classpath Configure your favorite logging framework and you set Java Logging HandlerIf you are a user of the Java util Logging API, you should already be familiar on how to configure (declaratively or programmatically) the framwork for logging. Below is a sample of what your configuration file would look like when configuring JmxLogger's Handler class. The handler is configured like any other Java Logging handler. Notice that the handler supports several attributes which can be specified in the logging properties file. Missing attributes are automatically assigned a default value. So, you can have a blank configuration if you wanted to (as long as the Handler is declared). handlers=jmxlogger.integration.logutil.JmxLogHandler, java.util.logging.ConsoleHandler # Default global logging level. .level=INFO # jmx log handler jmxlogger.Handler.level=INFO jmxlogger.Handler.filter= jmxlogger.Handler.logPattern= jmxlogger.Handler.formatter=java.util.logging.SimpleFormatter jmxlogger.Handler.objectName=jmxlogger.util.logging:type=JmxLogHandler jmxlogger.Handler.server=platform # Console log handler java.util.logging.ConsoleHandler.level = INFO java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter Java Logging ExampleOnce you have your handler configured, you simply use the logging API as you normally do. Usage of JmxLogger will be transparent to the developer. You simply send your log event to your logging framework. The framework then delegates propagation of your log event as JMX notifications using the JmxLogger API. import java.util.logging.Level; import java.util.logging.LogManager; import java.util.logging.Logger; public class SomeClassA { private static final Logger logger = Logger.getLogger(SomeClassA.class.getName()); public static void main(String[] args) { logger.log(Level.INFO, "I am happy!"); logger.log(Level.WARNING, "I am concerned..."); logger.log(Level.SEVERE, "I am in trouble, something went wrong."); logger.log(Level.FINE, "I am up, I am down, I am all around!"); } }For detail on how to use Java Util Logging API, see Java Logging Overview. Log4J AppenderSimilarly to Java Logging, JmxLogger supports the Log4J framework for logging. If you are a user of the Log4J framework, you should already be familiar with the configuration steps for the Log4J logger. Below is a sample log4j.xml configuration file. It shows how the JmxLogger Appender is configured for logging. The appender supports several attributes which can be left blank. The class defaults to sensible defaults if an attribute is missing. Log4J ExampleOnce you have JmxLogger configured (for Java Logging or Log4J), you are ready to use it. Usage of JmxLogger will be transparent to the developer. You simply send your log event to your logging framework. The framework then delegates propagation of your log event as JMX notifications using the JmxLogger API. import org.apache.log4j.Level; import org.apache.log4j.Logger; public class SomeClassB { private static Logger logger = Logger.getLogger(SomeClassB.class); public static void main (String[] args) { logger.log(Level.INFO, "I am happy!"); logger.log(Level.WARN, "I am concerned..."); logger.log(Level.ERROR, "I am in trouble, something went wrong."); logger.log(Level.DEBUG, "I am up, I am down, I am all around!"); } }JmxLogger LogsWhen you log your event using either Java Logging or Log4J (as show above in the example sections), your log events will get routed to the Handler or Appender defined in your configuration files. In both examples, we have a console and JmxLogger defined. Therefore, all logged events will be show up in the standard console. Logged events will also be emitted as JMX notifications. Using JConsole, you can see these events as they are logged in your application. That's it! You have seen how JmxLogger can effortlessly integrate JMX and the two standard logging API's available (Java Logging and Log4J). [Less]

Stajistics is a free monitoring and runtime performance statistics collection API for Java. Feature Goals: * To provide an extensible, flexible framework for statistics collection * To allow real ... [More] time monitoring of runtime statistics * To allow interactive control over runtime statistics collection * To support a variety of statistics data persistence strategies * To support integration with popular and industry standard APIs and frameworks such as servlets and Inversion of Control containers Features: * Extensible statistics collection API * In-memory statistics database * Event and alarming API * Configurable data retention policy (Planned) * Data persistence service (Planned) * JMX integration * XML based configuration (Planned) * Annotation based configuration (Planned) [Less]

Instrumentation is an important and useful feature for virtually any J2EE project. JMX is a Java standard that allows you monitor the state of and manage a J2EE application. The only problem is that ... [More] getting non-trivial data structures out is tedious. Jamax is an implementation for Open MBeans to allow you to get virtually any arbitrary Java object marshaled to an Open MBean so it can be displayed and manipulated in JConsole, jManage, the JBoss JMX console and any other JMX compliant inspector. [Less]

JmxBuilder Moves to Groovy Release 1.6JmxBuilder has been officially added to Groovy! As of version 1.6 RC1, JmxBuilder has been migrated as part of Groovy Core. While the documentation will remain ... [More] here, all future code release and improvement will be part of Groovy. Download Groovy 1.6 here - http://groovy.codehaus.org/Download You can still download the original JmxBuilder 0.5 beta here. JmxBuilderJmxBuilder is a Groovy-based domain specific language for the Java Management Extension (JMX) API. It uses the builder pattern to create an internal DSL that facilitates the exposure of regular Java and Groovy beans for runtime control and management via the MBean server.The Groovy JMX Builder DSL hides the complexity of creating and exporting management beans via the JMX API and provides a set of natural constructs to interact with the JMX infrastructure. FeaturesDomain Specific Language (DSL) for JMX API using Builder pattern Simplified JMX API's programmability Maintain the natural Groovy syntax Declaratively expose Java/Groovy objects as JMX managed MBeans Support class-embedded or explicit descriptors Inherent support for JMX's event model Seamlessly create JMX event broadcasters Attach event listeners as inline closures Use Groovy's dynamic nature to easily react to JMX events notifications Provides a flexible registration policy for MBean No special interfaces or class path restrictions Shields developer from complexity of JMX API Exposes attribute, constructors, operations, parameters, and notifications Simplifies the creation of connector servers and connector clients Support for exporting JMX timers Getting StartedIt's easy to start using the JmxBuilder DSL (as long as the jar is on your class path). Initialize the builder def jmxBldr = new JmxBuilder()You can optionally provide an MBeanServerConnection that the builder will use during its operations new JmxBuilder(server)Exporting an MBeanLet's say you have Java class called RequestController with the following methods public class RequestController { // constructors public RequestCopntroller() public RequestController(Map resource) // attributes public boolean isStarted() { ... } public int getRequestCount(){ ... } public int getResourceCount() { ... } public void setRequestLimit(int limit){ ... } public int getRequestLimit() { ... } // operations public void start(){ ... } public void stop(){ ... } public void putResource(String name, Object resource){ ... } public void makeRequest(String res) { ... } }You can export an instance of that class for management to an MBeanServer using def ctrl = new RequestController() jmx.export { bean(ctrl) } The code above will export an MBean into the MBeanServer for the specified object instance for management. JmxBuilder will do the following Generate a default JMX ObjectName Export all JMX attributes (in read-only) Export all operations JConsole view of Exported Bean You can see that JmxBuilder exports all attributes, operations, and constructor information automatically using this shorthand notation. You can customize your targeted attributes and operations description that you want to export (see below). Export DescriptorsYou can control, customize, and describe the information that is exported to the MBeanServer. JmxBuilder lets you describe your export information by declaring your descriptors inline or embedding the descriptors inside the object itself Overriding the ObjectNameOne of the thing you can do is to override the object name to customize your export. This is done as followed: jmxBldr.export { bean(target:ctrl, name:"jmx.builder:type=Object") } This willl export the MBean using the object name provided. You can use the string representation or an instance of ObjectName here. See JmxBuilderReference for detail. Controlling Attribute ExportYou can control the description and attribute export using JmxBuilder. Export with Attributes with Wildcard "*"You can use a wildcard character to export all attributes associated with the MBean. The snippet below exports all attributes, however, no operations or constructors will be defined nor exported into the MBeanServer. jmxBldr.export{ bean( target: ctrl, name: "jmx.builder:type=Object", attributes: "*" ) }See JmxBuilderReference for more detail on exporting attributes. Export Attributes by ListThe following code snippet provides a list of attributes to export. Only the listed attributes will be exposed for management. jmxBldr.export{ bean( target: ctrl, name: "jmx.builder:type=Object", attributes: ["Started","RequestCount", "ResourceCount"] ) }This snippet will cause JmxBuilder to export only the attributes listed in key "attributes:" and their associated getter operations. JConsole View See JmxBuilderReference for more detail on exporting attributes. Controlling Operation ExportJmxBuilder lets you describe and export information about operations declared on the underlying bean to be exported as MBean. You can implicitly describe and export all operations (using the wildcard) or specify which operation to export. Export with Operations with Wildcard "*"You can use a wildcard character to export all operations declared on the underlying bean to exported. The snippet below exports all operations, however, no attributes or constructors will be defined nor exported into the MBeanServer. jmxBldr.export{ bean( target: ctrl, name: "jmx.builder:type=Object2", operations: "*" ) }JConsole View You can see that JmxBuilder only exported operations on the MBean (including getter/setters). No attributes were described nor exported. See JmxBuilderReference for more detail on exporting attributes. Export Operations by ListYou can target operations to export by specifying a comma-separated list of the methods on the underlying bean to export for management. jmxBldr.export{ bean( target: ctrl, name: "jmx.builder:type=Object3", operations: ["start","stop", "makeRequest"] ) }JConsole View Notice that only the specified operations are described and export into the MBeanServer. See JmxBuilderReference for more detail on exporting operations. Handling EventsUsing JmxBuilder, you can intercept listen and react to events emitted on the MBeanServer's event bus. Conversely, JmxBuilder lets you emit your own event on the bus to be consumed by registered listeners. Attribute Change EventsOne basic event that JmxBuilder allows you to listen for is "attribute changes". You can set easily set your listener when you setup the bean for export. jmxBldr.export{ bean(target:ctrl, name:"jmx.builder:type=Object", attributes: [ "RequestLimit":[reable:true, writable:true, onChange:{e -> if(e.newValue > 10){ println "***** Warning, high limit detected *****" } } ] ] ) }The closure specified by key "onChange:" will be invoked whenever the attribute "RequestLimit" on the MBean is updated via the setter associated with the attribute. JConsole View Closure Executed Attribute "RequestLimit" updated to 22, causes the onChange event closure to be called. See JmxBuilderReference for more detail on event handling. Operation Call EventsSimilary to attribute change events, JmxBuilder supports callback closures for operation invokation. You can easily set up a listener closure that gets executed whenever an MBean operation is invoked. jmxBldr.export{ bean(target:ctrl, name:"jmx.builder:type=Object", operations: [ "makeRequest":[ onCall:{e -> println "***** A request was made *****" } ] ] ) }In the snippet above, the closure specified by key "onCall:" will be executed after each invokation of opeartion makeRequest on the MBean. Closure Executed See JmxBuilderReference for more detail on event handling. What's NextThe JmxBuilder DSL is capable of much more. Please review the JmxBuilderReference section for a list of all of the capabilities of the tool. FeedbackAll feedbacks are welcome. If you find a bug, don't hesitate to report it. [Less]