Monitor Streaming Audio

We’re happy to introduce our new audio check type.  Now NodePing can monitor HTTP streaming audio servers and notify you via email, SMS, and even voice alerts when your audio streams go offline.

The new audio check is available now and can be used to watch HTTP streaming audio services like ICEcast and SHOUTcast servers.  Set the target of the check to the URL specified inside your pls file.  If your pls file looks like:

NumberOfEntries=1
File1=http://example.com:8002/

Set the check target to “http://example.com:8002/“.  The check briefly connects to the stream and reads the headers returned to determine if the audio steam is up or down.

Many thanks to all who gave their “+1” to this new check type.  Your feedback and suggestions help us prioritize which enhancements and new check types our development team works on. If you’ve got a need for a specific check or an enhancement to an existing check, please let us know in the comments below or email us at support@nodeping.com.

Introducing NodePing’s Monitoring API

This is Part 1 in a series of posts we’ll have in the coming weeks detailing various aspects of NodePing’s new API. The API allows customers to manage most aspects of their site and server monitoring through an HTTP accessible RESTful interface. It provides list, read, write, and delete functionality for subaccounts, contacts, contact groups, and checks, as well as allowing you to retrieve checks and notifications. Access to the API is included in our service at no extra cost.

The API supports HTTP methods for most calls:

  • GET for listing or retrieving specific records,
  • PUT to update a record based on its ID,
  • POST to create new records (IDs are assigned automatically), and
  • DELETE to delete records.

All responses are JSON.

The API’s authentication is token based. You can find your token in the Account Settings area of your account, or if you’re logged in to the service it is also displayed on the Documentation page.

Documentation is available at https://nodeping.com/API_Documentation. Reference docs showing all supported calls are at https://nodeping.com/API_Reference.

Here’s an example of updating a monitoring check:
curl -X PUT -d'json={"threshold":4, "target":"http://www.example.com/index.html", "enable":"true", "notifications":[{"SKTUSP":"Days"}]}' 'https://api.nodeping.com/api/1/checks/201205050153W2Q4C-1FOC0YYM'

The response to that call would look something like this:

{
  "_id": "201205050153W2Q4C-1FOC0YYM",
  "_rev": "4-5069940f2a95fc6ae5564e329da755bd",
  "customer_id": "201205050153W2Q4C",
  "label": "Site 2",
  "interval": 1,
  "notifications": [ { "SKTUSP": "Days" } ],
  "type": "HTTP",
  "status": "modified",
  "modified": 1337744587374,
  "enable": "active",
  "public": false,
  "parameters": {
    "target": "http://www.example.com/index.html",
    "threshold": 4,
    "sens": "2"
  }
}

Since the API is brand new, we would really like to hear from people who start using it in real situations. Please let us know what works well, and what we could do to make interacting with the API easier.

Monitoring API, Branding, and now Voice!

We are very excited to be adding the following new features to NodePing:

NodePing was founded to provide monitoring services to a market segment that was severely underserved by other providers. Before NodePing, monitoring simply cost too much. Many monitoring services advertise low rates, but when you actually use their service you find out that in practice they cost far more than the impression their advertising gives. For those other services, actual costs are often hidden in complicated pricing formulas.

NodePing broke that paradigm by providing monitoring at a low, flat rate, with no hidden fees – one price, everything’s included.

Many of our customers have asked us to provide additional functionality. Most of our development, in fact, has been driven by feedback from our customers. Some functionality is harder to provide than others, especially because of our pricing structure. In particular, we have wanted to provide an API for some time, but our extremely narrow margin makes providing an API in a cost-effective manner difficult.

We talked to some of our customers about ways to provide this service. We also experimented some with pricing. What we learned validated our original strategy for NodePing. There is a market for these services that is not currently being adequately met by any other provider.

The new features will cause the average size of our customer accounts to increase slightly. After much discussion, we have decided to keep our pricing structure the same (one low flat rate) but in order to cover the changes we need to adjust the price slightly. Our new, monthly, flat-rate price is now $15 USD. Even with this increase, NodePing still the beats all of our major competitors prices by a wide margin.

