MonitorFactory (JAMon Core 2.81 API)

java.lang.Object
- com.jamonapi.MonitorFactory

```
public class MonitorFactory
extends Object
```
Static MonitorFactory that is good to use in most cases. In the situation when you want a different factory then instanciated FactoryEnabled directly. Note this is mostly a wrapper for FactoryEnabled and FactoryDisabled. You can also get the underlying factory with a call to getFactory()

Field Summary

Fields
Modifier and Type Field and Description

static String EXCEPTIONS_LABEL

Fields
Modifier and Type	Field and Description
`static String`	`EXCEPTIONS_LABEL`

Constructor Summary

Constructors
Constructor and Description

MonitorFactory()

Constructors
Constructor and Description
`MonitorFactory()`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static Monitor`	`add(MonKey key, double value)` Used when you want to create your own key for the monitor.
`static Monitor`	`add(String label, String units, double value)` Aggregate the passed in value with the monitor associated with the label, and the units.
`static Monitor`	`addException(Monitor mon, Throwable throwable)` Add 2 exception monitors.
`static Monitor`	`addException(Throwable throwable)` Track an exception except there is no other associated monitor to put the details in.
`static void`	`addListeners(List<JamonPropertiesLoader.JamonListenerProperty> listeners)` Add listeners.
`static void`	`disable()` Disable MonitorFactory.
`static void`	`disableTotalKeySizeTracking()` Call this method if you want to disable key size tracking.
`static void`	`enable()` Enable MonitorFactory.
`static void`	`enableActivityTracking(boolean enable)`
`static void`	`enableGlobalActive(boolean enable)`
`static void`	`enableTotalKeySizeTracking()` Call this method if you want to be able to call MonitorFactory.getTotalKeySize() to determine the size of all labels/keys in JAMon.
`static boolean`	`exists(MonKey key)` Return true if the monitor associated with the passed in key exists
`static boolean`	`exists(String label, String units)` Determine if the monitor associated with the label, and the units currently exists.
`static MonitorComposite`	`getComposite(String units)` Return the composite monitor (a collection of monitors) associated with the passed in units.
`static Object[][]`	`getData()` This returns the data for basic data with no range info.
`static MonitorFactoryInterface`	`getDebugFactory()` Returns the factory for creating debug monitors.
`static MonitorFactoryInterface`	`getFactory()` Get the current Factory (could be the enabled or disabled factory depending on what is enabled)
`static String[]`	`getHeader()` Deprecated.
`static Map`	`getMap()`
`static int`	`getMaxNumMonitors()` Get the maximum number of monitors that JAMon can store.
`static int`	`getMaxSqlSize()` Return the size that sql statements can be before truncating them.
`static Monitor`	`getMonitor()`
`static Monitor`	`getMonitor(MonKey key)` Get the monitor associated with the passed in key.
`static Monitor`	`getMonitor(String label, String units)` Return the monitor associated with the label, and units.
`static int`	`getNumRows()` This returns the number of monitors in this factory.
`static String[]`	`getRangeHeader()` Return the header for displaying what ranges are available.
`static Object[][]`	`getRangeNames()` Return the ranges in this factory.
`static String`	`getReport()` This returns an HTML report for basic data with no range info in the header.
`static String`	`getReport(String units)` This returns an HTML report for basic data with no range info in the header for the past in units.
`static MonitorComposite`	`getRootMonitor()` Return the composite monitor of all monitors for this factory
`static Monitor`	`getTimeMonitor(MonKey key)` Get the time monitor associated with the passed in key.
`static Monitor`	`getTimeMonitor(String label)` Return the time monitor associated with the label.
`static long`	`getTotalKeySize()` Returns the total key sizes which is the size of all String lables stored in JAMon.
`static String`	`getVersion()` Return the version of JAMon
`static boolean`	`isActivityTrackingEnabled()`
`static boolean`	`isDebugEnabled()` Is the Debug Monitor Factory currently enabled?
`static boolean`	`isEnabled()` Is the MonitorFactory currently enabled?
`static boolean`	`isGlobalActiveEnabled()`
`static boolean`	`isTotalKeySizeTrackingEnabled()`
`static Iterator`	`iterator()` Deprecated.
`static void`	`remove(MonKey key)` Remove the monitor associated with the passed in key
`static void`	`remove(String label, String units)` Remove/delete the specified monitor
`static void`	`reset()` Reset/remove all monitors.
`static void`	`setDebugEnabled(boolean enable)` Enable or disable the debug factory.
`static void`	`setEnabled(boolean enable)` Enable/Disable MonitorFactory.
`static void`	`setMap(Map map)` Use the specified map to hold the monitors.
`static void`	`setMaxNumMonitors(int maxMonitors)` Set the maximum number of monitors that JAMon can store.
`static void`	`setMaxSqlSize(int size)` Set the maximum size for a sql statement.
`static void`	`setRangeDefault(String key, RangeHolder rangeHolder)` Associate a range with a key/unit.
`static Monitor`	`start()` Return a timing monitor with units in milliseconds, that is not aggregated into the jamon stats.
`static Monitor`	`start(MonKey key)` Start using the passed in key.
`static Monitor`	`start(String label)` Return a timing monitor with units in milliseconds.
`static Monitor`	`startNano(MonKey key)` Provide your own key to a nanosecond timer
`static Monitor`	`startNano(String label)` start nanosecond timer
`static Monitor`	`startPrimary(MonKey key)` Start a monitor with the specified key and mark it as primary
`static Monitor`	`startPrimary(String label)` Return a timing monitor with units in milliseconds, that is not aggregated into the jamon stats.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - EXCEPTIONS_LABEL
```
public static final String EXCEPTIONS_LABEL
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - MonitorFactory
```
public MonitorFactory()
```
- Method Detail
  - getFactory
