def show_widget_with_current_and_past_value(widget): rrd_path = widget.rrd.path() info = rrdtool.info(rrd_path) #last_update = datetime.datetime.fromtimestamp(info["last_update"]).strftime("%m-%d %H:%M") last_update = str(info["last_update"]) current = rrdtool.fetch(rrd_path, "-s", last_update + "-1", "-e", "s+0", "LAST") yesterday = rrdtool.fetch(rrd_path, "-s", last_update + "-1d", "-e", "s+1", "LAST") lastweek = rrdtool.fetch(rrd_path, "-s", last_update + "-1w", "-e", "s+1", "LAST") current_value = current[2][0][0] field_def = None if widget.data_def: try: data_def = eval(widget.data_def.replace("\n", "").replace("\r", "")) ds = (current[1][0]) if data_def.has_key(ds): field_def = data_def[ds] try: data_rrd = rrdtool.fetch(rrd_path, "-s", str(int(last_update)-int(field_def[3]) * 60), "-e", last_update + "-1", "LAST") data_rrd = map(lambda x:x[0],data_rrd[2]) current_value = format_value_def(field_def,data_rrd) except: current_value = format_value(field_def, current_value) else: current_value = get_last_value(current) except: raise return widget.data_def else: current_value = get_last_value(current) return "<td>" + "</td><td>".join([current_value, get_last_value(yesterday, field_def) , get_last_value(lastweek, field_def)]) + "</td>"
def show_widget_with_current_value(widget): rrd_path = widget.rrd.path() info = rrdtool.info(rrd_path) last_update = str(info["last_update"]) current = rrdtool.fetch(rrd_path, "-s", last_update + "-1", "-e", "s+0", "LAST") if widget.data_def: try: data_def = eval(widget.data_def.replace("\n", "").replace("\r", "")) data = list(current[2][0]) ds = current[1] for i in range(0, len(ds)): if data_def.has_key(ds[i]): field_def = data_def[ds[i]] try: data_rrd = rrdtool.fetch(rrd_path, "-s", str(int(last_update)-int(field_def[3]) * 60), "-e", last_update + "-1", "LAST") data_rrd = map(lambda x:x[i],data_rrd[2]) data[i] = format_value_def(field_def,data_rrd) except: data[i] = format_value(field_def, data[i]) else: data[i] = str(data[i]) except: return widget.data_def #raise else: data = map(str, current[2][0]) #return check_date(info) + get_last_value(current) + "</td>" return "<td>" + "</td><td>".join(data) + "</td>"
def getStartTime(self): """Gets the timestamp of the first non-null entry in the RRD""" first = rrdtool.first(self.filename) end = rrdtool.last(self.filename) cf = self.getPeriodCF(first) try: info , _ds_rrd , data = rrdtool.fetch(self.filename, cf, "--start", str(first), "--end", str(end)) except rrdtool.error: # Adjust for daylight saving times first = first - 3600 end = end + 3600 info , _ds_rrd , data = rrdtool.fetch(self.filename, cf, "--start", str(first), "--end", str(end)) #start_rrd = info[0] #end_rrd = info[1] step = info[2] for line in data: all_none = True for value in line: if value is not None: all_none = False if not all_none: break first = first + step if first >= end: raise RRDError("The RRD file looks empty !") return first
def run(args, processId): try: perfPath = "/".join([args.perf_path, str(processId)]) create_cmd = 'RRA:AVERAGE:0.5:1:600\nRRA:AVERAGE:0.5:6:600\nRRA:AVERAGE:0.5:24:600\nRRA:AVERAGE:0.5:288:600\nRRA:MAX:0.5:6:600\nRRA:MAX:0.5:24:600\nRRA:MAX:0.5:288:600' rrd = RRDUtil(create_cmd, args.cycle_time) cycle_begin = time() dp_count = 0 for device in map(str, range(args.device_count)): begin = time() for device_dp in map(str, range(args.device_datapoints)): dp_count += 1 rrd.save(os.path.join(perfPath, device, device_dp), 42, 'GAUGE') for interface in map(str, range(args.component_count)): for interface_dp in map(str, range(args.component_datapoints)): dp_count += 1 path = os.path.join(perfPath, device, 'os', 'interfaces', interface, interface_dp) rrd.save(path, 42, 'DERIVE') rrdtool.fetch(rrd.performancePath(path) + '.rrd', 'AVERAGE', '-s', 'now-%d' % (args.cycle_time*2), '-e', 'now') cycle_duration = time() - cycle_begin return (cycle_duration, dp_count) except KeyboardInterrupt: return (0, 0)
def publishPower(): try: today = datetime.now() database = "/srv/dev-disk-by-label-DISK1/localdata/powermeter.rrd" max = rrdtool.fetch(database, "MAX", "--start=" + today.strftime("%Y%m%d"), "--end=" + today.strftime('%Y%m%d')) yesterday = today - timedelta(days=1) min = rrdtool.fetch(database, "MAX", "--start=" + yesterday.strftime("%Y%m%d"), "--end=" + yesterday.strftime('%Y%m%d')) day = yesterday.strftime("%d.%m.") consumption = max[2][0][0] - min[2][0][0] assessmentConsumption = 0 if (consumption < 0.001): assessmentConsumption = "2" elif (consumption < 1): assessmentConsumption = "1" elif (consumption < 5.0): assessmentConsumption = "0" elif (consumption < 7.0): assessmentConsumption = "1" else: assessmentProduction = "2" production = max[2][0][1] - min[2][0][1] assessmentProduction = 0 if (production < 0.001): if production < 0.0: production = 0.0 assessmentProduction = "-2" elif (production < 0.1): assessmentProduction = "-1" elif (production < 0.5): assessmentProduction = "0" elif (production < 0.9): assessmentProduction = "1" else: assessmentProduction = "2" if (consumption < 10.0): aClient.publish( "/inkplate/in/power", f"{day}@{consumption:.3f}@{assessmentConsumption}@{production:.3f}@{assessmentProduction}", qos=1, retain=True) else: aClient.publish( "/inkplate/in/power", f"{day}@{consumption:.2f}@{assessmentConsumption}@{production:.3f}@{assessmentProduction}", qos=1, retain=True) except: aClient.publish("/inkplate/in/power", "[email protected]@[email protected]@0", qos=1, retain=True)
def get_bandwidth(): """get bandwith""" fn = "/var/lib/pnp4nagios/iem-director0/eth0.rrd" ts = rrdtool.last(fn) data = rrdtool.fetch(fn, "AVERAGE", "-s", str(ts - 300), "-e", str(ts)) samples = data[2] fn = "/var/lib/pnp4nagios/iem-director1/eth0.rrd" ts = rrdtool.last(fn) data = rrdtool.fetch(fn, "AVERAGE", "-s", str(ts - 300), "-e", str(ts)) samples2 = data[2] j["stats"]["bandwidth"] = samples[-2][2] + samples2[-2][2]
def fetch(self, cf='LAST', start='now', end='now', res=''): '''Returns the result of an rrdfetch command''' if res == '': data = rrdtool.fetch(self.file_name, cf, '-s', str(start), '-e', str(end)) else: data = rrdtool.fetch(self.file_name, cf, '-s', str(start), '-e', str(end), '-r', str(res)) self.logger.debug( 'RRDtool fetch value cf={cf_} start={start_t} end={end_t} res={res_}:' .format(cf_=cf, start_t=start, end_t=end, res_=res)) self.logger.debug(data) return data
def fetch(self, cf='LAST', start='now', end='now', res=''): '''Returns the result of an rrdfetch command''' if res == '': data = rrdtool.fetch(self.file_name, cf, '-s', str(start), '-e', str(end)) else: data = rrdtool.fetch(self.file_name, cf, '-s', str(start), '-e', str(end), '-r', str(res)) self.logger.debug( 'RRDtool fetch value cf={cf_} start={start_t} end={end_t} res={res_}:'.format( cf_=cf, start_t= start, end_t= end, res_=res)) self.logger.debug(data) return data
def getLoadWeek(server_id): ''' get server current load and one week load''' import rrdtool try: rrdPath = s_service.objects.get( server__id=server_id, category__title__contains="Perfmon").rrd.path() except: return "</td><td>" info = rrdtool.info(rrdPath) last_update = str(info["last_update"]) current = rrdtool.fetch(rrdPath, "-s", last_update + "-604801", "-e", last_update, "LAST") load = "" ls = [] loadAvg = "" for i in range(len(current[1])): if current[1][i] == "load": for l in current[2][-10:]: if l[i] != None and l[i] != "nan": load = l[i] for l in current[2]: try: ls.append(float(l[i])) except: pass if load == "nan": load = "" try: load = int(load) except: pass if ls != []: loadAvg = str(sum(ls) / len(ls))[:5] return str(load) + "</td><td>" + loadAvg
def rrd_export(options): """Exports all RRD data. Raises: OSError, if output directory cannot be created. IOError, if output file cannot be created or written. """ open_func = open if options.compress: open_func = gzip.open options.output += '.gz' make_output_dirs(options.output) scale = options.step if options.counts else 1 with contextlib.closing(open_func(options.output, 'w')) as fd_output: for filename in get_rrd_files(options.rrddir_prefix): time_range, value_names, data = rrdtool.fetch( filename, 'AVERAGE', '--start', str(options.ts_start), '--end', str(options.ts_end)) # W0142 is the use of "* magic". These are legitimate use-cases. # 1) time_range is a 3-tuple (start, end, step): i.e. arguments to range. # 2) data is a list of tuples, which are transposed by zip. # i.e. [(a,), (b,), ...] -> [(a,b,...)] # pylint: disable=W0142 timestamps = range(*time_range) values = zip(*data) # pylint: enable=W0142 for i, value_name in enumerate(value_names): hostname, experiment, metric = get_canonical_names( filename, value_name, options) if metric is None or experiment in options.ignored_experiments: continue record = get_json_record(hostname, experiment, metric, timestamps, values[i], scale) write_json_record(fd_output, record, options.pretty_json)
def fetchLastData(self, rrdfile, rrdfield): now = datetime.now() past = now - timedelta(minutes=10) startTime = (past.strftime("%Y%m%d %H:%M")) endTime = (now.strftime("%Y%m%d %H:%M")) cmdString = [rrdfile, 'AVERAGE', '-s ' + startTime, '-e ' + endTime] (timeInfo, columns, rows) = rrdtool.fetch(cmdString) colIndex = list(columns).index(rrdfield) rows.pop( ) #chop off the latest value because RRD returns crazy last values sometimes #print "rrdfile=", rrdfile," , startTime=",startTime," , endTime=",endTime, " , time=", timeInfo, " , rows=", len(rows) lastTime = timeInfo[1] lastRow = rows.pop() if lastRow is None: lastValue = 0 else: value = lastRow[colIndex] if value is None: lastValue = 0 else: lastValue = value return lastTime, lastValue
def render (self, startTime, endTime, params): (metadata, titles, data) = rrdtool.fetch( self.rrdFile, "--start", str(startTime), "--end", str(endTime), "AVERAGE" ) try: self.responseCode(200) self.contentType('text/plain; charset=utf-8') out = "Timestamp\tWatts\tTemp" timestamp = metadata[0] for item in data: first = item[0] if first == None: first = 0; second = item[1] if second == None: second = 0; out += "%d\t%f\t%f" % (timestamp, first, second) timestamp = timestamp + metadata[2] except socket.error, e: pass
def _rrdfetch(self, CFS, start, end, res): ''' Does the heavy lifting of calling rrdtool.fetch for each CF in the CFS list and assembling the returned data in the self.data attribute. CFS: list of RRD CF's ([str]) e.g., ['AVERAGE', 'MIN', 'MAX'], ['LAST'] start: starting time reference (str) e.g., '-30m', '-1d', ... res: RRA resolution (str) e.g., '-5m', '1', '300', ... ''' if not self.rrd: return rrd = os.path.join(CHDIR, self.rrd) for i, CF in enumerate(CFS): # see http://oss.oetiker.ch/rrdtool/doc/rrdfetch.en.html data = rrdtool.fetch(rrd, CF, '-a', '-s', start, '-e', end, '-r', res) if i == 0: # set initial fetch data self.data = data else: # append new trace data self.data += (data[2], )
def resource(): db_name = 'rrdtool/' + request.form.get('server') + ".rrd" start_time = request.form.get('start_time') end_time = request.form.get('end_time') resolution = request.form.get('resolution') # type = request.form.get('type') print(db_name, start_time, end_time) data = rrdtool.fetch(db_name, 'AVERAGE', '-s {0}'.format(start_time), '-e {0}'.format(end_time)) # if type == "load": # d = data[2] # elif type == "cpu": # d = data[1] # elif type == 'memory': # d = data[0] data = list(zip(*data[2])) memory = list(map(lambda x: int(x) if x is not None else 0, data[0]))[:-2] cpu = list(map(lambda x: int(x) if x is not None else 0, data[1]))[:-2] load = list(map(lambda x: round(x, 2) if x is not None else 0, data[2]))[:-2] # print(data) return jsonify({ 'data': {'memory': memory, 'cpu': cpu, 'load': load} })
def indirect_export(self, tls, path, spec, start,interval): """ Indirect Export the RRD metrics to repository first connect then fetch finally send result to Repository it runs until the process stops """ repository_ip = str(spec.get_parameter_value("repository.url").split(":")[-2]) repository_port = int(spec.get_parameter_value("repository.url").split(":")[-1]) connect_to_repository(self, tls, repository_ip, repository_port) last_fetched_time = 0 # change the time expressed in UTC to local timezone start_local = change_to_local_tzone(start) print ("local start time :" + str(start_local)) print ("UTC start time :" + str(start)) while True: # fetch RRD files till the process killed by the function -> change_conf_indirect_export result_list = [] if(last_fetched_time == 0): #convert timedate fprmat to time format start_time_local = int(mktime(start_local.timetuple())) startTime = str (start_time_local - interval ) else: startTime = str(last_fetched_time) endTime = str (int(time())) rrd_files = [ f for f in listdir(path) if isfile(join(path,f)) and (".rrd" in f) ] for f in rrd_files : rrdMetric = rrdtool.fetch( (path + f), "AVERAGE" ,'--resolution', str(interval), '-s', startTime, '-e', endTime) rrd_time = rrdMetric[0][0] for tuple in rrdMetric[2]: if tuple[0] is not None: rrd_time = rrd_time + interval timestamp = float(rrd_time) value = float(tuple[0]) metric = f if (rrd_time > last_fetched_time): last_fetched_time = int(rrd_time) result_list.append((metric,timestamp,value)) print ("result list size : " + str(len (result_list))) if len(result_list) > 0: return_results_to_repository(self, result_list) sleep(interval)
def fetchDataFromRRDDatabase( databaseName, startTime, endTime, interval, graphicType): """ @summary : Returns the stored data from a database based on the desired interval. @retutn : Output obtained from the rrd fetch command. """ resolution = int(interval*60) if endTime > ( time.time() )/3600*3600: endTime = int(time.time())/3600*3600 #top of the hour...databases are never any newer # round end time to time closest to desired resolution EX : closest 10 minutes,hour,day,etc... endTime = int(endTime)/int(resolution)*int(resolution) try: output = rrdtool.fetch( databaseName, 'AVERAGE', '-r', str(resolution), '-s', "%s" %(startTime), '-e', '%s' %(endTime) ) #print databaseName, 'AVERAGE', '-r', str(resolution), '-s', "%s" %(startTime), '-e', '%s' %(endTime) except: pass #----------------------------------------------------------- output = "" #------------- print "Error.Could not fetch data from %s." %databaseName #------------------------------------------- print "Program terminated." #------------------------------------------------------------ sys.exit() return output
def _read_data_from_rrd(data_source_path, start, end, step, pipeline_: Pipeline): if not data_source_path: return if '<path_rra>/' not in data_source_path: logger_.debug( f'Path {data_source_path} does not contain "<path_rra>/", skipping' ) return rrd_file_path = data_source_path.replace('<path_rra>', _get_source_dir(pipeline_)) if not os.path.isfile(rrd_file_path): logger_.debug(f'File {rrd_file_path} does not exist') return if source.CactiSource.RRD_DIR_PATH in pipeline_.source.config: rrd_file_path = _copy_files_to_tmp_dir(pipeline_, rrd_file_path, data_source_path) result = rrdtool.fetch(rrd_file_path, 'AVERAGE', ['-s', start, '-e', end, '-r', step]) if source.CactiSource.RRD_DIR_PATH in pipeline_.source.config: os.remove(rrd_file_path) if not result or not result[0]: return # result[0][2] - is the closest available step to the step provided in the fetch command # if they differ - skip the source as the desired step is not available for it if result[0][2] != int(step) and not pipeline_.dynamic_step: return return result
def get_bandwidth(): fn = "/var/lib/pnp4nagios/mesonet/eth0.rrd" ts = rrdtool.last(fn) data = rrdtool.fetch(fn, "AVERAGE", "-s", str(ts - 300), "-e", str(ts)) samples = data[2] j['stats']['bandwidth'] = samples[-2][2]
def dump_histogram_data(self, period, step_in): end_ts_in = int( int(calendar.timegm(time.gmtime()) * step_in) / step_in) start_ts_in = int(end_ts_in - int(period)) result = rrdtool.fetch(self.rrd_location, 'AVERAGE', '-r', str(step_in), '-s', str(start_ts_in), '-e', str(end_ts_in)) periodic_cpu_usage = collections.defaultdict(lambda: 0.0) periodic_mem_usage = collections.defaultdict(lambda: 0.0) periodic_consolidated_usage = collections.defaultdict(lambda: 0.0) valid_rows = collections.defaultdict(lambda: 0.0) start_ts_out, _, step = result[0] current_ts = start_ts_out for _, cdp in enumerate(result[2]): current_ts += step if len(cdp) == 4: try: datetime_utc = time.gmtime(current_ts) date_group = self.get_date_group(datetime_utc, period) current_cpu_usage = round(100 * float(cdp[0])) / 100 current_mem_usage = round(100 * float(cdp[1])) / 100 current_consolidated_usage = round( 100 * float(cdp[2])) / 100 periodic_cpu_usage[date_group] += current_cpu_usage periodic_mem_usage[date_group] += current_mem_usage periodic_consolidated_usage[ date_group] += current_consolidated_usage valid_rows[date_group] += 1 except: pass return periodic_cpu_usage, periodic_mem_usage, periodic_consolidated_usage, valid_rows
def dump_trends_data(self, period, step_in): end_ts_in = int( int(calendar.timegm(time.gmtime()) * step_in) / step_in) start_ts_in = int(end_ts_in - int(period)) result = rrdtool.fetch(self.rrd_location, 'AVERAGE', '-r', str(step_in), '-s', str(start_ts_in), '-e', str(end_ts_in)) res_usage = collections.defaultdict(list) sum_res_usage = collections.defaultdict(lambda: 0.0) cumulated_cost = 0.0 start_ts_out, _, step = result[0] current_ts = start_ts_out for _, cdp in enumerate(result[2]): current_ts += step if len(cdp) == 4: try: datetime_utc = time.gmtime(current_ts) current_cpu_usage = round(100 * float(cdp[0])) / 100 current_mem_usage = round(100 * float(cdp[1])) / 100 current_consolidated_usage = round( 100 * float(cdp[2])) / 100 cumulated_cost += round(100 * float(cdp[3])) / 100 datetime_utc_json = time.strftime('%Y-%m-%dT%H:%M:%SZ', datetime_utc) res_usage[ResUsageType.CPU].append( '{"name":"%s","dateUTC":"%s","usage":%f}' % (self.dbname, datetime_utc_json, current_cpu_usage)) res_usage[ResUsageType.MEMORY].append( '{"name":"%s","dateUTC":"%s","usage":%f}' % (self.dbname, datetime_utc_json, current_mem_usage)) res_usage[ResUsageType.CONSOLIDATED].append( '{"name":"%s","dateUTC":"%s","usage":%s}' % (self.dbname, datetime_utc_json, current_consolidated_usage)) res_usage[ResUsageType.CUMULATED_COST].append( '{"name":"%s", "dateUTC":"%s","usage":%s}' % (self.dbname, datetime_utc_json, cumulated_cost)) sum_res_usage[ResUsageType.CPU] += current_cpu_usage sum_res_usage[ResUsageType.MEMORY] += current_mem_usage sum_res_usage[ResUsageType. CONSOLIDATED] += current_consolidated_usage sum_res_usage[ ResUsageType.CUMULATED_COST] += cumulated_cost except: pass if sum_res_usage[ResUsageType.CPU] > 0.0 and sum_res_usage[ ResUsageType.MEMORY] > 0.0: PROMETHEUS_HOURLY_USAGE_EXPORTER.labels( self.dbname, ResUsageType.CPU.name).set(current_cpu_usage) PROMETHEUS_HOURLY_USAGE_EXPORTER.labels( self.dbname, ResUsageType.MEMORY.name).set(current_mem_usage) PROMETHEUS_HOURLY_USAGE_EXPORTER.labels( self.dbname, ResUsageType.CONSOLIDATED.name).set(current_consolidated_usage) return (','.join(res_usage[ResUsageType.CPU]), ','.join(res_usage[ResUsageType.MEMORY]), ','.join(res_usage[ResUsageType.CONSOLIDATED]), ','.join(res_usage[ResUsageType.CUMULATED_COST])) return '', '', '', ''
def fetch_datapoints(rrd_file, periods, datasource): """Fetches the datapoints from the rrd-file""" datapoints = [] for period in periods: (time_info, columns, rows) = rrdtool.fetch(rrd_file, 'AVERAGE', '-s', str(period.start_time), '-e', str(period.end_time)) # rows.pop() # The last value may be NaN based on when last update was column_index = list(columns).index(datasource.name) values = [row[column_index] for row in rows] if datasource.type in ['COUNTER', 'DERIVE']: values = calculate_absolute_from_rate(values, time_info[-1]) timestamps = list(range(*time_info)) if period.step and period.step < time_info[-1]: num_missing_values = time_info[-1] / period.step values = insert_missing_values(values, num_missing_values - 1) timestamps = list(range(time_info[0], time_info[1], period.step)) datapoints.extend(p for p in zip(timestamps, values) if p[1] is not None) return datapoints
def get_rrd_line_value(rrd,start,end,line): import rrdtool current = rrdtool.fetch(rrd, "-s", str(start) + "-1", "-e", str(end), "LAST") for i in range(0,len(current[1])): if current[1][i] == line: break return map(lambda x:x[i],current[2])
def getStoreData(): fi = open('testData.txt','r') for line in fi: #generate data VAR1 = float(line) #see what we generated to determine if rrd data is correct print dataName1 + ': %f\n' % VAR1 #update rrd ret = rrdtool.update(name, "%d:%f" %(time.time(),VAR1)) #Error message. Error if time stamp is wrong if ret: print 'ERROR: ' + rrdtool.error() #set endtime for fetching data from rrd lastTimeStamp = rrdtool.last(name) #send data from RRDTool to server #CURRENTLY SENDS ALL CONTENTS OF RRD - to change replace startTime with 1 second ago... sendData(rrdtool.fetch(name, 'LAST', '--start', "%d" % (startTime) , '--end', '%d' % (lastTimeStamp))) #let me know if everything worked print 'client sleeping...\n' #sleep for 1 second time.sleep(1) fi.close()
def get_widget_alert_times(widget,start,end): result = {"error":0,"warning":0,"ok":0,"all":0} field_def = {} if widget.data_def: try: current = rrdtool.fetch(widget.rrd.path(), "-s", str(start) + "-1", "-e", str(end), "LAST") data_def = eval(widget.data_def.replace("\n", "").replace("\r", "")) ds = current[1] for i in range(0, len(ds)): if data_def.has_key(ds[i]): field_def[i] = data_def[ds[i]] flag = False; flat = True for l in current[2]: tmp = False for x,y in field_def.items(): if eval(str(l[x])+y[2]): tmp = True if tmp: flag = True else: flag = False flat = True if flag and flat: result["error"] += 1 flat = False except: pass return result
def parse(host, service, start='-1h', interval='60'): datapath = path.join(PERF_PATH, host) xml_path = path.join(datapath, '%s.xml' % service) rrd_path = path.join(datapath, '%s.rrd' % service) tree = ET.parse(xml_path) root = tree.getroot() labels = [s.find('LABEL').text for s in root.findall('DATASOURCE')] rrd_info = rrdtool.fetch(rrd_path, 'AVERAGE', '--start', start, '-r', interval) start, end, resolution = rrd_info[0] rrd_rows = rrd_info[2] data = {} for label_index, label in enumerate( labels): # we want a separate graph for every label timestamp = start result = [] for row in rrd_rows: x = timestamp y = row[label_index] # if y is None: y = float('nan') result.append({'x': x, 'y': y}) timestamp += resolution elements_to_avg = len( result) / 120 # ex. if there are 120 elements, average every 2 #new_result = [{'y': sum([el['y'] for el in grouped]) / elements_to_avg, 'x': grouped[0]['x']} \ #for grouped in zip(*[iter(result)] * elements_to_avg)] data[label] = result return data
def monthMaxAvg(f): r = rrdtool.fetch(f, 'MAX', '-s', '-30d') legitValues = [i[0] for i in r[2] if not i[0] is None] inp = sum(legitValues) / len(legitValues) legitValues = [i[1] for i in r[2] if not i[1] is None] out = sum(legitValues) / len(legitValues) return (inp, out)
def getLoadWeek(server_id): ''' get server current load and one week load''' import rrdtool try: rrdPath = s_service.objects.get(server__id = server_id,category__title__contains = "Perfmon").rrd.path() except: return "</td><td>" info = rrdtool.info(rrdPath) last_update = str(info["last_update"]) current = rrdtool.fetch(rrdPath, "-s", last_update + "-604801", "-e", last_update, "LAST") load = "";ls = [];loadAvg = "" for i in range(len(current[1])): if current[1][i] == "load": for l in current[2][-10:]: if l[i] != None and l[i] != "nan": load = l[i] for l in current[2]: try: ls.append(float(l[i])) except: pass if load == "nan":load = "" try: load = int(load) except: pass if ls != []: loadAvg = str(sum(ls)/len(ls))[:5] return str(load)+"</td><td>"+loadAvg
def rrd_get_stddev(rrdFile, ds, cf, start_time, end_time): """ from RRDhelper.pm """ (realvals, names, array) = rrdtool.fetch(\ str(rrdFile), str(cf), "--start=%d" % start_time, "--end=%d" % end_time) idx = list(names).index(ds) mysum = 0 mysqsum = 0 mycnt = 0 for line in array: val = line[idx] if val is not None: mycnt += 1 mysum += val mysqsum += val**2 if mycnt > 0: mysqdev = 1.0 / mycnt * (mysqsum - mysum**2 / mycnt) if mysqdev < 0.0: return 0.0 else: return sqrt(mysqdev) else: return None
def get(self, host, metric): if host not in self.application.plugin_info: self.write('404') self.finish() plugins = self.application.plugin_info[host].get('plugins', {}) if metric not in plugins: self.write('404') self.finish() instances = plugins[metric] cleaned_data = { 'units': UNIT_MAP.get(metric), } instance_data = {} offset = self.get_argument('range', default='24hr') if offset not in DATE_RANGE_MAP: raise HTTPError(400, 'Invalid date range') date_range = DATE_RANGE_MAP[offset] if metric.startswith('cpu-'): instances.remove('cpu-idle') if metric == 'df-local': instances.remove('df_complex-reserved') for instance in instances: load_file = str( os.path.join(self.application.settings['rrd_directory'], host, metric, '%s.rrd' % instance)) start = str(date_range['start']) res = str(date_range['resolution']) period, metrics, data = rrdtool.fetch(load_file, 'AVERAGE', '--start', start, '--resolution', res) start, end, resolution = period default = { 'start': start, 'end': end, 'resolution': resolution, 'timeline': [] } if metric == 'load': metrics = (metrics[0], ) data = ((i[0], ) for i in data) if len(metrics) == 1: key = instance instance_data[key] = default else: for name in metrics: key = '%s-%s' % (instance, name) instance_data[key] = default for item in data: for i, name in enumerate(metrics): if len(metrics) == 1: key = instance else: key = '%s-%s' % (instance, name) instance_data[key]['timeline'].append(item[i]) cleaned_data['instances'] = instance_data self.write(cleaned_data)
def underMinQuota(self, diffString="24h"): """ physical values over max in float 0..1 """ if not os.path.exists(self.getRrdFilename()): self.rrd_create() return None retFloat = 0.0 inpPQ = self.getPQinpQuantity() (minQuantity, minString) = self.getMinQuantity() if minQuantity is None: return None convMinPQ = minQuantity / inpPQ convMinPQ.ounit("1/s") convMin = float(convMinPQ) currtime = time.time() rrdRet = rrdtool.fetch(\ self.getRrdFilename(), "MIN", "--start=%d-%s" % (currtime, diffString), "--end=%d" % currtime ) rrdTimeTup, rrdVarTup, rrdValList = rrdRet nbrPoints = 0 nbrUnderMin = 0 for vals in rrdValList: for dim in range(len(vals)): if vals[dim] is not None: nbrPoints += 1 if vals[dim] < convMin: nbrUnderMin += 1 if nbrPoints > 0: retFloat = float(nbrUnderMin) / float(nbrPoints) return retFloat
def get_metric(): node = request.args.get('node', 0, type=str) # list of nodes avabilable from ganglia nodelist = listdir('/var/lib/ganglia/rrds/unspecified') for n in nodelist: if n != '__SummaryInfo__': nodes[n.split('.')[0]] = dict() nodes[n.split('.')[0]]['domain'] = n.split('.')[1] nodes[node.split('.')[0]]['f'] = dict() nodes[node.split('.')[0]]['s'] = dict() # use rrdtool to get load of server res = 600 # 5 minutes t = int(time.mktime(time.localtime(time.time()))) # need to move things out of 'unspecified" at some point... metrics = listdir('/var/lib/ganglia/rrds/unspecified/' + node + '.' + nodes[node]['domain']) for metric in metrics: rawdata = fetch('/var/lib/ganglia/rrds/unspecified/' + node + '.' + nodes[node]['domain'] + '/' + metric, 'AVERAGE', '-r ' + str(res), '-s e-30m', '-e ' + str(t/res*res))[2] # find maximum m = 0.0 for datapoint in rawdata: if isinstance(datapoint[0], float): if datapoint[0] > m: m = datapoint[0] if m == 0: ratio = 1 else: ratio = graph_height/m data = list() for i, datapoint in enumerate(rawdata): if isinstance(datapoint[0], float) and i < 6: # Maybe remove size limit... value = datapoint[0] * ratio point = value if '.' in str(value): point = str(value).split('.')[0]# + "." + str(value).split('.')[1][:2] # round to 2 decimal places data.append([str(point), datapoint[0]]) # append the normalised value for display plus the actual value for diagnosis if isinstance(datapoint[0], str): data.append(datapoint[0]) # TODO Handle string metrics here if isinstance(rawdata[0][0], float): nodes[node]['f'][metric.split('.')[0]] = data if isinstance(rawdata[0][0], str): nodes[node]['s'][metric.split('.')[0]] = data instances = [ instance for instance in session.query(sqlinstances) if instance.deleted == False] for instance in instances: print instance.host return jsonify(metrics=nodes[node])
def get_cpu_stats(self, start=600, step=60): now = int(time.time()) path = self._make_path('cpu') if step >= 1440: cf = 'AVERAGE' step = 1440 else: cf = 'LAST' start_ts = now - (now % step) negated = -(start - (start % step)) rdata = None try: rdata = rrdtool.fetch(str(path), cf, '-s', str(negated), '-e', str(start_ts), '-r', str(step)) except: return {} data = rdata[2] step = rdata[0][2] begin_ts = rdata[0][0] set = [] for i in data: if i[0] is None: continue set.append([begin_ts * 1000, i[0] / 10]) begin_ts += step return {'label': 'CPU usage (%)', 'data': set, 'color': "#336633"}
def _update(self, rrd_path, v): try: res = rrdtool.fetch(rrd_path, "AVERAGE", "--start", "now-60", "--end", "now"); # log.debug("-------------------->update") except: traceback.print_exc() return 0 if(res): start_time = res[0][0]; end_time = res[0][1]; step = res[0][2]; try: # if(res[2][0][0] == None): # rrdtool.update(rrd_path, str(start_time) + ":" + str(v)); # else: # rrdtool.update(rrd_path, str(end_time) + ":" + str(v)); rrdtool.update(rrd_path, str(end_time) + ":" + str(v)); except: t = end_time + 60; try: rrdtool.update(rrd_path, str(t) + ":" + str(v)); except: # log.debug("Update Error!! datasource_name: %s ", rrd_path); traceback.print_exc() #log.debug("Update Error!! datasource_name: %s servicename: %s time: %d value: %d", dbname, servicename, t, v); return 0 return 1;
def getwireless(apports, path, check): if check == "in": num = 0 elif check == "out": num = 1 end_str = os.path.basename(path).split('-') name_str = '_'.join(end_str[0:3]) + end_str[3] + ":00" end_str = '/'.join(end_str[0:3]) + " " + end_str[3] + ":00" first = True wirelessin = [] for p in sorted(apports): rrddata = rrdtool.fetch(os.path.join(path, p), "AVERAGE", "--resolution", "60s", "--start", "end-10h", "--end", end_str) start, end, step = rrddata[0] datanames = rrddata[1] values = rrddata[2] index = 0 for t in values: if not first: if t[num] != None: wirelessin[index] = wirelessin[index] + t[num] else: wirelessin[index] = wirelessin[index] + 0 else: if t[num] != None: wirelessin.append(t[num]) else: wirelessin.append(0) index = index + 1 first = False return wirelessin
def _fetch_data(self, rrdObject, startTime, endTime): """ Fetch data from RRD archive for given period of time. :param rrdObject: RRD :type rrdObject: String :type startTime: int :type endTime: int :return: Dictionary with data from RRD archive. :rtype: Dict """ # print rrdObject if not path.exists(rrdObject): raise Exception("File not exists: %s" % rrdObject) # print "%s - %s" % (startTime, endTime) rrd_data = None try: rrd_data = rrdtool.fetch(str(rrdObject), "AVERAGE", "--start", str(startTime), "--end", str(endTime)) except Exception as err: LOG.error("fetch exc %s | %s", err, rrdObject) return RrdData(info=rrd_data[0], additional=rrd_data[1], series=rrd_data[2])
def _fetch_rrd_data(self): ''' Fetch input, output data from the rrd file ''' logging.debug('RRD_PATH: %s',self.rrdfile) data = rrdtool.fetch(self.rrdfile, 'AVERAGE', '-r', '300', '-s','-300') return data
def fetchLastData(self,rrdfile,rrdfield): now = datetime.now() past = now - timedelta(minutes=10) startTime = (past.strftime("%Y%m%d %H:%M")) endTime = (now.strftime("%Y%m%d %H:%M")) cmdString = [rrdfile , 'AVERAGE' , '-s ' + startTime , '-e ' + endTime] (timeInfo, columns, rows) = rrdtool.fetch(cmdString) colIndex = list(columns).index(rrdfield) rows.pop() #chop off the latest value because RRD returns crazy last values sometimes #print "rrdfile=", rrdfile," , startTime=",startTime," , endTime=",endTime, " , time=", timeInfo, " , rows=", len(rows) lastTime = timeInfo[1] lastRow = rows.pop() if lastRow is None: lastValue = 0 else: value = lastRow[colIndex] if value is None: lastValue = 0 else: lastValue = value return lastTime, lastValue
def fetch(self,rrdfile,rrdfield,startTime, endTime): startString = time.strftime("%H:%M_%Y%m%d+%Ss", time.localtime(startTime)) endString = time.strftime("%H:%M_%Y%m%d+%Ss", time.localtime(endTime)) # if settings.FLUSHRRDCACHED: # rrdtool.flushcached(self.fs_path, '--daemon', settings.FLUSHRRDCACHED) cmdString = [rrdfile , 'AVERAGE' , '-s ' + str(startTime) , '-e ' + str(endTime)] #print cmdString (timeInfo, columns, rows) = rrdtool.fetch(cmdString) # (timeInfo, columns, rows) = rrdtool.fetch(self.datafile_name,'AVERAGE','-s ' + str(startTime),'-e ' + str(endTime)) colIndex = list(columns).index(rrdfield) rows.pop() #chop off the latest value because RRD returns crazy last values sometimes #values = (str(row[colIndex]) for row in rows) values = [] for row in rows: value = row[colIndex] if value is None: values.append(0) else: values.append(value) #print "rows_count=",len(rows) #print timeInfo #print columns #log("rows", rows) #log("values",values) #results = rrdtool.fetch(rrdfile,'AVERAGE','-s ' + str(startTime),'-e ' + str(endTime)) return (timeInfo, values)
def fetchDataFromRRDDatabase(databaseName, startTime, endTime, interval, graphicType): """ @summary : Returns the stored data from a database based on the desired interval. @retutn : Output obtained from the rrd fetch command. """ resolution = int(interval * 60) if endTime > (time.time()) / 3600 * 3600: endTime = int(time.time( )) / 3600 * 3600 #top of the hour...databases are never any newer # round end time to time closest to desired resolution EX : closest 10 minutes,hour,day,etc... endTime = int(endTime) / int(resolution) * int(resolution) try: output = rrdtool.fetch(databaseName, 'AVERAGE', '-r', str(resolution), '-s', "%s" % (startTime), '-e', '%s' % (endTime)) #print databaseName, 'AVERAGE', '-r', str(resolution), '-s', "%s" %(startTime), '-e', '%s' %(endTime) except: pass #----------------------------------------------------------- output = "" #------------- print "Error.Could not fetch data from %s." %databaseName #------------------------------------------- print "Program terminated." #------------------------------------------------------------ sys.exit() return output
def writeJson(consolidation,resolution): now=time.time() json_dict={} res=resolution end=int((now)/res)*res start=end-res #print now,start,end filename=CHARTPATH+consolidation+"values.json" try: ret = rrdtool.fetch('meteo.rrd',consolidation,"--start",str(start),"--end",str(end),"--resolution",str(res)); if ret: print rrdtool.error() #print ret mags=ret[1] values=ret[2][0] i=0 for mag in mags: #print mag,values[i] json_dict[mag]=int(values[i]*100)/100. i=i++1 #print consolidation,json_dict x = simplejson.dumps(json_dict) fi=open(filename,"w") fi.write(x) fi.close() except: os.remove(filename)
def are_graphable(host, service_list): """Flags services of host that are graphable (has state or trend)""" rra_path = settings.RRA_PATH for service in service_list: coilfile = '%s%s/%s.coil' % \ (rra_path, host, service['service_description']) rrd = '%s%s/%s.rrd' % (rra_path, host, service['service_description']) if os.path.exists(coilfile) and os.path.exists(rrd): coilstring = open(coilfile).read() coilstruct = coil.parse(coilstring) query = coilstruct.get('query') # rrdtool hates unicode strings, and Django gives us one, # so convert to ascii rrdslice = rrdtool.fetch(str(rrd), '--start', '0', '--end', '10', '--resolution', '1', 'AVERAGE') try: rrdslice[1].index('_state') service['is_graphable'] = True except ValueError: for key in query.keys(): val = query.get(key) if type() == type(query) and 'trend' in val: service['is_graphable'] = True break service['is_graphable'] = False else: service['is_graphable'] = False
def get_rrdseries(path, start_time=None, end_time=None, CF="AVERAGE"): _rrdargs = [] if start_time: int(start_time) _rrdargs.extend(["-s", "{}".format(start_time)]) if end_time: int(end_time) _rrdargs.extend(["-e", "{}".format(end_time)]) _series = [] _path = os.path.normpath(path) if not os.path.isabs(_path): _path = os.path.join(RRDPATH, _path) _inum = os.stat(_path).st_ino try: _meta, _name, _data = rrdtool.fetch(str(_path), str(CF), *_rrdargs) istart, iend, istep = _meta for i, n in enumerate(_name): _series.append({ 'index': '{}.{}'.format(_inum, i), 'name': n, 'sequence': [] }) for i, vals in enumerate(_data): _t = istart + i * istep for j in range(len(_name)): if vals[j] != None: assert (_series[j].get('name') == _name[j]) _pair = {"t": _t, "v": vals[j]} _series[j]['sequence'].append(_pair) except Exception as excn: print str(excn) pass return _series
def dump_histogram_data(self, period, step_in=None): if step_in is not None: step = int(step_in) else: step = int(RrdPeriod.PERIOD_1_HOUR_SEC) rrd_end_ts = int(int(calendar.timegm(time.gmtime()) * step) / step) rrd_start_ts = int(rrd_end_ts - int(period)) rrd_result = rrdtool.fetch(self.rrd_location, 'AVERAGE', '-r', str(step), '-s', str(rrd_start_ts), '-e', str(rrd_end_ts)) rrd_start_ts_out, _, step = rrd_result[0] rrd_current_ts = rrd_start_ts_out periodic_cpu_usage = collections.defaultdict(lambda: 0.0) periodic_mem_usage = collections.defaultdict(lambda: 0.0) for _, cdp in enumerate(rrd_result[2]): rrd_current_ts += step if len(cdp) == 2: try: rrd_cdp_gmtime = time.gmtime(rrd_current_ts) date_group = self.get_date_group(rrd_cdp_gmtime, period) current_cpu_usage = round(100 * float( cdp[0]), KOA_CONFIG.db_round_decimals) / 100 current_mem_usage = round(100 * float( cdp[1]), KOA_CONFIG.db_round_decimals) / 100 periodic_cpu_usage[date_group] += current_cpu_usage periodic_mem_usage[date_group] += current_mem_usage except: pass return periodic_cpu_usage, periodic_mem_usage
def is_graphable(host, service): """Checks if service of host is graphable (has state or trend)""" rra_path = settings.RRA_PATH coilfile = '%s%s/%s.coil' % (rra_path, host, service) rrd = '%s%s/%s.rrd' % (rra_path, host, service) if os.path.exists(coilfile) and os.path.exists(rrd): coilstring = open(coilfile).read() coilstruct = coil.parse(coilstring) query = coilstruct.get('query') # rrdtool hates unicode strings, and Django gives us one, # so convert to ascii rrdslice = rrdtool.fetch(str(rrd), '--start', '0', '--end', '10', '--resolution', '1', 'AVERAGE') try: rrdslice[1].index('_state') return True except ValueError: for key in query.keys(): val = query.get(key) if type() == type(query) and 'trend' in val: return True return False return False
def GetAnalogDataFromDatabase(start,end,resolution): # resolution in seconds # align start and end with fetchable time start_time = int(time.mktime(start.timetuple())/resolution)*resolution end_time = int(time.mktime(end.timetuple())/resolution)*resolution # t1 = time.time() # print('fetching...') result = rrdtool.fetch(config.database_path_analog, "AVERAGE","-r", str(resolution),"--start",str(start_time),"--end",str(end_time)) # t2 = time.time() # print('time to fetch: {}'.format(t2-t1)) start_r, end_r, step_r = result[0] data = np.round(np.array(result[2],dtype=np.float64)*1000)/1000 # t3 = time.time() # print('time to round: {}'.format(t3-t2)) time_s = np.linspace(start_r,end_r-1,len(result[2])) # t4 = time.time() index_all = np.where(np.invert(np.isnan(data[:,0]))) if len(index_all[0]) == 0: #no useful data in timerange return np.zeros([0,2]),[] else: first = index_all[0][0] last = index_all[0][-1] data_trim = data[first:last+1,:] time_s_trim = time_s[first:last+1] # t5 = time.time() # print('time to cut: {}'.format(t5-t4)) time_ = [datetime.fromtimestamp(t) for t in time_s_trim] # print('time to make timestamp: {}'.format(time.time()-t5)) return data_trim, time_
def _read_rrd(self, rrd_path, hostname, device_name): """Main metric fetching method. """ import rrdtool metric_count = 0 try: info = rrdtool.info(rrd_path) except Exception: # Unable to read RRD file, ignore it self.log.exception("Unable to read RRD file at %s" % rrd_path) return metric_count # Find the consolidation functions for the RRD metrics c_funcs = set([v for k, v in info.items() if k.endswith('.cf')]) for c in list(c_funcs): last_ts_key = '%s.%s' % (rrd_path, c) if last_ts_key not in self.last_ts: self.last_ts[last_ts_key] = time.time() continue start = self.last_ts[last_ts_key] last_ts = start try: fetched = rrdtool.fetch(rrd_path, c, '--start', str(start)) except rrdtool.error: # Start time was out of range, skip this RRD self.log.warn("Time %s out of range for %s" % (rrd_path, start)) return metric_count # Extract the data (start_ts, end_ts, interval) = fetched[0] metric_names = fetched[1] points = fetched[2] for k, m_name in enumerate(metric_names): m_name = self._format_metric_name(m_name, c) for i, p in enumerate(points): ts = start_ts + (i * interval) if p[k] is None: continue # Save this metric as a gauge val = self._transform_metric(m_name, p[k]) self.gauge(m_name, val, hostname=hostname, device_name=device_name, timestamp=ts, dimensions=self.dimensions) metric_count += 1 last_ts = (ts + interval) # Update the last timestamp based on the last valid metric self.last_ts[last_ts_key] = last_ts return metric_count
def get_rrd_stats(node_id, table_id, clean_flow_id): filename = str("%s/%s/%s/%s.rrd" % (rrd_dir, node_id, table_id, clean_flow_id)) diff = 60 * 120 # 30 min #diff2 = 60 * 15 end = int(time.time()) begin = end - diff data = [] if os.path.isfile(filename): result = rrdtool.fetch(filename, 'AVERAGE', '--start', str(begin), '--end', str(end), '-r', str(10)) keys = result[1] values = result[2] begin = result[0][0] end = result[0][1] step = result[0][2] ts = begin duration = end - begin for value in values: date = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S') data.append({'date': date, 'bytes': 0 if value[0] is None else value[0], 'packets': 0 if value[1] is None else value[1]}) ts += step return data
def compare_rrd_data_with_threshold(rrd_file_name,thresholdcontext): start_time = 'now - ' + str(VM_UTIL_20_DAYS*24*60*60) ''' start_time = 'now - ' + str(60*60) ''' end_time = 'now' rrd_file = get_rrd_file(rrd_file_name) cpu_data = [] mem_data = [] dskr_data = [] dskw_data = [] nwr_data = [] nww_data = [] rrd_logger.info("inside compare_rrd_data_with_threshold function rrd file is :"+str(rrd_file_name)) if os.path.exists(rrd_file): rrd_ret =rrdtool.fetch(rrd_file, 'MIN', '--start', start_time, '--end', end_time) fld_info = rrd_ret[1] data_info = rrd_ret[2] cpu_idx = fld_info.index('cpu') mem_idx = fld_info.index('ram') dskr_idx = fld_info.index('dr') dskw_idx = fld_info.index('dw') nwr_idx = fld_info.index('tx') nww_idx = fld_info.index('rx') cpu_threshold='N' read_threshold='N' write_threshold='N' CPUNoneIdentifier='Y' NWRNoneIdentifier='Y' NWWNoneIdentifier='Y' for row in data_info: if (row[cpu_idx] != None) : CPUNoneIdentifier='N' if int(row[cpu_idx]) > int(thresholdcontext['CPUThreshold']) : cpu_threshold='Y' if (row[nwr_idx] != None) : NWRNoneIdentifier='N' if int(row[nwr_idx]) > int(thresholdcontext['ReadThreshold']) : read_threshold='Y' if (row[nww_idx] != None) : NWWNoneIdentifier='N' if int(row[nww_idx]) > int(thresholdcontext['WriteThreshold']) : write_threshold='Y' if (cpu_threshold=='Y' or read_threshold=='Y' or write_threshold=='Y') : rrd_logger.info("Info about the VM:%s,row[cpu_idx]:%s,row[nwr_idx]:%s,row[nww_idx]:%s" %(rrd_file_name,row[cpu_idx],row[nwr_idx],row[nww_idx])) rrd_logger.info("Threshold is reached once.. VM:"+str(rrd_file_name)+" is in use") return False ## If only none values are read from the rrd .. do not send a warning email if(CPUNoneIdentifier=='N' and NWRNoneIdentifier=='N' and NWWNoneIdentifier =='N'): rrd_logger.info("Returning true to send warning email as threshold is never reached for VM:%s" %(rrd_file_name) ) return True else: rrd_logger.info("RRD capturing is not correct... returning all null values only for VM:%s" %(rrd_file_name) ) return False
def header(rrd_file): """ Returns a tuple of headers in the rrd file rrd_file - path to rrd file. """ rrd_file = str(rrd_file) header_index = 1 return rrdtool.fetch(rrd_file, 'MAX', '-s end-1min')[header_index]
def draw_cpu_bar(hostname): fname = os.path.join(RRD_PREFIX, os.path.basename(hostname), "cpu", "virt_cpu_total.rrd") try: values = rrdtool.fetch(fname, "AVERAGE")[2][-20:] except rrdtool.error, e: #raise InternalError(str(e)) values = [(0.0, )]
def show_widget_header(widget): rrd_path = widget.rrd.path() info = rrdtool.info(rrd_path) last_update = str(info["last_update"]) current = rrdtool.fetch(rrd_path, "-s", last_update, "-e", "s+1", "LAST") titles = map(lambda x: x.replace("_", " "), current[1]) return "<th>" + "</th><th>".join(titles) + "</th>"