FactoryDisabled (JAMon Core 2.81 API)

java.lang.Object
- com.jamonapi.FactoryDisabled

All Implemented Interfaces:

MonitorFactoryInterface, Serializable
```
public final class FactoryDisabled
extends Object
implements MonitorFactoryInterface
```
Factory that returns null monitors when JAMon is disabled. Method are noops. Any methods that return Monitors return NullMonitors (noop monitors).

See Also:

Serialized Form

Field Summary
- Fields inherited from interface com.jamonapi.MonitorFactoryInterface
  VERSION

Constructor Summary

Constructors
Constructor and Description

FactoryDisabled(MonitorFactoryInterface factoryEnabled)
Creates a new instance of FactoryDisabled

Constructors
Constructor and Description
`FactoryDisabled(MonitorFactoryInterface factoryEnabled)` Creates a new instance of FactoryDisabled

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Monitor`	`add(MonKey key, double value)` Used when you want to create your own key for the monitor.
`Monitor`	`add(String label, String units, double value)` Return a monitor with the given label and units.
`Monitor`	`addException(Monitor mon, Throwable throwable)` Add 2 exception monitors.
`Monitor`	`addException(Throwable throwable)` Track an exception except there is no other associated monitor to put the details in.
`void`	`addListeners(List<JamonPropertiesLoader.JamonListenerProperty> listeners)` Add listeners.
`FactoryDisabled`	`copy()`
`void`	`disableTotalKeySizeTracking()`
`void`	`enableActivityTracking(boolean enable)` This determines if activity tracking in ranges is enabled.
`void`	`enableGlobalActive(boolean enable)`
`void`	`enableTotalKeySizeTracking()` This will keep track of the total size of of the keys used to store the monitors which can be useful in keeping track of memory used by JAMon.
`boolean`	`exists(MonKey key)` Return true if the monitor associated with the passed in key exists
`boolean`	`exists(String label, String units)` Return true if the monitor associated with the passed in label and units exists
`MonitorComposite`	`getComposite(String units)` Return the composite monitor associated with the passed unit.
`Map`	`getMap()` Get the backing map that holds the the Monitors.
`int`	`getMaxNumMonitors()` Return the max number of configured of monitors.
`int`	`getMaxSqlSize()` Return the size that sql statements can be before truncating them.
`Monitor`	`getMonitor()` Returns a non-TimeMonitor that won't update the jamon factory.
`Monitor`	`getMonitor(MonKey key)` Get the monitor associated with the passed in key.
`Monitor`	`getMonitor(String label, String units)` Get the monitor with the passed in label, and units.
`int`	`getNumRows()` Get the number of monitors in this factory
`String[]`	`getRangeHeader()` Return the header associated with range names
`Object[][]`	`getRangeNames()` Return an array of range names.
`MonitorComposite`	`getRootMonitor()` Get the root composite monitor that contains all monitors in this factory
`Monitor`	`getTimeMonitor(MonKey key)` Get the time monitor associated with the passed in key.
`Monitor`	`getTimeMonitor(String label)` Get the time monitor associated with the passed in label.
`long`	`getTotalKeySize()`
`String`	`getVersion()` Get JAMon's version.
`boolean`	`isActivityTrackingEnabled()`
`boolean`	`isGlobalActiveEnabled()`
`boolean`	`isTotalKeySizeTrackingEnabled()`
`Iterator`	`iterator()`
`void`	`remove(MonKey key)` Remove the monitor associated with the passed in key
`void`	`remove(String label, String units)` Remove the monitor associated with the passed in label and units
`void`	`reset()` Reset jamon stats for this factory.
`void`	`setMap(Map map)` Set the map that holds the monitors.
`void`	`setMaxNumMonitors(int maxMonitors)` Set the max number of monitors that can be tracked.
`void`	`setMaxSqlSize(int size)` Set the maximum size for a sql statement.
`void`	`setRangeDefault(String key, RangeHolder rangeHolder)` Associate a Range mapping to any monitor that has a unit/key name that matches what is passed to key
`Monitor`	`start()` Returns a TimeMonitor that won't update the jamon factory.
`Monitor`	`start(MonKey key)` Start using the passed in key.
`Monitor`	`start(String label)` Return a time monitor (the units are implied and are ms.
`Monitor`	`startNano(MonKey key)` Provide your own key to a nanosecond timer
`Monitor`	`startNano(String label)` Create a timing monitor that uses nanosecond granularity (1,000,000 ns.=1 ms.)
`Monitor`	`startPrimary(MonKey key)` Start a monitor with the specified key and mark it as primary
`Monitor`	`startPrimary(String label)` Start a time monitor and mark it as primary

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

- Constructor Detail
  - FactoryDisabled
```
public FactoryDisabled(MonitorFactoryInterface factoryEnabled)
```
    Creates a new instance of FactoryDisabled
- Method Detail
  - add
```
public Monitor add(MonKey key,
                   double value)
