def F_Threads(pname):
a = pids()
for i in a:
try:
p = Process(i)
if p.name() == 'java':
cmd = ' '.join(p.cmdline())
if re.search(pname, cmd):
print p.num_threads()
except Exception, e:
continue
def get_stats(self):
"""Return statistics about our node"""
stats = {}
proc = Process()
def get_open_files():
if WINDOWS:
return proc.num_handles()
return proc.num_fds()
try:
self._too_many
except AttributeError:
sleep(1)
kv: "DeadSimpleKV" = self._too_many.get_by_string("DeadSimpleKV")
connected = []
[
connected.append(x) for x in kv.get('onlinePeers')
if x not in connected
]
stats['uptime'] = get_epoch() - kv.get('startTime')
stats['connectedNodes'] = '\n'.join(connected)
stats['blockCount'] = len(blockmetadb.get_block_list())
stats['blockQueueCount'] = len(kv.get('blockQueue'))
stats['threads'] = proc.num_threads()
stats['ramPercent'] = proc.memory_percent()
stats['fd'] = get_open_files()
stats['diskUsage'] = human_size(size(identify_home()))
return json.dumps(stats)
def get_stats(self):
"""Return statistics about our node"""
stats = {}
proc = Process()
def get_open_files():
if WINDOWS: return proc.num_handles()
return proc.num_fds()
try:
self._too_many
except AttributeError:
sleep(1)
comm_inst = self._too_many.get(communicator.OnionrCommunicatorDaemon,
args=(self._too_many, ))
connected = []
[
connected.append(x) for x in comm_inst.onlinePeers
if x not in connected
]
stats['uptime'] = comm_inst.getUptime()
stats['connectedNodes'] = '\n'.join(connected)
stats['blockCount'] = len(blockmetadb.get_block_list())
stats['blockQueueCount'] = len(comm_inst.blockQueue)
stats['threads'] = proc.num_threads()
stats['ramPercent'] = proc.memory_percent()
stats['fd'] = get_open_files()
stats['diskUsage'] = human_size(size(identify_home()))
return json.dumps(stats)
def server_info():
"""Return server statistics."""
started = time()
proc = Process()
process_size = proc.memory_info()
stats = []
memory = virtual_memory()
stats.append('Memory: {used} used of {total} ({percent}%)'.format(
used=naturalsize(memory.used),
total=naturalsize(memory.total),
percent=memory.percent))
bt = boot_time()
uptime = time() - bt
stats.append('Server Uptime: {delta} since {booted}'.format(
delta=util.format_timedelta(datetime.timedelta(seconds=uptime)),
booted=ctime(bt)))
if server.server.started is not None:
stats.append('Process Uptime: {} since {}'.format(
util.format_timedelta(datetime.datetime.utcnow() -
server.server.started),
server.server.started.ctime()))
stats.append('OS Version: {} ({})'.format(platform(), architecture()[0]))
stats.append('{type} : {version}'.format(type=python_implementation(),
version=sys.version))
stats.append('Number Of Threads: %d' % proc.num_threads())
stats.append('Process Memory:')
stats.append('Real: %s' % naturalsize(process_size.rss))
stats.append('Virtual: %s' % naturalsize(process_size.vms))
stats.append('Percent: %.2f' % proc.memory_percent())
stats.append('Lines of code in server: %d' % db.Base.code_lines())
stats.append('Objects in server: %d' % db.Base.number_of_objects())
stats.append('Statistics generated in %.2f seconds.' % (time() - started))
return stats
def track_process(p: psutil.Process):
pid = p.pid
with p.oneshot():
try:
res = p.memory_info()
tracker.add({
f'process.{p.pid}.{p.name()}.rss': res.rss,
f'process.{p.pid}.{p.name()}.vms': res.vms
})
except psutil.AccessDenied:
pass
try:
res = p.memory_percent()
tracker.add({
f'process.{p.pid}.{p.name()}.mem': res,
})
except psutil.AccessDenied:
pass
try:
res = p.cpu_percent()
tracker.add({
f'process.{p.pid}.{p.name()}.cpu': res,
})
except psutil.AccessDenied:
pass
try:
res = p.num_threads()
tracker.add({
f'process.{p.pid}.{p.name()}.threads': res,
})
except psutil.AccessDenied:
pass
def add_new_information_from_process_object(self, process: psutil.Process,
data_retrieval_timestamp: datetime.datetime) -> None:
"""
Adds the new information about the process to the application profile.
This should be mainly used for applications with only one process.
:raises TypeError if process is not of type psutil.Process or data_retrieval_timestamp is not of type
datetime.datetime.
:raises ValueError if data_retrieval_timestamp is newer than current time.
:param process: Information about the specific process.
:type process: psutil.Process
:param data_retrieval_timestamp: The time the data was retrieved.
:type data_retrieval_timestamp: datetime.datetime
"""
if not (isinstance(process, psutil.Process)):
raise TypeError(expected_type_but_received_message.format("process", "psutil.Process", process))
if not (isinstance(data_retrieval_timestamp, datetime.datetime)):
raise TypeError(expected_type_but_received_message.format("data_retrieval_timestamp", "datetime.datetime",
data_retrieval_timestamp))
if data_retrieval_timestamp.replace(tzinfo=None) > datetime.datetime.now():
raise ValueError("Argument data_retrieval_timestamp cannot be newer than current time. Value receive: {}"
.format(data_retrieval_timestamp))
# Get info from the process object. One of the following calls may raise an Error (OS, AccessDenied, etc).
open_files = process.open_files()
memory_info = process.memory_info()
child_process_count = len(process.children())
username = process.username()
threads_number = process.num_threads()
process.cpu_percent()
try:
connections_num = len(process.connections())
except psutil.AccessDenied:
connections_num = 0
time.sleep(0.1) # wait for cpu_percent to return a meaningful value.
cpu_percentage = process.cpu_percent()
self.add_open_files(open_files=open_files, data_retrieval_timestamp=data_retrieval_timestamp)
self.__memory_usages.append(memory_info.rss)
self.__data_retrieval_timestamp.append(data_retrieval_timestamp)
self.__child_processes_count.append(child_process_count)
self.__users.extend(username)
self.__cpu_percent_usages.append(cpu_percentage)
self.__threads_numbers.append(threads_number)
self.__connections_numbers.append(connections_num)
class _ProcessMonitor:
WARNING_THRESHOLD = 100 * 1024 * 1024
busy = False
def __init__(self):
self.process = Process()
self.peak_mem_res = 0
self.low_mem_warning = False
def monitor_task(self):
if sys.stdout.isatty():
while self.busy:
try:
# only print the data out every 10 seconds
if datetime.now().second / 10 == 0:
info = self._get_info()
output.debug(info)
else:
# call get_mem so that we record peak more accurately
self._get_mem()
time.sleep(1)
except Exception:
output.debug_exception()
self.busy = False
pass
else:
# if this isn't a TTY, no point in doing any of this
self.busy = False
def _get_info(self) -> str:
from yawast.external.memory_size import Size
# prime the call to cpu_percent, as the first call doesn't return useful data
self.process.cpu_percent(interval=1)
# use oneshot() to cache the data, so we minimize hits
with self.process.oneshot():
pct = self.process.cpu_percent()
times = self.process.cpu_times()
mem = self._get_mem()
mem_res = "{0:cM}".format(Size(mem.rss))
mem_virt = "{0:cM}".format(Size(mem.vms))
thr = self.process.num_threads()
vm = psutil.virtual_memory()
mem_total = "{0:cM}".format(Size(vm.total))
mem_avail_bytes = vm.available
mem_avail = "{0:cM}".format(Size(vm.available))
if mem_avail_bytes < self.WARNING_THRESHOLD and not self.low_mem_warning:
self.low_mem_warning = True
output.error(f"Low RAM Available: {mem_avail}")
cons = -1
try:
cons = len(self.process.connections(kind="inet"))
except Exception:
# we don't care if this fails
output.debug_exception()
cpu_freq = psutil.cpu_freq()
info = (f"Process Stats: CPU: {pct}% - Sys: {times.system} - "
f"User: {times.user} - Res: {mem_res} - Virt: {mem_virt} - "
f"Available: {mem_avail}/{mem_total} - Threads: {thr} - "
f"Connections: {cons} - CPU Freq: "
f"{int(cpu_freq.current)}MHz/{int(cpu_freq.max)}MHz")
return info
def _get_mem(self):
mem = self.process.memory_info()
if mem.rss > self.peak_mem_res:
self.peak_mem_res = mem.rss
output.debug(f"New high-memory threshold: {self.peak_mem_res}")
return mem
def __enter__(self):
self.busy = True
threading.Thread(target=self.monitor_task).start()
return self
def __exit__(self, exception, value, tb):
self.busy = False
if exception is not None:
return False
def track_process(self, p: psutil.Process):
with p.oneshot():
key = None
if p.pid in self.pids:
key = self.pids[p.pid]
if self.processes[key].name != p.name():
key = None
if key is None:
key = len(self.processes)
self.processes.append(ProcessInfo(key,
p.pid,
p.name()))
self.pids[p.pid] = key
self.data.update({
f'process.{key}.name': p.name(),
f'process.{key}.pid': p.pid,
f'process.{key}.ppid': p.ppid(),
f'process.{key}.create_time': p.create_time(),
})
try:
self.data.update({
f'process.{key}.exe': p.exe(),
})
except (psutil.AccessDenied, psutil.ZombieProcess):
pass
try:
self.data.update({
f'process.{key}.cmdline': '\n'.join(p.cmdline()),
})
except (psutil.AccessDenied, psutil.ZombieProcess):
pass
self.processes[key].active = True
try:
res = p.memory_info()
self.data.update({
f'process.{key}.rss': res.rss,
f'process.{key}.vms': res.vms,
})
except (psutil.AccessDenied, psutil.ZombieProcess):
pass
try:
res = p.cpu_times()
self.data.update({
f'process.{key}.user': res.user,
f'process.{key}.system': res.system,
})
if hasattr(res, 'iowait'):
self.data.update({
f'process.{key}.iowait': res.iowait,
})
except (psutil.AccessDenied, psutil.ZombieProcess):
pass
try:
res = p.cpu_percent()
self.data.update({
f'process.{key}.cpu': res,
})
except (psutil.AccessDenied, psutil.ZombieProcess):
pass
try:
res = p.num_threads()
self.data.update({
f'process.{key}.threads': res,
})
except (psutil.AccessDenied, psutil.ZombieProcess):
pass
def _get_threads_spawned(process: psutil.Process):
# n_threads = process.num_threads()
return process.num_threads()
