Documentation‎ > ‎User Guide‎ > ‎Custom Monitoring‎ > ‎

Java Providers

The following are the options available when defining a Java provider:
  • Classpath: Java classpath required by implementation class.
  • Class loader id: The id of the class loader to use; Use the same id for multiple provider instances using the same code to allow sharing of resources. The value is usually a string equal to the cutsom agent id to guarantee a unique name in the scope of this monitoring session
  • Implementation class: The name of the java class with the implementation for this provider.
  • Implementation class parameters: Parameters list to be passed to the impplementation class. Each parameter must be between double quotes (e.g. "param1" "param2").
A Java provider is a class that implements the following interface:

 * Interface that must be implemented by classes that are used with
 * the java provider.
public interface {
* @param parameters parameters required by this instance; they are in the same order
* as they were defined in the provider configuration.
* @param context the execution context (@see
void initialize(String[] parameters, context) throws Exception;
* @return the table with values; check the documentation for providers and their associated
* parsers for how the data should be organized in the table
String[][] getValues() throws Exception;
* Cleanup method. This method will be invoked when the provider is disposed of.
* @throws Exception
void cleanup() throws Exception;
where the interface is the execution context for the provider and has the following definition:

 * Context for classes used for Java providers.
public interface {
* The error message will be reported to the console. Use this method
* only for non-fatal errors, otherwise propagate all exceptions.
* @param error
* @param t
void error(String error, Throwable t);
You can define a Java provider by following these steps:
  • Install a custom agent: "Navigate to Tools" > "Agent Installer" > "Install" > "Custom Agent Installation" > "Agent Template Java" which will install an agent which has the following configuration data available, which is a list of 10 generic parameters:
    • Parameter1
    • Parameter2
    • ...
    • Parameter10
  • Add a Java provider to your agent created above. Navigate to Tools - Provider Managers. In this dialog select your agent and press 'Add'. A dialog will open where you define your provider. Select the provider with the name 'Java', disable the 'Optional' checkbox. Now you have to fill in the following fields:
    • Classpath: the classpath to the jar file with you provider implementation class e.g. C:/Java/myprovider.jar or {home}/lib/myprovider.jar if you want to copy the provider into IxoraRMS_install_folder/lib folder
    • Classloader id: MyCustomAgent
    • Implementation class name: the name of the class implementing the Java provider
  • Defining the parser for the java provider
  • In order to compile your class you need to add the following jar files from IxoraRMS/jars folder to your build path:
    • RMSCommon.jar
    • Provider_java.jar
    • IxoraCommon.jar
The following is an example of a Java provider that uses SQL to retrieve performance data.
package com.ixora.tutorials.providers;

import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.LinkedList;
import java.util.List;

import com.ixora.rms.providers.utils.sql.CachedConnection;
import com.ixora.rms.providers.utils.sql.ConnectionCache;

 * The implementation of a Java providers that reads data from a MySQL database.
public class MyJavaProvider implements JavaProviderImplementation {
* Execution context; use it to report non-fatal errors to the
* IxoraRMS console.
private JavaProviderImplementationContext fContext;
/** The JDBC driver. It is required by the connection cache. */
private Driver fDriver;
/** The JDBC connection string. */
private String fConnectionString;
/** The JDBC username */
private String fUsername;
/** The JDBC password */
private String fPassword;
/** The operation type */
private String fOperation;

* Use a connection cache which will be shared by all providers
* using this implementation class.
* If you are concern with the number of connections open to the database
* you should use a shared class loader to benefit from connection sharing.
private static ConnectionCache fConnectionCache;

static {
try {
fConnectionCache = new ConnectionCache();
}catch(Exception e) {

* @see[],
* @param parameters will be the following:
* jdbc connection string
* jdbc driver class name
* username - the jdbc username
* password - the jdbc password
* operation - depending on this value, different values are returned, allowing the same
* implementation class to be used by different java providers; this allows for possible sharing of
* database connections to reduce the cost of monitoring
public void initialize(String[] parameters, JavaProviderImplementationContext context) throws Exception {
if(parameters == null || parameters.length != 5) {
throw new Exception("Invalid parameters");
fConnectionString = parameters[0];
String driverClassName = parameters[1];
fUsername = parameters[2];
fPassword = parameters[3];
//fContext = context;

PrintWriter w = new PrintWriter(new OutputStreamWriter(System.out));

fDriver = DriverManager.getDriver(fConnectionString);

// Test if the connection is possible
Connection conn = DriverManager.getConnection(fConnectionString, fUsername, fPassword);

* @see
public String[][] getValues() throws Exception {
CachedConnection connection = null;
Statement statement = null;
ResultSet resultSet = null;
try {
connection = fConnectionCache.getConnection(
fDriver, fConnectionString, fUsername, fPassword);
statement = connection.getSQLConnection().createStatement();
resultSet = statement.executeQuery(getSQL());
int columnCount = resultSet.getMetaData().getColumnCount();
List<String[]> rows = new LinkedList<String[]>();
while( {
String[] row = new String[columnCount];
for(int i = 1; i <= columnCount; i++) {
Object obj = resultSet.getObject(i);
row[i-1] = obj.toString();
return rows.toArray(new String[rows.size()][columnCount]);
} finally {
if(resultSet != null) {
if(statement != null) {
if(connection != null) {

* Based on the configured operation it returns the corresponding SQL.
* Of course of it was that simple you would have used an SQL provider; probably
* depending on the operation specified during initialization a more complex
* type of processing would take place; in this example we assume that different
* operations means just using different SQLs.
* @throws Exception
* @return
private String getSQL() throws Exception {
if("default".equals(fOperation)) {
return "select counter1,counter2,counter3,counter4 from mytable";
throw new Exception("Unknown operation: " + fOperation);

* @see
public void cleanup() throws Exception {
;// not necessary, the connections in the ConnectionCache will time out if idle