```
    Description copied from interface: MonitorFactoryInterface
    
    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.
    
    Specified by:
    
    add in interface MonitorFactoryInterface
  - add
```
public Monitor add(String label,
                   String units,
                   double value)
```
    Description copied from interface: MonitorFactoryInterface
    
    Return a monitor with the given label and units. Note label has an effect on what range is used. If no range is associated with units then it will use the null range (i.e. no range)
    Sample Call: factory.add("com.fdsapi.MyException", "error", 1);
    
    Specified by:
    
    add in interface MonitorFactoryInterface
  - start
```
public Monitor start()
```
    Description copied from interface: MonitorFactoryInterface
    
    Returns a TimeMonitor that won't update the jamon factory.
    
    Specified by:
    
    start in interface MonitorFactoryInterface
  - start
```
public Monitor start(MonKey key)
```
    Description copied from interface: MonitorFactoryInterface
    
    Start using the passed in key. Note activity stats are incremented
    
    Specified by:
    
    start in interface MonitorFactoryInterface
  - start
```
public Monitor start(String label)
```
    Description copied from interface: MonitorFactoryInterface
    
    Return a time monitor (the units are implied and are ms. Note activity stats are incremented
    
    Specified by:
    
    start in interface MonitorFactoryInterface
  - startNano
```
public Monitor startNano(String label)
```
    Description copied from interface: MonitorFactoryInterface
    
    Create a timing monitor that uses nanosecond granularity (1,000,000 ns.=1 ms.)
    
    Specified by:
    
    startNano in interface MonitorFactoryInterface
  - startNano
```
public Monitor startNano(MonKey key)
```
    Description copied from interface: MonitorFactoryInterface
    
    Provide your own key to a nanosecond timer
    
    Specified by:
    
    startNano in interface MonitorFactoryInterface
  - startPrimary
```
public Monitor startPrimary(MonKey key)
```
    Description copied from interface: MonitorFactoryInterface
    
    Start a monitor with the specified key and mark it as primary
    
    Specified by:
    
    startPrimary in interface MonitorFactoryInterface
  - startPrimary
```
public Monitor startPrimary(String label)
```
    Description copied from interface: MonitorFactoryInterface
    
    Start a time monitor and mark it as primary
    
    Specified by:
    
    startPrimary in interface MonitorFactoryInterface
  - getMonitor
```
public Monitor getMonitor(MonKey key)
```
    Description copied from interface: MonitorFactoryInterface
    
    Get the monitor associated with the passed in key. It will be created if it doesn't exist
    
    Specified by:
    
    getMonitor in interface MonitorFactoryInterface
  - getMonitor
```
public Monitor getMonitor(String label,
                          String units)
```
    Description copied from interface: MonitorFactoryInterface
    
    Get the monitor with the passed in label, and units. It will be created if it doesn't exist
    
    Specified by:
    
    getMonitor in interface MonitorFactoryInterface
  - getTimeMonitor
```
public Monitor getTimeMonitor(MonKey key)
```
    Description copied from interface: MonitorFactoryInterface
    
    Get the time monitor associated with the passed in key. It will be created if it doesn't exist. The units are in ms.
    
    Specified by:
    
    getTimeMonitor in interface MonitorFactoryInterface
  - addException
```
public Monitor addException(Monitor mon,
                            Throwable throwable)
```
    Description copied from interface: MonitorFactoryInterface
    
    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.
    
    Specified by:
    
    addException in interface MonitorFactoryInterface
    
    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 Monitor addException(Throwable throwable)
```
    Description copied from interface: MonitorFactoryInterface
    
    Track an exception except there is no other associated monitor to put the details in. Equivalent to addException(null, throwable);
    
    Specified by:
    
    addException in interface MonitorFactoryInterface
    
    Parameters:
    
    throwable - exception to create a monitor for.
    
    Returns:
    
    Returns only the monitor associated with the specific exception even though 2 monitors are created.
  - getTimeMonitor
```
public Monitor getTimeMonitor(String label)
```
    Description copied from interface: MonitorFactoryInterface
    
    Get the time monitor associated with the passed in label. It will be created if it doesn't exist. The units are in ms.
    
    Specified by:
    
    getTimeMonitor in interface MonitorFactoryInterface
  - remove
```
public void remove(MonKey key)
```
    Description copied from interface: MonitorFactoryInterface
    
    Remove the monitor associated with the passed in key
    
    Specified by:
    
    remove in interface MonitorFactoryInterface
  - remove
