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()