MoSKito-Central is the centralised storage server for keeping performance data, collected by MoSKito Core.

Why would you need MoSKito-Central?

MoSKito-Core does not actually store data. It uses the application memory only to keep the value, obtained within the last monitoring interval. Once the new instance of the interval comes to an end, the newly received value substitutes the old one. The previous value is gone forever.

For example.

Let's say we're monitoring HTTP SessionCount with 1min interval.We start monitoring at 00:00. The value, received at 00:01 (first monitoring interval), amounts to 100.

The new interval ends at 00:02 and brings the value of 110.

Since 00:02, MoSKito only holds the latest value '110', forgetting the previous value '100' to never remember it again.

Such a way of storing data saves a huge amount of application memory.

However, from time to time you want to dig deeper back into the history of your application performance, and add time to your data.

To store the data (in application memory, filesystem or database) for later processing, you will need MoSKito-Central. 

MoSKito-Central is particularly useful if you:

  • monitor a distributed application and would like to have total knowledge about the hidden back end processes or communications between front end and back end,
  • monitor multiple applications and want to have all performance data accurately stored and dispatched.

MoSKito-Central may store performance data, collected over quite a long period of time.

This info shows how your app has been performing yesterday, a week or a month ago. That is essential for making a deep performance analysis and knowing if your improvements have effect on your app.


Centralised data archive

With MoSKito-Central, you store the entire performance info of your application in one place, within a well-ordered archive. 
All the monitored parameters, since the very start of monitoring process.

Why is this important?

If you care about the effectiveness of improvements you bring to your app, you'll have to measure them by comparing the current performance with the indicators you had in the past. In case the past performance info is spread over different storages, or you have been using various services while monitoring your app, then you're in a trouble. Finding the needed info may take days.

Surely, if you know for sure where all the data is stored, the search is a matter of seconds.

Just imagine how cool it would be to know, for example, how many user sessions you had on the first Monday in September, a year ago?!

MoSKito-Central gives you such a power! 

Complete tracing of inter-node communication

When you have a multi-node application, you may easily get lost in the calls or processes, running between the nodes. There might be even functions you totally forgot about, but still triggering system calls and consuming application resources. And the bigger the app becomes, the more difficult it gets to monitor everything.

MoSKito offers a perfect way to:

  • see the entire 'life inside your app' in its complexity and integrity,
  • avoid mixing the performance data you get from different parts of your app.

Once you deploy MoSKito-Essential on every application node and start sending data to MoSKito-Central, every tiny piece of info gets stored in its cell, making sure you never miss it. There are no more hidden calls or processes that might pass unnoticed, for the entire statistics is being recorded exactly the way it occurs in the application. 

Local storage ensures data security

If you are concerned about privacy and security of your app's data, MoSKito-Central is the most optimal solution.

MoSKito-Central is deployed on a local machine, and this is where it keeps everything. The data from other nodes of your app goes directly to MoSKito-Central storage,without passing any additional servers or external storages. You may be sure you're the only one to see or access your data, unless your local machine is well-protected. 

Multiple transfer protocols

On your project, you may use a certain type of data transfer. Using multiple protocols might cause mess. Total shifting to another protocol just for monitoring purposes would be too much.

With MoSKito-Central, everything's easy. You may use direct communication or transfer data via RMI or HTTP with the corresponding 'out-of-the-box' connectors.

What's better, you're not limited to the bundled options. With a little customisation, you may setup your own connectors (which is quite easy) and thus use any other transfer protocol. 

Absolute storage flexibility

With MoSKito-Central, you have no limitations in the way you store the obtained performance data.

You may choose between application memory as a quick option, avoiding additional storage configs.
You might opt for storing data in files: JSON, XML and CSV are instantly available, other formats are available after a simple configuration.
Finally, SQL and non-SQL options are useful if you're building a seriously organised and frequently accessed data storage. 

Embedded or standalone modes

Embedded mode may suit you perfectly if you're dealing with a simple, one-node application. This mode is a real resource-saver for small-sized applications. Read more…

The Remote (Standalone) mode is useful when you work on a complex, multi-node app with a complicated backend-frontend relations. Read more… 

How does it work?

  1. You deploy MoSKito-Central, thus setting up a local storage server.
  2. You connect MoSKito-Central and MoSKito-Core, that is integrated into your application. 
    The communication between Central and Core is established through MoSKito plug-in, that uses customised connectors for transferring data over different protocols:
    • REST connector for HTTP transfer, 
    • DistributeMe connector for RMI transfer,
    • Embedded connector for direct communication.
  3. After communication is established, you set up the storage configuration so that MoSKito-Central could store performance data:
    • in memory,
    • in filesystem with JSON, XML and CSV files (or other file formats), or
    • in SQL and non-SQL databases.

To know more about using HTTP or RMI protocols for sending data to Central, please read Setting Up MoSKito-Central in Remote Mode.

Modes of MoSKito-Central deployment

Remote Mode (Separate Application)

This is a normal, intended way of running Central.

Initiated on a separate machine/server, MoSKito-Central

  • receives performance snapshots of a monitored application via RMI or HTTP protocols, through DistributeMe or REST Connectors, and 
  • stores it on machine/server it was deployed on.

Embedded Mode

This is useful in case you only have one monitored application and you want to:

  • save the data on the app server's file system, or
  • have direct access to the storage place from where your app is running.

Such being the case, having additional remote application is unneeded overhead and using embedded mode saves time and resources.

Please read Set Up Moskito-Central in Embedded Mode for more info.

  • No labels