Monitor what matters to you and your users
Traditional monitoring systems are designed for low-level system metrics. Monique.io makes it easy to monitor high-level metrics coming from JSON data, health-checks or SQL queries.
Create account
How to monitor SQL query results?
Monique.io (1 line)
# directly send PostgreSQL query results

$ psql -c "SELECT country, COUNT(*) FROM user GROUP BY country" | curl --user 9fxvMi8aR3CZ5BsNj0rt0odW: --request POST --data-binary @- https://api.monique.io/reports/users_by_country
Traditional monitoring system (14 lines + TODO)
#!/usr/bin/python
import requests
import psycopg2

# Lets connect to the DB and execute the query
db = psycopg2.connect("dbname='' user='' host='localhost' password=''")
cursor = db.cursor()
rows = cursor.execute("""SELECT country, COUNT(*) FROM user GROUP BY country""")

# For each row, create a proper metric name and make an API call
for row in rows:
    country = row[0]
    count = row[1]
    metric_name = 'users_by_country.%s' % country
    requests.post(url='http://example.com/api/metric',
                  data={'metric': metric_name, 'value': count},
                  params={'api_key': '9fxvMi8aR3CZ5BsNj0rt0odW'})

    # TODO: decide on a metric naming scheme to handle more complex queries
    # TODO: set up a custom alerting script - builtin alerting rules are too limited
    # TODO: remember about adding new countries to the dashboard
BENEFITS
An increase in productivity.

Setting up dashboards using a traditional monitoring system or a dashboard framework requires a lot of tedious work. For each SQL query or a JSON endpoint the work must be repeated to create proper metric names or a format accepted by a dashboard widget.

Monique.io requires writing vastly less code by allowing multiple input types to be directly submitted.

More knowledge about what is really happening.

Traditional monitoring systems collect low-level metrics, like CPU or disk usage. However, this is just a tip of an iceberg — the most meaningful things happen in the application layer. APIs, microservices, database contents, backend services require custom monitoring.

Since it's easy to push data from these sources into Monique.io, you will end up having more meaningful information compared to using only the traditional tools.

More (and better) sleep.

Traditional monitoring systems support alerting on CPU usage and other system metrics. But if you want to set up checks on JSON data or SQL results, you will find it either hard or impossible — these tools are not meant for such use cases.

Monique.io's Javascript alarms allow defining any alerting logic. The checks that matter can be actually implemented — you shouldn't rely on reporting errors by your users when a monitoring system can handle it.

Making your monitoring setup more pleasant.

The limitations of the traditional solutions are often worked around by developing various in-house scripts that parse some data and check the health of services. However, the plethora of scripts, each doing its job in a different way, leads to a setup that is hard to manage.

Monique.io brings structure to the custom monitoring. The health-check results can be visualized on a dashboard and queried through the API. A heartbeat check ensures detecting problems like a dead or misconfigured server.

Sample dashboard
See live read-only view of the dashboard (obtained using dashboard sharing function)
The dashboard was created by putting three lines in /etc/crontab file, and making a few clicks to select numbers to graph (no agent installation, no configuration):
# directly send 'ps aux' output
*/30 * * * *      ps aux | curl --user 9fxvMi8aR3CZ5BsNj0rt0odW: --request POST --data-binary @- https://api.monique.io/reports/ps_aux

# directly send 'mysql' output
*/30 * * * *      mysql -e "SELECT country, COUNT(*) FROM user GROUP BY country" | curl --user 9fxvMi8aR3CZ5BsNj0rt0odW: --request POST --data-binary @- https://api.monique.io/reports/users_by_country

# directly send health check result
*/30 * * * *      if curl -s http://web | grep -q 'Welcome!'; then echo OK; else echo FAIL; fi | curl --user 9fxvMi8aR3CZ5BsNj0rt0odW: --request POST --data-binary @- https://api.monique.io/reports/web_check
It's very easy to monitor various things using Monique.io. More examples:
Rails query results
Django query results
Custom data (Python)
Microservice health check
API response
SQL results
Custom text
Cron job
CPU, disk, memory
require 'rest_client'

articles = Article.all

# Send JSON representation of results
RestClient.post 'https://api.monique.io/reports/articles', articles.to_json, :params => {:key => '9fxvMi8aR3CZ5BsNj0rt0odW'}
from django.core import serializers
import requests

qs = models.Choice.objects.filter(question_id=1).all()