The price adjustment will be implemented immediately for all new accounts. We aren’t changing pricing for our existing customers yet.

Thank you to all who suggested new features, offered input on the new pricing, and tested our new services. You’re making NodePing the best value in server and website monitoring in the world.

BigCouch 0.4 on Ubuntu 12.04

NodePing uses CouchDB and it’s big brother, BigCouch extensively for our database needs. After getting some shiny new hardware from the great guys over at Codero, we wanted to install BigCouch on the fresh new Ubuntu 12.04 release but, alas, the fine folks at Cloudant haven’t yet updated their repository for Ubuntu 12.04 so we took a swing at building from source.

First, we had to install some dependencies:

apt-get install erlang libicu48 libicu-dev libcurl4-openssl-dev zip autoconf2.13 runit

This took a while since the official Ubuntu repos are still pretty slow from the new release last week.

Download and install Spidermonkey (the javascript engine CouchDB uses). BigCouch requires version 1.92 so the older version in the Ubuntu repos won’t work.

wget http://ppa.launchpad.net/commonjs/ppa/ubuntu/pool/main/s/spidermonkey/spidermonkey_1.9.2.orig.tar.gz
tar zxvf spidermonkey_1.9.2.orig.tar.gz 
cd spidermonkey-1.9.2/src 
autoconf2.13 
./configure 
make 
make install

Grab the BigCouch code from git. At time of writing, it’s 0.4

git clone git://github.com/cloudant/bigcouch.git
cd bigcouch
./configure
make
make install

Now BigCouch is installed at /opt/bigcouch

We create a non-root user to run BigCouch under. We’ll use the same username that the official BigCouch binaries use so we can steal some start up scripts.

useradd bigcouch
chown bigcouch:bigcouch /opt/bigcouch -R

I stole the sv startup files/folders from an older Ubuntu BigCouch release and copied it to my home directory and then dropped it in place.

cp -r /home/mysupersecrethomefoldername/bigcouch /etc/sv/
ln -s /etc/sv/bigcouch /etc/service/bigcouch

Edit your config files at /opt/bigcouch/etc/vm.args and /opt/bigcouch/etc/local.ini following the instructions in the ‘Configure your nodes‘ section here then you should be able to start up BigCouch.

sv start bigcouch

Big thanks to BigCouch and CouchDB developers for their great work. NodePing couldn’t do what it does without you doing what you do!

SSH Check with Content String Matching

NodePing is happy to announce the new SSH check. In its simplest use, the new SSH monitoring provides a real SSH connection for monitoring those critical SSH services, but our check can do much more than that.

Not only can we monitor the availability of your SSH services on any port, but we can also optionally have the check log in and verify the presence, or absence, of a particular string in the login response. Pairing the SSH check with a login script makes it much more powerful and flexible. With it, you can monitor much more than SSH.

In the example below, we’re going to set a login script that checks server load, available memory, and disk usage. We’ll use its simple ‘PASS‘ or ‘FAIL‘ output to trigger email and SMS alerts from NodePing when the 1 minute load average goes over 4.0, when available memory drops below 50MB, or when the disk becomes more than 90% full.

The script is a simple BASH script that relies on commonly installed programs like ‘top’, ‘free’, and ‘df’ to determine the ‘PASS’/’FAIL’ status for each of the things we’re monitoring. It’s not the prettiest thing, but it seems to work well on an Ubuntu server.

#!/bin/bash
# Load average limit
# A quad-core server may be maxing out CPUs at 4.0
LOADLIMIT=4;
# Free memory floor in MB.
FREEMEMLIMIT=50;
# Disk usage in percentage, but without the percent sign. 
DISKUTILIZATION=90;
# Path to the disk partition you want to monitor.
DISKPATH='/dev/sda7';

LOAD=`top -n1 | grep 'load average' | awk -F" " '{print $12}'`;
LOAD=${LOAD:0:4}
LOAD=`echo "$LOAD > $LOADLIMIT" | bc`
if [ $LOAD -eq 1 ]; then
echo "LOAD:FAIL";
else
echo "LOAD:PASS";
fi

