Maintenance

Exclude planned downtime from your check uptime statistics using our newly released maintenance features.

All services need maintenance now and again. Required restarts and reboots usually mean services will be offline while security patches and updates are applied. Many SLA’s and Terms of Service exclude these kinds of activities from your uptime commitments, so disabling your checks during those down times is appropriate.  You also often don’t need notifications for planned events.

NodePing’s maintenance features make it simple to manage your monitoring for planned maintenance. You can create recurring and ad-hoc maintenance that will disable your selected checks for a user-specified duration in minutes.  It will then re-enable the checks after the time you specify, and if any of the checks are still failing at that point–maybe a service failed to restart–you’ll receive the regular ‘down’ notifications.

Some examples where maintenance comes in handy:

  • If your nightly database backup causes your HTTP checks to time out, create a recurring maintenance to disable those HTTP checks for the 3 minutes it takes to do the backup.
  • If your VPS provider sends an emergency maintenance email saying they’re replacing the router and to expect some network interruptions for the next hour, you can set the affected checks in an ad-hoc maintenance that will re-enable them after an hour.

Our new maintenance features will help you maintain your SLAs and alert you right away if your checks fail after maintenance is complete.

Recurring maintenance can be set using a familiar cron expression.

You can find information in our documentation about our maintenance features and the new maintenance API endpoint.

If you don’t yet have a NodePing account, please sign up for a free, 15-day trial and see if our reliable uptime monitoring is a good fit for you.

Probe Server Change [OR] and Addition [OT]

The following probe server will be changing IP addresses and location on 2020/01/22:

Portland, Oregon (OR) – USA is changing from
(162.210.173.188 / 2604:b480:ffff:ffff:fa06::10)
to
Hillsboro, Oregon (OR) – USA
(147.135.38.178 / 2604:2dc0:200:b2::10)

We’re also adding a new probe to the North America region on 2020/01/22:
Toronto, Ontario (OT) – CA
(172.105.6.187 / 2600:3c04::f03c:92ff:fe9b:dd03)

Please adjust your firewalls appropriately if you whitelist so your checks do not fail because of the probe IP address changes.

An always current and updated list of all the IP addresses for our probe servers can be found in the FAQ, a text file, and via DNS query, probes.nodeping.com.

[UPDATE – 2020-01-22 13:03GMT-7] – IP change and probe addition complete.

What is Website Monitoring?

You have a website.

It’s the access point of your business. The bridge between you and the world. It’s how potential customers find and judge your business. They scan your landing page, consider your prices and products, and ideally, fork over their money. But what if they couldn’t?

There are a thousand and one reasons your website might be down, but that doesn’t matter to a customer. Every second your website is down is a potential customer lost, and potential income going to a competitor. How many customers can you afford to lose because they try to visit your website when it isn’t working? You need to know the instant your website goes down – a way to check your uptime. That’s where website monitoring comes in.

Website monitoring companies like NodePing periodically check your website and alert you when we can’t connect. We aren’t just some guys sitting at our computers pressing refresh every so often. NodePing has servers all over the world that can check your website as often as once a minute. If our probes cannot connect to your site, or it takes longer than you say it should for the site to respond we’ll immediately crosscheck from different locations globally and notify your contacts quickly so they can get things working again.

You can be alerted by our eight notification methods and all our plans include unlimited international SMS. With notification scheduling, you can choose who gets notified when, so the right people are alerted as soon as possible so you can get your website fixed and back up, making money.

NodePing was created by a pair of nerds who know the challenge of trying to maintain a website. We wanted to create a service that you could set and forget. We don’t have flashy graphs or cute pictures. We just quickly and accurately monitor your uptime. Simple as that.

So what is Website Monitoring? It’s what can save you from losing customers. It saves you money. Buy peace of mind by starting a free trial at NodePing.com.

Probe Server Change [IL]

The following probe server will be changing IP addresses on 2019-12-12:

Chicago, Illinois (IL) – USA

(96.9.222.119 / 2602:ffc8:3d02::190:4ae6)
to
(172.93.197.58 / 2602:ffc8:1:14:225:90ff:fee6:8f90)

 

Please adjust your firewalls appropriately if you whitelist so your checks do not fail because of the probe IP address changes.

An always current and updated list of all the IP addresses for our probe servers can be found in the FAQ, a text file, and via DNS query, probes.nodeping.com.

[UPDATE – 2019-12-12 12:53 GMT-6] – IP change complete.

DNSSEC Monitoring

Your DNSSEC implementation is an important part of increasing authentication for your DNS data. NodePing’s DNS check can now verify DNSSEC authenticated data.

To monitor DNSSEC, NodePing uses public key cryptography to verify the digital signature in the data all the way back to the root servers. If there’s an issue anywhere in the chain, you’ll be the first to know with NodePing’s fast and accurate notifications.