# Send results serialized as JSON, using the standard serializer
requests.post('https://api.monique.io/reports/choices', params={'key''9fxvMi8aR3CZ5BsNj0rt0odW'}, data=serializers.serialize('json', qs))
import requests
import json

# send a single number
num = 86
requests.post('https://api.monique.io/reports/num', data=str(num), params={'key''9fxvMi8aR3CZ5BsNj0rt0odW'})

# send a list of numbers
num_list = [86, 43, 32]
requests.post('https://api.monique.io/reports/num_list', data=json.dumps(num_list), params={'key''9fxvMi8aR3CZ5BsNj0rt0odW'})

# send a dict
d = {'requests': 86, 'status''OK''flag'True}
requests.post('https://api.monique.io/reports/d', data=json.dumps(d), params={'key''9fxvMi8aR3CZ5BsNj0rt0odW'})

# send a nested dict
nd = {'x': {'nums': [1, 2], 'message''OK'}, 'y': 3.42}
requests.post('https://api.monique.io/reports/nd', data=json.dumps(nd), params={'key''9fxvMi8aR3CZ5BsNj0rt0odW'})

# send data from string
cdata = """
us 120
uk 34
de 27
it -
"""
requests.post('https://api.monique.io/reports/cdata', data=cdata, params={'key''9fxvMi8aR3CZ5BsNj0rt0odW'})
var restler = require('restler');

setInterval(function() {
    # Tags identify a microservice instance. They allow auto-creating dashboards with a tile created for each microservice instance. 
    var tags = ['microservice:search''pid:' + process.pid];

    # Send a status report containing memory usage data.
    restler.postJson('https://api.monique.io/reports/microservice_status', { 
            status: 'ok',
            # Arbitrary JSON-serializable data can be included in the sent data.
            memory: process.memoryUsage()
        }, { query: {
            tags: tags.join(','),
            key: '9fxvMi8aR3CZ5BsNj0rt0odW'
        }});
}, 60000);
# A JSON API response, like:
{
  "creator": {
    "name": "app184563"
  },
  "id": "43473",
  "likes": {
    "data": [ 1, 34, 35 ],
    "summary": {
      "total_count": 1022,
      "can_like": true,
      "has_liked": false
    }
  }
}

# can be sent directly:

curl https://graph.facebook.com/?ids=http://example.com | curl --user 9fxvMi8aR3CZ5BsNj0rt0odW: -XPOST --data-binary @- https://api.monique.io/reports/facebook_likes
# Send PostgreSQL results
$ psql -c "SELECT country, COUNT(*) FROM user GROUP BY country" | curl --user 9fxvMi8aR3CZ5BsNj0rt0odW: --request POST --data-binary @- https://api.monique.io/reports/users_by_country

# Send MySQL results
$ mysql -e "SELECT country, COUNT(*) FROM user GROUP BY country" | curl --user 9fxvMi8aR3CZ5BsNj0rt0odW: --request POST --data-binary @- https://api.monique.io/reports/users_by_country

# Send Oracle results
$ echo "SELECT * FROM EMPLOYEE;" | sqlplus -s HR/oracle | curl --user 9fxvMi8aR3CZ5BsNj0rt0odW: -XPOST --data-binary @- https://api.monique.io/reports/employees

# Send MongoDB results
$ mongo --quiet --eval 'JSON.stringify( db.restaurants.find().limit(10).toArray() )' | curl --user 9fxvMi8aR3CZ5BsNj0rt0odW: -XPOST --data-binary @- https://api.monique.io/reports/restaurants

# Send Cassandra results
$ cqlsh -e "SELECT count(*) FROM user" | curl --user 9fxvMi8aR3CZ5BsNj0rt0odW: --request POST --data-binary @- https://api.monique.io/reports/users_count
# Send lines containing ERROR string as one block of text.

cat app.log | grep ERROR | curl --user 9fxvMi8aR3CZ5BsNj0rt0odW: --request POST --data-binary @- https://api.monique.io/reports/job?format=single
      