MEMUSAGE=`free -m | grep '^Mem' | awk -F" " '{print $4}'`;
MEMUSAGE=`echo "$MEMUSAGE < $FREEMEMLIMIT" | bc`;
if [ $MEMUSAGE -eq 1 ]; then
echo "MEM:FAIL";
else
echo "MEM:PASS";
fi
DISKSPACE=`df | grep "$DISKPATH" | awk -F" " '{print $5}'`;
LEN=`expr "$DISKSPACE" : '.*'`;
LEN=`echo "$LEN-1" | bc`;
DISKSPACE=${DISKSPACE:0:$LEN}
DISKSPACE=`echo "$DISKSPACE > $DISKUTILIZATION " | bc`;
if [ $DISKSPACE -eq 1 ]; then
echo "DISK:FAIL";
else
echo "DISK:PASS";
fi
# logout right away
# This SSH user is restricted for security purposes
exit;

We saved this script as ‘mylogin.bash‘ in our user’s home folder and then edited the /etc/passwd file, replacing the shell ‘/bin/bash‘ with ‘/home/testuser/mylogin.bash‘.  Don’t forget to make the script file executable with something like

chmod 0755 /home/testuser/mylogin.bash 

Now when our test user logs in, we see something like:

Last login: Thu Apr 12 22:41:33 2012 from 127.0.0.1
LOAD:PASS
MEM:PASS
DISK:PASS
Connection to 127.0.0.1 closed.

It’s the response text above that will be checked against our user defined content string. In our SSH check configuration, we’ll set the ‘Content string‘ dropdown to ‘Does not contain‘ and type ‘FAIL‘ in the text field.  Now when NodePing’s probe servers login via SSH and find the word ‘FAIL‘ in the response, I’ll get a notification!

But the notification just says that the SSH check failed. We won’t know what failed.  It could be the load, memory, or disk.  Instead of logging in to see, I’ll be lazy and create three separate SSH checks, all with the same host and login information, but have one check for the string ‘LOAD:FAIL‘, another check for ‘MEM:FAIL‘, and the other ‘DISK:FAIL‘.  I’ll label the one that checks the load average a nice informative name like “Load Average on test server” and the other checks something similar. Now my SMS notification say something like “SSH Check failed for: Load Average on test server“, letting me know exactly what’s failing.

NodePing provides 1000 checks run at up to 1 minute intervals for only $10/month so you’re running out of reasons not to monitor everything. If you don’t have a NodePing account yet, sign up for our free 15-day trial and kick the tires.  We think you’ll like it.

The above example is fairly simple.  You can write your own login scripts in Node.js, Python, etc to check statuses for databases, VPN connections, virus definition updates,… dang near anything!  You can find information on how to configure your SSH checks in our documentation.

How will you use the new SSH check with content string matching?  Let us know in the comments below.

NodePing Tips – Using the Status Filter

NodePing allows you to watch up to 1000 web sites or services. Some of our customers monitor dozens or even hundreds of web sites. Others monitor several web sites, plus DNS, FTP, SSH, and a variety of other services. The sites and services being monitored are surprisingly varied, and scattered across the globe.

Lately we’ve been working on our UI to make it work better for all of the variations in how the service is used, especially for customers with a larger number of checks. Several enhancements have been made to the main Status list. Putting more information at your fingertips.

One enhancement that is surprisingly powerful is the dynamic filtering of the status list. If you type in the Search box at the top right of the list, the list of checks is dynamically filtered as you type. The filter continues to be applied as the information is updated. This means, for example, that you can type “FAIL” in the search box and it will list only the services that are currently listed as failing. As services change from PASS to FAIL and back, they will appear and disappear from the filtered list dynamically. This gives you an instant list of those services that are failing that you can just keep on your screen and it keeps itself updated.

Another use of the search filter is viewing groups of checks with common attributes. For example, you can view all web site monitoring by typing http in the search, which will display all of the checks with an HTTP type or with “http” in the label. This is even more useful tied to careful use of check labels. If you include the word “router” in the label for all your checks of routers, that makes it very easy to list them together using the search. You could also use this to list monitoring checks of a specific network, client, or location.