```
public void remove(String label,
                   String units)
```
    Description copied from interface: MonitorFactoryInterface
    
    Remove the monitor associated with the passed in label and units
    
    Specified by:
    
    remove in interface MonitorFactoryInterface
  - exists
```
public boolean exists(MonKey key)
```
    Description copied from interface: MonitorFactoryInterface
    
    Return true if the monitor associated with the passed in key exists
    
    Specified by:
    
    exists in interface MonitorFactoryInterface
  - exists
```
public boolean exists(String label,
                      String units)
```
    Description copied from interface: MonitorFactoryInterface
    
    Return true if the monitor associated with the passed in label and units exists
    
    Specified by:
    
    exists in interface MonitorFactoryInterface
  - getComposite
```
public MonitorComposite getComposite(String units)
```
    Description copied from interface: MonitorFactoryInterface
    
    Return the composite monitor associated with the passed unit. Note this method changed from jamon 1.0. Previously it took a regular expression that was matched on the label column and now it looks for any monitors that have the given range/unit key
    
    Specified by:
    
    getComposite in interface MonitorFactoryInterface
  - getRootMonitor
```
public MonitorComposite getRootMonitor()
```
    Description copied from interface: MonitorFactoryInterface
    
    Get the root composite monitor that contains all monitors in this factory
    
    Specified by:
    
    getRootMonitor in interface MonitorFactoryInterface
  - getNumRows
```
public int getNumRows()
```
    Description copied from interface: MonitorFactoryInterface
    
    Get the number of monitors in this factory
    
    Specified by:
    
    getNumRows in interface MonitorFactoryInterface
  - getRangeHeader
```
public String[] getRangeHeader()
```
    Description copied from interface: MonitorFactoryInterface
    
    Return the header associated with range names
    
    Specified by:
    
    getRangeHeader in interface MonitorFactoryInterface
  - getRangeNames
```
public Object[][] getRangeNames()
```
    Description copied from interface: MonitorFactoryInterface
    
    Return an array of range names. This is dynamic based on what was passed to setRangeDefault
    
    Specified by:
    
    getRangeNames in interface MonitorFactoryInterface
  - getVersion
```
public String getVersion()
```
    Description copied from interface: MonitorFactoryInterface
    
    Get JAMon's version. Example: 2.0
    
    Specified by:
    
    getVersion in interface MonitorFactoryInterface
  - setMap
```
public void setMap(Map map)
```
    Description copied from interface: MonitorFactoryInterface
    
    Set the map that holds the monitors. This could be used to aid jamon performance by passing in a high performance Thread safe map such as open source projects and jdk 1.5 have
    
    Specified by:
    
    setMap in interface MonitorFactoryInterface
  - setRangeDefault
```
public void setRangeDefault(String key,
                            RangeHolder rangeHolder)
```
    Description copied from interface: MonitorFactoryInterface
    
    Associate a Range mapping to any monitor that has a unit/key name that matches what is passed to key
    
    Specified by:
    
    setRangeDefault in interface MonitorFactoryInterface
  - reset
```
public void reset()
```
    Description copied from interface: MonitorFactoryInterface
    
    Reset jamon stats for this factory. Like recreating the factory
    
    Specified by:
    
    reset in interface MonitorFactoryInterface
  - enableGlobalActive
```
public void enableGlobalActive(boolean enable)
```
    Specified by:
    
    enableGlobalActive in interface MonitorFactoryInterface
  - isGlobalActiveEnabled
```
public boolean isGlobalActiveEnabled()
```
    Specified by:
    
    isGlobalActiveEnabled in interface MonitorFactoryInterface
  - getMonitor
```
public Monitor getMonitor()
```
    Description copied from interface: MonitorFactoryInterface
    
    Returns a non-TimeMonitor that won't update the jamon factory.
    
    Specified by:
    
    getMonitor in interface MonitorFactoryInterface
  - iterator
```
public Iterator iterator()
```
    Specified by:
    
    iterator in interface MonitorFactoryInterface
  - getMap
```
public Map getMap()
```
    Description copied from interface: MonitorFactoryInterface
    
    Get the backing map that holds the the Monitors. Keys=MonKeys, values=Monitor
    
    Specified by:
    
    getMap in interface MonitorFactoryInterface
  - enableActivityTracking