Designed to protect DNS clients from using forged or modified DNS data, DNSSEC ensures the information in the DNS reply is identical to what the owner of the DNS zone has digitally signed and published on their authoritative nameservers.

Only enable DNSSEC verification in your NodePing checks if your nameservers have that functionality.

If you do not yet have a NodePing account, please sign up for our free, 15-day trial. We’re confident you’ll find our uptime monitoring to not only be the fastest and most accurate, but also a great value.

Using NodePing’s API with Python

Over the years, NodePing has offered an API to manage most aspects of your monitoring. Today, we are introducing our new Python 2/3 library to interface with this API. Instead of reinventing the wheel in your code to interact with our API, drop this library into your project and with a few lines you can easily manage your checks and various other aspects of your account. With the Python library at your disposal, you can:

  • List, create, update, and delete checks
  • Manage contacts
  • Manage contact groups
  • Manage schedules
  • Get check results and uptime
  • Get notification information
  • Get probe information

This means that the Python library has feature parity with our API. You can get the code from our GitHub repository or install it from Pypi via pip. There is also some documentation written to help you by providing snippets of what your code might look like when querying the API with Python.

In this post, we will share a brief introduction to getting started with using the Python library and how it can be used to manage your account. You can use your installer of choice, but in this introduction I will use pip to install the library:


pip install nodeping-api

 

You may have to specify Python2 or 3 for your pip version, depending on your system. To start using the library, you will need to provide your API token as a variable, and an optional subaccount ID to start managing your checks.

 

From here, you can do things such as list failing checks:


#!/usr/bin/env python
# -*- coding: utf-8 -*-

""" Demo for Python library
"""

from pprint import pprint
from nodeping_api import get_checks

def main():
    """ Main function
    """

    token = 'my-secret-token'

    query = get_checks.GetChecks(token)
    checks = query.failing_checks()

    pprint(checks)

if __name__ == '__main__':
    main()

 

This example will collect all your failing checks and return them to be used in a dictionary format. The output might look something like this:

{'2019052211307H0IX-KCGJCX1X': {'_id': '2019052211307H0IX-KCGJCX1X',
    'created': 1563471438952,
    'customer_id': '2019052211307H0IX',
    'dep': False,
    'enable': 'active',
    'firstdown': 1563471472497,
    'homeloc': False,
    'interval': 3,
    'label': 'Test Check',
    'modified': 1563471438952,
    'notifications': [],
    'parameters': {'follow': False,
        'ipv6': False,
        'sens': 2,
        'target': 'https://notreal.nodeping.com/',
        'threshold': 5},
    'public': False,
    'queue': 'utcoCpoUJx',
    'runlocations': False,
    'state': 0,
    'status': 'assigned',
    'type': 'HTTP',
    'uuid': 've8s9sgj-j588-4li3-9ytp-1kho9wtutriy'}}

 

You can also create checks. For example, here is a basic idea of creating an HTTP check:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

""" Demo for Python library
"""

from pprint import pprint
from nodeping_api import create_check

def main():
    """ Main function
    """

    token = 'my-secret-token'

    target = 'https://nodeping.com'
    enabled = True
    public = False
    interval = 1
    runlocations = 'nam'

    created = create_check.http_check(
        token,
        target,
        label="Check NodePing",
        enabled=enabled,
        public=public,
        interval=interval,
        runlocations=runlocations
    )

    pprint(created)

if __name__ == '__main__':
    main()

 

Along with the output when the check is created. Note that it is in a dictionary format, but pretty printed so it’s easier to read here:

{'_id': '2019052211307H0IX-WEOR7GAH',
 'change': 1563474539024,
 'created': 1563474539024,
 'customer_id': '2019052211307H0IX',
 'dep': False,
 'enable': 'active',
 'homeloc': False,
 'interval': 1,
 'label': 'Check NodePing',
 'modified': 1563474539024,
 'parameters': {'follow': False,
                'ipv6': False,
                'sens': 2,
                'target': 'https://nodeping.com/',
                'threshold': 5},
 'runlocations': ['nam'],
 'public': False,
 'status': 'modified',
 'type': 'HTTP',
 'uuid': '1fog8q51-zdhv-4vmb-832r-tsun0o9unt3f'}

 

You can also get your uptime from a certain time interval. In this example, you can find what your uptime is since July, 2019

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from nodeping_api import results
from pprint import pprint


def main():
    """
    """

    token = 'my-secret-token'
    check_id = 'my-check-id'

    # Get uptime since July, 2019
    uptime_results = results.get_uptime(token, check_id, start="2019-07")

    pprint(uptime_results)


if __name__ == '__main__':
    main()

 

This will give you an output that looks something like this:
{'2019-07': {'down': 2154131, 'enabled': 2678400000, 'uptime': 99.92},
'2019-08': {'down': 88733, 'enabled': 753256766, 'uptime': 99.988},
'total': {'down': 2242864, 'enabled': 3431656766, 'uptime': 99.935}}

