/**
* 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. <b>Sample call:</b><br>
*
* <blockquote>
*
* <code><pre>
* Monitor mon=MonitorFactory.start("pageHits");<br>
* ...code being timed...<br>
* mon.stop();
*
* </pre></code>
*
* </blockquote>
*
* <br>
* <br>
*/
public static Monitor start(String label) {
return factory.start(label);
}
/** This returns an HTML report for basic data with no range info in the header. */
public static String getReport() {
return factory.getRootMonitor().getReport();
}
public static void enableActivityTracking(boolean enable) {
factory.enableActivityTracking(enable);
}
public static boolean isGlobalActiveEnabled() {
return factory.isGlobalActiveEnabled();
}
/**
* This returns the header for basic data with no range info in the header. This method is
* deprecated. use the methods associated
*
* <p>with the CompositeMonitor. The various getXXXHeader() methods of CompositeMonitors can
* return this information and more.
*/
public static String[] getHeader() {
return factory.getRootMonitor().getBasicHeader();
}
/** Remove/delete the specified monitor */
public static void remove(String label, String units) {
factory.remove(label, units);
}
/**
* Use the specified map to hold the monitors. This map should be threadsafe. This allows for the
* use of a faster map than
*
* <p>the default synchronzied HashMap()
*/
public static void setMap(Map map) {
factory.setMap(map);
}
/**
* 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. <b>Sample call:</b><br>
*
* <blockquote>
*
* <code><pre>
* Monitor mon=MonitorFactory.getMonitor("myPrimaryMonitor");<br>
*
* </pre></code>
*
* </blockquote>
*
* <br>
* <br>
*/
public static Monitor getMonitor(String label, String units) {
return factory.getMonitor(label, units);
}
/**
* 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. <b>Sample call:</b><br>
*
* <blockquote>
*
* <code><pre>
* Monitor mon=MonitorFactory.getTimeMonitor("myPrimaryMonitor");<br>
*
* </pre></code>
*
* </blockquote>
*
* <br>
* <br>
*/
public static Monitor getTimeMonitor(String label) {
return factory.getTimeMonitor(label);
}
/** Start a monitor with the specified key and mark it as primary */
public static Monitor startPrimary(MonKey key) {
return factory.startPrimary(key);
}
/** Start using the passed in key. Note activity stats are incremented */
public static Monitor start(MonKey key) {
return factory.start(key);
}
/**
* 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. <b>Sample
* call:</b><br>
*
* <blockquote>
*
* <code><pre>
* Monitor mon=MonitorFactory.startPrimary("myPrimaryMonitor");<br>
* ...code being timed...<br>
* mon.stop();
*
* </pre></code>
*
* </blockquote>
*
* <br>
* <br>
*/
public static Monitor startPrimary(String label) {
return factory.startPrimary(label);
}
public static Monitor getMonitor() {
return factory.getMonitor();
}
/**
* 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. <b>Sample call:</b><br>
*
* <blockquote>
*
* <code><pre>
* Monitor mon=MonitorFactory.start();<br>
* ...code being timed...<br>
* mon.stop();
*
* </pre></code>
*
* </blockquote>
*
* <br>
* <br>
*/
public static Monitor start() {
return factory.start();
}
/** Return the composite monitor of all monitors for this factory */
public static MonitorComposite getRootMonitor() {
return factory.getRootMonitor();
}
/**
* Get the time monitor associated with the passed in key. It will be created if it doesn't exist.
* The units are in ms.
*/
public static Monitor getTimeMonitor(MonKey key) {
return factory.getTimeMonitor(key);
}
/** Return the version of JAMon */
public static String getVersion() {
return factory.getVersion();
}
/**
* Determine if the monitor associated with the label, and the units currently exists. <b>Sample
* call:</b><br>
*
* <blockquote>
*
* <code><pre>
* Monitor mon=MonitorFactory.getTimeMonitor("myPrimaryMonitor");<br>
*
* </pre></code>
*
* </blockquote>
*
* <br>
* <br>
*/
public static boolean exists(String label, String units) {
return factory.exists(label, units);
}
/** Remove the monitor associated with the passed in key */
public static void remove(MonKey key) {
factory.remove(key);
}
/** Return true if the monitor associated with the passed in key exists */
public static boolean exists(MonKey key) {
return factory.exists(key);
}
/**
* Associate a range with a key/unit. Any monitor with the given unit will have this range. Any
* monitor with
*
* <p>no range associated with its unit will have no range.
*/
public static void setRangeDefault(String key, RangeHolder rangeHolder) {
factory.setRangeDefault(key, rangeHolder);
}
/**
* Return the composite monitor (a collection of monitors) associated with the passed in units.
* Note in JAMon 1.0 this method would take a lable 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. <b>Sample call:</b><br>
*
* <blockquote>
*
* <code><pre>
* Monitor mon=MonitorFactory.getComposite("ms.");<br>
* mon=MonitorFactory.getComposite("allMonitors");<br>
*
* </pre></code>
*
* </blockquote>
*
* <br>
* <br>
*/
public static MonitorComposite getComposite(String units) {
return factory.getComposite(units);
}
public static void enableGlobalActive(boolean enable) {
factory.enableGlobalActive(enable);
}
/** This returns the number of monitors in this factory. */
public static int getNumRows() {
return factory.getNumRows();
}
/**
* This returns the data for basic data with no range info.
*
* <p>The various getXXXData() methods of CompositeMonitors can return this information and more.
*/
public static Object[][] getData() {
return factory.getRootMonitor().getBasicData();
}
/** Return the header for displaying what ranges are available. */
public static String[] getRangeHeader() {
return factory.getRangeHeader();
}
/** Iterator that contains Monitor's that are in this factory */
public static Iterator iterator() {
return factory.iterator();
}
/** Return the ranges in this factory. */
public static Object[][] getRangeNames() {
return factory.getRangeNames();
}
public static boolean isActivityTrackingEnabled() {
return factory.isActivityTrackingEnabled();
}
/**
* 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.
*/
public static Monitor add(MonKey key, double value) {
return factory.add(key, value);
}