```
public void enableActivityTracking(boolean enable)
```
    Description copied from interface: MonitorFactoryInterface
    
    This determines if activity tracking in ranges is enabled. Activity tracking allows you to see how performance tracks to the number of activities (monitors) that are running. For example it can let you see how your web site scales by seeing how performance correlates when 10 simultaneous pages are being invoked, or 20, 30, 40, 50 etc. Disabling or enabling will affect current monitors as well as any others that are subsequently created. One problem at this point is that any in flight monitors can be disabled/enabled while they are in flight leading to results that may be off. For this reason it is best to enable/disable before any monitors have been created or when you know none are running. A future enhancement may be to delay this capability until no monitors are running. Note disabling global active turns off a subset of this capability.
    
    Specified by:
    
    enableActivityTracking in interface MonitorFactoryInterface
  - isActivityTrackingEnabled
```
public boolean isActivityTrackingEnabled()
```
    Specified by:
    
    isActivityTrackingEnabled in interface MonitorFactoryInterface
  - getMaxNumMonitors
```
public int getMaxNumMonitors()
```
    Description copied from interface: MonitorFactoryInterface
    
    Return the max number of configured of monitors.
    
    Specified by:
    
    getMaxNumMonitors in interface MonitorFactoryInterface
  - setMaxNumMonitors
```
public void setMaxNumMonitors(int maxMonitors)
```
    Description copied from interface: MonitorFactoryInterface
    
    Set the max number of monitors that can be tracked. The default is unlimited. When this value is set the number of jamon monitors is capped at this number and does not grow unbounded. Once this threshold has been reached any additional are not stored in the Map and no warning is given. If the threshold is set, but the monitors currently exceed this number the current monitors remain, however no new ones will be added.
    
    Specified by:
    
    setMaxNumMonitors in interface MonitorFactoryInterface
    
    Parameters:
    
    maxMonitors - If positive then this is the max number of monitors that can be stored. 0 or negative means monitors can grow unbounded.
  - enableTotalKeySizeTracking
```
public void enableTotalKeySizeTracking()
```
    Description copied from interface: MonitorFactoryInterface
    
    This will keep track of the total size of of the keys used to store the monitors which can be useful in keeping track of memory used by JAMon. To have accureate measurements enableTotalKeySizeTracking() must be called before any monitors are stored.
    
    Specified by:
    
    enableTotalKeySizeTracking in interface MonitorFactoryInterface
  - disableTotalKeySizeTracking
```
public void disableTotalKeySizeTracking()
```
    Specified by:
    
    disableTotalKeySizeTracking in interface MonitorFactoryInterface
  - getTotalKeySize
```
public long getTotalKeySize()
```
    Specified by:
    
    getTotalKeySize in interface MonitorFactoryInterface
  - isTotalKeySizeTrackingEnabled
```
public boolean isTotalKeySizeTrackingEnabled()
```
    Specified by:
    
    isTotalKeySizeTrackingEnabled in interface MonitorFactoryInterface
  - getMaxSqlSize
```
public int getMaxSqlSize()
```
    Description copied from interface: MonitorFactoryInterface
    
    Return the size that sql statements can be before truncating them. This will limit the size of JAMon labels for sql statements
    
    Specified by:
    
    getMaxSqlSize in interface MonitorFactoryInterface
    
    Returns:
    
    the max size that the sql is allowed to be before being truncated.
  - addListeners
```
public void addListeners(List<JamonPropertiesLoader.JamonListenerProperty> listeners)
```
    Description copied from interface: MonitorFactoryInterface
    
    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.
    
    Specified by:
    
    addListeners in interface MonitorFactoryInterface
  - setMaxSqlSize
```
public void setMaxSqlSize(int size)
```
    Description copied from interface: MonitorFactoryInterface
    
    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.
    
    Specified by:
    
    setMaxSqlSize in interface MonitorFactoryInterface
  - copy
```
public FactoryDisabled copy()
```
    Specified by:
    
    copy in interface MonitorFactoryInterface
    
    Returns:
    
    a deep copy of this object

Class FactoryDisabled

Field Summary

Fields inherited from interface com.jamonapi.MonitorFactoryInterface

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

FactoryDisabled

Method Detail

add

add

start

start

start

startNano

startNano

startPrimary

startPrimary

getMonitor

getMonitor

getTimeMonitor

addException

addException

getTimeMonitor

remove

remove

exists

exists

getComposite

getRootMonitor

getNumRows

getRangeHeader

getRangeNames

getVersion

setMap

setRangeDefault

reset

enableGlobalActive

isGlobalActiveEnabled

getMonitor

iterator

getMap

enableActivityTracking

isActivityTrackingEnabled

getMaxNumMonitors

setMaxNumMonitors

enableTotalKeySizeTracking

disableTotalKeySizeTracking

getTotalKeySize

isTotalKeySizeTrackingEnabled

getMaxSqlSize

addListeners

setMaxSqlSize

copy