This is only a snippet of what the library can do, and the documentation is detailed to get you started on your journey. Give it a try and see how you can improve your uptime monitoring in your Python projects. This code is free and available to download. We encourage pull requests for new features so if you make changes or have requests, feel free to share.

If you aren’t using NodePing yet, you can sign up for a free, 15-day trial and test out monitoring your services today and take advantage of our API in your own Python projects.

Probe Server Change [OH]

The following probe server will be changing IP addresses on 2019-08-07:

Columbus, Ohio (OH) – USA

(206.222.22.82 / 2001:1828:0:6a::2)
to
(64.79.76.50 / 2001:1828:0:f6::2)

 

Please adjust your firewalls appropriately if you whitelist so your checks do not fail because of the probe IP address changes.

An always current and updated list of all the IP addresses for our probe servers can be found in the FAQ, a text file, and via DNS query, probes.nodeping.com.

[UPDATE – 2019-08-07 15:05 GMT-6] – IP change complete.

Probe Server Addition [PE]

The following probe server will be added on 2019/07/10:

Perth, Australia (PE) – AU
(203.29.240.44 / 2404:9400:4:0:216:3eff:fee1:3c1b)

Please adjust your firewalls appropriately if you whitelist so your checks do not fail because of the probe IP address changes.

An always current and updated list of all the IP addresses for our probe servers can be found in the FAQ, a text file, and via DNS query, probes.nodeping.com.

 

[UPDATE – 2019-07-10 16:24GMT-6] – the addition of the new probe is now complete.

PUSH Client Wizard

Last year, we introduced a new feature called PUSH Checks. This check type allows your server to push numeric metrics into our system, track the metrics, send a heartbeat, and receive alerts based on the results. This is a powerful tool, and we use it internally at NodePing to monitor system load, backup processes, gather metrics from logs, and a variety of other things. We’re also glad to hear about customers using this feature in interesting ways as well.

However, until now setting up a PUSH check could be challenging. You would have to create the check, download a copy of the client and configure it with the Check ID and Checktoken as well as configure the metrics. So today we’re releasing a PUSH Client Wizard (available on GitHub) that makes PUSH Checks really easy to configure and deploy across your systems using an interactive command line wizard. This Python 3 client is able to run on any system with Python 3.5 or newer, and has been tested on Linux, Windows 10, and FreeBSD.

Features

So what can it do? The wizard lets you list your existing PUSH checks, create new PUSH checks, and delete PUSH checks you no longer want.

When listing checks, it will show information such as:

  • Your check’s label
  • ID
  • Checktoken
  • If the check will fail when its results are old
  • PASS/FAIL status
  • If it’s enabled/disabled
  • Run Interval

When creating a check you can configure all sorts of information for the check such as:

  • The client you will use (POSIX, Python, Python3, PowerShell)
  • Information about the check (Label, interval, enabled, public reports, fail when old)
  • Metrics to gather for the check (or none for basic heartbeat functionality) and values for pass/fail
  • Contacts and their notification schedules
  • Client configuration
  • Remote/local deployment

Configuring the client is an optional step if you want to do it yourself. When configuring the client, you have the ability to deploy the new PUSH check client locally or remotely over SSH! Once the client has been configured, a cron job or Windows Task Scheduler event information will be provided so you can simply copy/paste the provided information at the end.

This tool will allow you to quickly and easily manage your PUSH checks so you can monitor your systems with PUSH checks in less time.

Give the wizard a try today!

We encourage pull requests for new features so if you make changes you think others would find useful, please do share.

If you aren’t using NodePing yet, you can sign up for a free, 15-day trial and test out our new PUSH checks yourself and give the new wizard a try.

Check for Silence in Audio Streams

We’re happy to announce a new volume detection feature for audio streams.

Our AUDIO check is great at making sure your stream is up and running but until this update we didn’t have a way to tell if the audio playing was dead air. Silence detection is an important part of providing audio streaming and NodePing can now send you notifications if your Internet radio, podcast, or other audio stream is playing silence instead of your content.

Our volume detection samples 10 seconds of your stream and computes an average decibel level of the audio. If that detected volume level is lower than your configured threshold (-90 to 0 with a default of -45) your AUDIO check will fail and you’ll receive any configured alerts.

Dead air detection takes more resources (CPU, RAM, bandwidth) so the new feature is only available in our “Provider” plan.  If you’re a current NodePing customer and would like to try it out, please let us know and we can provide a temporary free upgrade for you to kick the tires. If you don’t yet have a NodePing account, please sign up for our 15-day, free trial and then go to the billing section and upgrade your trial (still free) to a “Provider” plan to get access to the new feature in your AUDIO checks.

For more information check our AUDIO check documentation or contact us. We’d love to hear what you think of the new feature and what you’d like to see next.