The search filter is made possible by the capabilities of the DataTables plugin. Recent versions of DataTables have added some key features that have made our lives much easier in developing a rich interface for our web application.

We hope the new enhancements to our UI make the service even more useful, and we’re looking forward to hearing about the ways people use it that we didn’t think of.

Port Connect Check Now Available

There are thousands of network protocols NodePing doesn’t have checks for (yet) :-) But that shouldn’t stop you from being able to monitor the availability of your services.  Using our new Port Connect check, you can test the responsiveness of nearly any TCP protocol on any port.

This is great news for those running lesser-known services, or services on non-standard ports, who are having a hard time finding a monitoring service to help them track availability. Our Port Connect check will attempt to create a standard TCP socket connection to your host on the specified port and report back if your server accepted the connection.

The Port Connect check can also help ensure that a particular port is not accepting traffic as well. This is useful for making sure your firewall is blocking a specific port for services that need a little extra vigilance. The check will send a notification if it is ever able to successfully connect.

You can learn more about the Port Connect check and how to configure it in our documentation.  If you don’t yet have a NodePing account, you can sign up for a 15-day free trial and give our new Port Connect check a try.  We think you’ll like it.

FTP Check Now Looks for Files Too!

Until today, the NodePing FTP check was fairly basic but we’ve rolled up our sleeves to add the awesome sauce and are proud to announce our new and improved FTP monitoring check.

Features:

  • Monitor FTP on any port, not just 21
  • Supports anonymous logins
  • Verify FTP user logins (optional)
  • Verify the existence, or non-existence of a file on your FTP server (optional)

Detailed information about how to configure your FTP checks can be found in our documentation.

The “file exists” feature in particular can be a huge help for those who wish to do more than just check to see if their FTP service is currently running. We’ll send you a notification if that important file goes missing from your FTP service – or if a particular file suddenly appears! This can be used to receive an alert when an application error log file gets created.  Or you could write your own scripts for internal processes that trigger NodePing SMS alerts by touching files on your FTP server.

The new enhancements are available on your account now at NodePing.  If you don’t have a NodePing account, you can sign up today for a free 15-day trial and for $10 a month you can monitor 1000 servers and get unlimited email and international SMS alerts.

SSL Certificate Check

An SSL certificate is an important part of serving up secure websites. It puts the ‘S’ in HTTPS and gives your visitors that warm fuzzy feeling when they see that padlock in their browsers. But those SSL certificates don’t last forever. Most have to be renewed every 1-3 years and should you forget and let that certificate expire, your visitors will be met with an ugly “This Site is Untrusted‘ message instead of your great content. Let NodePing keep an eye on your SSL certificates with our new SSL check available today.

Monitoring your SSL certificate with NodePing will allow you to receive notifications if the certificates is nearing its expiration, is replaced with an invalid certificate, or if your webserver is incorrectly serving it. You can also configure how many days in advance of expiration you’d like to receive the notification, giving you time to renew and install a new certificate without interruption.

The new SSL check is just one more link in your comprehensive server monitoring chain. NodePing is happy to keep an eye on your SSL certificates. If you don’t have an account yet, sign up for a free 15 day trial at http://nodeping.com.

Let us know what you think of the new SSL check in the comments below.

Monitoring results now available in JSON and CSV formats

Many of our customers monitor their own customers’ websites, or they monitor services about which they have to periodically report availability and incident statistics. Many of them would like to include status information in their own dash boards or integrate results with other data in reports. All of that calls for the data to be available in formats that can be easily used by scripts, or easily imported into spreadsheets.

NodePing has now added the ability to retrieve monitoring results in JSON and CSV format. JSON is ideal for scripting situations, such as creating your own dashboards or views of the data. CSV is great for loading the results data into your spreadsheets for analysis or creating reports for customers or management.

Both of these formats are available as extensions to our public reporting feature, which we added a while back. When you turn on public reporting, you are given a UUID that identifies that check. The same UUID can be used to access the data as a public report (you need to know the UUID, which gives you some control over who sees it, but does not require a login), as JSON output, or as a CSV download.

You can read more about these features and see some sample URLs on our Reporting page in the NodePing Documentation.