Python psutil.disk_io_counters() Examples
The following are 30
code examples of psutil.disk_io_counters().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
psutil
, or try the search function
.
.
Example #1
| Source File: system_status.py From Paradrop with Apache License 2.0 | 12 votes |
|
def getSystemInfo(cls):
system = {
'boot_time': psutil.boot_time(),
'cpu_count': psutil.cpu_count(),
'cpu_stats': psutil.cpu_stats().__dict__,
'cpu_times': [k.__dict__ for k in psutil.cpu_times(percpu=True)],
'disk_io_counters': psutil.disk_io_counters().__dict__,
'disk_usage': [],
'net_io_counters': psutil.net_io_counters().__dict__,
'swap_memory': psutil.swap_memory().__dict__,
'virtual_memory': psutil.virtual_memory().__dict__
}
partitions = psutil.disk_partitions()
for p in partitions:
if p.mountpoint in cls.INCLUDED_PARTITIONS:
usage = psutil.disk_usage(p.mountpoint)
system['disk_usage'].append({
'mountpoint': p.mountpoint,
'total': usage.total,
'used': usage.used
})
return system
Example #2
| Source File: test_misc.py From psutil with BSD 3-Clause "New" or "Revised" License | 6 votes |
|
def test_serialization(self):
def check(ret):
if json is not None:
json.loads(json.dumps(ret))
a = pickle.dumps(ret)
b = pickle.loads(a)
self.assertEqual(ret, b)
check(psutil.Process().as_dict())
check(psutil.virtual_memory())
check(psutil.swap_memory())
check(psutil.cpu_times())
check(psutil.cpu_times_percent(interval=0))
check(psutil.net_io_counters())
if LINUX and not os.path.exists('/proc/diskstats'):
pass
else:
if not APPVEYOR:
check(psutil.disk_io_counters())
check(psutil.disk_partitions())
check(psutil.disk_usage(os.getcwd()))
check(psutil.users())
Example #3
| Source File: test_misc.py From vnpy_crypto with MIT License | 6 votes |
|
def test_serialization(self):
def check(ret):
if json is not None:
json.loads(json.dumps(ret))
a = pickle.dumps(ret)
b = pickle.loads(a)
self.assertEqual(ret, b)
check(psutil.Process().as_dict())
check(psutil.virtual_memory())
check(psutil.swap_memory())
check(psutil.cpu_times())
check(psutil.cpu_times_percent(interval=0))
check(psutil.net_io_counters())
if LINUX and not os.path.exists('/proc/diskstats'):
pass
else:
if not APPVEYOR:
check(psutil.disk_io_counters())
check(psutil.disk_partitions())
check(psutil.disk_usage(os.getcwd()))
check(psutil.users())
Example #4
| Source File: test_linux.py From vnpy_crypto with MIT License | 6 votes |
|
def test_sector_size_mock(self):
# Test SECTOR_SIZE fallback in case 'hw_sector_size' file
# does not exist.
def open_mock(name, *args, **kwargs):
if PY3 and isinstance(name, bytes):
name = name.decode()
if "hw_sector_size" in name:
flag.append(None)
raise IOError(errno.ENOENT, '')
else:
return orig_open(name, *args, **kwargs)
flag = []
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock):
psutil.disk_io_counters()
assert flag
Example #5
| Source File: test_linux.py From vnpy_crypto with MIT License | 6 votes |
|
def test_procfs_path(self):
tdir = tempfile.mkdtemp()
try:
psutil.PROCFS_PATH = tdir
self.assertRaises(IOError, psutil.virtual_memory)
self.assertRaises(IOError, psutil.cpu_times)
self.assertRaises(IOError, psutil.cpu_times, percpu=True)
self.assertRaises(IOError, psutil.boot_time)
# self.assertRaises(IOError, psutil.pids)
self.assertRaises(IOError, psutil.net_connections)
self.assertRaises(IOError, psutil.net_io_counters)
self.assertRaises(IOError, psutil.net_if_stats)
self.assertRaises(IOError, psutil.disk_io_counters)
self.assertRaises(IOError, psutil.disk_partitions)
self.assertRaises(psutil.NoSuchProcess, psutil.Process)
finally:
psutil.PROCFS_PATH = "/proc"
os.rmdir(tdir)
Example #6
| Source File: test_linux.py From vnpy_crypto with MIT License | 6 votes |
|
def test_disk_io_counters_kernel_2_6_full_mocked(self):
# Tests /proc/diskstats parsing format for 2.6 kernels,
# lines reporting all metrics:
# https://github.com/giampaolo/psutil/issues/767
with mock_open_content(
'/proc/partitions',
textwrap.dedent("""\
major minor #blocks name
8 0 488386584 hda
""")):
with mock_open_content(
'/proc/diskstats',
" 3 0 hda 1 2 3 4 5 6 7 8 9 10 11"):
ret = psutil.disk_io_counters(nowrap=False)
self.assertEqual(ret.read_count, 1)
self.assertEqual(ret.read_merged_count, 2)
self.assertEqual(ret.read_bytes, 3 * SECTOR_SIZE)
self.assertEqual(ret.read_time, 4)
self.assertEqual(ret.write_count, 5)
self.assertEqual(ret.write_merged_count, 6)
self.assertEqual(ret.write_bytes, 7 * SECTOR_SIZE)
self.assertEqual(ret.write_time, 8)
self.assertEqual(ret.busy_time, 10)
Example #7
| Source File: test_misc.py From vnpy_crypto with MIT License | 6 votes |
|
def test_cache_clear_public_apis(self):
psutil.disk_io_counters()
psutil.net_io_counters()
caches = wrap_numbers.cache_info()
for cache in caches:
self.assertIn('psutil.disk_io_counters', cache)
self.assertIn('psutil.net_io_counters', cache)
psutil.disk_io_counters.cache_clear()
caches = wrap_numbers.cache_info()
for cache in caches:
self.assertIn('psutil.net_io_counters', cache)
self.assertNotIn('psutil.disk_io_counters', cache)
psutil.net_io_counters.cache_clear()
caches = wrap_numbers.cache_info()
self.assertEqual(caches, ({}, {}, {}))
# ===================================================================
# --- Example script tests
# ===================================================================
Example #8
| Source File: diskio_host_crawler.py From agentless-system-crawler with Apache License 2.0 | 6 votes |
|
def _crawl_disk_io_counters(self):
try:
disk_counters = psutil.disk_io_counters(perdisk=True)
for device_name in disk_counters:
counters = disk_counters[device_name]
curr_counters = [
counters.read_count,
counters.write_count,
counters.read_bytes,
counters.write_bytes
]
logger.debug(
u'Disk I/O counters - {0}: {1}'.format(device_name,
curr_counters))
yield (device_name, curr_counters)
except OSError as e:
logger.debug(
u'Caught exception when crawling disk I/O counters: {0}'.
format(e))
Example #9
| Source File: test_linux.py From vnpy_crypto with MIT License | 6 votes |
|
def test_disk_io_counters_kernel_2_4_mocked(self):
# Tests /proc/diskstats parsing format for 2.4 kernels, see:
# https://github.com/giampaolo/psutil/issues/767
with mock_open_content(
'/proc/partitions',
textwrap.dedent("""\
major minor #blocks name
8 0 488386584 hda
""")):
with mock_open_content(
'/proc/diskstats',
" 3 0 1 hda 2 3 4 5 6 7 8 9 10 11 12"):
ret = psutil.disk_io_counters(nowrap=False)
self.assertEqual(ret.read_count, 1)
self.assertEqual(ret.read_merged_count, 2)
self.assertEqual(ret.read_bytes, 3 * SECTOR_SIZE)
self.assertEqual(ret.read_time, 4)
self.assertEqual(ret.write_count, 5)
self.assertEqual(ret.write_merged_count, 6)
self.assertEqual(ret.write_bytes, 7 * SECTOR_SIZE)
self.assertEqual(ret.write_time, 8)
self.assertEqual(ret.busy_time, 10)
Example #10
| Source File: disk.py From integrations-core with BSD 3-Clause "New" or "Revised" License | 6 votes |
|
def collect_latency_metrics(self):
for disk_name, disk in iteritems(psutil.disk_io_counters(True)):
self.log.debug('IO Counters: %s -> %s', disk_name, disk)
try:
# x100 to have it as a percentage,
# /1000 as psutil returns the value in ms
read_time_pct = disk.read_time * 100 / 1000
write_time_pct = disk.write_time * 100 / 1000
metric_tags = [] if self._custom_tags is None else self._custom_tags[:]
metric_tags.append('device:{}'.format(disk_name))
metric_tags.append('device_name:{}'.format(_base_device_name(disk_name)))
if self.devices_label.get(disk_name):
metric_tags.append(self.devices_label.get(disk_name))
self.rate(self.METRIC_DISK.format('read_time_pct'), read_time_pct, tags=metric_tags)
self.rate(self.METRIC_DISK.format('write_time_pct'), write_time_pct, tags=metric_tags)
except AttributeError as e:
# Some OS don't return read_time/write_time fields
# http://psutil.readthedocs.io/en/latest/#psutil.disk_io_counters
self.log.debug('Latency metrics not collected for %s: %s', disk_name, e)
Example #11
| Source File: test_misc.py From psutil with BSD 3-Clause "New" or "Revised" License | 6 votes |
|
def test_cache_clear_public_apis(self):
if not psutil.disk_io_counters() or not psutil.net_io_counters():
return self.skipTest("no disks or NICs available")
psutil.disk_io_counters()
psutil.net_io_counters()
caches = wrap_numbers.cache_info()
for cache in caches:
self.assertIn('psutil.disk_io_counters', cache)
self.assertIn('psutil.net_io_counters', cache)
psutil.disk_io_counters.cache_clear()
caches = wrap_numbers.cache_info()
for cache in caches:
self.assertIn('psutil.net_io_counters', cache)
self.assertNotIn('psutil.disk_io_counters', cache)
psutil.net_io_counters.cache_clear()
caches = wrap_numbers.cache_info()
self.assertEqual(caches, ({}, {}, {}))
# ===================================================================
# --- Example script tests
# ===================================================================
Example #12
| Source File: test_linux.py From psutil with BSD 3-Clause "New" or "Revised" License | 6 votes |
|
def test_emulate_kernel_2_4(self):
# Tests /proc/diskstats parsing format for 2.4 kernels, see:
# https://github.com/giampaolo/psutil/issues/767
with mock_open_content(
'/proc/diskstats',
" 3 0 1 hda 2 3 4 5 6 7 8 9 10 11 12"):
with mock.patch('psutil._pslinux.is_storage_device',
return_value=True):
ret = psutil.disk_io_counters(nowrap=False)
self.assertEqual(ret.read_count, 1)
self.assertEqual(ret.read_merged_count, 2)
self.assertEqual(ret.read_bytes, 3 * SECTOR_SIZE)
self.assertEqual(ret.read_time, 4)
self.assertEqual(ret.write_count, 5)
self.assertEqual(ret.write_merged_count, 6)
self.assertEqual(ret.write_bytes, 7 * SECTOR_SIZE)
self.assertEqual(ret.write_time, 8)
self.assertEqual(ret.busy_time, 10)
Example #13
| Source File: test_linux.py From psutil with BSD 3-Clause "New" or "Revised" License | 6 votes |
|
def test_emulate_kernel_2_6_limited(self):
# Tests /proc/diskstats parsing format for 2.6 kernels,
# where one line of /proc/partitions return a limited
# amount of metrics when it bumps into a partition
# (instead of a disk). See:
# https://github.com/giampaolo/psutil/issues/767
with mock_open_content(
'/proc/diskstats',
" 3 1 hda 1 2 3 4"):
with mock.patch('psutil._pslinux.is_storage_device',
return_value=True):
ret = psutil.disk_io_counters(nowrap=False)
self.assertEqual(ret.read_count, 1)
self.assertEqual(ret.read_bytes, 2 * SECTOR_SIZE)
self.assertEqual(ret.write_count, 3)
self.assertEqual(ret.write_bytes, 4 * SECTOR_SIZE)
self.assertEqual(ret.read_merged_count, 0)
self.assertEqual(ret.read_time, 0)
self.assertEqual(ret.write_merged_count, 0)
self.assertEqual(ret.write_time, 0)
self.assertEqual(ret.busy_time, 0)
Example #14
| Source File: profile.py From eggroll with Apache License 2.0 | 6 votes |
|
def get_system_metric(interval=1):
io_start = psutil.disk_io_counters()._asdict()
net_start = psutil.net_io_counters()._asdict()
cpu_percent = psutil.cpu_percent(interval=interval)
memory = psutil.virtual_memory()._asdict()
io_end = psutil.disk_io_counters()._asdict()
net_end = psutil.net_io_counters()._asdict()
result = {}
io = {}
for k, v in io_end.items():
io[k] = io_end[k] - io_start[k]
net = {}
for k, v in net_end.items():
net[k] = net_end[k] - net_start[k]
result['cpu_percent'] = cpu_percent
result['memory'] = memory
result['io'] = io
result['net'] = net
result['metric_type'] = 'system'
return result
Example #15
| Source File: test_linux.py From jarvis with GNU General Public License v2.0 | 6 votes |
|
def test_sector_size_mock(self):
# Test SECTOR_SIZE fallback in case 'hw_sector_size' file
# does not exist.
def open_mock(name, *args, **kwargs):
if PY3 and isinstance(name, bytes):
name = name.decode()
if "hw_sector_size" in name:
flag.append(None)
raise IOError(errno.ENOENT, '')
else:
return orig_open(name, *args, **kwargs)
flag = []
orig_open = open
patch_point = 'builtins.open' if PY3 else '__builtin__.open'
with mock.patch(patch_point, side_effect=open_mock):
psutil.disk_io_counters()
assert flag
Example #16
| Source File: test_linux.py From jarvis with GNU General Public License v2.0 | 6 votes |
|
def test_procfs_path(self):
tdir = tempfile.mkdtemp()
try:
psutil.PROCFS_PATH = tdir
self.assertRaises(IOError, psutil.virtual_memory)
self.assertRaises(IOError, psutil.cpu_times)
self.assertRaises(IOError, psutil.cpu_times, percpu=True)
self.assertRaises(IOError, psutil.boot_time)
# self.assertRaises(IOError, psutil.pids)
self.assertRaises(IOError, psutil.net_connections)
self.assertRaises(IOError, psutil.net_io_counters)
self.assertRaises(IOError, psutil.net_if_stats)
self.assertRaises(IOError, psutil.disk_io_counters)
self.assertRaises(IOError, psutil.disk_partitions)
self.assertRaises(psutil.NoSuchProcess, psutil.Process)
finally:
psutil.PROCFS_PATH = "/proc"
os.rmdir(tdir)
Example #17
| Source File: test_misc.py From jarvis with GNU General Public License v2.0 | 6 votes |
|
def test_cache_clear_public_apis(self):
psutil.disk_io_counters()
psutil.net_io_counters()
caches = wrap_numbers.cache_info()
for cache in caches:
self.assertIn('psutil.disk_io_counters', cache)
self.assertIn('psutil.net_io_counters', cache)
psutil.disk_io_counters.cache_clear()
caches = wrap_numbers.cache_info()
for cache in caches:
self.assertIn('psutil.net_io_counters', cache)
self.assertNotIn('psutil.disk_io_counters', cache)
psutil.net_io_counters.cache_clear()
caches = wrap_numbers.cache_info()
self.assertEqual(caches, ({}, {}, {}))
# ===================================================================
# --- Example script tests
# ===================================================================
Example #18
| Source File: test_misc.py From jarvis with GNU General Public License v2.0 | 6 votes |
|
def test_serialization(self):
def check(ret):
if json is not None:
json.loads(json.dumps(ret))
a = pickle.dumps(ret)
b = pickle.loads(a)
self.assertEqual(ret, b)
check(psutil.Process().as_dict())
check(psutil.virtual_memory())
check(psutil.swap_memory())
check(psutil.cpu_times())
check(psutil.cpu_times_percent(interval=0))
check(psutil.net_io_counters())
if LINUX and not os.path.exists('/proc/diskstats'):
pass
else:
if not APPVEYOR:
check(psutil.disk_io_counters())
check(psutil.disk_partitions())
check(psutil.disk_usage(os.getcwd()))
check(psutil.users())
Example #19
| Source File: webapp.py From pyrocore with GNU General Public License v2.0 | 6 votes |
|
def json_charts(self, req):
""" Return charting data.
"""
disk_used, disk_total, disk_detail = 0, 0, []
for disk_usage_path in self.cfg.disk_usage_path.split(os.pathsep):
disk_usage = self.guarded(psutil.disk_usage, os.path.expanduser(disk_usage_path.strip()))
if disk_usage:
disk_used += disk_usage.used
disk_total += disk_usage.total
disk_detail.append((disk_usage.used, disk_usage.total))
data = dict(
engine = self.json_engine(req),
uptime = time.time() - psutil.BOOT_TIME, # pylint: disable=no-member
fqdn = self.guarded(socket.getfqdn),
cpu_usage = self.guarded(psutil.cpu_percent, 0),
ram_usage = self.guarded(psutil.virtual_memory),
swap_usage = self.guarded(psutil.swap_memory),
disk_usage = (disk_used, disk_total, disk_detail) if disk_total else None,
disk_io = self.guarded(psutil.disk_io_counters),
net_io = self.guarded(psutil.net_io_counters),
)
return data
Example #20
| Source File: client_psutil_plugin.py From hubblemon with Apache License 2.0 | 6 votes |
|
def collect_disk(self, stat):
d = psutil.disk_io_counters(perdisk=False)
stat['psutil_disk'] = { 'read_count':d.read_count,
'write_count':d.write_count,
'read_bytes':d.read_bytes,
'write_bytes':d.write_bytes,
'read_time':d.read_time,
'write_time':d.write_time }
ds = psutil.disk_io_counters(perdisk=True)
for k, d in ds.items():
stat['psutil_disk-%s' % k] = { 'read_count':d.read_count,
'write_count':d.write_count,
'read_bytes':d.read_bytes,
'write_bytes':d.write_bytes,
'read_time':d.read_time,
'write_time':d.write_time }
Example #21
| Source File: test_linux.py From psutil with BSD 3-Clause "New" or "Revised" License | 6 votes |
|
def test_procfs_path(self):
tdir = self.get_testfn()
os.mkdir(tdir)
try:
psutil.PROCFS_PATH = tdir
self.assertRaises(IOError, psutil.virtual_memory)
self.assertRaises(IOError, psutil.cpu_times)
self.assertRaises(IOError, psutil.cpu_times, percpu=True)
self.assertRaises(IOError, psutil.boot_time)
# self.assertRaises(IOError, psutil.pids)
self.assertRaises(IOError, psutil.net_connections)
self.assertRaises(IOError, psutil.net_io_counters)
self.assertRaises(IOError, psutil.net_if_stats)
# self.assertRaises(IOError, psutil.disk_io_counters)
self.assertRaises(IOError, psutil.disk_partitions)
self.assertRaises(psutil.NoSuchProcess, psutil.Process)
finally:
psutil.PROCFS_PATH = "/proc"
Example #22
| Source File: test_linux.py From psutil with BSD 3-Clause "New" or "Revised" License | 6 votes |
|
def test_emulate_include_partitions(self):
# Make sure that when perdisk=True disk partitions are returned,
# see:
# https://github.com/giampaolo/psutil/pull/1313#issuecomment-408626842
with mock_open_content(
'/proc/diskstats',
textwrap.dedent("""\
3 0 nvme0n1 1 2 3 4 5 6 7 8 9 10 11
3 0 nvme0n1p1 1 2 3 4 5 6 7 8 9 10 11
""")):
with mock.patch('psutil._pslinux.is_storage_device',
return_value=False):
ret = psutil.disk_io_counters(perdisk=True, nowrap=False)
self.assertEqual(len(ret), 2)
self.assertEqual(ret['nvme0n1'].read_count, 1)
self.assertEqual(ret['nvme0n1p1'].read_count, 1)
self.assertEqual(ret['nvme0n1'].write_count, 5)
self.assertEqual(ret['nvme0n1p1'].write_count, 5)
Example #23
| Source File: test_linux.py From psutil with BSD 3-Clause "New" or "Revised" License | 6 votes |
|
def test_emulate_kernel_2_6_full(self):
# Tests /proc/diskstats parsing format for 2.6 kernels,
# lines reporting all metrics:
# https://github.com/giampaolo/psutil/issues/767
with mock_open_content(
'/proc/diskstats',
" 3 0 hda 1 2 3 4 5 6 7 8 9 10 11"):
with mock.patch('psutil._pslinux.is_storage_device',
return_value=True):
ret = psutil.disk_io_counters(nowrap=False)
self.assertEqual(ret.read_count, 1)
self.assertEqual(ret.read_merged_count, 2)
self.assertEqual(ret.read_bytes, 3 * SECTOR_SIZE)
self.assertEqual(ret.read_time, 4)
self.assertEqual(ret.write_count, 5)
self.assertEqual(ret.write_merged_count, 6)
self.assertEqual(ret.write_bytes, 7 * SECTOR_SIZE)
self.assertEqual(ret.write_time, 8)
self.assertEqual(ret.busy_time, 10)
Example #24
| Source File: health.py From openwhisk-package-kafka with Apache License 2.0 | 5 votes |
|
def getDiskIOCounters():
read_count, write_count, read_bytes, write_bytes, read_time, write_time, read_merged_count, write_merged_count,\
busy_time = psutil.disk_io_counters()
disk_io_counters = {}
disk_io_counters['read_count'] = read_count
disk_io_counters['write_count'] = write_count
disk_io_counters['read_bytes'] = '%d MB' % (read_bytes / MEGABYTE)
disk_io_counters['write_bytes'] = '%d MB' % (write_bytes / MEGABYTE)
disk_io_counters['read_time'] = '%d seconds' % (read_time / MILLISECONDS_IN_SECOND)
disk_io_counters['write_time'] = '%d seconds' % (write_time / MILLISECONDS_IN_SECOND)
disk_io_counters['read_merged_count'] = read_merged_count
disk_io_counters['write_merged_count'] = write_merged_count
disk_io_counters['busy_time'] = '%d seconds' % (busy_time / MILLISECONDS_IN_SECOND)
return disk_io_counters
Example #25
| Source File: test_memory_leaks.py From jarvis with GNU General Public License v2.0 | 5 votes |
|
def test_disk_io_counters(self):
self.execute(psutil.disk_io_counters, nowrap=False)
# --- proc
Example #26
| Source File: node.py From psdash with Creative Commons Zero v1.0 Universal | 5 votes |
|
def get_disks_counters(self, perdisk=True):
return dict((dev, c._asdict()) for dev, c in psutil.disk_io_counters(perdisk=perdisk).iteritems())
Example #27
| Source File: disk.py From guildai with Apache License 2.0 | 5 votes |
|
def _timed_disk_io_counters():
import psutil
counters = {}
now = time.time()
for key, counts in psutil.disk_io_counters(True).items():
counts_dict = counts._asdict()
counts_dict["timestamp"] = now
counters[key] = counts_dict
return counters
Example #28
| Source File: filesystem.py From pkmeter with BSD 3-Clause "New" or "Revised" License | 5 votes |
|
def _disk_io_counters(self):
io = psutil.disk_io_counters()
return {
'read_count': io.read_count,
'write_count': io.write_count,
'read_bytes': io.read_bytes,
'write_bytes': io.write_bytes,
'read_time': io.read_time,
'write_time': io.write_time,
}
Example #29
| Source File: system_metrics_collector.py From trinity with MIT License | 5 votes |
|
def read_disk_stats() -> DiskStats:
stats = psutil.disk_io_counters()
return DiskStats(
read_count=stats.read_count,
read_bytes=stats.read_bytes,
write_count=stats.write_count,
write_bytes=stats.write_bytes,
)
Example #30
| Source File: health.py From openwhisk-package-kafka with Apache License 2.0 | 5 votes |
|
def generateHealthReport(consumers, lastCanaryTime):
healthReport = {}
healthReport['last_db_canary'] = secondsSince(lastCanaryTime)
healthReport['uptime'] = getUpdateTime()
healthReport['cpu_times'] = getCPUTimes()
healthReport['cpu_percent'] = getCPUPercent()
healthReport['virtual_memory'] = getVirtualMemory()
healthReport['swap_memory'] = getSwapMemory()
healthReport['disk_usage'] = getDiskUsage()
healthReport['disk_io_counters'] = getDiskIOCounters()
healthReport['net_io_counters'] = getNetworkIOCounters()
healthReport['consumers'] = getConsumers(consumers)
return healthReport
