Generally everything can be monitored with MoSKito. However, some things need to be monitored more often than others. And some things needs to be monitored so often, that they come out of the box. Here a list of Stats objects that come out of the box. Stat objects represents stats (statistics) about something that can be count. A single stat object represents usage of a single monitored object, that can be an url, a method, a business case, a thread, a memory pool, a disk or file, a cpu or anything else worth monitoring.

Below you will see general stat class and what is monitored. 

Stats

The following diagram gives a short overview of stat classes that come out of the box.

Before we begin

How to read the table:

Please note, even the Value is the name of the StatValue Object used inside the *Stats object, the accessor methods can differ. For example, to add time to total time in totalRequests you have to call addExecutionTime. Also an accessor can do different type of things, for example:

	public void addRequest() {
		totalRequests.increase();
		currentRequests.increase();
		maxCurrentRequests.setValueIfGreaterThanCurrentAsLong(currentRequests.getValueAsLong());
	}
	public void addExecutionTime(long time) {
		totalTime.increaseByLong(time);
		lastRequest.setValueAsLong(time);
		minTime.setValueIfLesserThanCurrentAsLong(time);
		maxTime.setValueIfGreaterThanCurrentAsLong(time);
	}

Please refer to the documentation and examples on how to use the stat objects correctly (or use built-in annotations) 

RequestOrientedStats. 

A huge bunch of stats is request oriented (method calls, urls, web-actions etc). The class net.anotheria.moskito.core.predefined.RequestOrientedStats provides general functionality for the request oriented stats. The concrete subclasses add only specific handling.

RequestOrientedStats

ServiceStats

Used for service like components (Service, API etc), also for Dynamic Proxies (See net.anotheria.moskito.core.dynamic.MoskitoInvokationProxy) and @MonitorClass, @Monitor CDI and AOP annotations.

ServiceStats class has no additional fields.

ActionStats

ActionStats are used by/for action driven frameworks such as struts or ano-maf, but similar to ServiceStats, differs from the RequestStats just by name. The point of having different names(classes) is that it allows the stats to be presented in different decorators and not getting mixed in webui.

ServletStats

ServletStats is the extension of the request oriented stats for http servlets and have three additional values. Each method (get,put,head...) will get its own stats object with all the values. See net.anotheria.moskito.web.MoskitoHttpServlet for examples or easy to extend counting servlet.

FilterStats

Same as Servlet Stats, but for Filters. See net.anotheria.moskito.web.MoskitoFilter, net.anotheria.moskito.web.filters.DomainFilter, net.anotheria.moskito.web.filters.RefererFilter or net.anotheria.moskito.web.filters.RequestURIFilter for usage example or building your own.

Environment and JVM Stats

Environment and JVM Stats are a huge group of stats that are not produced by the Application directly, but by its environment, either the JVM or the operating system or hardware. Most of those stats are gathered from appropriate MBeans.

Memory

Memory is one of the most important parameters of any system in production. 

MemoryStats

Based on Runtime.freeMemory(), maxMemory() and totalMemory() this simple object gives some overview about the memory. MemoryStats are builtin and available ootb. See net.anotheria.moskito.core.util.BuiltInMemoryProducer. 

A MemoryStats object exists for each stat: free, max and total. The MemoryStats are updated once a minute by a Timer.

A small example how it looks like in the WebUI:

MemoryPoolStats

This stats object is based on the MemoryPoolMXBean and provides information about available memory pools. MemoryPoolStats are builtin and available ootb. See net.anotheria.moskito.core.util.BuiltInMemoryPoolProducer. MemoryPoolStats are updated once a minute by a Timer. 

MemoryPoolStats are much more precise than the MemoryStats. See java.lang.management.MemoryUsage for details.

VirtualMemoryPoolStats

Sometimes its hard to calculate the different heap pools to one heap usage. VirtualMemoryPoolStats do exactly that by combining different pools by their heap-ness into heap and non-heap pools. VirtualMemoryPoolStats are builtin and available ootb. See net.anotheria.moskito.core.util.BuiltInMemoryPoolVirtualProducer. Virtual Memory Pool has exactly the same values (cumulated) as underlying pools and therefore the same values and shortcuts.

Threading

Threads are no less important than memory. The data is based on java.lang.management.ThreadMXBean.

ThreadCountStats

This stat object is for simple thread counting. It always has one stat. The data is updated once a minute. See net.anotheria.moskito.core.util.BuiltInThreadCountProducer.

ThreadStateStats

ThreadStateStats are ment to hold amount of threads in each state (BLOCKED, WAITING etc). However, the corresponding producer is currently disabled as of 2.0.1.  If it would be reenabled, it would deliver following data for each possible STATE: 

Process

OSStats

OSStats are based on com.sun.management.UnixOperatingSystemMXBean and therefore only supported on Unix Platforms. 

Example:

RuntimeStats

RuntimeStats are useful if you want to know how long your application is running without logging into the machine. They are not that relevant for monitoring. It is based on java.lang.management.RuntimeMXBean.

Example:

Keeping

Keeping refers to everything that is stored temporary somewhere (probably in memory) and is proceeded somehow. Keeping related stats can be used for capacity planing and monitoring and for throughput monitoring. Following Stats belong into this category:

CacheStats

CacheStats are good for monitoring ... caches! Alas if you want a collection of good and easy to use monitored caches - check out ano-prise-caches.

Not all cache implementations will provide every possible stat value.

QueueStats

A queue in moskitos sense is something between two components, where one component (feeder) add stuff from one end, and the other (processor) works on the other end and removes it. Of course it can be many2many.

Despite their beautifulness, QueueStats are somewhat out of date and are subject to be reworked in near future. 

QueuingSystemStats

Used for monitoring of QueuingSystems. As for now, only one such system is known: net.anotheria.anoprise.processor.QueuedMultiProcessor.

Despite their beautifulness, QueuingSystemStats are somewhat out of date and are subject to be reworked in near future. 

StorageStats

Storages are basically wrapper to maps. And storage stats monitor accesses to it. 

Counters

Counters are basically lightweight producers. Extremely lightweight producers. The have one or multiple dimensions, where each dimension means one stat value. All Counters extend net.anotheria.moskito.core.counter.GenericCounterStats.

Counter

The counter is a useful utility for counting stuff. Easy as that. Combined with the @Count annotation for both aop and cdi, Counter allows simple counting of something count-worthy. Therefore it only has one property:

MaleFemale

This is an example of two-dimensional counter and counts separately accesses by male and female users for each case (of course if you let it call it).

GuestMemberPremium

This is an example of a three-dimensional counter.