def test_process_list_cache(aggregator):
config = {
'instances': [{'name': 'python', 'search_string': ['python']}, {'name': 'python', 'search_string': ['python']}]
}
process1 = ProcessCheck(common.CHECK_NAME, {}, {}, [config['instances'][0]])
process2 = ProcessCheck(common.CHECK_NAME, {}, {}, [config['instances'][1]])
process1.check(config['instances'][0])
process2.check(config['instances'][1])
# Should always succeed
assert process1.process_list_cache.elements[0].name() == "Process 1"
# Fails with 'assert "Process 2" == "Process 1"' if process list cache is not shared
assert process2.process_list_cache.elements[0].name() == "Process 1"
def test_check_collect_children(mock_process, aggregator):
instance = {'name': 'foo', 'pid': 1, 'collect_children': True}
process = ProcessCheck(common.CHECK_NAME, {}, {})
process.check(instance)
aggregator.assert_metric('system.processes.number',
value=1,
tags=generate_expected_tags(instance))
def test_check_missing_pid(aggregator):
instance = {'name': 'foo', 'pid_file': '/foo/bar/baz'}
process = ProcessCheck(common.CHECK_NAME, {}, {})
process.check(instance)
aggregator.assert_service_check('process.up',
count=1,
status=process.CRITICAL)
def test_ad_cache(aggregator):
config = {
'instances': [{
'name': 'python',
'search_string': ['python'],
'ignore_denied_access': 'false'
}]
}
process = ProcessCheck(common.CHECK_NAME, {}, {}, config['instances'])
def deny_name(obj):
raise psutil.AccessDenied()
with patch.object(psutil.Process, 'name', deny_name):
with pytest.raises(psutil.AccessDenied):
process.check(config['instances'][0])
assert len(process.ad_cache) > 0
# The next run shouldn't throw an exception
process.check(config['instances'][0])
# The ad cache should still be valid
assert process.should_refresh_ad_cache('python') is False
# Reset caches
process.last_ad_cache_ts = {}
process.last_pid_cache_ts = {}
# Shouldn't throw an exception
process.check(config['instances'][0])
def test_check_missing_process(aggregator, caplog):
caplog.set_level(logging.DEBUG)
instance = {'name': 'foo', 'search_string': ['fooprocess', '/usr/bin/foo'], 'exact_match': False}
process = ProcessCheck(common.CHECK_NAME, {}, {})
process.check(instance)
aggregator.assert_service_check('process.up', count=1, status=process.CRITICAL)
assert "Unable to find process named ['fooprocess', '/usr/bin/foo'] among processes" in caplog.text
def test_check(mock_process, aggregator):
(minflt, cminflt, majflt, cmajflt) = [1, 2, 3, 4]
def mock_get_pagefault_stats(pid):
return [minflt, cminflt, majflt, cmajflt]
process = ProcessCheck(common.CHECK_NAME, {}, {})
config = common.get_config_stubs()
for idx in range(len(config)):
instance = config[idx]['instance']
if 'search_string' not in instance.keys():
process.check(instance)
else:
with patch(
'datadog_checks.process.ProcessCheck.find_pids',
return_value=mock_find_pid(instance['name'], instance['search_string']),
):
process.check(instance)
# these are just here to ensure it passes the coverage report.
# they don't really "test" for anything.
for sname in common.PAGEFAULT_STAT:
aggregator.assert_metric(
'system.processes.mem.page_faults.' + sname, at_least=0, tags=generate_expected_tags(instance)
)
def test_check_filter_user(mock_process, aggregator):
instance = {'name': 'foo', 'pid': 1, 'user': '******'}
process = ProcessCheck(common.CHECK_NAME, {}, {})
with patch('datadog_checks.process.ProcessCheck._filter_by_user', return_value={1, 2}):
process.check(instance)
aggregator.assert_metric('system.processes.number', value=2, tags=generate_expected_tags(instance))
def test_process_service_check(aggregator):
process = ProcessCheck(common.CHECK_NAME, {}, {})
process._process_service_check('warning', 3, {
'warning': [4, 6],
'critical': [2, 10]
}, [])
process._process_service_check('no_top_ok', 3, {
'warning': [2, float('inf')],
'critical': [2, float('inf')]
}, [])
process._process_service_check('no_top_critical', 0, {
'warning': [2, float('inf')],
'critical': [2, float('inf')]
}, [])
aggregator.assert_service_check('process.up',
count=1,
tags=['process:warning'],
status=process.WARNING)
aggregator.assert_service_check('process.up',
count=1,
tags=['process:no_top_ok'],
status=process.OK)
aggregator.assert_service_check('process.up',
count=1,
tags=['process:no_top_critical'],
status=process.CRITICAL)
def test_psutil_wrapper_accessors(aggregator):
# Load check with empty config
process = ProcessCheck(common.CHECK_NAME, {}, {})
meminfo = process.psutil_wrapper(get_psutil_proc(), 'memory_info', ['rss', 'vms', 'foo'], False)
assert 'rss' in meminfo
assert 'vms' in meminfo
assert 'foo' not in meminfo
def test_check_collect_children(mock_process, reset_process_list_cache,
aggregator, dd_run_check):
instance = {'name': 'foo', 'pid': 1, 'collect_children': True}
process = ProcessCheck(common.CHECK_NAME, {}, [instance])
dd_run_check(process)
aggregator.assert_metric('system.processes.number',
value=1,
tags=generate_expected_tags(instance))
def test_process_list_cache(aggregator, dd_run_check):
config = {
'instances': [{
'name': 'python',
'search_string': ['python']
}, {
'name': 'python',
'search_string': ['python']
}]
}
process1 = ProcessCheck(common.CHECK_NAME, {}, [config['instances'][0]])
process2 = ProcessCheck(common.CHECK_NAME, {}, [config['instances'][1]])
with patch('datadog_checks.process.cache.ProcessListCache.reset'):
dd_run_check(process1)
dd_run_check(process2)
# Should always succeed
assert process1.process_list_cache.elements[0].name() == "Process 1"
# Fails with 'assert "Process 2" == "Process 1"' if process list cache is not shared
assert process2.process_list_cache.elements[0].name() == "Process 1"
def test_check_real_process_regex(aggregator):
"Check to specifically find this python pytest running process using regex."
from datadog_checks.utils.platform import Platform
instance = {
'name': 'py',
'search_string': ['.*python.*pytest'],
'exact_match': False,
'ignored_denied_access': True,
'thresholds': {
'warning': [1, 10],
'critical': [1, 100]
},
}
process = ProcessCheck(common.CHECK_NAME, {}, {})
expected_tags = generate_expected_tags(instance)
process.check(instance)
for mname in common.PROCESS_METRIC:
# cases where we don't actually expect some metrics here:
# - if io_counters() is not available
# - if memory_info_ex() is not available
# - first run so no `cpu.pct`
if ((not _PSUTIL_IO_COUNTERS and '.io' in mname)
or (not _PSUTIL_MEM_SHARED and 'mem.real' in mname)
or mname == 'system.processes.cpu.pct'):
continue
if Platform.is_windows():
metric = common.UNIX_TO_WINDOWS_MAP.get(mname, mname)
else:
metric = mname
aggregator.assert_metric(metric, at_least=1, tags=expected_tags)
aggregator.assert_service_check('process.up',
count=1,
tags=expected_tags + ['process:py'])
# this requires another run
process.check(instance)
aggregator.assert_metric('system.processes.cpu.pct',
count=1,
tags=expected_tags)
aggregator.assert_metric('system.processes.cpu.normalized_pct',
count=1,
tags=expected_tags)
def test_check(mock_process, reset_process_list_cache, aggregator,
dd_run_check):
config = common.get_config_stubs()
for idx in range(len(config)):
instance = config[idx]['instance']
process = ProcessCheck(common.CHECK_NAME, {}, [instance])
if 'search_string' not in instance.keys():
dd_run_check(process)
else:
with patch(
'datadog_checks.process.ProcessCheck.find_pids',
return_value=mock_find_pid(instance['name'],
instance['search_string']),
):
dd_run_check(process)
# these are just here to ensure it passes the coverage report.
# they don't really "test" for anything.
for sname in common.PAGEFAULT_STAT:
aggregator.assert_metric('system.processes.mem.page_faults.' +
sname,
at_least=0,
tags=generate_expected_tags(instance))
def test_psutil_wrapper_simple_fail(aggregator):
# Load check with empty config
process = ProcessCheck(common.CHECK_NAME, {}, {})
name = process.psutil_wrapper(get_psutil_proc(), 'blah', None, False)
assert name is None
def test_relocated_procfs(aggregator):
import tempfile
import shutil
import uuid
unique_process_name = str(uuid.uuid4())
my_procfs = tempfile.mkdtemp()
def _fake_procfs(arg, root=my_procfs):
for key, val in iteritems(arg):
path = os.path.join(root, key)
if isinstance(val, dict):
os.mkdir(path)
_fake_procfs(val, path)
else:
with open(path, "w") as f:
f.write(str(val))
_fake_procfs(
{
'1': {
'status': ("Name:\t{}\nThreads:\t1\n").format(unique_process_name),
'stat': ('1 ({}) S 0 1 1 ' + ' 0' * 46).format(unique_process_name),
'statm': '10970 3014 2404 77 0 2242 0',
'cmdline': unique_process_name,
'fd': {},
'io': (
'rchar: 397865373\n'
'wchar: 32186\n'
'syscr: 2695852\n'
'syscw: 202\n'
'read_bytes: 1208320\n'
'write_bytes: 0\n'
'cancelled_write_bytes: 0\n'
),
},
'stat': ("cpu 13034 0 18596 380856797 2013 2 2962 0 0 0\n" "btime 1448632481\n"),
}
)
config = {
'init_config': {'procfs_path': my_procfs},
'instances': [
{
'name': 'moved_procfs',
'search_string': [unique_process_name],
'exact_match': False,
'ignored_denied_access': True,
'thresholds': {'warning': [1, 10], 'critical': [1, 100]},
}
],
}
process = ProcessCheck(common.CHECK_NAME, config['init_config'], {}, config['instances'])
try:
with patch('socket.AF_PACKET', create=True), patch('sys.platform', 'linux'), patch(
'psutil._psutil_linux', create=True
), patch('psutil._psutil_posix', create=True):
process.check(config["instances"][0])
finally:
shutil.rmtree(my_procfs)
psutil.PROCFS_PATH = '/proc'
expected_tags = generate_expected_tags(config['instances'][0])
expected_tags += ['process:moved_procfs']
aggregator.assert_service_check('process.up', count=1, tags=expected_tags)
def test_psutil_wrapper_simple(aggregator):
# Load check with empty config
process = ProcessCheck(common.CHECK_NAME, {}, [{}])
name = process.psutil_wrapper(get_psutil_proc(), 'name')
assert name is not None
def check():
return ProcessCheck(common.CHECK_NAME, {}, [common.INSTANCE])
def check():
return ProcessCheck(common.CHECK_NAME, {}, {})
def test_relocated_procfs(aggregator):
from datadog_checks.utils.platform import Platform
import tempfile
import shutil
import uuid
already_linux = Platform.is_linux()
unique_process_name = str(uuid.uuid4())
my_procfs = tempfile.mkdtemp()
def _fake_procfs(arg, root=my_procfs):
for key, val in arg.iteritems():
path = os.path.join(root, key)
if isinstance(val, dict):
os.mkdir(path)
_fake_procfs(val, path)
else:
with open(path, "w") as f:
f.write(str(val))
_fake_procfs({
'1': {
'status': ("Name:\t{}\nThreads:\t1\n").format(unique_process_name),
'stat':
('1 ({}) S 0 1 1 ' + ' 0' * 46).format(unique_process_name),
'cmdline': unique_process_name,
},
'stat': ("cpu 13034 0 18596 380856797 2013 2 2962 0 0 0\n"
"btime 1448632481\n"),
})
config = {
'init_config': {
'procfs_path': my_procfs
},
'instances': [{
'name': 'moved_procfs',
'search_string': [unique_process_name],
'exact_match': False,
'ignored_denied_access': True,
'thresholds': {
'warning': [1, 10],
'critical': [1, 100]
},
}]
}
version = int(psutil.__version__.replace(".", ""))
process = ProcessCheck(common.CHECK_NAME, config['init_config'], {},
config['instances'])
try:
def import_mock(name,
i_globals={},
i_locals={},
fromlist=[],
level=-1,
orig_import=__import__):
# _psutil_linux and _psutil_posix are the
# C bindings; use a mock for those
if name in ('_psutil_linux', '_psutil_posix') or level >= 1 and\
('_psutil_linux' in fromlist or '_psutil_posix' in fromlist):
m = MagicMock()
# the import system will ask us for our own name
m._psutil_linux = m
m._psutil_posix = m
# there's a version safety check in psutil/__init__.py;
# this skips it
m.version = version
return m
return orig_import(name, i_globals, i_locals, fromlist, level)
# contextlib.nested is deprecated in favor of with MGR1, MGR2, ... etc
# but we have too many mocks to fit on one line and apparently \ line
# continuation is not flake8 compliant, even when semantically
# required (as here). Patch is unlikely to throw errors that are
# suppressed, so the main downside of contextlib is avoided.
with contextlib.nested(
patch('sys.platform', 'linux'),
patch('socket.AF_PACKET', create=True),
patch('__builtin__.__import__', side_effect=import_mock)):
if not already_linux:
# Reloading psutil fails on linux, but we only
# need to do so if we didn't start out on a linux platform
reload(psutil)
assert Platform.is_linux()
process.check(config["instances"][0])
finally:
shutil.rmtree(my_procfs)
if not already_linux:
# restore the original psutil that doesn't have our mocks
reload(psutil)
else:
psutil.PROCFS_PATH = '/proc'
expected_tags = generate_expected_tags(config['instances'][0])
expected_tags += ['process:moved_procfs']
aggregator.assert_service_check('process.up', count=1, tags=expected_tags)