def r_engine_status(): cpu_used = int(round((psutil.cpu_times().user * 100) + \ (psutil.cpu_times().system * 100), 0)) cpu_free = int(round(psutil.cpu_times().idle * 100, 0)) s = { "cpu": { "used": cpu_used, "free": cpu_free }, "memory": { "physical": { "used": psutil.phymem_usage().used, "free": psutil.phymem_usage().free }, "virtual": { "used": psutil.virtmem_usage().used, "free": psutil.virtmem_usage().free } }, "disk": { "used": psutil.disk_usage('/').used, "free": psutil.disk_usage('/').free } } r = Response("success", "status", s).get() return r
def get_HRRR_value(getthisDATE): """ Getting HRRR data, just return the value """ print getthisDATE, psutil.virtmem_usage().used/1000000000, psutil.virtmem_usage().percent H = get_hrrr_variable(getthisDATE, 'TMP:2 m', fxx=0, model='hrrr', field='sfc', value_only=True, verbose=False) return H['value']
def get_virtmem(): usage = {} fields = list(virtmem_usage()._fields) mem = virtmem_usage() for field in fields: usage["virtual_memory_" + field] = mem.__getattribute__(field) return usage
def stat(self): ds = dict() ds['pt'] = int(psutil.phymem_usage().total / 1024) ds['pf'] = int(psutil.phymem_usage().free / 1024) ds['pu'] = int(psutil.phymem_usage().used / 1024) ds['pb'] = int(psutil.phymem_buffers() / 1024) ds['pc'] = int(psutil.cached_phymem() / 1024) ds['st'] = int(psutil.virtmem_usage().total / 1024) ds['su'] = int(psutil.virtmem_usage().used / 1024) return ds
def getMemStatus(self): memstatus = {} memstatus['total_phymem'] = str(int(psutil.TOTAL_PHYMEM ) /1024 /1024) + " MB" memstatus['total_virtmem'] = str(int(psutil.total_virtmem()) /1024 /1024) + " MB" memstatus['phymem_usage_percent'] = psutil.phymem_usage().percent memstatus['phymem_usage_used'] = str(int(psutil.phymem_usage().used) /1024 /1024) + "MB" memstatus['phtmem_usage_free'] = str(int(psutil.phymem_usage().free) /1024 /1024) + "MB" memstatus['virtmem_usage_percent'] = psutil.virtmem_usage().percent memstatus['virtmem_usage_used'] = str(int(psutil.virtmem_usage().used) /1024 /1024) + "MB" memstatus['virtmem_usage_free'] = str(int(psutil.virtmem_usage().free) /1024 /1024) + "MB" return memstatus
def get_memory_stats(self): memory = { "physical": { "used": psutil.phymem_usage().used, "free": psutil.phymem_usage().free }, "virtual": { "used": psutil.virtmem_usage().used, "free": psutil.virtmem_usage().free } } return memory
def printStatus(out, checkcpu): doc=getDOMImplementation().createDocument(None, "status", None) node=doc.createElement("node") a=XMLJobManager() status=a.listByStatus() node.setAttribute("running", str(is_running())) node.setAttribute("pending", str(status[0])) node.setAttribute("processing", str(status[1])) node.setAttribute("finished", str(status[2])) node.setAttribute("failed", str(status[3])) doc.documentElement.appendChild(node) mem=doc.createElement("memory") phy=psutil.phymem_usage() virt=psutil.virtmem_usage() mem.setAttribute("total_physical", str(phy.total)) mem.setAttribute("avail_physical", str(phy.total-phy.used)) mem.setAttribute("total_virtual", str(virt.total)) mem.setAttribute("avail_virtual", str(virt.total-virt.used)) doc.documentElement.appendChild(mem) if checkcpu: cpu=doc.createElement("cpu") cpu.setAttribute("usage", str(psutil.cpu_percent(3))) doc.documentElement.appendChild(cpu) lsl=LocalStoreList() for disk in lsl.disks: d=doc.createElement("disk") d.setAttribute("guid", disk.uuid) d.setAttribute("online", str(disk.online)) d.setAttribute('freespace', str(disk.freespace)) doc.documentElement.appendChild(d) doc.writexml(out)
def get_snapshot_as_list(self): ps = psutil.Process(self.pid) return (self.group(ps.get_memory_info()[0]), self.group(ps.get_memory_info()[1]), '%02d' % ps.get_cpu_percent(), self.group(psutil.phymem_usage().free), self.group(psutil.virtmem_usage().free))
def cpustat(self): tags = "node:%s %s" % (self.nodename, self.tags) val = int(psutil.cpu_percent()) measurement = "cpu_perc" key = "%s.%s" % (self.nodename, measurement) self.measure(key, measurement, tags, val, aggrkey=measurement) val = int(psutil.avail_phymem() / 1024 / 1024) measurement = "mem_free_mb" key = "%s.%s" % (self.nodename, measurement) self.measure(key, measurement, tags, val, aggrkey=measurement) val = int(psutil.virtmem_usage()[3]) measurement = "mem_virt_perc" key = "%s.%s" % (self.nodename, measurement) self.measure(key, measurement, tags, val, aggrkey=measurement) val = int(psutil.phymem_usage()[2]) measurement = "mem_phy_perc" key = "%s.%s" % (self.nodename, measurement) self.measure(key, measurement, tags, val, aggrkey=measurement) res = psutil.cpu_times_percent() names = [ "cputimeperc_user", "cputimeperc_nice", "cputimeperc_system", "cputimeperc_idle", "cputimeperc_iowait", "cputimeperc_irq", "cputimeperc_softirq", "steal", "guest", "guest_nice" ] for i in range(len(names)): if names[i].startswith("cputime"): val = int(res[i]) measurement = names[i] key = "%s.%s" % (self.nodename, measurement) self.measure(key, measurement, tags, val, aggrkey=measurement)
def runinsert(): cpu_usage = psutil.cpu_percent() mem_usage = psutil.phymem_usage().percent disk_usage = psutil.disk_usage('/').percent virtual = psutil.virtmem_usage().percent network = simplejson.dumps(psutil.network_io_counters(True)) conn = sqlite3.connect('stats.db') cur = conn.cursor() cur.execute("DELETE FROM stats WHERE timestamp < datetime('now','localtime','-7 days')") # cur.execute("DELETE FROM stats WHERE timestamp < datetime('now', 'localtime','-1 hour')") conn.commit() cur.execute("INSERT INTO stats (cpu, memory, disk, virtual, network) VALUES (?, ?, ?, ?, ? )", (cpu_usage, mem_usage, disk_usage, virtual, network)) # DUBUG # cur.execute("SELECT * FROM stats") # print(cur.fetchall()) conn.commit() conn.close()
def get_mem_stats(): '''return mem stats''' if hasattr(psutil, 'cached_phymem') and hasattr(psutil, 'phymem_buffers'): cachemem = psutil.cached_phymem() + psutil.phymem_buffers() else: cachemem = -1 phymem = psutil.phymem_usage() mem = { 'cache': cachemem, 'total': phymem.total, 'used': phymem.used, 'free': phymem.free, 'percent': phymem.percent } virtmem = psutil.virtmem_usage() memswap = { 'total': virtmem.total, 'used': virtmem.used, 'free': virtmem.free, 'percent': virtmem.percent } return {"cache": cachemem, "mem": mem, "swap": memswap}
def calculate_resizing_tofitmemory(x_size,y_size,n_slices,byte): """ Predicts the percentage (between 0 and 1) to resize the image to fit the memory, giving the following information: x_size, y_size: image size n_slices: number of slices byte: bytes allocated for each pixel sample """ imagesize = x_size * y_size * n_slices * byte * 28 # USING LIBSIGAR #import sigar #sg = sigar.open() #ram_free = sg.mem().actual_free() #ram_total = sg.mem().total() #swap_free = sg.swap().free() #sg.close() # USING PSUTIL import psutil try: if (psutil.version_info>=(0,6,0)): ram_free = psutil.virtual_memory().available ram_total = psutil.virtual_memory().total swap_free = psutil.swap_memory().free else: ram_free = psutil.phymem_usage().free + psutil.cached_phymem() + psutil.phymem_buffers() ram_total = psutil.phymem_usage().total swap_free = psutil.virtmem_usage().free except: print "Exception! psutil version < 0.3 (not recommended)" ram_total = psutil.TOTAL_PHYMEM # this is for psutil < 0.3 ram_free = 0.8 * psutil.TOTAL_PHYMEM swap_free = psutil.avail_virtmem() print "RAM_FREE=", ram_free print "RAM_TOTAL=", ram_total if (sys.platform == 'win32'): if (platform.architecture()[0] == '32bit'): if ram_free>1400000000: ram_free=1400000000 if ram_total>1400000000: ram_total=1400000000 if (sys.platform == 'linux2'): if (platform.architecture()[0] == '32bit'): if ram_free>3500000000: ram_free=3500000000 if ram_total>3500000000: ram_total=3500000000 if (swap_free>ram_total): swap_free=ram_total resize = (float((ram_free+0.5*swap_free)/imagesize)) resize=math.sqrt(resize) # this gives the "resize" for each axis x and y if (resize>1): resize=1 return round(resize,2)
def get_mem_swap(self,): """ Get memory and swap usage """ try: # psutil >= 0.6.0 phymem = psutil.virtual_memory() buffers = psutil.virtual_memory().buffers cached = psutil.virtual_memory().cached vmem = psutil.swap_memory() except AttributeError: # psutil > 0.4.0 and < 0.6.0 phymem = psutil.phymem_usage() buffers = getattr(psutil, 'phymem_buffers', lambda: 0)() cached = getattr(psutil, 'cached_phymem', lambda: 0)() vmem = psutil.virtmem_usage() mem_used = phymem.total - (phymem.free + buffers + cached) return ( phymem.percent, mem_used, phymem.total, vmem.percent, vmem.used, vmem.total)
def collect_virtmem_usage(self): """ TODO skip the percentage? it can be calculated by graphite, so... """ stats = psutil.virtmem_usage() for k,v in stats._asdict().iteritems(): self.add_data("virtmem.%s"%k,v)
def info_loop(max_ctr = 100): exit_loop = False internal_ctr = 0 while not exit_loop: q = psutil.cpu_percent(interval=1) #q = q/10 cpuload = '%.0f'%(q) cpuload = 'cpu load: ' + cpuload + '%' print cpuload #ser.write(cpuload) q = psutil.phymem_usage() # mem = '%.0f'%(q.percent/10) mem = '%.0f'%(q.percent) mem = 'memory: ' + mem + '%' print mem #ser.write(mem) q = psutil.virtmem_usage() virtmem = '%.0f'%(q.percent/10) virtmem = 'virtmem: '+virtmem + '%' print virtmem time.sleep(0.5) internal_ctr = internal_ctr + 1 if (internal_ctr > max_ctr): self.exit_loop = True print '\n'
def get_mem_stats(): '''return mem stats''' if hasattr(psutil, 'cached_phymem') and hasattr(psutil, 'phymem_buffers'): cachemem = psutil.cached_phymem() + psutil.phymem_buffers() else: cachemem = -1 phymem = psutil.phymem_usage() mem = { 'cache': cachemem, 'total': phymem.total, 'used': phymem.used, 'free': phymem.free, 'percent': phymem.percent } virtmem = psutil.virtmem_usage() memswap = { 'total': virtmem.total, 'used': virtmem.used, 'free': virtmem.free, 'percent': virtmem.percent } return { "cache": cachemem, "mem": mem, "swap": memswap }
def prepare_memory(self): physmem = psutil.phymem_usage() vmem = psutil.virtual_memory() swap = psutil.virtmem_usage() return { 'virtual': { 'total': vmem.total, 'used': vmem.used, 'available': vmem.available, 'percent': vmem.percent, 'free': vmem.free, 'active': vmem.active, 'inactive': vmem.inactive, 'wired': vmem.wired, }, 'physical': { 'total': physmem.total, 'used': physmem.used, 'free': physmem.free, 'percent': physmem.percent, }, 'swap': { 'total': swap.total, 'used': swap.used, 'free': swap.free, 'percent': swap.percent, }, }
def do_index(environ, start_response): env = Environment(loader=FileSystemLoader(environ['DOCUMENT_ROOT'])); template = env.get_template('index.html') start_response('200 OK',[('Content-Type','text/html')]) ## getting CPU info cpu_info = psutil.cpu_percent(interval=1, percpu=True) phymem_info = psutil.phymem_usage() virtmem_info = psutil.virtmem_usage() disk_info = psutil.disk_usage(config.map['global']['data_dir']) ## getting status of modules mod_exec_IF.connect(); if ( mod_exec_IF.connected() ): procs = mod_exec_IF.list(); for mod in procs: if mod.state == mod_exec_IF.RUNNING: mod.statestr = 'RUN' elif mod.state == mod_exec_IF.RESTARTING: mod.statestr = 'RESTART' elif mod.state == mod_exec_IF.STOPPED: mod.statestr = 'STOPPED' else: procs = [] return [str(template.render( cpu_info=cpu_info,phymem_info=phymem_info,virtmem_info=virtmem_info,disk_info=disk_info, procs_connected=mod_exec_IF.connected(), procs=procs ))]
def cpustat(self): tags="node:%s %s"%(self.nodename,self.tags) val=int(psutil.cpu_percent()) measurement="cpu_perc" key="%s.%s"%(self.nodename,measurement) self.measure(key,measurement,tags,val,aggrkey=measurement) val=int(psutil.avail_phymem()/1024/1024) measurement="mem_free_mb" key="%s.%s"%(self.nodename,measurement) self.measure(key,measurement,tags,val,aggrkey=measurement) val=int(psutil.virtmem_usage()[3]) measurement="mem_virt_perc" key="%s.%s"%(self.nodename,measurement) self.measure(key,measurement,tags,val,aggrkey=measurement) val=int(psutil.phymem_usage()[2]) measurement="mem_phy_perc" key="%s.%s"%(self.nodename,measurement) self.measure(key,measurement,tags,val,aggrkey=measurement) res=psutil.cpu_times_percent() names=["cputimeperc_user","cputimeperc_nice","cputimeperc_system","cputimeperc_idle","cputimeperc_iowait","cputimeperc_irq","cputimeperc_softirq","steal","guest","guest_nice"] for i in range(len(names)): if names[i].startswith("cputime"): val=int(res[i]) measurement=names[i] key="%s.%s"%(self.nodename,measurement) self.measure(key,measurement,tags,val,aggrkey=measurement)
def report_mem(prev_values=None, msg=None): """ Show status of phy/virt mem, and if given previous values, report differences requires the psutil module - avail in apt-get, but I used pip """ if msg is None: msg = "" else: msg += ": " if type(prev_values) == type(""): # catch error in prev_values msg += prev_values prev_values = None print("need msg= in call to report_mem") # available in linux is free + buffers + cached if hasattr(psutil, "swap_memory"): # new version (0.7+) pm = psutil.virtual_memory().available # was psutil.avail_phymem() vm = psutil.swap_memory().free # was psutil.avail_virtmem() else: pm = psutil.phymem_usage().free # was .avail_phymem() vm = psutil.virtmem_usage().free # avail_virtmem() tim = seconds() print("{msg}{pm:.3g} GB phys mem, {vm:.3g} GB virt mem avail".format(msg=msg, pm=pm / 1e9, vm=vm / 1e9)), if prev_values is None: print() else: print( "- dt={dt:.2g}s, used {pm:.2g} GB phys, {vm:.2g} GB virt".format( pm=(prev_values[0] - pm) / 1e9, vm=(prev_values[1] - vm) / 1e9, dt=tim - prev_values[2] ) ) return (pm, vm, tim)
def query_system_status(): """Query global mem, CPU, disk, and network (if present)""" uptime = int(time.time() - psutil.BOOT_TIME) uptime = str(datetime.timedelta(seconds=uptime)) try: used_mem = psutil.virtmem_usage().percent used_cpu = psutil.cpu_percent( percpu=False) #N.B Only looking at one CPU used_disk = psutil.disk_usage('/').percent total_network = psutil.network_io_counters(pernic=True) network_sent, network_rcvd = -1, -1 if network_interface in total_network: network_sent = round( total_network[network_interface].bytes_sent / 1024.0 / 1024.0, 2) network_rcvd = round( total_network[network_interface].bytes_recv / 1024.0 / 1024.0, 2) except psutil.AccessDenied: loggging.error("Access denied when trying to query PID %d" % p) return None return { 'used_mem': used_mem, 'used_cpu': used_cpu, 'used_disk': used_disk, 'network_sent': network_sent, 'network_rcvd': network_rcvd, 'uptime': uptime }
def dump_tolog(cCpu, cSensor, cData): logFile = open("data/ForensicLog.txt", 'a+') cPhyMem = psutil.phymem_usage() cVirMem = psutil.virtmem_usage() cNetTraffic = psutil.network_io_counters(pernic=True) cPartitionInfo = psutil.disk_partitions() cActiveProcess = '' logFile.write('*===================================================*' + '\n') logFile.write('|Forensic Activity Logged at: ' + datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") + '\n') logFile.write('*===================================================*' + '\n') logFile.write('SYSCOND: MALFUNCTION | CPU LOAD: ' + cCpu + '% | SENSOR: ' + cSensor + ' | READ: ' + cData + '\n') logFile.write('PHYSICAL MEMORY:\n' + str(cPhyMem) + '\n\n') logFile.write('VIRTUAL MEMORY :\n' + str(cVirMem) + '\n\n') logFile.write('NETWORK STATUS :\n' + str(cNetTraffic) + '\n\n') logFile.write('MOUNTED DISKS :\n' + str(cPartitionInfo) + '\n\n') logFile.write('PROCESS LIST :\n') for proc in psutil.process_iter(): logFile.write(str(proc) + ',') logFile.write('\n') logFile.close() return
def __init__(self, interval, history_len): """ :param interval: Collect statistics according to this interval. :param history_len: Use this many to compute avg/max statistics. """ self.interval = interval self.history_len = history_len try: import psutil # @UnresolvedImport @Reimport except: self._available = False else: self._available = True self.cpu = Collect('cpu', lambda: psutil.cpu_percent(interval=0), interval, history_len) try: # new in 0.8 psutil.virtual_memory().percent get_mem = lambda: psutil.virtual_memory().percent except: get_mem = lambda: psutil.phymem_usage().percent self.mem = Collect('mem', get_mem, interval, history_len) try: # new in 0.8 psutil.swap_memory().percent get_mem = lambda: psutil.swap_memory().percent except: get_mem = lambda: psutil.virtmem_usage().percent self.swap_mem = Collect('swap', get_mem, interval, history_len)
def runinsert(): cpu_usage = psutil.cpu_percent() mem_usage = psutil.phymem_usage().percent disk_usage = psutil.disk_usage('/').percent virtual = psutil.virtmem_usage().percent network = simplejson.dumps(psutil.network_io_counters(True)) conn = sqlite3.connect('stats.db') cur = conn.cursor() cur.execute( "DELETE FROM stats WHERE timestamp < datetime('now','localtime','-7 days')" ) # cur.execute("DELETE FROM stats WHERE timestamp < datetime('now', 'localtime','-1 hour')") conn.commit() cur.execute( "INSERT INTO stats (cpu, memory, disk, virtual, network) VALUES (?, ?, ?, ?, ? )", (cpu_usage, mem_usage, disk_usage, virtual, network)) # DUBUG # cur.execute("SELECT * FROM stats") # print(cur.fetchall()) conn.commit() conn.close()
def collect(self): """ Collect memory stats """ if os.access(self.PROC, os.R_OK): file = open(self.PROC) data = file.read() file.close() for line in data.splitlines(): try: name, value, units = line.split() name = name.rstrip(':') value = int(value) if (name not in _KEY_MAPPING and 'detailed' not in self.config): continue for unit in self.config['byte_unit']: value = diamond.convertor.binary.convert(value=value, oldUnit=units, newUnit=unit) self.publish(name, value, metric_type='GAUGE') # TODO: We only support one unit node here. Fix it! break except ValueError: continue return True elif psutil: phymem_usage = psutil.phymem_usage() virtmem_usage = psutil.virtmem_usage() units = 'b' for unit in self.config['byte_unit']: value = diamond.convertor.binary.convert( value=phymem_usage.total, oldUnit=units, newUnit=unit) self.publish('MemTotal', value, metric_type='GAUGE') value = diamond.convertor.binary.convert( value=phymem_usage.free, oldUnit=units, newUnit=unit) self.publish('MemFree', value, metric_type='GAUGE') value = diamond.convertor.binary.convert( value=virtmem_usage.total, oldUnit=units, newUnit=unit) self.publish('SwapTotal', value, metric_type='GAUGE') value = diamond.convertor.binary.convert( value=virtmem_usage.free, oldUnit=units, newUnit=unit) self.publish('SwapFree', value, metric_type='GAUGE') # TODO: We only support one unit node here. Fix it! break return True return None
def action(): import psutil import os import statsd statscl = statsd.StatsClient() pipe = statscl.pipeline() results={} val=psutil.cpu_percent() results["cpu.percent"]=val results["cpu.promile"]=val * 10 # we store promile to have more percision cput= psutil.cpu_times() for key in cput.__dict__.keys(): val=cput.__dict__[key] results["cpu.time.%s"%(key)]=val counter=psutil.network_io_counters(False) bytes_sent, bytes_recv, packets_sent, packets_recv, errin, errout, dropin, dropout=counter results["network.kbytes.recv"]=round(bytes_recv/1024.0,0) results["network.kbytes.send"]=round(bytes_sent/1024.0,0) results["network.packets.recv"]=packets_recv results["network.packets.send"]=packets_sent results["network.error.in"]=errin results["network.error.out"]=errout results["network.drop.in"]=dropin results["network.drop.out"]=dropout avg1min, avg5min, avg15min = os.getloadavg() results["load.avg1min"] = int(avg1min * 100) results["load.avg5min"] = int(avg5min * 100) results["load.avg15min"] = int(avg15min * 100) memory=psutil.virtual_memory() results["memory.used"]=round((memory.used - memory.cached)/1024.0/1024.0,2) results["memory.cached"]=round(memory.cached/1024.0/1024.0,2) results["memory.free"]=round(memory.total/1024.0/1024.0,2) - results['memory.used'] - results['memory.cached'] results["memory.percent"]=memory.percent total,used,free,percent,sin,sout=psutil.virtmem_usage() results["swap.free"]=round(free/1024.0/1024.0,2) results["swap.used"]=round(used/1024.0/1024.0,2) results["swap.percent"]=percent stat = j.system.fs.fileGetContents('/proc/stat') stats = dict() for line in stat.splitlines(): _, key, value = re.split("^(\w+)\s", line) stats[key] = value num_ctx_switches = int(stats['ctxt']) results["cpu.num_ctx_switches"]=num_ctx_switches for key, value in results.iteritems(): pipe.gauge("%s_%s_%s" % (j.application.whoAmI.gid, j.application.whoAmI.nid, key), int(round(value))) pipe.send() return results
def loadSummaryData(self): summary_data = {} summary_data['cpu'] = [psutil.cpu_percent()] summary_data['memory'] = [psutil.phymem_usage().percent] summary_data['disk'] = [psutil.disk_usage('/').percent] summary_data['virtual'] = [psutil.virtmem_usage().percent] summary_data['uptime'] = commands.getoutput('uptime') return summary_data
def update(self): phys_mem = psutil.phymem_usage() self.mem_usage = {'total': phys_mem.total, 'used': phys_mem.used, 'free': phys_mem.free, 'percent': phys_mem.percent, 'buffers': psutil.phymem_buffers(), 'cached': psutil.cached_phymem()} virt_mem = psutil.virtmem_usage() self.swap_usage = {'total': virt_mem.total, 'used': virt_mem.used, 'free': virt_mem.free, 'percent': virt_mem.percent}
def getMemoryUsage(): phymem = psutil.phymem_usage() # @IgnorePep8 virtmem = psutil.virtmem_usage() # @IgnorePep8 swapmem = psutil.swap_memory() # @IgnorePep8 return { # @IgnorePep8 "physical" : phymem.percent, # @IgnorePep8 "virtual" : virtmem.percent, # @IgnorePep8 "swap" : swapmem.percent} # @IgnorePep8
def make_memsafe(): if sys.platform.startswith('linux'): import resource import psutil for rsrc in (resource.RLIMIT_AS, resource.RLIMIT_DATA): freemem = psutil.virtmem_usage().free hard = int(round(freemem *.8)) soft = hard resource.setrlimit(rsrc, (soft, hard)) #limit to 80% of available memory
def calculateSystemUsage(self): cpuall = psutil.cpu_percent(interval=0) cores = len(psutil.cpu_percent(interval=0, percpu=True)) diskusage = psutil.disk_usage("/") physramusage = psutil.phymem_usage() virtramusage = psutil.virtmem_usage() processes = len(psutil.get_pid_list()) theList = [cpuall, cores, diskusage[3], physramusage[3], virtramusage[3], processes] return theList
def make_memsafe(): if sys.platform.startswith('linux'): import resource import psutil for rsrc in (resource.RLIMIT_AS, resource.RLIMIT_DATA): freemem = psutil.virtmem_usage().free hard = int(round(freemem * .8)) soft = hard resource.setrlimit(rsrc, (soft, hard)) #limit to 80% of available memory
def virtual_memory_usage(): ''' Return a dict that describes free and available memory, both physical and virtual. CLI Example:: salt '*' ps.virtual_memory_usage ''' return dict(psutil.virtmem_usage()._asdict())
def memory(warning = 0.85, critical=0.95): pm = psutil.phymem_usage() vm = psutil.virtmem_usage() sf = sv = "ok" ff = pm.percent / 100.0 fv = vm.percent / 100.0 if ff > warning: sf = "warning" if ff > critical: sf = "critical" if fv > warning: sv = "warning" if fv > critical: sv = "critical" alert("phisycal memory", sf, ff, "%.2f%% used\n\n%s" % (ff * 100, memory_report())) alert("virtual memory", sv, fv, "%.2f%% used\n\n%s" % (fv * 100, memory_report()))
def print_header(procs_status): """Print system-related info, above the process list.""" def get_dashes(perc): dashes = "|" * int((float(perc) / 10 * 4)) empty_dashes = " " * (40 - len(dashes)) return dashes, empty_dashes # cpu usage for cpu_num, perc in enumerate(psutil.cpu_percent(interval=0, percpu=True)): dashes, empty_dashes = get_dashes(perc) print_line(" CPU%-2s [%s%s] %5s%%" % (cpu_num, dashes, empty_dashes, perc)) # physmem usage (on linux we include buffers and cached values # to match htop results) phymem = psutil.phymem_usage() dashes, empty_dashes = get_dashes(phymem.percent) buffers = getattr(psutil, 'phymem_buffers', lambda: 0)() cached = getattr(psutil, 'cached_phymem', lambda: 0)() used = phymem.total - (phymem.free + buffers + cached) line = " Mem [%s%s] %5s%% %6s/%s" % ( dashes, empty_dashes, phymem.percent, str(int(used / 1024 / 1024)) + "M", str(int(phymem.total / 1024 / 1024)) + "M" ) print_line(line) # swap usage vmem = psutil.virtmem_usage() dashes, empty_dashes = get_dashes(vmem.percent) line = " Swap [%s%s] %5s%% %6s/%s" % ( dashes, empty_dashes, vmem.percent, str(int(vmem.used / 1024 / 1024)) + "M", str(int(vmem.total / 1024 / 1024)) + "M" ) print_line(line) # processes number and status st = [] for x, y in procs_status.items(): if y: st.append("%s=%s" % (x, y)) st.sort(key=lambda x: x[:3] in ('run', 'sle'), reverse=1) print_line(" Processes: %s (%s)" % (len(procs), ' '.join(st))) # load average, uptime uptime = datetime.now() - datetime.fromtimestamp(psutil.BOOT_TIME) av1, av2, av3 = os.getloadavg() line = " Load average: %.2f %.2f %.2f Uptime: %s" \ % (av1, av2, av3, str(uptime).split('.')[0]) print_line(line)
def print_header(procs_status, num_procs): """Print system-related info, above the process list.""" def get_dashes(perc): dashes = "|" * int((float(perc) / 10 * 4)) empty_dashes = " " * (40 - len(dashes)) return dashes, empty_dashes # cpu usage for cpu_num, perc in enumerate(psutil.cpu_percent(interval=0, percpu=True)): dashes, empty_dashes = get_dashes(perc) print_line(" CPU%-2s [%s%s] %5s%%" % (cpu_num, dashes, empty_dashes, perc)) # physmem usage (on linux we include buffers and cached values # to match htop results) phymem = psutil.phymem_usage() dashes, empty_dashes = get_dashes(phymem.percent) buffers = getattr(psutil, 'phymem_buffers', lambda: 0)() cached = getattr(psutil, 'cached_phymem', lambda: 0)() used = phymem.total - (phymem.free + buffers + cached) line = " Mem [%s%s] %5s%% %6s/%s" % ( dashes, empty_dashes, phymem.percent, str(int(used / 1024 / 1024)) + "M", str(int(phymem.total / 1024 / 1024)) + "M" ) print_line(line) # swap usage vmem = psutil.virtmem_usage() dashes, empty_dashes = get_dashes(vmem.percent) line = " Swap [%s%s] %5s%% %6s/%s" % ( dashes, empty_dashes, vmem.percent, str(int(vmem.used / 1024 / 1024)) + "M", str(int(vmem.total / 1024 / 1024)) + "M" ) print_line(line) # processes number and status st = [] for x, y in procs_status.items(): if y: st.append("%s=%s" % (x, y)) st.sort(key=lambda x: x[:3] in ('run', 'sle'), reverse=1) print_line(" Processes: %s (%s)" % (num_procs, ' '.join(st))) # load average, uptime uptime = datetime.now() - datetime.fromtimestamp(psutil.BOOT_TIME) av1, av2, av3 = os.getloadavg() line = " Load average: %.2f %.2f %.2f Uptime: %s" \ % (av1, av2, av3, str(uptime).split('.')[0]) print_line(line)
def _handler_update_memory_display(self): vmu = psutil.virtmem_usage() # SWAP / pagefile memory pmu = psutil.phymem_usage() # physical RAM # we show the user how much physical+swap they're using out of the total available total_used = (vmu[1]+pmu[1]) / 1024 / 1024 / 1024.0 total_avail = (vmu[0]+vmu[0]) / 1024 / 1024 / 1024.0 mem_msg = "%.1f / %.1f GB" % (total_used , total_avail) # write into the second section of the statusbar self._main_frame.GetStatusBar().SetStatusText(mem_msg, 1) # and log a warning to the message window if (total_avail > 0) and (total_used / total_avail > 0.95): self.log_info("You have almost exhausted all available memory. Free up memory to prevent crashing.")
def format_output(self): phy = psutil.phymem_usage() virt = psutil.virtmem_usage() return { "phy_mem_total": phy[0] / ONE_MB, "phy_mem_used": phy[1] / ONE_MB, "phy_mem_free": phy[2] / ONE_MB, "phy_mem_percent": phy[3], "virt_mem_total": virt[0] / ONE_MB, "virt_mem_used": virt[1] / ONE_MB, "virt_mem_free": virt[2] / ONE_MB, "virt_mem_percent": virt[3], }
def snapshot(self): phymem = psutil.phymem_usage() # memory usage is in bytes (long int) virtmem = psutil.virtmem_usage() self.cpu = time.clock() # current process cpu time in seconds (float) self.wall = time.time() # current wall clock time in seconds since the epoch (float) self.mem_total = phymem.total self.mem = phymem.used self.mem_free = phymem.free self.mem_pc = phymem.percent self.vmem_total = virtmem.total self.vmem = virtmem.used self.vmem_free = virtmem.free self.vmem_pc = virtmem.percent
def memory(warning=0.85, critical=0.95): pm = psutil.phymem_usage() vm = psutil.virtmem_usage() sf = sv = "ok" ff = pm.percent / 100.0 fv = vm.percent / 100.0 if ff > warning: sf = "warning" if ff > critical: sf = "critical" if fv > warning: sv = "warning" if fv > critical: sv = "critical" alert("phisycal memory", sf, ff, "%.2f%% used\n\n%s" % (ff * 100, memory_report())) alert("virtual memory", sv, fv, "%.2f%% used\n\n%s" % (fv * 100, memory_report()))
def test_avail_virtmem(self): # This test is not particularly accurate and may fail if the OS is # consuming memory for other applications. # We just want to test that the difference between psutil result # and sysctl's is not too high. p = subprocess.Popen("sysctl vm.vmtotal", shell=1, stdout=subprocess.PIPE) result = p.communicate()[0].strip() if sys.version_info >= (3,): result = str(result, sys.stdout.encoding) _, sysctl_avail_virtmem = parse_sysctl_vmtotal(result) psutil_avail_virtmem = psutil.virtmem_usage().free difference = abs(sysctl_avail_virtmem - psutil_avail_virtmem) # let's assume the test is failed if difference is > 0.5 MB if difference > (0.5 * 2**20): self.fail(difference)
def _handler_update_memory_display(self): vmu = psutil.virtmem_usage() # SWAP / pagefile memory pmu = psutil.phymem_usage() # physical RAM # we show the user how much physical+swap they're using out of the total available total_used = (vmu[1] + pmu[1]) / 1024 / 1024 / 1024.0 total_avail = (vmu[0] + vmu[0]) / 1024 / 1024 / 1024.0 mem_msg = "%.1f / %.1f GB" % (total_used, total_avail) # write into the second section of the statusbar self._main_frame.GetStatusBar().SetStatusText(mem_msg, 1) # and log a warning to the message window if (total_avail > 0) and (total_used / total_avail > 0.95): self.log_info( "You have almost exhausted all available memory. Free up memory to prevent crashing." )
def virtual_memory_usage(): ''' .. deprecated:: Helium Use :mod:`ps.virtual_memory <salt.modules.ps.virtual_memory>` instead. Return a dict that describes free and available memory, both physical and virtual. CLI Example: .. code-block:: bash salt '*' ps.virtual_memory_usage ''' salt.utils.warn_until( 'Helium', '\'ps.virtual_memory_usage\' is deprecated. Please use' '\'ps.virtual_memory\' instead. This functionality will' 'be removed in Salt {version}.') return dict(psutil.virtmem_usage()._asdict())
def test_total_virtmem(self): # This test is not particularly accurate and may fail if the OS is # consuming memory for other applications. # We just want to test that the difference between psutil result # and sysctl's is not too high. p = subprocess.Popen("sysctl vm.vmtotal", shell=1, stdout=subprocess.PIPE) result = p.communicate()[0].strip() if sys.version_info >= (3,): result = str(result, sys.stdout.encoding) sysctl_total_virtmem, _ = parse_sysctl_vmtotal(result) psutil_total_virtmem = psutil.virtmem_usage().total difference = abs(sysctl_total_virtmem - psutil_total_virtmem) # On my system I get a difference of 4657152 bytes, probably because # the system is consuming memory for this same test. # Assuming psutil is right, let's use a tollerance of 10 MB and consider # the test as failed if we go over it. if difference > (10 * 2**20): self.fail("sysctl=%s; psutil=%s; difference=%s;" %( sysctl_total_virtmem, psutil_total_virtmem, difference))
def values(self): try: loadavg1, loadavg5, loadavg15 = os.getloadavg() except OSError: loadavg1, loadavg5, loadavg15 = 0, 0, 0 try: phys = psutil.phymem_usage() virt = psutil.virtmem_usage() return {'results': { 'physical': (phys.percent, 'Percent'), 'virtual' : (virt.percent, 'Percent'), 'loadavg1': (loadavg1, 'Count'), 'loadavg5': (loadavg5, 'Count'), 'loadavg15': (loadavg15, 'Count'), } } except OSError as e: raise MetricException(e) except psutil.error.AccessDenied as e: raise MetricException('Access denied in psutil')
def do(kwargs): params = ['total', 'used', 'free', 'percent'] ret = obj_to_dict(psutil.phymem_usage(), params, prefix='physical_memory_') ret.update(obj_to_dict(psutil.virtmem_usage(), params, prefix='virtual_memory_')) ret.update({'timestamp': unicode(datetime.utcnow())}) yield ret
def test_total_virtmem(self): tot1 = psutil.virtmem_usage().total tot2 = os.path.getsize("/var/vm/swapfile0") self.assertEqual(tot1, tot2)
def collect_virtmem_usage(self): stats = psutil.virtmem_usage() for k, v in stats._asdict().iteritems(): self.registry.gauge("virtmem.%s" % k).set_value(v)
def virtual_mem_size(): """ Return the total amount of virtual memory available on the system. """ return psutil.virtmem_usage().total
def print_header(procs_status): """Print system-related info, above the process list.""" benchmark = [] if len(BENCHMARK_HEADER) == 0: needs_header = True BENCHMARK_HEADER.append('Seconds') else: needs_header = False timedelta = datetime.now() - BENCHMARK_START benchmark.append(str(timedelta.days * 24 * 60 * 60 + timedelta.seconds)) # cpu usage for cpu_num, perc in enumerate(psutil.cpu_percent(interval=0, percpu=True)): # Add the header info to the BENCHMARK_HEADER if needs_header: BENCHMARK_HEADER.append(str(cpu_num)) # Add all percentages for the cpu usage benchmark.append("%5s" % perc) # physmem usage (on linux we include buffers and cached values # to match htop results) phymem = psutil.phymem_usage() buffers = getattr(psutil, 'phymem_buffers', lambda: 0)() cached = getattr(psutil, 'cached_phymem', lambda: 0)() used = phymem.total - (phymem.free + buffers + cached) if needs_header: BENCHMARK_HEADER.append('MemPercent') BENCHMARK_HEADER.append('MemUsed') BENCHMARK_HEADER.append('MemTotal') benchmark.append("%5s" % str(phymem.percent)) benchmark.append("%6s" % str(int(used / 1024 / 1024))) benchmark.append("%s" % str(int(phymem.total / 1024 / 1024))) # swap usage vmem = psutil.virtmem_usage() if needs_header: BENCHMARK_HEADER.append('SwapPercent') BENCHMARK_HEADER.append('SwapUsed') BENCHMARK_HEADER.append('SwapTotal') benchmark.append("%5s" % str(vmem.percent)) benchmark.append("%6s" % str(int(vmem.used / 1024 / 1024))) benchmark.append("%s" % str(int(vmem.total / 1024 / 1024))) # processes number and status st = [] for x, y in procs_status.items(): if y: st.append("%s=%s" % (x, y)) st.sort(key=lambda x: x[:3] in ('run', 'sle'), reverse=1) if needs_header: BENCHMARK_HEADER.append('Processes') BENCHMARK_HEADER.append('Running') BENCHMARK_HEADER.append('Sleeping') benchmark.append("%s" % len(procs)) if 'running' in st: benchmark.append("%s" % st.split(' ').split('=')[-1]) else: benchmark.append("0") if "sleeping" in st: benchmark.append("%s" % st.split('=')[-1]) else: benchmark.append("0") # load average, uptime uptime = datetime.now() - datetime.fromtimestamp(psutil.BOOT_TIME) av1, av2, av3 = os.getloadavg() line = " Load average: %.2f %.2f %.2f Uptime: %s" \ % (av1, av2, av3, str(uptime).split('.')[0]) if needs_header: BENCHMARK_HEADER.append('Load1') BENCHMARK_HEADER.append('Load2') BENCHMARK_HEADER.append('Load3') BENCHMARK_HEADER.append('Processes') # Now write the header BENCHMARK_FILE.write("%s\n" % '\t'.join(BENCHMARK_HEADER)) benchmark.append("%.2f" % av1) benchmark.append("%.2f" % av2) benchmark.append("%.2f" % av3) return benchmark