def test_env_vars(self):
config = Config(config_file=None)
self.assertEqual(config.options['config_file'], '~/.alerta.conf')
with mod_env(ALERTA_CONF_FILE='~/.alerta.test.conf',
ALERTA_DEFAULT_PROFILE='test-profile',
ALERTA_ENDPOINT='http://foo/bar/baz',
ALERTA_API_KEY='test-key',
REQUESTS_CA_BUNDLE='',
CLICOLOR='',
DEBUG='1'):
# conf file
config = Config(config_file=None)
self.assertEqual(config.options['config_file'],
'~/.alerta.test.conf', os.environ)
config = Config(config_file='/dev/null')
self.assertEqual(config.options['config_file'], '/dev/null')
# profile
config = Config(config_file=None)
config.get_config_for_profle()
self.assertEqual(config.options['profile'], 'test-profile',
os.environ)
# endpoint
self.client = Client()
self.assertEqual(self.client.endpoint, 'http://foo/bar/baz')
# api key
self.assertEqual(config.options['key'], 'test-key')
def __init__(self):
self.api = Client()
LOG.info('Starting UDP listener...')
# Set up syslog UDP listener
try:
self.udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.udp.bind(('', SYSLOG_UDP_PORT))
except socket.error as e:
LOG.error('Syslog UDP error: %s', e)
sys.exit(2)
LOG.info('Listening on syslog port %s/udp' % SYSLOG_UDP_PORT)
LOG.info('Starting TCP listener...')
# Set up syslog TCP listener
try:
self.tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.tcp.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.tcp.bind(('', SYSLOG_TCP_PORT))
self.tcp.listen(5)
except socket.error as e:
LOG.error('Syslog TCP error: %s', e)
sys.exit(2)
LOG.info('Listening on syslog port %s/tcp' % SYSLOG_TCP_PORT)
self.shuttingdown = False
def setUp(self):
self.client = Client()
alarm_model = {
'name': 'Alerta 8.0.1',
'severity': {
'security': 0,
'critical': 1,
'major': 2,
'minor': 3,
'warning': 4,
'indeterminate': 5,
'informational': 6,
'normal': 7,
'ok': 7,
'cleared': 7,
'debug': 8,
'trace': 9,
'unknown': 10
},
'defaults': {
'normal_severity': 'normal'
}
}
config = Config(config_file=None,
config_override={'alarm_model': alarm_model})
self.obj = config.options
self.obj['client'] = self.client
self.runner = CliRunner(echo_stdin=True)
def senddata(self, content):
config_file = os.environ.get('ALERTA_CONF_FILE') or OPTIONS['config_file']
config = configparser.RawConfigParser(defaults=OPTIONS)
try:
config.read(os.path.expanduser(config_file))
except Exception:
sys.exit("Problem reading configuration file %s - is this an ini file?" % config_file)
want_profile = os.environ.get('ALERTA_DEFAULT_PROFILE') or config.defaults().get('profile')
if want_profile and config.has_section('profile %s' % want_profile):
for opt in OPTIONS:
try:
OPTIONS[opt] = config.getboolean('profile %s' % want_profile, opt)
except (ValueError, AttributeError):
OPTIONS[opt] = config.get('profile %s' % want_profile, opt)
else:
for opt in OPTIONS:
try:
OPTIONS[opt] = config.getboolean('DEFAULT', opt)
except (ValueError, AttributeError):
OPTIONS[opt] = config.get('DEFAULT', opt)
try:
LOG.debug("[alerta] sendto=%s ", OPTIONS.get("endpoint"))
api = Client(endpoint=OPTIONS.get("endpoint"), key=OPTIONS.get("key"), ssl_verify=OPTIONS.get("sslverify"))
api.send_alert(**content)
except RequestException as e:
raise EAException("send message has error: %s" % e)
elastalert_logger.info("send msg success" )
def cli(ctx, config_file, profile, endpoint_url, output, color, debug):
"""
Alerta client unified command-line tool.
"""
config = Config(config_file)
config.get_config_for_profle(profile)
config.get_remote_config(endpoint_url)
ctx.obj = config.options
# override current options with command-line options or environment variables
ctx.obj['output'] = output or config.options['output']
ctx.obj['color'] = color or os.environ.get('CLICOLOR',
None) or config.options['color']
endpoint = endpoint_url or config.options['endpoint']
ctx.obj['client'] = Client(endpoint=endpoint,
key=config.options['key'],
token=get_token(endpoint),
username=config.options.get('username', None),
password=config.options.get('password', None),
timeout=float(config.options['timeout']),
ssl_verify=config.options['sslverify'],
debug=debug or os.environ.get('DEBUG', None)
or config.options['debug'])
def run(self):
"""Run the App main logic.
This method should contain the core logic of the App.
"""
alerta_api_key = self.tcex.playbook.read(self.args.alerta_api_key)
alerta_api_endpoint = self.tcex.playbook.read(self.args.alerta_api_endpoint)
alert_id = self.tcex.playbook.read(self.args.alert_id)
query = self.tcex.playbook.read(self.args.query, True)
# initialize alerta client
client = Client(endpoint=alerta_api_endpoint, key=alerta_api_key)
if not alert_id and not query:
self.tcex.log.info('Retrieving all alerts from {}'.format(alerta_api_endpoint))
alerts = client.get_alerts()
elif alert_id:
self.tcex.log.info('Retrieving alert with id "{}"'.format(alert_id))
alerts = [client.get_alert(alert_id)]
elif query:
raise NotImplementedError('The ability to search for a query is not implemented yet. If you need it, create an issue here: https://github.com/ThreatConnect-Inc/threatconnect-playbooks/issues')
# TODO: the difficulty here is that the query should be a tuple (I think) and I'm not sure how to (elegantly) convert the incoming string to a tuple
# self.tcex.log.info('Retrieving alerts matching the query: {}'.format(query))
# alerts = client.search(query)
alerts_json = self.convert_to_json(alerts)
self.tcex.playbook.create_output('alerta.alerts', alerts_json, 'StringArray')
self.tcex.playbook.create_output('alerta.alerts.0', alerts_json[0], 'String')
self.tcex.playbook.create_output('alerta.alertCount', len(alerts_json), 'String')
def run(self):
api = Client(endpoint=OPTIONS['endpoint'], key=OPTIONS['key'])
keep_alive = 0
while not self.should_stop:
for alertid in on_hold.keys():
try:
(alert, hold_time) = on_hold[alertid]
except KeyError:
continue
if time.time() > hold_time:
self.send_email(alert)
try:
del on_hold[alertid]
except KeyError:
continue
if keep_alive >= 10:
tag = OPTIONS['smtp_host'] or 'alerta-mailer'
try:
api.heartbeat(tags=[tag])
except Exception as e:
time.sleep(5)
continue
keep_alive = 0
keep_alive += 1
time.sleep(2)
def run(self):
endpoint = os.environ.get('ALERTA_ENDPOINT', 'http://localhost:8080')
key = os.environ.get('ALERTA_API_KEY', None)
self.api = Client(endpoint=endpoint, key=key)
data = sys.stdin.read()
LOG.info('snmptrapd -> %r', data)
data = unicode(data, 'utf-8', errors='ignore')
LOG.debug('unicoded -> %s', data)
snmptrapAlert = SnmpTrapHandler.parse_snmptrap(data)
if snmptrapAlert:
try:
self.api.send(snmptrapAlert)
except Exception as e:
LOG.warning('Failed to send alert: %s', e)
LOG.debug('Send heartbeat...')
try:
origin = '{}/{}'.format('snmptrap', platform.uname()[1])
self.api.heartbeat(origin, tags=[__version__])
except Exception as e:
LOG.warning('Failed to send heartbeat: %s', e)
def cli(ctx, config_file, profile, endpoint_url, output, color, debug):
"""
Alerta client unified command-line tool.
"""
config = Config(config_file)
config.get_config_for_profle(profile)
ctx.obj = dict()
ctx.obj['timezone'] = config.options['timezone']
ctx.obj['output'] = output or config.options['output']
ctx.obj['color'] = color or os.environ.get('CLICOLOR', None) or config.options['color']
endpoint = endpoint_url or config.options['endpoint']
ctx.obj['provider'] = config.options['provider']
ctx.obj['client_id'] = config.options['client_id']
ctx.obj['github_url'] = config.options['github_url']
ctx.obj['gitlab_url'] = config.options['gitlab_url']
ctx.obj['client'] = Client(
endpoint=endpoint,
key=config.options['key'],
token=get_token(endpoint),
timeout=float(config.options['timeout']),
ssl_verify=config.options['sslverify'],
debug=debug or os.environ.get('DEBUG', None) or config.options['debug']
)
def run(self):
api = Client(endpoint=OPTIONS['endpoint'], key=OPTIONS['key'])
keep_alive = 0
while not self.should_stop:
for alertid in list(on_hold.keys()):
try:
(alert, hold_time) = on_hold[alertid]
except KeyError:
continue
if time.time() > hold_time:
self.diagnose(alert)
try:
del on_hold[alertid]
except KeyError:
continue
if keep_alive >= 10:
try:
origin = '{}'.format('alerta-trigger')
api.heartbeat(origin, tags=[__version__])
except Exception as e:
time.sleep(5)
continue
keep_alive = 0
keep_alive += 1
time.sleep(2)
def setUp(self):
self.client = Client()
config = Config(config_file=None)
self.obj = config.options
self.obj['client'] = self.client
self.runner = CliRunner(echo_stdin=True)
def alerta(self):
"""Return alerta instance, create new if missing"""
if self._alerta is None:
LOGGER.warning('No alerta exist. Create client.')
self._alerta = Client(endpoint=self.alerta_config.alerta_endpoint,
debug=self.alerta_config.alerta_debug,
timeout=self.alerta_config.alerta_timeout,
key=self.alerta_api_key)
return self._alerta
def __init__(self):
default_url = "http://localhost:8080/api"
self.endpoint = os.environ.get("ALERTA_ENDPOINT", default_url)
self.key = os.environ.get("ALERTA_KEY", "")
self.ssl_verify = os.environ.get("ALERTA_SSL_VERIFY", False)
self.client = Client(endpoint=self.endpoint,
key=self.key,
ssl_verify=self.ssl_verify)
def post_receive(self, alert):
client = Client(endpoint=FORWARD_URL)
fw_count = alert.attributes.get('fw_count') or 0
fw_count = fw_count + 1
if fw_count >= FORWARD_MAX_LENGTH:
LOG.debug('alert discarded by cycle overflow')
return
alert.attributes['fw_count'] = fw_count
client.send_alert(**alert.serialize)
return
def run(self):
self.running = True
# Create internal queue
self.queue = Queue.Queue()
self.api = Client()
# Initialiase ping targets
ping_list = init_targets()
# Start worker threads
LOG.debug('Starting %s worker threads...', SERVER_THREAD_COUNT)
for i in range(SERVER_THREAD_COUNT):
w = WorkerThread(self.api, self.queue)
try:
w.start()
except Exception as e:
LOG.error('Worker thread #%s did not start: %s', i, e)
continue
LOG.info('Started worker thread: %s', w.getName())
while not self.shuttingdown:
try:
for p in ping_list:
if 'targets' in p and p['targets']:
for target in p['targets']:
environment = p['environment']
service = p['service']
retries = p.get('retries', PING_MAX_RETRIES)
self.queue.put(
(environment, service, target, retries,
time.time()))
LOG.debug('Send heartbeat...')
try:
origin = '{}/{}'.format('pinger', platform.uname()[1])
self.api.heartbeat(origin, tags=[__version__])
except Exception as e:
LOG.warning('Failed to send heartbeat: %s', e)
time.sleep(LOOP_EVERY)
LOG.info('Ping queue length is %d', self.queue.qsize())
except (KeyboardInterrupt, SystemExit):
self.shuttingdown = True
LOG.info('Shutdown request received...')
self.running = False
for i in range(SERVER_THREAD_COUNT):
self.queue.put(None)
w.join()
def main():
api = Client()
listener = Listener()
while True:
listener.send_cmd('READY\n')
headers, body = listener.wait()
event = headers['eventname']
if event.startswith('TICK'):
try:
origin = '{}/{}'.format('supervisord', platform.uname()[1])
api.heartbeat(origin, tags=[headers['ver'], event])
except Exception as e:
listener.log_stderr(e)
listener.send_cmd('RESULT 4\nFAIL')
else:
listener.send_cmd('RESULT 2\nOK')
else:
if event.endswith('FATAL'):
severity = 'critical'
elif event.endswith('BACKOFF'):
severity = 'warning'
elif event.endswith('EXITED'):
severity = 'minor'
else:
severity = 'normal'
try:
api.send_alert(
resource='%s:%s' %
(platform.uname()[1], body['processname']),
environment='Production',
service=['supervisord'],
event=event,
correlate=[
'PROCESS_STATE_STARTING', 'PROCESS_STATE_RUNNING',
'PROCESS_STATE_BACKOFF', 'PROCESS_STATE_STOPPING',
'PROCESS_STATE_EXITED', 'PROCESS_STATE_STOPPED',
'PROCESS_STATE_FATAL', 'PROCESS_STATE_UNKNOWN'
],
value='serial=%s' % headers['serial'],
severity=severity,
origin=headers['server'],
text='State changed from %s to %s.' %
(body['from_state'], event),
raw_data='%s\n\n%s' %
(json.dumps(headers), json.dumps(body)))
except Exception as e:
listener.log_stderr(e)
listener.send_cmd('RESULT 4\nFAIL')
else:
listener.send_cmd('RESULT 2\nOK')
def post_receive(self, alert):
if not FORWARD_URL or not FORWARD_API_KEY:
return
client = Client(endpoint=FORWARD_URL, key=FORWARD_API_KEY)
fw_count = alert.attributes.get('fw_count') or 0
fw_count = fw_count+1
if fw_count >= FORWARD_MAX_LENGTH:
LOG.debug('alert discarded by cycle overflow')
return
alert.get('attributes')['fw_count'] = fw_count
client.send_alert(
**alert
)
return
def run(self):
endpoint = os.environ.get('ALERTA_ENDPOINT', 'http://localhost:8080')
key = os.environ.get('ALERTA_API_KEY', None)
self.api = Client(endpoint=endpoint, key=key)
data = sys.stdin.read()
LOG.info('snmptrapd -> %r', data)
try:
data = unicode(data, 'utf-8', errors='ignore') # python 2
except NameError:
pass
LOG.debug('unicoded -> %s', data)
try:
resource, event, correlate, trap_version, trapvars = self.parse_snmptrap(data)
if resource and event:
self.api.send_alert(
resource=resource,
event=event,
correlate=correlate,
group='SNMP',
value=trapvars['$w'],
severity='indeterminate',
environment='Production',
service=['Network'],
text=trapvars['$W'],
event_type='snmptrapAlert',
attributes={'trapvars': {k.replace('$', '_'): v for k, v in trapvars.items()}},
tags=[trap_version],
create_time=datetime.datetime.strptime('%sT%s.000Z' % (trapvars['$x'], trapvars['$X']), '%Y-%m-%dT%H:%M:%S.%fZ'),
raw_data=data
)
except Exception as e:
LOG.warning('Failed to send alert: %s', e)
LOG.debug('Send heartbeat...')
try:
origin = '{}/{}'.format('snmptrap', platform.uname()[1])
self.api.heartbeat(origin, tags=[__version__])
except Exception as e:
LOG.warning('Failed to send heartbeat: %s', e)
def run(self):
self.running = True
self.queue = Queue.Queue()
self.api = Client(endpoint=settings.ENDPOINT, key=settings.API_KEY)
# Start worker threads
LOG.debug('Starting %s worker threads...', SERVER_THREADS)
for i in range(SERVER_THREADS):
w = WorkerThread(self.queue, self.api)
try:
w.start()
except Exception as e:
LOG.error('Worker thread #%s did not start: %s', i, e)
continue
LOG.info('Started worker thread: %s', w.getName())
while not self.shuttingdown:
try:
for check in settings.checks:
self.queue.put((check, time.time()))
LOG.debug('Send heartbeat...')
try:
origin = '{}/{}'.format('urlmon', platform.uname()[1])
self.api.heartbeat(origin, tags=[__version__])
except Exception as e:
LOG.warning('Failed to send heartbeat: %s', e)
time.sleep(LOOP_EVERY)
LOG.info('URL check queue length is %d', self.queue.qsize())
except (KeyboardInterrupt, SystemExit):
self.shuttingdown = True
LOG.info('Shutdown request received...')
self.running = False
for i in range(SERVER_THREADS):
self.queue.put(None)
w.join()
def run(self):
"""Run the App main logic.
This method should contain the core logic of the App.
"""
alerta_api_key = self.tcex.playbook.read(self.args.alerta_api_key)
alerta_api_endpoint = self.tcex.playbook.read(
self.args.alerta_api_endpoint)
resource = self.tcex.playbook.read(self.args.resource_under_alarm)
event = self.tcex.playbook.read(self.args.event_name)
severity = self.tcex.playbook.read(self.args.severity)
service = self.tcex.playbook.read(self.args.services, True)
environment = self.tcex.playbook.read(self.args.environment)
# initialize alerta client
client = Client(endpoint=alerta_api_endpoint, key=alerta_api_key)
new_alert = client.send_alert(resource,
event,
severity=severity,
environment=environment,
service=service)[1]
self.tcex.playbook.create_output('alerta.alertId', new_alert.id)
def setUp(self):
self.client = Client(endpoint='http://api:8080', key='demo-key')
def run(self):
while True:
LOG.debug('Waiting on input queue...')
try:
check, queue_time = self.queue.get()
except TypeError:
LOG.info('%s is shutting down.', self.getName())
break
if time.time() - queue_time > LOOP_EVERY:
LOG.warning(
'URL request for %s to %s expired after %d seconds.',
check['resource'], check['url'],
int(time.time() - queue_time))
self.queue.task_done()
continue
resource = check['resource']
LOG.info('%s polling %s...', self.getName(), resource)
status, reason, body, rtt = self.urlmon(check)
status_regex = check.get('status_regex', None)
search_string = check.get('search', None)
rule = check.get('rule', None)
warn_thold = check.get('warning', SLOW_WARNING_THRESHOLD)
crit_thold = check.get('critical', SLOW_CRITICAL_THRESHOLD)
checker_api = check.get('api_endpoint', None)
checker_apikey = check.get('api_key', None)
if (checker_api and checker_apikey):
local_api = Client(endpoint=checker_api, key=checker_apikey)
else:
local_api = self.api
try:
description = HTTP_RESPONSES[status]
except KeyError:
description = 'undefined'
if not status:
event = 'HttpConnectionError'
severity = 'major'
value = reason
text = 'Error during connection or data transfer (timeout=%d).' % MAX_TIMEOUT
elif status_regex:
if re.search(status_regex, str(status)):
event = 'HttpResponseRegexOK'
severity = 'normal'
value = '%s (%d)' % (description, status)
text = 'HTTP server responded with status code %d that matched "%s" in %dms' % (
status, status_regex, rtt)
else:
event = 'HttpResponseRegexError'
severity = 'major'
value = '%s (%d)' % (description, status)
text = 'HTTP server responded with status code %d that failed to match "%s"' % (
status, status_regex)
elif 100 <= status <= 199:
event = 'HttpInformational'
severity = 'normal'
value = '%s (%d)' % (description, status)
text = 'HTTP server responded with status code %d in %dms' % (
status, rtt)
elif 200 <= status <= 299:
event = 'HttpResponseOK'
severity = 'normal'
value = '%s (%d)' % (description, status)
text = 'HTTP server responded with status code %d in %dms' % (
status, rtt)
elif 300 <= status <= 399:
event = 'HttpRedirection'
severity = 'minor'
value = '%s (%d)' % (description, status)
text = 'HTTP server responded with status code %d in %dms' % (
status, rtt)
elif 400 <= status <= 499:
event = 'HttpClientError'
severity = 'minor'
value = '%s (%d)' % (description, status)
text = 'HTTP server responded with status code %d in %dms' % (
status, rtt)
elif 500 <= status <= 599:
event = 'HttpServerError'
severity = 'major'
value = '%s (%d)' % (description, status)
text = 'HTTP server responded with status code %d in %dms' % (
status, rtt)
else:
event = 'HttpUnknownError'
severity = 'warning'
value = 'UNKNOWN'
text = 'HTTP request resulted in an unhandled error.'
if event in ['HttpResponseOK', 'HttpResponseRegexOK']:
if rtt > crit_thold:
event = 'HttpResponseSlow'
severity = 'critical'
value = '%dms' % rtt
text = 'Website available but exceeding critical RT thresholds of %dms' % crit_thold
elif rtt > warn_thold:
event = 'HttpResponseSlow'
severity = 'warning'
value = '%dms' % rtt
text = 'Website available but exceeding warning RT thresholds of %dms' % warn_thold
if search_string and body:
LOG.debug('Searching for %s', search_string)
found = False
for line in body.split('\n'):
m = re.search(search_string, line)
if m:
found = True
LOG.debug("Regex: Found %s in %s", search_string,
line)
break
if not found:
event = 'HttpContentError'
severity = 'minor'
value = 'Search failed'
text = 'Website available but pattern "%s" not found' % search_string
elif rule and body:
LOG.debug('Evaluating rule %s', rule)
headers = check.get('headers', {})
if 'Content-type' in headers and headers[
'Content-type'] == 'application/json':
try:
body = json.loads(body)
except ValueError as e:
LOG.error('Could not evaluate rule %s: %s', rule,
e)
try:
eval(
rule
) # NOTE: assumes request body in variable called 'body'
except (SyntaxError, NameError, ZeroDivisionError) as e:
LOG.error('Could not evaluate rule %s: %s', rule, e)
except Exception as e:
LOG.error('Could not evaluate rule %s: %s', rule, e)
else:
if not eval(rule):
event = 'HttpContentError'
severity = 'minor'
value = 'Rule failed'
text = 'Website available but rule evaluation failed (%s)' % rule
LOG.debug("URL: %s, Status: %s (%s), Round-Trip Time: %dms -> %s",
check['url'], description, status, rtt, event)
resource = check['resource']
correlate = _HTTP_ALERTS
group = 'Web'
environment = check['environment']
service = check['service']
text = text
tags = check.get('tags', list())
threshold_info = "%s : RT > %d RT > %d x %s" % (
check['url'], warn_thold, crit_thold, check.get('count', 1))
try:
local_api.send_alert(
resource=resource,
event=event,
correlate=correlate,
group=group,
value=value,
severity=severity,
environment=environment,
service=service,
text=text,
event_type='serviceAlert',
tags=tags,
attributes={'thresholdInfo': threshold_info})
except Exception as e:
LOG.warning('Failed to send alert: %s', e)
self.queue.task_done()
LOG.info('%s check complete.', self.getName())
self.queue.task_done()
def main():
config_file = os.environ.get('ALERTA_CONF_FILE') or OPTIONS['config_file']
config = configparser.RawConfigParser(defaults=OPTIONS)
try:
config.read(os.path.expanduser(config_file))
except Exception:
sys.exit("Problem reading configuration file %s - is this an ini file?" % config_file)
parser = argparse.ArgumentParser(
prog='zabbix-alerta',
usage='zabbix-alerta SENDTO SUMMARY BODY',
description='Zabbix-to-Alerta integration script',
epilog=epilog,
formatter_class=argparse.RawTextHelpFormatter
)
parser.add_argument(
'sendto',
help='config profile or alerta API endpoint and key'
)
parser.add_argument(
'summary',
help='alert summary'
)
parser.add_argument(
'body',
help='alert body (see format below)'
)
args, left = parser.parse_known_args()
# sendto=apiUrl[;key]
if args.sendto.startswith('http://') or args.sendto.startswith('https://'):
want_profile = None
try:
OPTIONS['endpoint'], OPTIONS['key'] = args.sendto.split(';', 1)
except ValueError:
OPTIONS['endpoint'] = args.sendto
# sendto=profile
else:
want_profile = args.sendto or os.environ.get('ALERTA_DEFAULT_PROFILE') or config.defaults().get('profile')
if want_profile and config.has_section('profile %s' % want_profile):
for opt in OPTIONS:
try:
OPTIONS[opt] = config.getboolean('profile %s' % want_profile, opt)
except (ValueError, AttributeError):
OPTIONS[opt] = config.get('profile %s' % want_profile, opt)
else:
for opt in OPTIONS:
try:
OPTIONS[opt] = config.getboolean('DEFAULT', opt)
except (ValueError, AttributeError):
OPTIONS[opt] = config.get('DEFAULT', opt)
parser.set_defaults(**OPTIONS)
args = parser.parse_args()
if args.debug or not os.path.isdir('/var/log/zabbix'):
LOG.basicConfig(stream=sys.stderr, format=LOG_FORMAT, datefmt=LOG_DATE_FMT, level=LOG.DEBUG)
else:
LOG.basicConfig(filename=LOG_FILE, format=LOG_FORMAT, datefmt=LOG_DATE_FMT, level=LOG.INFO)
LOG.info("[alerta] endpoint=%s key=%s", args.endpoint, args.key)
api = Client(endpoint=args.endpoint, key=args.key, ssl_verify=args.sslverify)
LOG.debug("[alerta] sendto=%s, summary=%s, body=%s", args.sendto, args.summary, args.body)
try:
alert = parse_zabbix(args.summary, args.body)
api.send_alert(**alert)
except (SystemExit, KeyboardInterrupt):
LOG.warning("Exiting zabbix-alerta.")
sys.exit(0)
except Exception as e:
LOG.error(e, exc_info=1)
sys.exit(1)
def setUp(self):
self.client = Client()
self.alert = """
def setUp(self):
self.client = Client()
self.customer = """
def cli(sendto, summary, body):
"""
Zabbix-to-Alerta integration script
INSTALL
$ ln -s `which zabbix-alerta` <AlertScriptsPath>
ALERT FORMAT
OPERATIONS
Default subject:
{TRIGGER.STATUS}: {TRIGGER.NAME}
Default message:
\b
resource={HOST.NAME1}
event={ITEM.KEY1}
environment=Production
severity={TRIGGER.SEVERITY}!!
status={TRIGGER.STATUS}
ack={EVENT.ACK.STATUS}
service={TRIGGER.HOSTGROUP.NAME}
group=Zabbix
value={ITEM.VALUE1}
text={TRIGGER.STATUS}: {TRIGGER.NAME}
tags={EVENT.TAGS}
attributes.ip={HOST.IP1}
attributes.thresholdInfo={TRIGGER.TEMPLATE.NAME}: {TRIGGER.EXPRESSION}
attributes.moreInfo=<a href="http://x.x.x.x/tr_events.php?triggerid={TRIGGER.ID}&eventid={EVENT.ID}">Zabbix console</a>
type=zabbixAlert
dateTime={EVENT.DATE}T{EVENT.TIME}Z
RECOVERY
Default subject:
{TRIGGER.STATUS}: {TRIGGER.NAME}
Default message:
\b
resource={HOST.NAME1}
event={ITEM.KEY1}
environment=Production
severity={TRIGGER.SEVERITY}!!
status={TRIGGER.STATUS}
ack={EVENT.ACK.STATUS}
service={TRIGGER.HOSTGROUP.NAME}
group=Zabbix
value={ITEM.VALUE1}
text={TRIGGER.STATUS}: {ITEM.NAME1}
tags={EVENT.RECOVERY.TAGS}
attributes.ip={HOST.IP1}
attributes.thresholdInfo={TRIGGER.TEMPLATE.NAME}: {TRIGGER.EXPRESSION}
attributes.moreInfo=<a href="http://x.x.x.x/tr_events.php?triggerid={TRIGGER.ID}&eventid={EVENT.RECOVERY.ID}">Zabbix console</a>
type=zabbixAlert
dateTime={EVENT.RECOVERY.DATE}T{EVENT.RECOVERY.TIME}Z
"""
# FIXME - use {ITEM.APPLICATION} for alert "group" when ZBXNEXT-2684 is resolved (see https://support.zabbix.com/browse/ZBXNEXT-2684)
click.echo('[alerta] Sending message "{}" to {}...'.format(summary, sendto))
options = default_config
parser = configparser.RawConfigParser(defaults=options)
options['config_file'] = os.environ.get('ALERTA_CONF_FILE') or options['config_file']
parser.read(os.path.expanduser(options['config_file']))
# sendto=apiUrl[;key]
if sendto.startswith('http://') or sendto.startswith('https://'):
want_profile = None
try:
options['endpoint'], options['key'] = sendto.split(';', 1)
except ValueError:
options['endpoint'] = sendto
# sendto=profile
else:
want_profile = sendto or os.environ.get('ALERTA_DEFAULT_PROFILE') or parser.defaults().get('profile')
if want_profile and parser.has_section('profile %s' % want_profile):
for opt in options:
try:
options[opt] = parser.getboolean('profile %s' % want_profile, opt)
except (ValueError, AttributeError):
options[opt] = parser.get('profile %s' % want_profile, opt)
else:
for opt in options:
try:
options[opt] = parser.getboolean('DEFAULT', opt)
except (ValueError, AttributeError):
options[opt] = parser.get('DEFAULT', opt)
options['profile'] = want_profile
options['endpoint'] = os.environ.get('ALERTA_ENDPOINT', options['endpoint'])
options['key'] = os.environ.get('ALERTA_API_KEY', options['key'])
api = Client(
endpoint=options['endpoint'], key=options['key'], timeout=options['timeout'], ssl_verify=options['sslverify']
)
try:
alert = parse_zabbix(summary, body)
api.send_alert(**alert)
except Exception as e:
click.secho('ERROR: {}'.format(e))
raise click.Abort()
click.echo('Successfully sent message "{}" to {}!'.format(summary, options['endpoint']))
def setUp(self):
self.client = Client()
self.user = """
def alerta_api(alerta_config):
endpoint = "http://{0}:{1}/api".format(alerta_config["alerta_host"],
alerta_config["alerta_port"])
client = Client(endpoint=endpoint, ssl_verify=False)
return client
def setUp(self):
self.client = Client()
self.key = """
timeout = 900
try:
origin = client.kv.get('alerta/origin')[1]['Value']
except TypeError:
print("No value defined, using default")
origin = "consul"
try:
alerttype = client.kv.get('alerta/alerttype')[1]['Value']
except TypeError:
print("No value defined, using default")
alerttype = "ConsulAlert"
api = Client(endpoint=url, key=key)
SEVERITY_MAP = {
'critical': 'critical',
'warning': 'warning',
'passing': 'ok',
}
def createalert( data ):
try:
environment = client.kv.get('alerta/env/{0}'.format(data['Node']))[1]['Value']
except:
try:
environment = client.kv.get('alerta/defaultenv')[1]['Value']
except:
environment = "Production"