# Monique.io supports heartbeat checks, which can be used to ensure that cron jobs 
# are run at specified intervals.
20 3 * * *    custom_script.sh && (echo run_ok | curl --user 9fxvMi8aR3CZ5BsNj0rt0odW: --request POST --data-binary @- https://api.monique.io/reports/custom_script.sh)

# To capture return codes and time elapsed during a command run,
# 'moniqueio run' command can be used. moniqueio is a set of extra command line
# tools available at https://github.com/monique-io/moniqueio-tools.
10 0 * * *    moniqueio run make_backup.sh | curl --user 9fxvMi8aR3CZ5BsNj0rt0odW: --request POST --data-binary @- https://api.monique.io/reports/job?tags=job:make_backup
 # Collecting system metrics is not a primary use case for Monique.io, but they still can be easily submitted.
 # Command output and the content of system files is usually correctly parsed without specifying a format:
 $ cat /proc/meminfo | curl --user 9fxvMi8aR3CZ5BsNj0rt0odW: --request POST --data-binary @- https://api.monique.io/reports/memory
 
 # A tag containing an IP address can be automatically added, enabling auto-creating
 # a dashboard tile for each server:
 $ df | curl --user 9fxvMi8aR3CZ5BsNj0rt0odW: --request POST --data-binary @- https://api.monique.io/reports/diskfree?autotags=ip
 
 # To automatically collect a more comprehensive set of system metrics, the extra 'moniqueio' tool can be used:
 moniqueio --api-key 9fxvMi8aR3CZ5BsNj0rt0odW sysreports --tag-ip
 
HOW IT WORKS
Examples of sending data into Monique.io are boring — whether it's a nested JSON document, an ASCII table containing SQL results or a text file, the same HTTP POST call handles the processing, even without specifying an input format. The data is automatically parsed into a tabular format and immediately available for graphing and alerting.

Adding charts to a dashboard is very easy — just click the wanted values.

(8-second video)
JAVASCRIPT ALARMS
The sent data — in the original and the tabular format — are available to the Javascript code that can perform tests and trigger alarms. The "dry run" mode and print calls make the code easy to investigate and debug.

The list of other features includes: sending a custom message to a Slack channel, querying historic data, making HTTP requests, synchronizing incidents with Slack, PagerDuty and custom third-party services.

The alarms are run in a robust and secure environment with notifications sent for failures like Javascript errors or timeouts.
Defining alarms in Javascript
AUTO-CREATED DASHBOARDS
Multiple instances of servers, containers or microservices can be monitored by attaching a tag to submitted data, for example ip:192.168.1.8. A dashboard tile can be automatically created for each tag value.

The mechanism is very lightweight and isn't limited to selected technologies. It can be used to automatically create a dashboard tile for each monitored entity — whether it comes from a system-level area (an HTTP endpoint, a cron job, a process) or a higher-level source (customer's data, stock price, an offered product).

Extra features include setting a maximum time a tile can live without receiving new data (which can be set for ephemeral entities that should disappear from a dashboard after a deletion) and controlling whether X and Y axes of charts should be synchronized.
Sample dashboard from microservice health checks
HEARTBEAT CHECKS
If a server sending a health-check report dies or a cron job is misconfigured, the data is no longer being sent. A heartbeat check assures that an alarm will be triggered in such cases.

The checks can be configured for specific tags, which can contain a source IP address, a cron job name or a process PID.
A heartbeat check
THERE'S MORE
API
The API lets you do more than just submitting data: retrieve parsed report instances, store arbitrary data, directly trigger alarms, programmatically set heartbeat checks .
TOOLS
A GitHub project contains extra tools that make solutions to many tasks one-liners (monitoring unit test results, processing log files, monitoring cron jobs, collecting system-level data and more).
UX
For some reason many monitoring systems have poor user experience. Monique.io's UI stays clean and simple, even when what happens behind the scenes is complex.
24 / 7
A monitoring system should be something you can rely on 24/7/365. Monique.io is run using a highly-available cluster and for the last 12 months the availability of the Web, API and Alarms service exceeded 99.99%.
SECURITY
Keeping your data secure is our highest priority. HTTPS everywhere, fine-grained access checking and doing periodic security reviews are some of the measures we take.
TRIAL
The 10-day trial allows you to check all Monique.io features without entering credit card or personal data. We are happy to answer all questions submitted to the email address support@monique.io.
MONIQUE.IO VS OTHERS
Click on for explanation.
Task
Monique.io
Traditional monitoring system
Dashboard framework
Monitoring CPU usage
Monitoring SQL results
Monitoring custom microservices
Setting up dashboards for specific services (like Google Analytics or Stripe)
Monitoring custom data (JSON, health-checks, text and numeric values)
Make setting up monitoring a joyful experience
(and save a lot of time and money)
Sign up for a trial

(or just see plan options)
GETTING IN TOUCH
Do you wonder how Monique.io could be actually used in your projects,
or if it can replace other monitoring systems? Ask us anything.