def test_not_kill_switch_504(self, mock_logging, mock_post):
mock_post.return_value = MockResponse(code=504)
a = netuitive.Client(api_key='apikey')
mock_post.side_effect = urllib2.HTTPError(a.url, 504, '', {}, None)
e = netuitive.Element()
e.add_sample('nonsparseDataStrategy',
1434110794,
1,
'COUNTER',
host='hostname')
resp = a.post(e)
resp2 = a.post(e)
self.assertNotEqual(resp, True)
self.assertFalse(resp2)
self.assertFalse(a.disabled)
self.assertEqual(
mock_logging.exception.call_args_list[0][0][0],
'error posting payload to api ingest endpoint (%s): %s')
def __init__(self, *args, **kwargs):
super(HeartbeatCollector, self).__init__(*args, **kwargs)
self.hostname = self.get_hostname()
self.ttl = self.config['ttl']
self.connection_timeout = 5
if not netuitive:
self.log.error(
'netuitive import failed. Heartbeat collector disabled')
self.enabled = False
return
try:
self.version = self._get_version()
if 'netuitive_connection_timeout' in self.config:
self.connection_timeout = int(
self.config['netuitive_connection_timeout'])
self.api = netuitive.Client(
url=self.config['netuitive_url'],
api_key=self.config['netuitive_api_key'],
agent=self.version,
connection_timeout=self.connection_timeout)
except Exception as e:
self.log.debug(e)
def test_kill_switch_410(self, mock_logging, mock_post):
mock_post.return_value = MockResponse(code=410)
a = netuitive.Client(api_key='apikey')
mock_post.side_effect = urllib2.HTTPError(a.url, 410, '', {}, None)
e = netuitive.Element()
e.add_sample('nonsparseDataStrategy',
1434110794,
1,
'COUNTER',
host='hostname')
resp = a.post(e)
resp2 = a.post(e)
self.assertNotEqual(resp, True)
self.assertFalse(resp2)
self.assertTrue(a.disabled)
self.assertEqual(
mock_logging.exception.call_args_list[0][0][0],
'Posting has been disabled.See previous errors for details.')
def test_repeat_failure_general_http(self, mock_logging, mock_post):
a = netuitive.Client(api_key='apikey')
e = netuitive.Element()
e.add_sample('nonsparseDataStrategy',
1434110794,
1,
'COUNTER',
host='hostname')
errs = [403, 429, 503, 404, 503, 204, 307, 302, 405, 413]
for i in range(a.max_post_errors):
mock_post.return_value = MockResponse(code=errs[i])
mock_post.side_effect = urllib2.HTTPError(a.url, errs[i], '', {},
None)
resp = a.post(e)
resp = a.post(e)
self.assertNotEqual(resp, True)
self.assertFalse(resp)
self.assertFalse(a.disabled)
self.assertEqual(len(e.samples), 0)
self.assertEqual(
mock_logging.exception.call_args_list[0][0][0],
'error posting payload to api ingest endpoint (%s): %s')
def __init__(self, *args, **kwargs):
super(PortCheckCollector, self).__init__(*args, **kwargs)
self.hostname = self.get_hostname()
self.ttl = self.config['ttl']
self.ports = {}
for port_name, cfg in self.config['port'].items():
port_cfg = {}
for key in ('number', ):
port_cfg[key] = cfg.get(key, [])
for key in ('protocol', ):
port_cfg[key] = cfg.get(key, [])
self.ports[port_name] = port_cfg
if not netuitive:
self.log.error(
'netuitive import failed. PortCheckCollector disabled')
self.enabled = False
return
try:
self.version = self._get_version()
self.api = netuitive.Client(self.config['netuitive_url'],
self.config['netuitive_api_key'],
self.version)
except Exception as e:
self.log.debug(e)
def __init__(self, config, element, version='develop'):
logger.debug('Poster')
threading.Thread.__init__(self)
self.setName('PosterThread')
self.lock = threading.Lock()
self.config = config
self.runner = threading.Event()
self.sample_count = float(0)
self.packet_count = float(0)
self.event_count = float(0)
self.metric_prefix = self.config['prefix']
self.stats_prefix = 'statsd.netuitive-statsd'
self.no_internal_metrics = self.config['no_internal_metrics']
self.flush_time = 0
logger.debug('Messages will be sent to ' + self.config['url'])
self.api = netuitive.Client(self.config['url'],
self.config['api_key'],
agent='Netuitive-Statsd/' + str(version))
self.interval = int(self.config['interval'])
self.hostname = config['hostname']
self.events = []
self.elements = Elements(self.hostname, element)
self.flush_error_count = 0
self.flush_error_max = max(self.interval * 15, 900)
def test_outsync(self, mock_gmtime, mock_time, mock_logging, mock_req,
mock_post):
resp_headers = {
'Access-Control-Allow-Credentials': 'true',
'Access-Control-Allow-Methods': 'POST, PUT, GET, OPTIONS, DELETE',
'Access-Control-Allow-Origin': '*',
'Access-Control-Max-Age': 3600,
'Content-Language': 'en-US',
'Content-Type': 'text/html;charset=UTF-8',
'Date': 'Thu, 1 Jan 1970 00:00:00 GMT',
'Server': 'nginx',
'Vary': 'Accept-Encoding',
'Vary': 'Origin',
'X-Application-Context': 'application:8080',
'X-Frame-Options': 'SAMEORIGIN',
'Content-Length': 2499,
'Connection': 'Close'
}
mock_time.return_value = time.mktime(datetime(1970, 1, 1).timetuple())
mock_gmtime.return_value = datetime(1971, 1, 1).timetuple()
mock_post.return_value = MockResponse(code=302,
resp_headers=resp_headers)
a = netuitive.Client(api_key='apikey')
resp = a.check_time_offset()
self.assertEqual(31536000, resp)
self.assertFalse(a.time_insync())
def test_custom_endpoint(self):
# test custom endpoint url creation
a = netuitive.Client('https://example.com/ingest', 'apikey')
self.assertEqual(a.url, 'https://example.com/ingest')
self.assertEqual(a.api_key, 'apikey')
self.assertEqual(a.dataurl, 'https://example.com/ingest/apikey')
self.assertEqual(a.eventurl,
'https://example.com/ingest/events/apikey')
def test_trailing_slash(self):
# test negation of trailing / on the url
a = netuitive.Client('https://example.com/ingest/', 'apikey')
self.assertEqual(a.url, 'https://example.com/ingest')
self.assertEqual(a.api_key, 'apikey')
self.assertEqual(a.dataurl, 'https://example.com/ingest/apikey')
self.assertEqual(a.eventurl,
'https://example.com/ingest/events/apikey')
def test_minimum(self):
# test infrastructure endpoint url creation
a = netuitive.Client(api_key='apikey')
self.assertEqual(a.url, 'https://api.app.netuitive.com/ingest')
self.assertEqual(a.api_key, 'apikey')
self.assertEqual(a.dataurl,
'https://api.app.netuitive.com/ingest/apikey')
self.assertEqual(a.eventurl,
'https://api.app.netuitive.com/ingest/events/apikey')
def __init__(self, config=None):
"""
initialize Netuitive api and populate agent host metadata
"""
if not netuitive:
self.log.error('netuitive import failed. Handler disabled')
self.enabled = False
return
try:
Handler.__init__(self, config)
logging.debug("initialize Netuitive handler")
self.version = self._get_version()
self.api = netuitive.Client(self.config['url'],
self.config['api_key'], self.version)
self.element = netuitive.Element(
location=self.config.get('location'))
self.batch_size = int(self.config['batch'])
self.max_backlog_multiplier = int(
self.config['max_backlog_multiplier'])
self.trim_backlog_multiplier = int(
self.config['trim_backlog_multiplier'])
self._add_sys_meta()
self._add_aws_meta()
self._add_docker_meta()
self._add_azure_meta()
self._add_config_tags()
self._add_config_relations()
self._add_collectors()
self.flush_time = 0
try:
self.config['write_metric_fqns'] = str_to_bool(
self.config['write_metric_fqns'])
except KeyError, e:
self.log.warning('write_metric_fqns missing from the config')
self.config['write_metric_fqns'] = False
if self.config['write_metric_fqns']:
self.metric_fqns_path = self.config['metric_fqns_path']
truncate_fqn_file = open(self.metric_fqns_path, "w")
truncate_fqn_file.close()
logging.debug(self.config)
def test_infrastructure_endpoint(self):
# test infrastructure endpoint url creation
a = netuitive.Client('https://example.com/ingest/infrastructure',
'apikey')
self.assertEqual(a.url, 'https://example.com/ingest/infrastructure')
self.assertEqual(a.api_key, 'apikey')
self.assertEqual(a.dataurl,
'https://example.com/ingest/infrastructure/apikey')
self.assertEqual(
a.eventurl,
'https://example.com/ingest/events/infrastructure/apikey')
def test_null_element_id(self, mock_logging, mock_post):
mock_post.return_value = MockResponse(code=202)
# test infrastructure endpoint url creation
a = netuitive.Client(api_key='apikey')
e = netuitive.Element()
resp = a.post(e)
self.assertEqual(None, resp)
self.assertEqual(str(mock_logging.exception.call_args_list[0][0][2]),
'element id is not set')
def test_failure_general_http(self, mock_logging, mock_post):
mock_post.return_value = MockResponse(code=500)
# test infrastructure endpoint url creation
a = netuitive.Client(api_key='apikey')
mock_post.side_effect = urllib2.HTTPError(a.url, 500, '', {}, None)
e = netuitive.Check('check', 'test', 60)
resp = a.post_check(e)
self.assertNotEqual(resp, True)
self.assertEquals(mock_post.call_count, a.max_check_retry_count + 1)
self.assertEqual(mock_logging.exception.call_args_list[0][0][0], 'HTTPError posting payload to api ingest endpoint (%s): %s')
def test_failure_general(self, mock_logging, mock_post):
mock_post.side_effect = urllib2.URLError('something')
# test infrastructure endpoint url creation
a = netuitive.Client(api_key='apikey')
e = netuitive.Event(
'test', 'INFO', 'test event', 'big old test message', 'INFO')
resp = a.post_event(e)
self.assertNotEqual(resp, True)
self.assertEqual(mock_logging.exception.call_args_list[0][0][
0], 'error posting payload to api ingest endpoint (%s): %s')
def test_success(self, mock_logging, mock_post):
mock_post.return_value = MockResponse(code=202)
# test infrastructure endpoint url creation
a = netuitive.Client(api_key='apikey')
e = netuitive.Event('test', 'INFO', 'test event',
'big old test message', 'INFO')
resp = a.post_event(e)
self.assertTrue(resp)
self.assertEqual(mock_logging.exception.call_args_list, [])
def test_not_kill_switch_504(self, mock_logging, mock_post):
mock_post.return_value = MockResponse(code=504)
# test infrastructure endpoint url creation
a = netuitive.Client(api_key='apikey')
mock_post.side_effect = urllib2.HTTPError(a.url, 504, '', {}, None)
c = netuitive.Check('check', 'test', 60)
resp = a.post_check(c)
resp2 = a.post_check(c)
self.assertNotEqual(resp, True)
self.assertFalse(resp2)
self.assertFalse(a.disabled)
self.assertEqual(mock_logging.exception.call_args_list[0][0][0], 'HTTPError posting payload to api ingest endpoint (%s): %s')
def test_kill_switch_410(self, mock_logging, mock_post):
mock_post.return_value = MockResponse(code=410)
# test infrastructure endpoint url creation
a = netuitive.Client(api_key='apikey')
mock_post.side_effect = urllib2.HTTPError(a.url, 410, '', {}, None)
c = netuitive.Check('check', 'test', 60)
resp = a.post_check(c)
resp2 = a.post_check(c)
self.assertNotEqual(resp, True)
self.assertFalse(resp2)
self.assertTrue(a.disabled)
self.assertEqual(mock_logging.exception.call_args_list[0][0][0], 'Posting has been disabled.See previous errors for details.')
def __init__(self, *args, **kwargs):
super(ProcessCheckCollector, self).__init__(*args, **kwargs)
self.hostname = self.get_hostname()
self.ttl = self.config['ttl']
if not netuitive:
self.log.error('netuitive import failed. ProcessCheckCollector disabled')
self.enabled = False
return
try:
self.version = self._get_version()
self.api = netuitive.Client(self.config['netuitive_url'], self.config['netuitive_api_key'], self.version)
except Exception as e:
self.log.debug(e)
def test_failure_general(self, mock_logging, mock_post):
mock_post.return_value = MockResponse(code=500)
# test infrastructure endpoint url creation
a = netuitive.Client(api_key='apikey')
mock_post.side_effect = urllib2.URLError('something')
e = netuitive.Element()
e.add_sample(
'nonsparseDataStrategy', 1434110794, 1, 'COUNTER', host='hostname')
resp = a.post(e)
self.assertNotEqual(resp, True)
self.assertEqual(mock_logging.exception.call_args_list[0][0][
0], 'error posting payload to api ingest endpoint (%s): %s')
def test_success(self, mock_logging, mock_post):
mock_post.return_value = MockResponse(code=202)
# test infrastructure endpoint url creation
a = netuitive.Client(api_key='apikey')
e = netuitive.Element()
e.add_sample(
'nonsparseDataStrategy', 1434110794, 1, 'COUNTER', host='hostname')
resp = a.post(e)
self.assertTrue(resp)
self.assertEqual(mock_logging.exception.call_args_list, [])
def test_failure_general_http(self, mock_logging, mock_post):
mock_post.return_value = MockResponse(code=500)
# test infrastructure endpoint url creation
a = netuitive.Client(api_key='apikey')
mock_post.side_effect = urllib2.HTTPError(a.url, 500, '', {}, None)
e = netuitive.Event(
'test', 'INFO', 'test event', 'big old test message', 'INFO')
resp = a.post_event(e)
self.assertNotEqual(resp, True)
self.assertEqual(mock_logging.exception.call_args_list[0][0][
0], 'error posting payload to api ingest endpoint (%s): %s')
def test_success(self, mock_logging, mock_post):
mock_post.return_value = MockResponse(code=202)
# test infrastructure endpoint url creation
a = netuitive.Client(api_key='apikey')
c = netuitive.Check('check', 'test', 60)
resp = a.post_check(c)
self.assertTrue(resp)
args, kwargs = mock_post.call_args
self.assertEqual(kwargs['timeout'], 5)
self.assertEqual(mock_logging.exception.call_args_list, [])
def __init__(self, config=None):
"""
initialize Netuitive api and populate agent host metadata
"""
if not netuitive:
self.log.error('netuitive import failed. Handler disabled')
self.enabled = False
return
try:
Handler.__init__(self, config)
logging.debug("initialize Netuitive handler")
self.version = self._get_version()
self.api = netuitive.Client(self.config['url'],
self.config['api_key'], self.version)
self.element = netuitive.Element(
location=self.config.get('location'))
self.batch_size = int(self.config['batch'])
self.max_backlog_multiplier = int(
self.config['max_backlog_multiplier'])
self.trim_backlog_multiplier = int(
self.config['trim_backlog_multiplier'])
self._add_sys_meta()
self._add_aws_meta()
self._add_docker_meta()
self._add_config_tags()
self._add_config_relations()
logging.debug(self.config)
except Exception as e:
logging.exception('NetuitiveHandler: init - %s', str(e))
def test_custom_agent(self):
# test default agent string
a = netuitive.Client('https://example.com/ingest', 'apikey', 'phil')
self.assertEqual(a.agent, 'phil')
def test_default_agent(self):
# test default agent string
a = netuitive.Client('https://example.com/ingest', 'apikey')
self.assertEqual(a.agent, 'Netuitive-Python/' + netuitive.__version__)
import netuitive
import time
import os
ApiClient = netuitive.Client(url=os.environ.get('API_URL'),
api_key=os.environ.get('CUSTOM_API_KEY'))
MyElement = netuitive.Element()
MyElement.add_attribute('Language', 'Python')
MyElement.add_attribute('app_version', '7.0')
MyElement.add_relation('my_child_element')
MyElement.add_tag('Production', 'True')
MyElement.add_tag('app_tier', 'True')
timestamp = int(time.mktime(time.localtime()))
MyElement.add_sample('app.error', timestamp, 1, host='appserver01')
MyElement.add_sample('app.request', timestamp, 10, host='appserver01')
ApiClient.post(MyElement)
MyElement.clear_samples()
MyEvent = netuitive.Event('appserver01', 'INFO', 'test event',
'this is a test message', 'INFO')
ApiClient.post_event(MyEvent)
MyCheck = netuitive.Check('heartbeat', 'element', 60)
def test_client_connection_timeout(self):
a = netuitive.Client(connection_timeout=30)
self.assertEqual(a.connection_timeout, 30)
