mirror of
https://github.com/mtan93/cachet-url-monitor.git
synced 2026-03-22 21:03:23 +00:00
Compare commits
36 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
0ed87469ce | ||
|
|
bdd74a89c7 | ||
|
|
cb5137c526 | ||
|
|
3830063ba4 | ||
|
|
e4bd02c44f | ||
|
|
e8d4b88c79 | ||
|
|
9f3e2b6eff | ||
|
|
740f726b48 | ||
|
|
a147adda35 | ||
|
|
c59126fd0f | ||
|
|
9ccdc7e5c3 | ||
|
|
96346926cd | ||
|
|
194a07c403 | ||
|
|
fe0325dc9e | ||
|
|
23326fd828 | ||
|
|
969a2b1580 | ||
|
|
b018f9e675 | ||
|
|
d63420ac01 | ||
|
|
a3a91edadc | ||
|
|
2c01d8eb30 | ||
|
|
a83abfd1d3 | ||
|
|
ca358eab2b | ||
|
|
0f53ff8678 | ||
|
|
9c8c89c1dd | ||
|
|
9051f2d9b3 | ||
|
|
15dc800c9b | ||
|
|
8fce82b721 | ||
|
|
d105f73c4b | ||
|
|
e0418e79fc | ||
|
|
6f70206603 | ||
|
|
d7bf54fa0a | ||
|
|
47ff348071 | ||
|
|
f563526a2a | ||
|
|
a91a1ad0ea | ||
|
|
2a385c93b6 | ||
|
|
bcc2e2cf19 |
1
.gitignore
vendored
1
.gitignore
vendored
@@ -10,3 +10,4 @@ share/
|
||||
*.egg-info
|
||||
MANIFEST
|
||||
dist/
|
||||
.idea
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
FROM python:2-onbuild
|
||||
MAINTAINER Mitsuo Takaki <mitsuotakaki@gmail.com>
|
||||
|
||||
VOLUME /usr/src/app/
|
||||
COPY config.yml /usr/src/app/config/
|
||||
VOLUME /usr/src/app/config/
|
||||
|
||||
ENTRYPOINT ["python", "cachet_url_monitor/scheduler.py", "config.yml"]
|
||||
CMD ["python", "cachet_url_monitor/scheduler.py", "config/config.yml"]
|
||||
|
||||
46
README.md
46
README.md
@@ -1,18 +1,26 @@
|
||||
[](https://waffle.io/mtakaki/cachet-url-monitor)
|
||||
# Status
|
||||
|
||||
[](https://coveralls.io/github/mtakaki/cachet-url-monitor?branch=master)
|
||||
[](https://www.codacy.com/app/mitsuotakaki/cachet-url-monitor?utm_source=github.com&utm_medium=referral&utm_content=mtakaki/cachet-url-monitor&utm_campaign=Badge_Grade)
|
||||
[](https://hub.docker.com/r/mtakaki/cachet-url-monitor/)
|
||||
[](https://hub.docker.com/r/mtakaki/cachet-url-monitor/)
|
||||
|
||||
[](https://pypi.python.org/pypi/cachet-url-monitor)
|
||||
|
||||
cachet-url-monitor
|
||||
========================
|
||||
Python plugin for [cachet](cachethq.io) that monitors an URL, verifying it's response status and latency. The frequency the URL is tested is configurable, along with the assertion applied to the request response.
|
||||
|
||||
This project is available at PyPI: [https://pypi.python.org/pypi/cachet-url-monitor](https://pypi.python.org/pypi/cachet-url-monitor)
|
||||
|
||||
## Configuration
|
||||
|
||||
```yaml
|
||||
endpoint:
|
||||
url: http://www.google.com
|
||||
method: GET
|
||||
timeout: 0.010 # seconds
|
||||
timeout: 1 # seconds
|
||||
expectation:
|
||||
- type: HTTP_STATUS
|
||||
status: 200
|
||||
@@ -21,10 +29,13 @@ endpoint:
|
||||
- type: REGEX
|
||||
regex: ".*<body>.*"
|
||||
cachet:
|
||||
api_url: http://status.cachethq.io/api/v1/
|
||||
api_url: http://status.cachethq.io/api/v1
|
||||
token: my_token
|
||||
component_id: 1
|
||||
metric_id: 1
|
||||
action:
|
||||
- CREATE_INCIDENT
|
||||
- UPDATE_STATUS
|
||||
frequency: 30
|
||||
```
|
||||
|
||||
@@ -41,6 +52,9 @@ frequency: 30
|
||||
- **token**, the API token.
|
||||
- **component_id**, the id of the component we're monitoring. This will be used to update the status of the component.
|
||||
- **metric_id**, this will be used to store the latency of the API. If this is not set, it will be ignored.
|
||||
- **action**, the action to be done when one of the expectations fails. This is optional and if left blank, nothing will be done to the component.
|
||||
- **CREATE_INCIDENT**, we will create an incident when the expectation fails.
|
||||
- **UPDATE_STATUS**, updates the component status
|
||||
- **frequency**, how often we'll send a request to the given URL. The unit is in seconds.
|
||||
|
||||
## Setting up
|
||||
@@ -48,7 +62,7 @@ frequency: 30
|
||||
The application should be installed using **virtualenv**, through the following command:
|
||||
|
||||
```
|
||||
$ git clone git@github.com:mtakaki/cachet-url-monitor.git
|
||||
$ git clone https://github.com/mtakaki/cachet-url-monitor.git
|
||||
$ virtualenv cachet-url-monitor
|
||||
$ cd cachet-url-monitor
|
||||
$ source bin/activate
|
||||
@@ -59,4 +73,28 @@ To start the agent:
|
||||
|
||||
```
|
||||
$ python cachet_url_monitor/scheduler.py config.yml
|
||||
```
|
||||
```
|
||||
|
||||
## Docker
|
||||
|
||||
You can run the agent in docker, so you won't need to worry about installing python, virtualenv, or any other dependency into your OS. The `Dockerfile` and `docker-compose.yml` files are already checked in and it's ready to be used.
|
||||
|
||||
To start the agent in a container using docker compose:
|
||||
|
||||
```
|
||||
$ docker-compose build
|
||||
$ docker-compose up
|
||||
```
|
||||
|
||||
Or pulling directly from [dockerhub](https://hub.docker.com/r/mtakaki/cachet-url-monitor/). You will need to create your own custom `config.yml` file and run (it will pull latest):
|
||||
|
||||
```
|
||||
$ docker pull mtakaki/cachet-url-monitor
|
||||
$ docker run --rm -it -v "$PWD":/usr/src/app/config/ mtakaki/cachet-url-monitor
|
||||
```
|
||||
|
||||
If you're going to use a file with a name other than `config.yml`, you will need to map the local file, like this:
|
||||
|
||||
```
|
||||
$ docker run --rm -it -v "$PWD"/my_config.yml:/usr/src/app/config/config.yml:ro mtakaki/cachet-url-monitor:0.2
|
||||
```
|
||||
|
||||
@@ -1,91 +1,271 @@
|
||||
#!/usr/bin/env python
|
||||
import abc
|
||||
import copy
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
import time
|
||||
|
||||
import requests
|
||||
import timeit
|
||||
from yaml import dump
|
||||
from yaml import load
|
||||
|
||||
import status as st
|
||||
|
||||
# This is the mandatory fields that must be in the configuration file in this
|
||||
# same exact structure.
|
||||
configuration_mandatory_fields = {
|
||||
'endpoint': ['url', 'method', 'timeout', 'expectation'],
|
||||
'cachet': ['api_url', 'token', 'component_id'],
|
||||
'frequency': []}
|
||||
|
||||
|
||||
class ConfigurationValidationError(Exception):
|
||||
"""Exception raised when there's a validation error."""
|
||||
|
||||
def __init__(self, value):
|
||||
self.value = value
|
||||
|
||||
def __str__(self):
|
||||
return repr(self.value)
|
||||
|
||||
|
||||
class ComponentNonexistentError(Exception):
|
||||
"""Exception raised when the component does not exist."""
|
||||
|
||||
def __init__(self, component_id):
|
||||
self.component_id = component_id
|
||||
|
||||
def __str__(self):
|
||||
return repr('Component with id [%d] does not exist.' % (self.component_id,))
|
||||
|
||||
|
||||
def get_current_status(endpoint_url, component_id, headers):
|
||||
"""Retrieves the current status of the component that is being monitored. It will fail if the component does
|
||||
not exist or doesn't respond with the expected data.
|
||||
:return component status.
|
||||
"""
|
||||
get_status_request = requests.get('%s/components/%s' % (endpoint_url, component_id), headers=headers)
|
||||
|
||||
if get_status_request.ok:
|
||||
# The component exists.
|
||||
return get_status_request.json()['data']['status']
|
||||
else:
|
||||
raise ComponentNonexistentError(component_id)
|
||||
|
||||
|
||||
class Configuration(object):
|
||||
"""Represents a configuration file, but it also includes the functionality
|
||||
of assessing the API and pushing the results to cachet.
|
||||
"""
|
||||
|
||||
def __init__(self, config_file):
|
||||
#TODO(mtakaki|2016-04-26): Needs validation if the config is correct.
|
||||
#TODO(mtakaki|2016-04-28): Accept overriding settings using environment
|
||||
# variables so we have a more docker-friendly approach.
|
||||
self.logger = logging.getLogger('cachet_url_monitor.configuration.Configuration')
|
||||
self.config_file = config_file
|
||||
self.data = load(file(self.config_file, 'r'))
|
||||
self.expectations = [Expectaction.create(expectation) for expectation
|
||||
in self.data['endpoint']['expectation']]
|
||||
|
||||
# Exposing the configuration to confirm it's parsed as expected.
|
||||
self.print_out()
|
||||
|
||||
# We need to validate the configuration is correct and then validate the component actually exists.
|
||||
self.validate()
|
||||
|
||||
# We store the main information from the configuration file, so we don't keep reading from the data dictionary.
|
||||
self.headers = {'X-Cachet-Token': os.environ.get('CACHET_TOKEN') or self.data['cachet']['token']}
|
||||
|
||||
self.endpoint_method = os.environ.get('ENDPOINT_METHOD') or self.data['endpoint']['method']
|
||||
self.endpoint_url = os.environ.get('ENDPOINT_URL') or self.data['endpoint']['url']
|
||||
self.endpoint_timeout = os.environ.get('ENDPOINT_TIMEOUT') or self.data['endpoint'].get('timeout') or 1
|
||||
|
||||
self.api_url = os.environ.get('CACHET_API_URL') or self.data['cachet']['api_url']
|
||||
self.component_id = os.environ.get('CACHET_COMPONENT_ID') or self.data['cachet']['component_id']
|
||||
self.metric_id = os.environ.get('CACHET_METRIC_ID') or self.data['cachet'].get('metric_id')
|
||||
|
||||
# We need the current status so we monitor the status changes. This is necessary for creating incidents.
|
||||
self.status = get_current_status(self.api_url, self.component_id, self.headers)
|
||||
|
||||
self.logger.info('Monitoring URL: %s %s' % (self.endpoint_method, self.endpoint_url))
|
||||
self.expectations = [Expectaction.create(expectation) for expectation in self.data['endpoint']['expectation']]
|
||||
for expectation in self.expectations:
|
||||
self.logger.info('Registered expectation: %s' % (expectation,))
|
||||
|
||||
def is_create_incident(self):
|
||||
"""Will verify if the configuration is set to create incidents or not.
|
||||
:return True if the configuration is set to create incidents or False it otherwise.
|
||||
"""
|
||||
return 'create_incident' in self.data['cachet'] and self.data['cachet']['create_incident']
|
||||
|
||||
def is_update_status(self):
|
||||
"""Will verify if the configuration is set to update status or not.
|
||||
:return True if the configuration is set to update status or False it otherwise.
|
||||
"""
|
||||
return 'update_status' in self.data['cachet'] and self.data['cachet']['update_status']
|
||||
|
||||
def get_action(self):
|
||||
"""Retrieves the action list from the configuration. If it's empty, returns an empty list.
|
||||
:return: The list of actions, which can be an empty list.
|
||||
"""
|
||||
if self.data['cachet'].get('action') is None:
|
||||
return []
|
||||
else:
|
||||
return self.data['cachet']['action']
|
||||
|
||||
def validate(self):
|
||||
"""Validates the configuration by verifying the mandatory fields are
|
||||
present and in the correct format. If the validation fails, a
|
||||
ConfigurationValidationError is raised. Otherwise nothing will happen.
|
||||
"""
|
||||
configuration_errors = []
|
||||
for key, sub_entries in configuration_mandatory_fields.iteritems():
|
||||
if key not in self.data:
|
||||
configuration_errors.append(key)
|
||||
|
||||
for sub_key in sub_entries:
|
||||
if sub_key not in self.data[key]:
|
||||
configuration_errors.append('%s.%s' % (key, sub_key))
|
||||
|
||||
if ('endpoint' in self.data and 'expectation' in
|
||||
self.data['endpoint']):
|
||||
if (not isinstance(self.data['endpoint']['expectation'], list) or
|
||||
(isinstance(self.data['endpoint']['expectation'], list) and
|
||||
len(self.data['endpoint']['expectation']) == 0)):
|
||||
configuration_errors.append('endpoint.expectation')
|
||||
|
||||
if len(configuration_errors) > 0:
|
||||
raise ConfigurationValidationError(
|
||||
'Config file [%s] failed validation. Missing keys: %s' % (self.config_file,
|
||||
', '.join(configuration_errors)))
|
||||
|
||||
def evaluate(self):
|
||||
"""Sends the request to the URL set in the configuration and executes
|
||||
each one of the expectations, one by one. The status will be updated
|
||||
according to the expectation results.
|
||||
"""
|
||||
try:
|
||||
self.request = requests.request(self.data['endpoint']['method'],
|
||||
self.data['endpoint']['url'],
|
||||
timeout=self.data['endpoint']['timeout'])
|
||||
self.request = requests.request(self.endpoint_method, self.endpoint_url, timeout=self.endpoint_timeout)
|
||||
self.current_timestamp = int(time.time())
|
||||
except requests.ConnectionError:
|
||||
self.logger.warning('The URL is unreachable: %s %s' %
|
||||
(self.data['endpoint']['method'],
|
||||
self.data['endpoint']['url']))
|
||||
self.status = 3
|
||||
self.message = 'The URL is unreachable: %s %s' % (self.endpoint_method, self.endpoint_url)
|
||||
self.logger.warning(self.message)
|
||||
self.status = st.COMPONENT_STATUS_PARTIAL_OUTAGE
|
||||
return
|
||||
except requests.HTTPError:
|
||||
self.logger.exception('Unexpected HTTP response')
|
||||
self.status = 3
|
||||
self.message = 'Unexpected HTTP response'
|
||||
self.logger.exception(self.message)
|
||||
self.status = st.COMPONENT_STATUS_PARTIAL_OUTAGE
|
||||
return
|
||||
except requests.Timeout:
|
||||
self.logger.warning('Request timed out')
|
||||
self.status = 3
|
||||
self.message = 'Request timed out'
|
||||
self.logger.warning(self.message)
|
||||
self.status = st.COMPONENT_STATUS_PERFORMANCE_ISSUES
|
||||
return
|
||||
|
||||
# We initially assume the API is healthy.
|
||||
self.status = 1
|
||||
self.status = st.COMPONENT_STATUS_OPERATIONAL
|
||||
self.message = ''
|
||||
for expectation in self.expectations:
|
||||
status = expectation.get_status(self.request)
|
||||
|
||||
# The greater the status is, the worse the state of the API is.
|
||||
if status > self.status:
|
||||
self.status = status
|
||||
self.message = expectation.get_message(self.request)
|
||||
self.logger.info(self.message)
|
||||
|
||||
def push_status_and_metrics(self):
|
||||
params = {'id': self.data['cachet']['component_id'], 'status':
|
||||
self.status}
|
||||
headers = {'X-Cachet-Token': self.data['cachet']['token']}
|
||||
component_request = requests.put('%s/components/%d' %
|
||||
(self.data['cachet']['api_url'],
|
||||
self.data['cachet']['component_id']),
|
||||
params=params, headers=headers)
|
||||
if component_request.status_code == 200:
|
||||
def print_out(self):
|
||||
self.logger.info('Current configuration:\n%s' % (self.__repr__()))
|
||||
|
||||
def __repr__(self):
|
||||
temporary_data = copy.deepcopy(self.data)
|
||||
# Removing the token so we don't leak it in the logs.
|
||||
del temporary_data['cachet']['token']
|
||||
return dump(temporary_data, default_flow_style=False)
|
||||
|
||||
def push_status(self):
|
||||
"""Pushes the status of the component to the cachet server. It will update the component
|
||||
status based on the previous call to evaluate().
|
||||
"""
|
||||
params = {'id': self.component_id, 'status': self.status}
|
||||
component_request = requests.put('%s/components/%d' % (self.api_url, self.component_id), params=params,
|
||||
headers=self.headers)
|
||||
if component_request.ok:
|
||||
# Successful update
|
||||
self.logger.info('Component update: status [%d]' % (self.status,))
|
||||
else:
|
||||
# Failed to update the API status
|
||||
self.logger.warning('Component update failed with status [%d]: API'
|
||||
' status: [%d]' % (component_request.status_code, self.status))
|
||||
' status: [%d]' % (component_request.status_code, self.status))
|
||||
|
||||
def push_metrics(self):
|
||||
"""Pushes the total amount of seconds the request took to get a response from the URL.
|
||||
It only will send a request if the metric id was set in the configuration.
|
||||
"""
|
||||
if 'metric_id' in self.data['cachet'] and hasattr(self, 'request'):
|
||||
params = {'id': self.metric_id, 'value': self.request.elapsed.total_seconds(),
|
||||
'timestamp': self.current_timestamp}
|
||||
metrics_request = requests.post('%s/metrics/%d/points' % (self.api_url, self.metric_id), params=params,
|
||||
headers=self.headers)
|
||||
|
||||
if metrics_request.ok:
|
||||
# Successful metrics upload
|
||||
self.logger.info('Metric uploaded: %.6f seconds' %
|
||||
(self.request.elapsed.total_seconds(),))
|
||||
else:
|
||||
self.logger.warning('Metric upload failed with status [%d]' %
|
||||
(metrics_request.status_code,))
|
||||
|
||||
def push_incident(self):
|
||||
"""If the component status has changed, we create a new incident (if this is the first time it becomes unstable)
|
||||
or updates the existing incident once it becomes healthy again.
|
||||
"""
|
||||
if hasattr(self, 'incident_id') and self.status == st.COMPONENT_STATUS_OPERATIONAL:
|
||||
# If the incident already exists, it means it was unhealthy but now it's healthy again.
|
||||
params = {'status': 4, 'visible': 1, 'component_id': self.component_id, 'component_status': self.status,
|
||||
'notify': True}
|
||||
|
||||
incident_request = requests.put('%s/incidents/%d' % (self.api_url, self.incident_id), params=params,
|
||||
headers=self.headers)
|
||||
if incident_request.ok:
|
||||
# Successful metrics upload
|
||||
self.logger.info(
|
||||
'Incident updated, API healthy again: component status [%d], message: "%s"' % (
|
||||
self.status, self.message))
|
||||
del self.incident_id
|
||||
else:
|
||||
self.logger.warning('Incident update failed with status [%d], message: "%s"' % (
|
||||
incident_request.status_code, self.message))
|
||||
elif not hasattr(self, 'incident_id') and self.status != st.COMPONENT_STATUS_OPERATIONAL:
|
||||
# This is the first time the incident is being created.
|
||||
params = {'name': 'URL unavailable', 'message': self.message, 'status': 1, 'visible': 1,
|
||||
'component_id': self.component_id, 'component_status': self.status, 'notify': True}
|
||||
incident_request = requests.post('%s/incidents' % (self.api_url,), params=params, headers=self.headers)
|
||||
if incident_request.ok:
|
||||
# Successful incident upload.
|
||||
self.incident_id = incident_request.json()['data']['id']
|
||||
self.logger.info(
|
||||
'Incident uploaded, API unhealthy: component status [%d], message: "%s"' % (
|
||||
self.status, self.message))
|
||||
else:
|
||||
self.logger.warning(
|
||||
'Incident upload failed with status [%d], message: "%s"' % (
|
||||
incident_request.status_code, self.message))
|
||||
|
||||
|
||||
class Expectaction(object):
|
||||
"""Base class for URL result expectations. Any new excpectation should extend
|
||||
this class and the name added to create() method.
|
||||
"""
|
||||
|
||||
@staticmethod
|
||||
def create(configuration):
|
||||
"""Creates a list of expectations based on the configuration types
|
||||
list.
|
||||
"""
|
||||
expectations = {
|
||||
'HTTP_STATUS': HttpStatus,
|
||||
'LATENCY': Latency,
|
||||
'REGEX': Regex
|
||||
}
|
||||
'HTTP_STATUS': HttpStatus,
|
||||
'LATENCY': Latency,
|
||||
'REGEX': Regex
|
||||
}
|
||||
return expectations.get(configuration['type'])(configuration)
|
||||
|
||||
@abc.abstractmethod
|
||||
@@ -105,13 +285,16 @@ class HttpStatus(Expectaction):
|
||||
|
||||
def get_status(self, response):
|
||||
if response.status_code == self.status:
|
||||
return 1
|
||||
return st.COMPONENT_STATUS_OPERATIONAL
|
||||
else:
|
||||
return 3
|
||||
return st.COMPONENT_STATUS_PARTIAL_OUTAGE
|
||||
|
||||
def get_message(self, response):
|
||||
return 'Unexpected HTTP status (%s)' % (response.status_code,)
|
||||
|
||||
def __str__(self):
|
||||
return repr('HTTP status: %s' % (self.status,))
|
||||
|
||||
|
||||
class Latency(Expectaction):
|
||||
def __init__(self, configuration):
|
||||
@@ -119,23 +302,30 @@ class Latency(Expectaction):
|
||||
|
||||
def get_status(self, response):
|
||||
if response.elapsed.total_seconds() <= self.threshold:
|
||||
return 1
|
||||
return st.COMPONENT_STATUS_OPERATIONAL
|
||||
else:
|
||||
return 2
|
||||
return st.COMPONENT_STATUS_PERFORMANCE_ISSUES
|
||||
|
||||
def get_message(self, response):
|
||||
return 'Latency above threshold: %.4f' % (response.elapsed.total_seconds(),)
|
||||
return 'Latency above threshold: %.4f seconds' % (response.elapsed.total_seconds(),)
|
||||
|
||||
def __str__(self):
|
||||
return repr('Latency threshold: %.4f seconds' % (self.threshold,))
|
||||
|
||||
|
||||
class Regex(Expectaction):
|
||||
def __init__(self, configuration):
|
||||
self.regex = re.compile(configuration['regex'])
|
||||
self.regex_string = configuration['regex']
|
||||
self.regex = re.compile(configuration['regex'], re.UNICODE + re.DOTALL)
|
||||
|
||||
def get_status(self, response):
|
||||
if self.regex.match(response.text):
|
||||
return 1
|
||||
return st.COMPONENT_STATUS_OPERATIONAL
|
||||
else:
|
||||
return 3
|
||||
return st.COMPONENT_STATUS_PARTIAL_OUTAGE
|
||||
|
||||
def get_message(self, response):
|
||||
return 'Regex did not match anything in the body'
|
||||
|
||||
def __str__(self):
|
||||
return repr('Regex: %s' % (self.regex_string,))
|
||||
|
||||
@@ -1,37 +1,73 @@
|
||||
#!/usr/bin/env python
|
||||
from configuration import Configuration
|
||||
import logging
|
||||
import schedule
|
||||
import sys
|
||||
import time
|
||||
|
||||
import schedule
|
||||
|
||||
from configuration import Configuration
|
||||
|
||||
|
||||
class Agent(object):
|
||||
"""Monitor agent that will be constantly verifying if the URL is healthy
|
||||
and updating the component.
|
||||
"""
|
||||
def __init__(self, configuration):
|
||||
|
||||
def __init__(self, configuration, decorators=None):
|
||||
self.configuration = configuration
|
||||
if decorators is None:
|
||||
decorators = []
|
||||
self.decorators = decorators
|
||||
|
||||
def execute(self):
|
||||
"""Will verify the API status and push the status and metrics to the
|
||||
cachet server.
|
||||
"""
|
||||
self.configuration.evaluate()
|
||||
self.configuration.push_status_and_metrics()
|
||||
self.configuration.push_metrics()
|
||||
|
||||
for decorator in self.decorators:
|
||||
decorator.execute(self.configuration)
|
||||
|
||||
def start(self):
|
||||
"""Sets up the schedule based on the configuration file."""
|
||||
schedule.every(self.configuration.data['frequency']).seconds.do(self.execute)
|
||||
|
||||
|
||||
class Decorator(object):
|
||||
def execute(self, configuration):
|
||||
pass
|
||||
|
||||
|
||||
class UpdateStatusDecorator(Decorator):
|
||||
def execute(self, configuration):
|
||||
configuration.push_status()
|
||||
|
||||
|
||||
class CreateIncidentDecorator(Decorator):
|
||||
def execute(self, configuration):
|
||||
configuration.push_incident()
|
||||
|
||||
|
||||
class Scheduler(object):
|
||||
def __init__(self, config_file):
|
||||
self.logger = logging.getLogger('cachet_url_monitor.scheduler.Scheduler')
|
||||
self.configuration = Configuration(config_file)
|
||||
self.agent = Agent(self.configuration)
|
||||
self.agent = self.get_agent()
|
||||
|
||||
self.stop = False
|
||||
|
||||
def get_agent(self):
|
||||
action_names = {
|
||||
'CREATE_INCIDENT': CreateIncidentDecorator,
|
||||
'UPDATE_STATUS': UpdateStatusDecorator,
|
||||
}
|
||||
actions = []
|
||||
for action in self.configuration.get_action():
|
||||
self.logger.info('Registering action %s' % (action))
|
||||
actions.append(action_names[action]())
|
||||
return Agent(self.configuration, decorators=actions)
|
||||
|
||||
def start(self):
|
||||
self.agent.start()
|
||||
self.logger.info('Starting monitor agent...')
|
||||
|
||||
10
cachet_url_monitor/status.py
Normal file
10
cachet_url_monitor/status.py
Normal file
@@ -0,0 +1,10 @@
|
||||
#!/usr/bin/env python
|
||||
|
||||
COMPONENT_STATUS_OPERATIONAL = 1
|
||||
COMPONENT_STATUS_PERFORMANCE_ISSUES = 2
|
||||
COMPONENT_STATUS_PARTIAL_OUTAGE = 3
|
||||
COMPONENT_STATUS_MAJOR_OUTAGE = 4
|
||||
|
||||
COMPONENT_STATUSES = [COMPONENT_STATUS_OPERATIONAL,
|
||||
COMPONENT_STATUS_PERFORMANCE_ISSUES, COMPONENT_STATUS_PARTIAL_OUTAGE,
|
||||
COMPONENT_STATUS_MAJOR_OUTAGE]
|
||||
11
config.yml
11
config.yml
@@ -1,17 +1,20 @@
|
||||
endpoint:
|
||||
url: http://localhost:8080/swagger
|
||||
method: GET
|
||||
timeout: 0.01
|
||||
timeout: 1
|
||||
expectation:
|
||||
- type: HTTP_STATUS
|
||||
status: 200
|
||||
- type: LATENCY
|
||||
threshold: 1
|
||||
- type: REGEX
|
||||
regex: ".*<body>.*"
|
||||
regex: '.*(<body).*'
|
||||
cachet:
|
||||
api_url: http://status.cachethq.io/api/v1/
|
||||
api_url: https://demo.cachethq.io/api/v1
|
||||
token: my_token
|
||||
component_id: 1
|
||||
metric_id: 1
|
||||
#metric_id: 1
|
||||
action:
|
||||
- CREATE_INCIDENT
|
||||
- UPDATE_STATUS
|
||||
frequency: 30
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
PyYAML==3.11
|
||||
codacy-coverage==1.2.18
|
||||
ipython==4.2.0
|
||||
mock==2.0.0
|
||||
pudb==2016.1
|
||||
|
||||
2
setup.py
2
setup.py
@@ -2,7 +2,7 @@
|
||||
from distutils.core import setup
|
||||
|
||||
setup(name='cachet-url-monitor',
|
||||
version='0.1',
|
||||
version='0.3',
|
||||
description='Cachet URL monitor plugin',
|
||||
author='Mitsuo Takaki',
|
||||
author_email='mitsuotakaki@gmail.com',
|
||||
|
||||
@@ -1,31 +1,53 @@
|
||||
#!/usr/bin/env python
|
||||
import mock
|
||||
import unittest
|
||||
import sys
|
||||
from requests import ConnectionError,HTTPError,Timeout
|
||||
import unittest
|
||||
|
||||
import cachet_url_monitor.status
|
||||
import mock
|
||||
from requests import ConnectionError, HTTPError, Timeout
|
||||
|
||||
sys.modules['requests'] = mock.Mock()
|
||||
sys.modules['logging'] = mock.Mock()
|
||||
from cachet_url_monitor.configuration import Configuration
|
||||
from test.test_support import EnvironmentVarGuard
|
||||
|
||||
|
||||
class ConfigurationTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
def getLogger(name):
|
||||
self.mock_logger = mock.Mock()
|
||||
return self.mock_logger
|
||||
|
||||
sys.modules['logging'].getLogger = getLogger
|
||||
|
||||
def get(url, headers):
|
||||
get_return = mock.Mock()
|
||||
get_return.ok = True
|
||||
get_return.json = mock.Mock()
|
||||
get_return.json.return_value = {'data': {'status': 1}}
|
||||
return get_return
|
||||
|
||||
sys.modules['requests'].get = get
|
||||
|
||||
self.env = EnvironmentVarGuard()
|
||||
self.env.set('CACHET_TOKEN', 'token2')
|
||||
|
||||
self.configuration = Configuration('config.yml')
|
||||
sys.modules['requests'].Timeout = Timeout
|
||||
sys.modules['requests'].ConnectionError = ConnectionError
|
||||
sys.modules['requests'].HTTPError = HTTPError
|
||||
|
||||
def test_init(self):
|
||||
assert len(self.configuration.data) == 3
|
||||
assert len(self.configuration.expectations) == 3
|
||||
self.assertEqual(len(self.configuration.data), 3, 'Configuration data size is incorrect')
|
||||
self.assertEquals(len(self.configuration.expectations), 3, 'Number of expectations read from file is incorrect')
|
||||
self.assertDictEqual(self.configuration.headers, {'X-Cachet-Token': 'token2'}, 'Header was not set correctly')
|
||||
self.assertEquals(self.configuration.api_url, 'https://demo.cachethq.io/api/v1',
|
||||
'Cachet API URL was set incorrectly')
|
||||
|
||||
def test_evaluate(self):
|
||||
def total_seconds():
|
||||
return 0.1
|
||||
|
||||
def request(method, url, timeout=None):
|
||||
response = mock.Mock()
|
||||
response.status_code = 200
|
||||
@@ -37,11 +59,13 @@ class ConfigurationTest(unittest.TestCase):
|
||||
sys.modules['requests'].request = request
|
||||
self.configuration.evaluate()
|
||||
|
||||
assert self.configuration.status == 1
|
||||
self.assertEquals(self.configuration.status, cachet_url_monitor.status.COMPONENT_STATUS_OPERATIONAL,
|
||||
'Component status set incorrectly')
|
||||
|
||||
def test_evaluate_with_failure(self):
|
||||
def total_seconds():
|
||||
return 0.1
|
||||
|
||||
def request(method, url, timeout=None):
|
||||
response = mock.Mock()
|
||||
# We are expecting a 200 response, so this will fail the expectation.
|
||||
@@ -54,76 +78,80 @@ class ConfigurationTest(unittest.TestCase):
|
||||
sys.modules['requests'].request = request
|
||||
self.configuration.evaluate()
|
||||
|
||||
assert self.configuration.status == 3
|
||||
self.assertEquals(self.configuration.status, cachet_url_monitor.status.COMPONENT_STATUS_PARTIAL_OUTAGE,
|
||||
'Component status set incorrectly')
|
||||
|
||||
def test_evaluate_with_timeout(self):
|
||||
def request(method, url, timeout=None):
|
||||
assert method == 'GET'
|
||||
assert url == 'http://localhost:8080/swagger'
|
||||
assert timeout == 0.010
|
||||
self.assertEquals(method, 'GET', 'Incorrect HTTP method')
|
||||
self.assertEquals(url, 'http://localhost:8080/swagger', 'Monitored URL is incorrect')
|
||||
self.assertEquals(timeout, 0.010)
|
||||
|
||||
raise Timeout()
|
||||
|
||||
sys.modules['requests'].request = request
|
||||
self.configuration.evaluate()
|
||||
|
||||
assert self.configuration.status == 3
|
||||
self.assertEquals(self.configuration.status, cachet_url_monitor.status.COMPONENT_STATUS_PERFORMANCE_ISSUES,
|
||||
'Component status set incorrectly')
|
||||
self.mock_logger.warning.assert_called_with('Request timed out')
|
||||
|
||||
def test_evaluate_with_connection_error(self):
|
||||
def request(method, url, timeout=None):
|
||||
assert method == 'GET'
|
||||
assert url == 'http://localhost:8080/swagger'
|
||||
assert timeout == 0.010
|
||||
self.assertEquals(method, 'GET', 'Incorrect HTTP method')
|
||||
self.assertEquals(url, 'http://localhost:8080/swagger', 'Monitored URL is incorrect')
|
||||
self.assertEquals(timeout, 0.010)
|
||||
|
||||
raise ConnectionError()
|
||||
|
||||
sys.modules['requests'].request = request
|
||||
self.configuration.evaluate()
|
||||
|
||||
assert self.configuration.status == 3
|
||||
self.mock_logger.warning.assert_called_with(('The URL is '
|
||||
'unreachable: GET http://localhost:8080/swagger'))
|
||||
self.assertEquals(self.configuration.status, cachet_url_monitor.status.COMPONENT_STATUS_PARTIAL_OUTAGE,
|
||||
'Component status set incorrectly')
|
||||
self.mock_logger.warning.assert_called_with('The URL is unreachable: GET http://localhost:8080/swagger')
|
||||
|
||||
def test_evaluate_with_http_error(self):
|
||||
def request(method, url, timeout=None):
|
||||
assert method == 'GET'
|
||||
assert url == 'http://localhost:8080/swagger'
|
||||
assert timeout == 0.010
|
||||
self.assertEquals(method, 'GET', 'Incorrect HTTP method')
|
||||
self.assertEquals(url, 'http://localhost:8080/swagger', 'Monitored URL is incorrect')
|
||||
self.assertEquals(timeout, 0.010)
|
||||
|
||||
raise HTTPError()
|
||||
|
||||
sys.modules['requests'].request = request
|
||||
self.configuration.evaluate()
|
||||
|
||||
assert self.configuration.status == 3
|
||||
self.mock_logger.exception.assert_called_with(('Unexpected HTTP '
|
||||
'response'))
|
||||
self.assertEquals(self.configuration.status, cachet_url_monitor.status.COMPONENT_STATUS_PARTIAL_OUTAGE,
|
||||
'Component status set incorrectly')
|
||||
self.mock_logger.exception.assert_called_with('Unexpected HTTP response')
|
||||
|
||||
def test_push_status_and_metrics(self):
|
||||
def test_push_status(self):
|
||||
def put(url, params=None, headers=None):
|
||||
assert url == 'http://status.cachethq.io/api/v1//components/1'
|
||||
assert params == {'id': 1, 'status': 1}
|
||||
assert headers == {'X-Cachet-Token': 'my_token'}
|
||||
self.assertEquals(url, 'https://demo.cachethq.io/api/v1/components/1', 'Incorrect cachet API URL')
|
||||
self.assertDictEqual(params, {'id': 1, 'status': 1}, 'Incorrect component update parameters')
|
||||
self.assertDictEqual(headers, {'X-Cachet-Token': 'token2'}, 'Incorrect component update parameters')
|
||||
|
||||
response = mock.Mock()
|
||||
response.status_code = 200
|
||||
return response
|
||||
|
||||
sys.modules['requests'].put = put
|
||||
self.configuration.status = 1
|
||||
self.configuration.push_status_and_metrics()
|
||||
self.assertEquals(self.configuration.status, cachet_url_monitor.status.COMPONENT_STATUS_OPERATIONAL,
|
||||
'Incorrect component update parameters')
|
||||
self.configuration.push_status()
|
||||
|
||||
def test_push_status_and_metrics_with_failure(self):
|
||||
def test_push_status_with_failure(self):
|
||||
def put(url, params=None, headers=None):
|
||||
assert url == 'http://status.cachethq.io/api/v1//components/1'
|
||||
assert params == {'id': 1, 'status': 1}
|
||||
assert headers == {'X-Cachet-Token': 'my_token'}
|
||||
self.assertEquals(url, 'https://demo.cachethq.io/api/v1/components/1', 'Incorrect cachet API URL')
|
||||
self.assertDictEqual(params, {'id': 1, 'status': 1}, 'Incorrect component update parameters')
|
||||
self.assertDictEqual(headers, {'X-Cachet-Token': 'token2'}, 'Incorrect component update parameters')
|
||||
|
||||
response = mock.Mock()
|
||||
response.status_code = 300
|
||||
response.status_code = 400
|
||||
return response
|
||||
|
||||
sys.modules['requests'].put = put
|
||||
self.configuration.status = 1
|
||||
self.configuration.push_status_and_metrics()
|
||||
self.assertEquals(self.configuration.status, cachet_url_monitor.status.COMPONENT_STATUS_OPERATIONAL,
|
||||
'Incorrect component update parameters')
|
||||
self.configuration.push_status()
|
||||
|
||||
@@ -1,9 +1,10 @@
|
||||
#!/usr/bin/env python
|
||||
import unittest
|
||||
|
||||
import mock
|
||||
import re
|
||||
import unittest
|
||||
from cachet_url_monitor.configuration import Expectaction,Latency
|
||||
from cachet_url_monitor.configuration import HttpStatus,Regex
|
||||
from cachet_url_monitor.configuration import HttpStatus, Regex
|
||||
from cachet_url_monitor.configuration import Latency
|
||||
|
||||
|
||||
class LatencyTest(unittest.TestCase):
|
||||
@@ -16,6 +17,7 @@ class LatencyTest(unittest.TestCase):
|
||||
def test_get_status_healthy(self):
|
||||
def total_seconds():
|
||||
return 0.1
|
||||
|
||||
request = mock.Mock()
|
||||
elapsed = mock.Mock()
|
||||
request.elapsed = elapsed
|
||||
@@ -26,6 +28,7 @@ class LatencyTest(unittest.TestCase):
|
||||
def test_get_status_unhealthy(self):
|
||||
def total_seconds():
|
||||
return 2
|
||||
|
||||
request = mock.Mock()
|
||||
elapsed = mock.Mock()
|
||||
request.elapsed = elapsed
|
||||
@@ -36,13 +39,14 @@ class LatencyTest(unittest.TestCase):
|
||||
def test_get_message(self):
|
||||
def total_seconds():
|
||||
return 0.1
|
||||
|
||||
request = mock.Mock()
|
||||
elapsed = mock.Mock()
|
||||
request.elapsed = elapsed
|
||||
elapsed.total_seconds = total_seconds
|
||||
|
||||
assert self.expectation.get_message(request) == ('Latency above '
|
||||
'threshold: 0.1000')
|
||||
'threshold: 0.1000 seconds')
|
||||
|
||||
|
||||
class HttpStatusTest(unittest.TestCase):
|
||||
@@ -69,7 +73,7 @@ class HttpStatusTest(unittest.TestCase):
|
||||
request.status_code = 400
|
||||
|
||||
assert self.expectation.get_message(request) == ('Unexpected HTTP '
|
||||
'status (400)')
|
||||
'status (400)')
|
||||
|
||||
|
||||
class RegexTest(unittest.TestCase):
|
||||
@@ -77,11 +81,11 @@ class RegexTest(unittest.TestCase):
|
||||
self.expectation = Regex({'type': 'REGEX', 'regex': '.*(find stuff).*'})
|
||||
|
||||
def test_init(self):
|
||||
assert self.expectation.regex == re.compile('.*(find stuff).*')
|
||||
assert self.expectation.regex == re.compile('.*(find stuff).*', re.UNICODE + re.DOTALL)
|
||||
|
||||
def test_get_status_healthy(self):
|
||||
request = mock.Mock()
|
||||
request.text = 'We could find stuff in this body.'
|
||||
request.text = 'We could find stuff\n in this body.'
|
||||
|
||||
assert self.expectation.get_status(request) == 1
|
||||
|
||||
@@ -96,4 +100,4 @@ class RegexTest(unittest.TestCase):
|
||||
request.text = 'We will not find it here'
|
||||
|
||||
assert self.expectation.get_message(request) == ('Regex did not match '
|
||||
'anything in the body')
|
||||
'anything in the body')
|
||||
|
||||
@@ -1,10 +1,11 @@
|
||||
#!/usr/bin/env python
|
||||
import mock
|
||||
import unittest
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
import mock
|
||||
|
||||
sys.modules['schedule'] = mock.Mock()
|
||||
sys.modules['cachet_url_monitor.configuration.Configuration'] = mock.Mock()
|
||||
from cachet_url_monitor.scheduler import Agent,Scheduler
|
||||
from cachet_url_monitor.scheduler import Agent, Scheduler
|
||||
|
||||
|
||||
class AgentTest(unittest.TestCase):
|
||||
@@ -17,11 +18,11 @@ class AgentTest(unittest.TestCase):
|
||||
|
||||
def test_execute(self):
|
||||
evaluate = self.configuration.evaluate
|
||||
push_status_and_metrics = self.configuration.push_status_and_metrics
|
||||
push_status = self.configuration.push_status
|
||||
self.agent.execute()
|
||||
|
||||
evaluate.assert_called_once()
|
||||
push_status_and_metrics.assert_called_once()
|
||||
push_status.assert_not_called()
|
||||
|
||||
def test_start(self):
|
||||
every = sys.modules['schedule'].every
|
||||
@@ -33,16 +34,24 @@ class AgentTest(unittest.TestCase):
|
||||
|
||||
|
||||
class SchedulerTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.mock_configuration = sys.modules[('cachet_url_monitor.configuration'
|
||||
'.Configuration')]
|
||||
@mock.patch('requests.get')
|
||||
def setUp(self, mock_requests):
|
||||
def get(url, headers):
|
||||
get_return = mock.Mock()
|
||||
get_return.ok = True
|
||||
get_return.json = mock.Mock()
|
||||
get_return.json.return_value = {'data': {'status': 1}}
|
||||
return get_return
|
||||
|
||||
mock_requests.get = get
|
||||
|
||||
self.scheduler = Scheduler('config.yml')
|
||||
|
||||
def test_init(self):
|
||||
assert self.scheduler.stop == False
|
||||
|
||||
def test_start(self):
|
||||
#TODO(mtakaki|2016-05-01): We need a better way of testing this method.
|
||||
# TODO(mtakaki|2016-05-01): We need a better way of testing this method.
|
||||
# Leaving it as a placeholder.
|
||||
self.scheduler.stop = True
|
||||
self.scheduler.start()
|
||||
|
||||
Reference in New Issue
Block a user