```
public static MonitorFactoryInterface getFactory()
```
    Get the current Factory (could be the enabled or disabled factory depending on what is enabled)
  - getDebugFactory
```
public static MonitorFactoryInterface getDebugFactory()
```
    Returns the factory for creating debug monitors. The debug factory can be disabled independently from the regular factory. Debug monitors are no different than monitors returned by the regular monitor factory. However the debug factory can be used to monitor items in a test environment and disable them in production.
    Sample Call: MonitorFactory.getDebugFactory().start();
  - add
```
public static Monitor add(String label,
                          String units,
                          double value)
```
    Aggregate the passed in value with the monitor associated with the label, and the units. The aggregation tracks hits, avg, total, min, max and more. Note the monitor returned is threadsafe. However, it is best to get a monitor vi this method and not reuse the handle as TimeMonitors are not thread safe (see the getTimeMonitor method.
    Sample call:
```
 Monitor mon=MonitorFactory.add("bytes.sent","MB", 1024);
 
```
  - add
```
public static Monitor add(MonKey key,
                          double value)
```
    Used when you want to create your own key for the monitor. This works similarly to a group by clause where the key is any columns used after the group by clause.
  - start
```
public static Monitor start(String label)
```
    Return a timing monitor with units in milliseconds. stop() should be called on the returned monitor to indicate the time that the process took. Note time monitors keep the starttime as an instance variable and so every time you want to use a TimeMonitor you should get a new instance.
    Sample call:
```
  Monitor mon=MonitorFactory.start("pageHits");
   ...code being timed...
  mon.stop();
 
```
  - start
```
public static Monitor start()
```
    Return a timing monitor with units in milliseconds, that is not aggregated into the jamon stats. stop() should be called on the returned monitor to indicate the time that the process took. Note time monitors keep the starttime as an instance variable and so every time you want to use a TimeMonitor you should get a new instance.
    Sample call:
```
  Monitor mon=MonitorFactory.start();
    ...code being timed...
  mon.stop();
 
```
  - getMonitor
```
public static Monitor getMonitor()
```
  - startPrimary
```
public static Monitor startPrimary(String label)
```
    Return a timing monitor with units in milliseconds, that is not aggregated into the jamon stats. The concept of primary allows you to correlate performance of all monitors with the most resource intensive things the app does which helps you determine scalability.
    Sample call:
```
  Monitor mon=MonitorFactory.startPrimary("myPrimaryMonitor");
    ...code being timed...
  mon.stop();
 
```
  - startPrimary
```
public static Monitor startPrimary(MonKey key)
```
    Start a monitor with the specified key and mark it as primary
  - start
```
public static Monitor start(MonKey key)
```
    Start using the passed in key. Note activity stats are incremented
  - startNano
```
public static Monitor startNano(String label)
```
    start nanosecond timer
  - startNano
```
public static Monitor startNano(MonKey key)
```
    Provide your own key to a nanosecond timer
  - getMonitor
```
public static Monitor getMonitor(String label,
                                 String units)
```
    Return the monitor associated with the label, and units. All statistics associated with the monitor can then be accessed such as hits, total, avg, min, and max. If the monitor does not exist it will be created.
    Sample call:
```
  Monitor mon=MonitorFactory.getMonitor("myPrimaryMonitor");
 
```
  - getMonitor
```
public static Monitor getMonitor(MonKey key)
```
    Get the monitor associated with the passed in key. It will be created if it doesn't exist
  - getTimeMonitor
```
public static Monitor getTimeMonitor(String label)
```
    Return the time monitor associated with the label. All statistics associated with the monitor can then be accessed such as hits, total, avg, min, and max. If the monitor does not exist it will be created.
    Sample call:
```
  Monitor mon=MonitorFactory.getTimeMonitor("myPrimaryMonitor");
 
```
  - getTimeMonitor
```
public static Monitor getTimeMonitor(MonKey key)
```
    Get the time monitor associated with the passed in key. It will be created if it doesn't exist. The units are in ms.
  - exists
```
public static boolean exists(String label,
                             String units)
```
    Determine if the monitor associated with the label, and the units currently exists.
    Sample call:
```
  Monitor mon=MonitorFactory.getTimeMonitor("myPrimaryMonitor");
 
```
  - exists
```
public static boolean exists(MonKey key)
```
    Return true if the monitor associated with the passed in key exists
  - getComposite
```
public static MonitorComposite getComposite(String units)
```
    Return the composite monitor (a collection of monitors) associated with the passed in units. Note in JAMon 1.0 this method would take a label and would return all monitors that matched that criterion. This ability is now better performed using ArraySQL from the FormattedDataSet API. See JAMonAdmin.jsp for an example.
    Sample call:
```
  Monitor mon=MonitorFactory.getComposite("ms.");
  mon=MonitorFactory.getComposite("allMonitors");
 
```
  - getNumRows
```
public static int getNumRows()
```
    This returns the number of monitors in this factory.
  - getRangeHeader
```
public static String[] getRangeHeader()
```
    Return the header for displaying what ranges are available.
  - getRangeNames
```
public static Object[][] getRangeNames()
```
    Return the ranges in this factory.
  - getRootMonitor
```
public static MonitorComposite getRootMonitor()
```
    Return the composite monitor of all monitors for this factory
  - getVersion
```
public static String getVersion()
```
    Return the version of JAMon
  - remove
```
public static void remove(String label,
                          String units)
```
    Remove/delete the specified monitor
  - remove
```
public static void remove(MonKey key)
```
    Remove the monitor associated with the passed in key
  - setMap
```
public static void setMap(Map map)
```
    Use the specified map to hold the monitors. This map should be threadsafe. This allows for the use of a faster map than the default: synchronzied HashMap()
  - getMap
```
public static Map getMap()
```
  - setRangeDefault
```
public static void setRangeDefault(String key,
                                   RangeHolder rangeHolder)
```
    Associate a range with a key/unit. Any monitor with the given unit will have this range. Any monitor with no range associated with its unit will have no range.
  - setEnabled
```
public static void setEnabled(boolean enable)
```
    Enable/Disable MonitorFactory. When enabled (true) the factory returns monitors that store aggregate stats. When disabled (false) null/noop monitors are returned. enable()/disable() can also be used to perform the same function
  - setDebugEnabled
```
public static void setDebugEnabled(boolean enable)
```
    Enable or disable the debug factory. The debug factory can be enabled/disabled at runtime. Calling this method with a false also disables calls to MonitorFactory.getDebugFactory(int debugPriorityLevel)
    Sample Call:
```
   MonitorFactory.setDebugEnabled(false);
   MonitorFactory.getDebugFactory().start(); // no stats are gathered.
 
```
  - enable
```
public static void enable()
```
    Enable MonitorFactory. When enabled the factory returns monitors that store aggregate stats. This method has the same effect as calling MonitorFactor.setEnabled(true).
  - disable
```
public static void disable()
```
    Disable MonitorFactory. When disabled the factory returns null/noop monitors. This method has the same effect as calling MonitorFactor.setEnabled(true).
  - isEnabled
```
public static boolean isEnabled()
```
    Is the MonitorFactory currently enabled?
  - isDebugEnabled
```
public static boolean isDebugEnabled()
```
    Is the Debug Monitor Factory currently enabled?
  - isGlobalActiveEnabled
```
public static boolean isGlobalActiveEnabled()
```
  - enableGlobalActive
```
public static void enableGlobalActive(boolean enable)
```
  - reset
```
public static void reset()
```
    Reset/remove all monitors. If the factory is disabled this method has no action.
  - getHeader
```
@Deprecated
public static String[] getHeader()
```
    Deprecated.
    
    This returns the header for basic data with no range info in the header. This method is deprecated. use the methods associated with the CompositeMonitor. The various getXXXHeader() methods of CompositeMonitors can return this information and more.
  - getData
```
public static Object[][] getData()
```
    This returns the data for basic data with no range info. The various getXXXData() methods of CompositeMonitors can return this information and more.
  - getReport
```
public static String getReport()
```
    This returns an HTML report for basic data with no range info in the header.
  - getReport
```
public static String getReport(String units)
```
    This returns an HTML report for basic data with no range info in the header for the past in units. This method will be removed in the next release.
  - iterator
```
@Deprecated
public static Iterator iterator()
```
    Deprecated.
    
    Iterator that contains Monitor's that are in this factory
  - enableActivityTracking
```
public static void enableActivityTracking(boolean enable)
```
  - isActivityTrackingEnabled
```
public static boolean isActivityTrackingEnabled()
```
  - setMaxNumMonitors
```
public static void setMaxNumMonitors(int maxMonitors)
```
    Set the maximum number of monitors that JAMon can store. This can be set to reduce the jamon memory footprint. By default JAMon's size is unlimited.
    
    Parameters:
    
    maxMonitors - maximum number of monitors that JAMon can store.
  - getMaxNumMonitors
```
public static int getMaxNumMonitors()
```
    Get the maximum number of monitors that JAMon can store.
  - enableTotalKeySizeTracking
```
public static void enableTotalKeySizeTracking()
```
    Call this method if you want to be able to call MonitorFactory.getTotalKeySize() to determine the size of all labels/keys in JAMon.
  - disableTotalKeySizeTracking
```
public static void disableTotalKeySizeTracking()
```
    Call this method if you want to disable key size tracking.
  - isTotalKeySizeTrackingEnabled
```
public static boolean isTotalKeySizeTrackingEnabled()
```
    Returns:
    
    true if totalKeySizeTracking is enabled.
  - getTotalKeySize
```
public static long getTotalKeySize()
```
    Returns the total key sizes which is the size of all String lables stored in JAMon. This can be helpful to trigger a call to reset if the amount of memory consumed gets too high.
    
    Returns:
    
    Size of all monitor label strings
  - setMaxSqlSize
```
public static void setMaxSqlSize(int size)
```
    Set the maximum size for a sql statement. Sql bigger than this will be truncated before a JAMon label is created via the JAMon JDBC proxy driver. This is useful to limit the size in memory that jamon occupies due to really long sql statements. For backwards compatibility The default is to not limit the statement size.
    
    Parameters:
    
    size -
  - getMaxSqlSize
```
public static int getMaxSqlSize()
```
    Return the size that sql statements can be before truncating them. This will limit the size of JAMon labels for sql statements
    
    Returns:
    
    returns the max size that sql statements are allowed to be
  - addException
```
public static Monitor addException(Monitor mon,
                                   Throwable throwable)
```
    Add 2 exception monitors. One for the specific exception and the other a catchall monitor for all exceptions. It will also put the stacktrace in the details for both of these monitors as well as for the monitor being passed in which would typically be the code associated with throwing the exception. Passing in a null for mon is acceptable.
    
    Parameters:
    
    mon - optional monitor where we want to store the stack trace.
    
    throwable - exception that we want to create a monitor for
    
    Returns:
    
    Returns only the monitor associated with the specific exception even though 2 monitors are created.
  - addException
```
public static Monitor addException(Throwable throwable)
```
    Track an exception except there is no other associated monitor to put the details in. Equivalent to addException(null, throwable);
    
    Parameters:
    
    throwable - exception to create a monitor for.
    
    Returns:
    
    Returns only the monitor associated with the specific exception even though 2 monitors are created.
  - addListeners
```
public static void addListeners(List<JamonPropertiesLoader.JamonListenerProperty> listeners)
```
    Add listeners. These can be read from a properties file (@see JamonPropertiesLoader). It should be done as part of application startup. One use is to ensure that exceptions details are tracked at application startup. The @see JamonServletContextListener automatically reads the values from the properties file if there are any of them.
    
    Since:
    
    2.79

Class MonitorFactory

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

EXCEPTIONS_LABEL

Constructor Detail

MonitorFactory

Method Detail

getFactory

getDebugFactory

add

add

start

start

getMonitor

startPrimary

startPrimary

start

startNano

startNano

getMonitor

getMonitor

getTimeMonitor

getTimeMonitor

exists

exists

getComposite

getNumRows

getRangeHeader

getRangeNames

getRootMonitor

getVersion

remove

remove

setMap

getMap

setRangeDefault

setEnabled

setDebugEnabled

enable

disable

isEnabled

isDebugEnabled

isGlobalActiveEnabled

enableGlobalActive

reset

getHeader

getData

getReport

getReport

iterator

enableActivityTracking

isActivityTrackingEnabled

setMaxNumMonitors

getMaxNumMonitors

enableTotalKeySizeTracking

disableTotalKeySizeTracking

isTotalKeySizeTrackingEnabled

getTotalKeySize

setMaxSqlSize

getMaxSqlSize

addException

addException

addListeners