Example #1
0
def _create_mongodb_actions_file(destination_file, first_ts):
    """Create a rrd file to store mongodb action statistics.

    Mimics the file settings used by collectd for it's rrd file creation.
    """
    rrdtool.create(
        destination_file,
        '--start', '{}-10'.format(first_ts),
        '--step', '5',
        'DS:insert:GAUGE:10:{min}:{max}'.format(min=0, max=281474976710000),
        'DS:query:GAUGE:10:{min}:{max}'.format(min=0, max=281474976710000),
        'DS:update:GAUGE:10:{min}:{max}'.format(min=0, max=281474976710000),
        'DS:delete:GAUGE:10:{min}:{max}'.format(min=0, max=281474976710000),
        'RRA:AVERAGE:0.1:1:1200',
        'RRA:MIN:0.1:1:1200',
        'RRA:MAX:0.1:1:1200',
        'RRA:AVERAGE:0.1:14:1234',
        'RRA:MIN:0.1:14:1234',
        'RRA:MAX:0.1:14:1234',
        'RRA:AVERAGE:0.1:100:1209',
        'RRA:MIN:0.1:100:1209',
        'RRA:MAX:0.1:100:1209',
        'RRA:AVERAGE:0.1:446:1201',
        'RRA:MIN:0.1:446:1201',
        'RRA:MAX:0.1:446:1201',
        'RRA:AVERAGE:0.1:5270:1200',
        'RRA:MIN:0.1:5270:1200',
        'RRA:MAX:0.1:5270:1200',
    )
Example #2
0
def update(countrycity):
  country, city = countrycity.split('_',1)
  DB = RRD_PATH + 'weather_' + country + '_' + city + '.rrd'
  if not os.path.isfile(DB):
    rrdtool.create(DB,
      '-s', '300',
      'DS:humidity:GAUGE:600:0:100',
      'DS:temperature:GAUGE:600:U:U',
      'RRA:AVERAGE:0.5:1:576',
      'RRA:AVERAGE:0.5:6:672',
      'RRA:AVERAGE:0.5:24:732',
      'RRA:AVERAGE:0.5:144:1460'
    )
  stats = load(country, city);
  error = rrdtool.update(DB,
    '-t', 'humidity:temperature',
    'N:' + stats['humidity'] + ':' + stats['temperature']
  )
  if error:
    log(__file__, 'An error occured : ' + error)
  else:
    log(__file__, 'Stats for '+city+' are: '+stats['humidity']+'%, '+stats['temperature']+' C')
    for period in PERIODS:
      graph(country, city, 'temperature', period)
      graph(country, city, 'humidity', period)
  return
Example #3
0
def updateRrrd(powerconsumption):
  try: 
    import rrdtool
    if not os.path.exists("fritz.rrd"):
      rrdtool.create("fritz.rrd", "--step", "300", "DS:power:GAUGE:900:0:150", 'RRA:AVERAGE:0.5:12:3600', 'RRA:AVERAGE:0.5:288:3600', 'RRA:AVERAGE:0.5:1:3600')
    rrdtool.update("fritz.rrd", "N:%f" % powerconsumption)
  except: raise
Example #4
0
def _create_mongodb_memory_file(destination_file, first_ts):
    """Create a rrd file to store mongodb memory usage statistics.

    Mimics the file settings used by collectd for it's rrd file creation.
    """
    rrdtool.create(
        destination_file,
        '--start', '{}-10'.format(first_ts),
        '--step', '5',
        'DS:vsize:GAUGE:600:{min}:{max}'.format(min=0, max=281474976710000),
        'DS:res:GAUGE:600:{min}:{max}'.format(min=0, max=281474976710000),
        'RRA:AVERAGE:0.1:1:1200',
        'RRA:MIN:0.1:1:1200',
        'RRA:MAX:0.1:1:1200',
        'RRA:AVERAGE:0.1:14:1234',
        'RRA:MIN:0.1:14:1234',
        'RRA:MAX:0.1:14:1234',
        'RRA:AVERAGE:0.1:100:1209',
        'RRA:MIN:0.1:100:1209',
        'RRA:MAX:0.1:100:1209',
        'RRA:AVERAGE:0.1:446:1201',
        'RRA:MIN:0.1:446:1201',
        'RRA:MAX:0.1:446:1201',
        'RRA:AVERAGE:0.1:5270:1200',
        'RRA:MIN:0.1:5270:1200',
        'RRA:MAX:0.1:5270:1200',
    )
Example #5
0
    def init_rrd(self, fname, m):
        """init_rrd

        Set-up Data Sources (DS)
        Set-up Round Robin Archives (RRA):
        - day,week,month and year archives
        - 2 types : AVERAGE and MAX

        parameter : start time
        return    : last epoch recorded
        """
        ds_type = 'ABSOLUTE'
        rows = xpoints / points_per_sample
        realrows = int(rows * 1.1)    # ensure that the full range is covered
        day_steps = int(3600 * 24 / (rrdstep * rows))
        week_steps = day_steps * 7
        month_steps = week_steps * 5
        year_steps = month_steps * 12

        # Set up data sources for our RRD
        params = []
        for v in variables:
            params += ['DS:%s:%s:%s:0:U' % (v, ds_type, rrdstep * 2)]

        # Set up RRD to archive data
        for cf in ['AVERAGE', 'MAX']:
            for step in [day_steps, week_steps, month_steps, year_steps]:
                params += ['RRA:%s:0.5:%s:%s' % (cf, step, realrows)]

        # With those setup, we can now created the RRD
        rrdtool.create(str(fname),
                       '--start', str(m),
                       '--step', str(rrdstep),
                       *params)
        return m
Example #6
0
def createRRD():
    global nameArray
    tcReturnVal = subprocess.check_output([tcPath, "-s", "qdisc", "show", "dev", defaultDev])
    #split in to the qdiscs and then remove the empty place at [0].
    splitString = tcReturnVal.split("qdisc")
    splitString.pop(0)



    for x in splitString:
        #split into lines
        stringLine = x.split("\n")
        #there are three lines...
        nameLine = stringLine[0].split(" ")
        statsLine = stringLine[1].split(" ")
        rateLine = stringLine[2].split(" ")

        queueType = nameLine[1]
        queueName = nameLine[2].replace(':','-')
        rootOrParent = nameLine[3]

        nameArray.append({'name':queueName,'type':queueType,'rootOrParent':rootOrParent})

        fullFileName = (workingPath + queueName + ".rrd").replace(":","-")
        rrdtool.create(fullFileName,
            '--step', '5',
            'DS:packetSent:COUNTER:10:U:U',
            'DS:bytesSent:COUNTER:10:U:U',
            'DS:dropped:COUNTER:10:U:U',
            'DS:overlimits:COUNTER:10:U:U',
            'DS:requeues:COUNTER:10:U:U',
            'RRA:AVERAGE:0.5:1:600',
            'RRA:AVERAGE:0.5:6:360')
Example #7
0
    def update_rrd_simple(self, rrdfile, count):

        timestamp = int(time.time())

        try:
            open(rrdfile)
        except IOError:
            print __name__, ": Creating %s.." % (rrdfile)
            rrdtool.create(rrdfile,
                           '-b', str(timestamp-1), '-s300',
                           'DS:ds0:GAUGE:600:0:1000000',
                           'RRA:HWPREDICT:1440:0.1:0.0035:288',
                           'RRA:AVERAGE:0.5:1:800',
                           'RRA:AVERAGE:0.5:6:800',
                           'RRA:AVERAGE:0.5:24:800',
                           'RRA:AVERAGE:0.5:288:800',
                           'RRA:MAX:0.5:1:800',
                           'RRA:MAX:0.5:6:800',
                           'RRA:MAX:0.5:24:800',
                           'RRA:MAX:0.5:288:800')
        else:
            print __name__, ": Updating %s with value (Count=%s).." \
                % (rrdfile, count)
            try:
                rrdtool.update(rrdfile, str(timestamp) + ":" + \
                            str(count))
            except Exception, e:
                print "Error updating %s: %s" % (rrdfile, e)
Example #8
0
    def update_rrd(self, rrdfile, compromise, attack):

        timestamp = int(time.time())

        try:
            open(rrdfile)

        except IOError:
            logger.error("Creating %s.." % (rrdfile))
# This needs some checking, we don't need HWPREDICT here and I got some probs
# on MacosX (def update_rrd_simple) so I removed aberrant behaviour detection.
            try:
                rrdtool.create(rrdfile,
                               '-b', str(timestamp-1), '-s300',
                               'DS:ds0:GAUGE:600:0:1000000',
                               'DS:ds1:GAUGE:600:0:1000000',
                               'RRA:AVERAGE:0.5:1:800',
                               'RRA:HWPREDICT:1440:0.1:0.0035:288',
                               'RRA:AVERAGE:0.5:6:800',
                               'RRA:AVERAGE:0.5:24:800',
                               'RRA:AVERAGE:0.5:288:800',
                               'RRA:MAX:0.5:1:800',
                               'RRA:MAX:0.5:6:800',
                               'RRA:MAX:0.5:24:800',
                               'RRA:MAX:0.5:288:800')
            except Exception, e:
                logger.warning(": Error creating %s.." % (rrdfile))
                return
Example #9
0
    def update_rrd_simple(self, rrdfile, count):

        timestamp = int(time.time())

        try:
            open(rrdfile)

        except IOError:
            logger.error(": Creating %s.." % (rrdfile))
            rrdtool.create(rrdfile,
                           '-b', str(timestamp), '-s300',
                           'DS:ds0:GAUGE:600:0:1000000',
                           'RRA:AVERAGE:0.5:1:800',
                           'RRA:AVERAGE:0.5:6:800',
                           'RRA:AVERAGE:0.5:24:800',
                           'RRA:AVERAGE:0.5:288:800',
                           'RRA:MAX:0.5:1:800',
                           'RRA:MAX:0.5:6:800',
                           'RRA:MAX:0.5:24:800',
                           'RRA:MAX:0.5:288:800')
        else:
            logger.info("Updating %s with value (Count=%s).." \
                % (rrdfile, str(count)))

            try:
                rrdtool.update(rrdfile, str(timestamp) + ":" + \
                            str(count))

            except Exception, e:
                logger.error("Error updating %s: %s" % (rrdfile, e))
Example #10
0
def updateChannelRRD(dataDir, name, values, lastTS={}):
    filename = os.path.join(dataDir, '%s.rrd' % name)

    if os.path.isfile(filename):
        updates = []
        for ts, v in values:
            ts = int(ts + 0.5)

            # Throw out updates that are less than a second apart.
            if ts != lastTS.get(name, 0):
                lastTS[name] = ts
                updates.append('%s:%s' % (ts, v))

        print updates
        rrdtool.update(filename, *updates)
    
    else:
        rra = []
        for cf in 'AVERAGE', 'MIN', 'MAX':
            rra.extend([
                    "RRA:%s:0.99:1:172800" % cf,
                    "RRA:%s:0.99:60:2880" % cf,
                    "RRA:%s:0.5:420:2880" % cf,
                    "RRA:%s:0.5:1860:2880" % cf,
                    "RRA:%s:0.5:21900:2880" % cf,
                    ])
        rrdtool.create(filename,
                       "DS:value:GAUGE:120:U:U",
                       "-s 1", *rra)
Example #11
0
def update_graph_database(rrd_dir, type, n_source, n_binary):
    if not rrd_dir:
        return

    rrd_file = os.path.join(rrd_dir, type.lower() + '.rrd')
    update = [rrd_file, "N:%s:%s" % (n_source, n_binary)]

    try:
        rrdtool.update(*update)
    except rrdtool.error:
        create = [rrd_file] + """
--step
300
--start
0
DS:ds0:GAUGE:7200:0:1000
DS:ds1:GAUGE:7200:0:1000
RRA:AVERAGE:0.5:1:599
RRA:AVERAGE:0.5:6:700
RRA:AVERAGE:0.5:24:775
RRA:AVERAGE:0.5:288:795
RRA:MAX:0.5:1:600
RRA:MAX:0.5:6:700
RRA:MAX:0.5:24:775
RRA:MAX:0.5:288:795
""".strip().split("\n")
        try:
            rrdtool.create(*create)
            rrdtool.update(*update)
        except rrdtool.error as e:
            print(('warning: queue_report: rrdtool error, skipping %s.rrd: %s' % (type, e)))
    except NameError:
        pass
Example #12
0
def rrd_update(rrdfile, name, value, slope):

    # fix annoying unicode issues
    rrdfile = str(rrdfile)
    
    dstype = 'GAUGE'
    if slope == 'zero':
        dstype = 'ABSOLUTE'
        # for now don't care about invariants
        return
    elif slope == 'both':
        dstype = 'GAUGE'
    elif slope == 'positive':
        dstype = 'COUNTER'
        
    token = 'DS:' + name + ':' + dstype + ':60:U:U'
    if not os.path.exists(rrdfile):
        logging.info("Creating %s\n", rrdfile)
        # 1440 is minutes per day
        # 300 minutes = 5 hours
        # 30 hours = 1800 minutes
        rrdtool.create(rrdfile, '--step=20', token,
                       # 1 point at 20s, 900 of them 300m, 5 hours
                       'RRA:AVERAGE:0.5:1:900',
                       # 3 points @ 20s = 60s = 1m, 30 hours
                       'RRA:AVERAGE:0.5:3:1800'
                       )
        # no else
    svalue = str(value)
    logging.debug("Updating '%s' with value of '%s'", rrdfile, svalue)
    rrdtool.update(rrdfile, 'N:' + svalue)
Example #13
0
def _create_mem_rrd_command(rrd_name, start, period):
    """Create a new RRD for managing memory utilisation information.

    The new RRD will have a specific sampling period, plus a 10s roll up for one minute, a minute roll up for one hour,
    and an hourly roll up for one day.

    :param rrd_name: The name of the RRD
    :type rrd_name: str
    :param start: The start of the new RRD. None means now.
    :type start: int
    :param period: The sampling period, in number of seconds
    :type period: int
    """
    if not start:
        start = time.time()

    int_period = int(period)
    samples_per_hour = 3600 / int_period
    samples_per_min = 60 / int_period

    rrdtool.create(str(rrd_name), '--start', str(int(start)), '--step', str(period),
                   'DS:memtotal:GAUGE:' + str(int_period * 2) + ':0:U',
                   'DS:memused:GAUGE:' + str(int_period * 2) + ':0:U',
                   'DS:memfree:GAUGE:' + str(int_period * 2) + ':0:U',
                   'DS:swaptotal:GAUGE:' + str(int_period * 2) + ':0:U',
                   'DS:swapused:GAUGE:' + str(int_period * 2) + ':0:U',
                   'DS:swapfree:GAUGE:' + str(int_period * 2) + ':0:U',
                   'DS:buffers:GAUGE:' + str(int_period * 2) + ':0:U',
                   'DS:cached:GAUGE:' + str(int_period * 2) + ':0:U',
                   'RRA:LAST:0.5:1:' + str(samples_per_hour),  # Samples as is, good for 1 hour
                   'RRA:AVERAGE:0.5:' + str(samples_per_min) + ':' + str(12 * 60),  # Minute rollup for 12h
                   'RRA:AVERAGE:0.5:' + str(samples_per_hour) + ':' + str(24),  # Hourly rollup for 24h
                   'RRA:AVERAGE:0.5:' + str(24 * samples_per_hour) + ':' + str(7))  # Daily rollup for 1w
def create_rrd_files():
    start_time = int(time.time())
    timeout = str(2*time_interval)
    rrdtool.create(str(cpufile+'.rrd'), '--step', str(time_interval),
            '--start', str(start_time),
            'DS:cpu_percent:GAUGE:'+timeout+':0:U',
            'RRA:AVERAGE:0.5:1:17280', # stores samples collected for 1 day 5*60*24
            'RRA:AVERAGE:0.5:360:240', # 30min averages for 5 days
            'RRA:AVERAGE:0.5:720:240', # 1 hour averages for 10 days
            'RRA:AVERAGE:0.5:1440:240', # 2 hour averages for 20 days
            'RRA:AVERAGE:0.5:8640:40', # 12 hour averages for 20 days
            'RRA:AVERAGE:0.5:12780:60', # 1 day averages for 60 days
            'RRA:AVERAGE:0.5:89460:10') # 1 week for 10 weeks
    rrdtool.create(str(memfile+'.rrd'), '--step', str(time_interval),
            '--start', str(start_time),
            'DS:mem_percent:GAUGE:'+timeout+':0:U',
            'RRA:MAX:0.5:1:17280', # stores samples collected for 1 day 5*60*24
            'RRA:MAX:0.5:720:240', # 1 hour averages for 5 days
            'RRA:MAX:0.5:12780:10', # 1 day averages for 10 days
            'RRA:MIN:0.5:1:17280', # stores samples collected for 1 day 5*60*24
            'RRA:MIN:0.5:720:240', # 1 hour averages for 5 days
            'RRA:MIN:0.5:12780:10', # 1 day averages for 10 days
            'RRA:AVERAGE:0.5:1:17280', # stores samples collected for 1 day 5*60*24
            'RRA:AVERAGE:0.5:360:240', # 30min averages for 5 days
            'RRA:AVERAGE:0.5:720:240', # 1 hour averages for 10 days
            'RRA:AVERAGE:0.5:1440:240', # 2 hour averages for 20 days
            'RRA:AVERAGE:0.5:8640:40', # 12 hour averages for 20 days
            'RRA:AVERAGE:0.5:12780:60', # 1 day averages for 60 days
            'RRA:AVERAGE:0.5:89460:10') # 1 week for 10 weeks
 def createRRDFile( self, dataPointName, rrdCreateCommand ):
     """
     Create an RRD file if it does not exist or if the step value has changed.
     Returns the basename of the rrdFile, suitable for checking thresholds.
     """
     self.log.debug( 'Checking RRD File for %s' % dataPointName )
     
     if not self.daemonName: 
         return
     
     directory = zenPath( 'perf', 'Daemons', self.monitor )
     if not os.path.exists( directory ):
         self.log.debug( 'Creating directory: %s' % directory )
         os.makedirs( directory )
         
     fileName = '%s_%s.rrd' % ( self.daemonName, dataPointName )
     filePath = zenPath( directory, fileName )
     step = rrdCreateCommand[rrdCreateCommand.index('--step')+1]
     if not os.path.exists( filePath ) or \
             self._hasStepTimeChanged( filePath, step ):
         import getpass
         self.log.debug( 'Creating RRD file %s as user %s with options %s' % 
             ( filePath, getpass.getuser(), rrdCreateCommand ) )
         rrdtool.create( filePath, *rrdCreateCommand )
     else:
         self.log.debug( 'RRD file already exists' )
Example #16
0
def rrdupdate(owdata):
    if config.rrdenable:
	stime = int(time.mktime(time.localtime()))
	path = config.rrdpath
	step = 300
	hb = 3600
	xff = 0.5
	HOUR = 3600
	YEAR = 31536000
	steps1 = 1
	rows1 = YEAR // step
	for sensor in owdata:
	    (value, timestamp) = owdata[sensor]
	    if value == config.owfail:
		continue
	    rrdfile = '%s/%s.rrd' % (path, sensor.upper())
	    if not os.path.isfile(rrdfile):
		try:
		    rrdtool.create(rrdfile, '--step', '%d' % step,
			'DS:data:GAUGE:%d:U:U' % hb,
			'RRA:AVERAGE:%d:%d:%d' % (xff, steps1, rows1))
		except rrdtool.error, e:
		    logger.warning(e)
	        logger.debug("RRD %s created" % sensor)
	    info = rrdtool.info(rrdfile)
	    if ((stime - info['last_update']) > step):
	        try:
		    rrdtool.update(rrdfile,'%s:%s' % (timestamp, value))
		except rrdtool.error, e:
		    logger.warning(e)
	        logger.debug("RRD %s updated" % sensor)
Example #17
0
    def create_rrd_db(self):
        cfg.log.debug("Creating generic rrd database %s" % self.filename)

        overdue_secs = self.interval_secs * 2
        summary_interval = self.interval_secs * cfg.points_to_summarize
        intervals_per_day = 86400 / summary_interval
        intervals_to_keep = cfg.days_to_keep * intervals_per_day

        # Hold 180 days of data before it rolls out, average/max calculated every 4 hours
        # samples are expected every hour
        try:
            rrdtool.create(str(self.filename),
                           '--step', str(cfg.interval_secs),
                           '--start', '0',
                           'DS:node_count:GAUGE:%s:U:U' % overdue_secs,
                           'DS:nodes_active:GAUGE:%s:U:U' % overdue_secs,
                           'DS:raw_capacity:GAUGE:%s:U:U' % overdue_secs,
                           'DS:raw_used:GAUGE:%s:U:U' % overdue_secs,
                           'DS:usable_capacity:GAUGE:%s:U:U' % overdue_secs,
                           'DS:used_capacity:GAUGE:%s:U:U' % overdue_secs,
                           'RRA:AVERAGE:0.5:%d:%d' % (cfg.points_to_summarize, intervals_to_keep),
                           'RRA:MAX:0.5:%d:%d' % (cfg.points_to_summarize, intervals_to_keep))
            self.db_usable = True
        except rrdtool.error:
            self.db_usable = False
Example #18
0
def touch_rrd(item):
    """
    create a rrd database for each ip, if not exists
    """

    for _type,_target in item['result'].items(): 
        ip = item['ip']
        if not os.path.isdir('./%s'%ip):
            os.mkdir('./%s'%ip)

        for result in item['result'][_type]:
            # example: ['166.111.8.28','30','ms']
            rrd_filename = './%s/%s_%s.rrd'%(ip,_type,format_url(result[0]))
            
            if not os.path.exists(rrd_filename):
                rrdtool.create(rrd_filename, '--step','900',
                               '--start','-8640000',
                                "DS:result:GAUGE:2000:U:U",
                                "RRA:AVERAGE:0.5:1:600",
                                "RRA:AVERAGE:0.5:24:775",
                                "RRA:MAX:0.5:1:600",
                                "RRA:MAX:0.5:24:775",
                                )
            #then update it
            rrdtool.update(rrd_filename,"%d:%s"%(item['time'],result[1]))
Example #19
0
def create_rrd(filename, when = None):
	args = [ filename ]
	if when is not None:
		args.append("-b%s" % when)
	args += [ "-s300",
		"DS:icmp_flows:ABSOLUTE:600:0:U",
		"DS:tcp_flows:ABSOLUTE:600:0:U",
		"DS:udp_flows:ABSOLUTE:600:0:U",
		"DS:gre_flows:ABSOLUTE:600:0:U",
		"DS:esp_flows:ABSOLUTE:600:0:U",
		"DS:other_flows:ABSOLUTE:600:0:U",
		"DS:icmp_bytes:ABSOLUTE:600:0:U",
		"DS:tcp_bytes:ABSOLUTE:600:0:U",
		"DS:udp_bytes:ABSOLUTE:600:0:U",
		"DS:gre_bytes:ABSOLUTE:600:0:U",
		"DS:esp_bytes:ABSOLUTE:600:0:U",
		"DS:other_bytes:ABSOLUTE:600:0:U",
		"DS:icmp_packets:ABSOLUTE:600:0:U",
		"DS:tcp_packets:ABSOLUTE:600:0:U",
		"DS:udp_packets:ABSOLUTE:600:0:U",
		"DS:gre_packets:ABSOLUTE:600:0:U",
		"DS:esp_packets:ABSOLUTE:600:0:U",
		"DS:other_packets:ABSOLUTE:600:0:U",
		"RRA:AVERAGE:0.75:1:4800",
		"RRA:AVERAGE:0.5:6:2400",
		"RRA:AVERAGE:0.5:24:1200",
		"RRA:AVERAGE:0.5:288:1500",
	]
	print >> sys.stderr, "Creating %s" % filename
	rrdtool.create(*args)
Example #20
0
def update():
  DB = RRD_PATH + 'speedtest.rrd'
  if not os.path.isfile(DB):
    rrdtool.create(DB,
            '-s', '300',
            'DS:in:GAUGE:600:0:U',
            'DS:out:GAUGE:600:0:U',
            'DS:ping:GAUGE:600:0:U',
            'RRA:AVERAGE:0.5:1:576',
            'RRA:AVERAGE:0.5:6:672',
            'RRA:AVERAGE:0.5:24:732',
            'RRA:AVERAGE:0.5:144:1460'
    )
  stats = load()
  error = rrdtool.update(DB,
        '-t', 'in:out:ping',
        'N:'+str(stats['in'])+':'+str(stats['out'])+':'+str(stats['ping'])
  )
  if error:
    log(__file__, 'An error occured : ' + error)
  else:
    for period in PERIODS:
      graph(period)
    log(__file__, 'BandWith stats : %sMB/s up, %sMB/s down' % (stats['in']/(1024*1024), stats['out']/(1024*1024)))
  return
Example #21
0
 def rrdcreate(self):
     if not self.id:
         return None
     
     cmd = []
     path = self.get_rrd_path()
     cmd.append(str(path))
     
     # options
     cmd.append('--start')
     cmd.append(str(self.start.strftime("%s")))
     cmd.append('--step')
     cmd.append(str(self.step))
     
     if not self.overwrite:
         cmd.append('--no-overwrite')
     
     ds = []
     for name in self.get_ds_list():
         row = getattr(self, name, None)
         if row:
             ds.append(str(row.to_string()))
     cmd.append(ds)
     
     for name in self.get_rra_list():
         row = getattr(self, name, None)
         if row:
             cmd.append(str(row.to_string()))
     
     rrdtool.create(*cmd)
    def createDatabase(self):
        '''create rrd databases. Existing databases will
        not be overwritten'''

        params = globals()
        params.update(locals())

        if not os.path.exists(self.rrd_power):
            logging.info(
                "creating new rrd database %s" % self.rrd_power)
            data_sources = []
            for profile in DAILY_PROFILES:
                mi, ma = RANGES[profile]
                data_sources.append(
                    'DS:%s:GAUGE:120:%i:%i' % (profile, mi, ma))

            rra = [
                # short-term
                'RRA:AVERAGE:0.5:%(SHORT_TERM_VALUES_PER_AGGREGATE)i:%(SHORT_TERM_NUM_VALUES)i',
                # medium term
                'RRA:AVERAGE:0.5:%(MEDIUM_TERM_VALUES_PER_AGGREGATE)i:%(MEDIUM_TERM_NUM_VALUES)i',
                'RRA:MIN:0.5:%(MEDIUM_TERM_VALUES_PER_AGGREGATE)i:%(MEDIUM_TERM_NUM_VALUES)i',
                'RRA:MAX:0.5:%(MEDIUM_TERM_VALUES_PER_AGGREGATE)i:%(MEDIUM_TERM_NUM_VALUES)i',
                # longterm profile
                'RRA:AVERAGE:0.5:%(LONG_TERM_VALUES_PER_AGGREGATE)i:%(LONG_TERM_NUM_VALUES)i',
                'RRA:MIN:0.5:%(LONG_TERM_VALUES_PER_AGGREGATE)i:%(LONG_TERM_NUM_VALUES)i',
                'RRA:MAX:0.5:%(LONG_TERM_VALUES_PER_AGGREGATE)i:%(LONG_TERM_NUM_VALUES)i',
            ]

            rra = [x % params for x in rra]

            rrdtool.create(self.rrd_power,
                           '--step', str(HEART_BEAT),
                           *data_sources + rra)
def create_database(dbname):
    print "CREATE DATABASE"
    rrdtool.create(
        "tree/database/" + dbname + ".rrd",
        "--step",
        "300",
        "--start",
        "0",
        "DS:pmin:GAUGE:600:U:U",
        "DS:pmax:GAUGE:600:U:U",
        "DS:pavg:GAUGE:600:U:U",
        "DS:plos:GAUGE:600:0:100",
        "RRA:AVERAGE:0.5:1:10080",
        "RRA:AVERAGE:0.5:5:8934",
        "RRA:AVERAGE:0.5:60:8784",
        "RRA:AVERAGE:0.5:1440:3660",
        "RRA:MIN:0.5:1:10080",
        "RRA:MIN:0.5:5:8934",
        "RRA:MIN:0.5:60:8784",
        "RRA:MIN:0.5:1440:3660",
        "RRA:MAX:0.5:1:10080",
        "RRA:MAX:0.5:5:8934",
        "RRA:MAX:0.5:60:8784",
        "RRA:MAX:0.5:1440:3660",
    )
Example #24
0
def create_rrd_db(dsname, offs, step=60 ):
        rrdf=rrdpath+"/"+dsname+".rrd"
	try:
		os.remove(rrdf);
	except:
		win.addstr(6, 0, "Failed to remove "+rrdf);
		win.refresh();
        finally:
            win.addstr(6, 0, "RRD file: "+rrdf+" has been removed");
	    win.refresh();

        #win.addstr(7, 0, "Created a new RRD file: "+rrdfile+"     ");
        #win.refresh();
	try:
		rrdtool.create(str(rrdf), "--step", str(step), "--start", str(offs),
		"DS:"+str(dsname)+":GAUGE:120:0:24000",
                "RRA:AVERAGE:0.5:1:864000",
                "RRA:AVERAGE:0.5:60:129600",
                "RRA:AVERAGE:0.5:3600:13392")
	except Exception as e:
        	win.addstr(7, 0, "Failed to create a new RRD file: "+rrdf+"     "+str(e));
		win.insstr(9, 0, "                               ");
        	win.refresh();
		curses.endwin();
		exit();
Example #25
0
def create_rrd():
  print 'Creating RRD: ' + count_rrd
  # Create RRD to store counter and consumption:
  # 1 trigger cycle matches consumption of 1/revs_per_kWh
  # Counter is GAUGE (kWh)
  # Consumption is ABSOLUTE (W)
  # 1 value per minute for 3 days
  # 1 value per day for 30 days
  # 1 value per week for 10 years
  # Consolidation LAST for counter
  # Consolidation AVERAGE for consumption
  try:
    rrdtool.create(count_rrd, 
      '--no-overwrite',
      '--step', '60',
      'DS:counter:GAUGE:86400:0:1000000',
      'DS:consum:ABSOLUTE:86400:0:1000000',
      'RRA:LAST:0.5:1:4320',
      'RRA:AVERAGE:0.5:1:4320',
      'RRA:LAST:0.5:1440:30',
      'RRA:AVERAGE:0.5:1440:30',
      'RRA:LAST:0.5:10080:520',
      'RRA:AVERAGE:0.5:10080:520')
  except Exception as e:
    print 'Error ' + str(e)
Example #26
0
def  create_rrd(rrd_dir, host, port):
    rrdtool.create(rrd_dir + host + "_" + port + "_mem_status.rrd",
           "--start", '-10s',
           "--step", "60",
           "DS:total_request:COUNTER:1800:0:U",
           "DS:get_request:COUNTER:1800:0:U",
           "DS:set_request:COUNTER:1800:0:U",
           "DS:total_mem:GAUGE:1800:0:U",
           "DS:used_mem:GAUGE:1800:0:U",
           "RRA:AVERAGE:0.5:1:360",
           "RRA:AVERAGE:0.5:5:288",
           "RRA:AVERAGE:0.5:30:336",
           "RRA:AVERAGE:0.5:120:372",
           "RRA:AVERAGE:0.5:1440:366",
           "RRA:AVERAGE:0.5:10080:262",
           "RRA:MAX:0.5:5:288",
           "RRA:MAX:0.5:30:336",
           "RRA:MAX:0.5:120:372",
           "RRA:MAX:0.5:1440:366",
           "RRA:MAX:0.5:10080:262",
           "RRA:MAX:0.5:10:228",
           "RRA:MIN:0.5:5:288",
           "RRA:MIN:0.5:30:336",
           "RRA:MIN:0.5:120:372",
           "RRA:MIN:0.5:1440:366",
           "RRA:MIN:0.5:10080:262",
            ) 
Example #27
0
def update():
  DB = RRD_PATH + 'voltages.rrd'
  ds = []
  for sensor in cfg.Sensors:
    ds.append('DS:'+sensor+':GAUGE:600:0:U')
  if not os.path.isfile(DB):
    rrdtool.create(DB,
      '-s', '300',
      ds,
      'RRA:AVERAGE:0.5:1:576',
      'RRA:AVERAGE:0.5:6:672',
      'RRA:AVERAGE:0.5:24:732',
      'RRA:AVERAGE:0.5:144:1460'
    )
  stats = {}
  for sensor in cfg.Sensors:
    stats[sensor] = load(sensor)
  error = rrdtool.update(DB,
    '-t', ':'.join(cfg.Sensors),
    'N:'+':'.join(stats.values())
  )
  print ':'.join(stats.values())
  if error:
    log(__file__, 'An error occured : ' + error)
  else:
    for period in PERIODS:
      for sensor in cfg.Sensors:
        graph(sensor, period)
      if hasattr(cfg, 'MergeGraphs') and cfg.MergeGraphs == 1:
        graphMerge(period)
    log(__file__, 'voltage update : %s' % str(stats))
  return
Example #28
0
def mem_check():
	path = "rrd/mem.rrd"
	swap = "rrd/swap.rrd"
	if os.path.exists(path) == False:
		rrdtool.create(path, "--step", str(step),
			"DS:used:GAUGE:%i:0:U" % heartbeat,
			"DS:buffers:GAUGE:%i:0:U" % heartbeat,
			"DS:cached:GAUGE:%i:0:U" % heartbeat,
			"DS:swap:GAUGE:%i:0:U" % heartbeat,
			rra_month,
			rra_month_min,
			rra_month_max,
			rra_year,
			rra_year_min,
			rra_year_max
			)

	if os.path.exists(swap) == False:
		rrdtool.create(swap, "--step", str(step),
			"DS:swap:GAUGE:%i:0:U" % heartbeat,
			rra_month,
			rra_month_min,
			rra_month_max,
			rra_year,
			rra_year_min,
			rra_year_max
			)

	return
Example #29
0
 def _generate_rrd(self):
     '''
     Create rrd file if rrdfile is None
     '''
     stime = int(time.time()) - 1 * 86400
     dpoints = 288
     etime = stime + (dpoints * 300)
     fname = os.path.join(os.path.abspath(os.path.dirname('./')), 
                          'test.rrd')
     rrdtool.create('test.rrd' ,
             '--start' , str(stime) ,
             "DS:input:COUNTER:600:U:U",
             "DS:output:COUNTER:600:U:U",
             "RRA:AVERAGE:0.5:1:600",
             "RRA:AVERAGE:0.5:6:700",
             "RRA:AVERAGE:0.5:24:775",
             "RRA:AVERAGE:0.5:288:797",
             "RRA:MAX:0.5:1:600",
             "RRA:MAX:0.5:6:700",
             "RRA:MAX:0.5:24:775",
             "RRA:MAX:0.5:444:797",)
     ctime = stime
     input = 0
     output = 0
     for i in xrange(dpoints):
         input += random.randrange(self.bandwidth / 2, self.bandwidth +
                                   self.bandwidth * 2) * 100
         output += random.randrange(self.bandwidth / 2, self.bandwidth +
                                    self.bandwidth * 2) * 100
         ctime += 300
         rrdtool.update(fname , '%d:%d:%d' % (ctime , input, output))
     return os.path.join(os.path.abspath(os.path.dirname('./')), "test.rrd")
Example #30
0
def create_rrd(rrd_file,m_type="None"):
    if m_type=="host":
        ret = rrdtool.create( rrd_file, "--step", str(STEP) ,"--start", str(int(time.time())),
        "DS:cpu:GAUGE:%s:0:U"   % str(TIME_DIFF_MS),
        "DS:ram:GAUGE:%s:0:U"     % str(TIME_DIFF_MS),
        "DS:dr:GAUGE:%s:0:U"    % str(TIME_DIFF_MS),
        "DS:dw:GAUGE:%s:0:U"    % str(TIME_DIFF_MS),
        "DS:tx:GAUGE:%s:0:U"      % str(TIME_DIFF_MS),
        "DS:rx:GAUGE:%s:0:U"      % str(TIME_DIFF_MS),
        "DS:tmp:GAUGE:%s:0:U"      % str(TIME_DIFF_MS),
        "DS:pwr:GAUGE:%s:0:U"      % str(TIME_DIFF_MS),
        "RRA:MIN:0:1:200000",       # Data stored for every five minute
        "RRA:AVERAGE:0.5:12:100",   # Average data stored for every hour (300*12)
        "RRA:AVERAGE:0.5:288:50",   # Average data stored for every day (300*288)
        "RRA:AVERAGE:0.5:8928:24",  # Average data stored for every month (300*8928)
        "RRA:AVERAGE:0.5:107136:10")# Average data stored for every year (300*107136)
    else:
        ret = rrdtool.create( rrd_file, "--step", str(STEP) ,"--start", str(int(time.time())),
        "DS:cpu:GAUGE:%s:0:U"   % str(TIME_DIFF_MS),
        "DS:ram:GAUGE:%s:0:U"     % str(TIME_DIFF_MS),
        "DS:dr:GAUGE:%s:0:U"    % str(TIME_DIFF_MS),
        "DS:dw:GAUGE:%s:0:U"    % str(TIME_DIFF_MS),
        "DS:tx:GAUGE:%s:0:U"      % str(TIME_DIFF_MS),
        "DS:rx:GAUGE:%s:0:U"      % str(TIME_DIFF_MS),
        "RRA:MIN:0:1:200000",       # Data stored for every five minute
        "RRA:AVERAGE:0.5:12:100",   # Average data stored for every hour (300*12)
        "RRA:AVERAGE:0.5:288:50",   # Average data stored for every day (300*288)
        "RRA:AVERAGE:0.5:8928:24",  # Average data stored for every month (300*8928)
        "RRA:AVERAGE:0.5:107136:10")# Average data stored for every year (300*107136)

    if ret:
        rrd_logger.warn(rrdtool.error())
#!/usr/bin/python
#-*- coding: iso-8859-15 -*-
# INDUINO METEOSTATION
# http://induino.wordpress.com
#
# NACHO MAS 2013

import sys
import rrdtool
from meteoconfig import *

#10s raw values for 3hour, 1min for 24 hours, 5 min for 24*7 hours,
# 1hour for 1 year, 1day dor 10 years!
ret = rrdtool.create(
    RRDFILE, "--step", "1", "--start", '0', "DS:HR:GAUGE:600:U:U",
    "DS:Thr:GAUGE:600:U:U", "DS:IR:GAUGE:600:U:U", "DS:Tir:GAUGE:600:U:U",
    "DS:P:GAUGE:600:U:U", "DS:Tp:GAUGE:600:U:U", "DS:Dew:GAUGE:600:U:U",
    "DS:Light:GAUGE:600:U:U", "DS:T:GAUGE:600:U:U", "DS:clouds:GAUGE:600:U:U",
    "DS:skyT:GAUGE:600:U:U", "DS:cloudFlag:GAUGE:600:U:U",
    "DS:dewFlag:GAUGE:600:U:U", "DS:frezzingFlag:GAUGE:600:U:U",
    "RRA:AVERAGE:0.5:1:10800", "RRA:AVERAGE:0.5:60:1440",
    "RRA:AVERAGE:0.5:300:1008", "RRA:AVERAGE:0.5:3600:8760",
    "RRA:AVERAGE:0.5:86400:3650", "RRA:MAX:0.5:1:10800", "RRA:MAX:0.5:60:1440",
    "RRA:MAX:0.5:300:1008", "RRA:MAX:0.5:3600:8760", "RRA:MAX:0.5:86400:3650",
    "RRA:MIN:0.5:1:10800", "RRA:MIN:0.5:60:1440", "RRA:MIN:0.5:300:1008",
    "RRA:MIN:0.5:3600:8760", "RRA:MIN:0.5:86400:3650")

if ret:
    print rrdtool.error()
Example #32
0
def get_mysqlstatus(db_host):
    global status
    global output
    connection1 = 0.0
    slow_queries1 = 0.0
    com_select1 = 0
    com_update1 = 0
    com_delete1 = 0
    com_insert1 = 0
    com_questions1 = 0
    valid_count = 1
    sql = 'show global status where Variable_name in (\
        "Connections", \
        "Slow_queries", \
        "Qcache_hits",\
        "Qcache_inserts", \
        "Qcache_lowmem_prunes", \
        "Qcache_not_cached", \
        "Queries", \
        "Questions", \
        "Com_select", \
        "Com_insert", \
        "Com_update", \
        "Com_delete", \
        "Table_locks_waited", \
        "Uptime" \
         )'

    try:
        cursor.execute(sql)
        results = cursor.fetchall()
        for row in results:
            if row[0] == "Slow_queries":
                slow_queries = row[1]
            if row[0] == "Connections":
                connection = row[1]
            if row[0] == "Com_update":
                com_update = row[1]
            if row[0] == "Com_select":
                com_select = row[1]
            if row[0] == "Com_delete":
                com_delete = row[1]
            if row[0] == "Com_insert":
                com_insert = row[1]
            if row[0] == "Questions":
                questions = row[1]

        if os.path.exists(rrd_dir + host + "_mysql_status.rrd"):
            rrdtool.update(
                rrd_dir + host + "_mysql_status.rrd",
                '%s:%s:%s:%s:%s:%s:%s:%s' %
                (time.strftime(
                    "%s", time.localtime(time.time() - 10)), str(connection),
                 str(slow_queries), str(com_select), str(com_insert),
                 str(com_update), str(com_delete), str(questions)))
            (start, ds,
             data) = rrdtool.fetch(rrd_dir + host + "_mysql_status.rrd",
                                   "AVERAGE", "-s", "-300s")
            for row in data:
                if row[0] != None:
                    connection1 += row[0]
                    slow_queries1 += row[1]
                    com_select1 += row[2]
                    com_insert1 += row[3]
                    com_update1 += row[4]
                    com_delete1 += row[5]
                    com_questions1 += row[6]
                    valid_count += 1
            slow_queries1 = slow_queries1 / valid_count
            connection1 = connection1 / valid_count
            com_select1 = com_select1 / valid_count
            com_insert1 = com_insert1 / valid_count
            com_update1 = com_update1 / valid_count
            com_delete1 = com_delete1 / valid_count
            com_questions1 = com_questions1 / valid_count
            output += "slow_queries1:%f, connection1:%f, select:%f, insert:%f, update:%f, delete:%f, questions:%f" % (
                slow_queries1, connection1, com_select1, com_insert1,
                com_update1, com_delete1, com_questions1)
            output += "connection:%s" % connection
            output += "slow_query:%s" % slow_queries
            if slow_queries1 > 100:
                output += "too many slow_queries"
                status = service_status['critical']
            if connection1 > 500:
                output += "too many connections"
                status = service_status['critical']
        else:
            rrdtool.create(
                rrd_dir + host + "_mysql_status.rrd",
                "--start",
                '-10s',
                "--step",
                "60",
                "DS:connections:COUNTER:1800:0:U",
                "DS:slow_queries:COUNTER:1800:0:U",
                "DS:com_select:COUNTER:1800:0:U",
                "DS:com_insert:COUNTER:1800:0:U",
                "DS:com_update:COUNTER:1800:0:U",
                "DS:com_delete:COUNTER:1800:0:U",
                "DS:Questions:COUNTER:1800:0:U",
                "RRA:AVERAGE:0.5:1:360",
                "RRA:AVERAGE:0.5:5:288",
                "RRA:AVERAGE:0.5:30:336",
                "RRA:AVERAGE:0.5:120:372",
                "RRA:AVERAGE:0.5:1440:366",
                "RRA:AVERAGE:0.5:10080:262",
                "RRA:MAX:0.5:5:288",
                "RRA:MAX:0.5:30:336",
                "RRA:MAX:0.5:120:372",
                "RRA:MAX:0.5:1440:366",
                "RRA:MAX:0.5:10080:262",
                "RRA:MAX:0.5:10:228",
                "RRA:MIN:0.5:5:288",
                "RRA:MIN:0.5:30:336",
                "RRA:MIN:0.5:120:372",
                "RRA:MIN:0.5:1440:366",
                "RRA:MIN:0.5:10080:262",
            )

    except Exception, e:
        print e
Example #33
0
# -*- coding: utf-8 -*-
#!/usr/bin/python
import rrdtool
import time

cur_time = str(int(time.time()))
rrd = rrdtool.create(
    'Flow.rrd', '--step', '300', '--start', cur_time,
    'DS:eth0_in:COUNTER:600:0:U', 'DS:eth0_out:COUNTER:600:0:U',
    'RRA:AVERAGE:0.5:1:600', 'RRA:AVERAGE:0.5:6:700', 'RRA:AVERAGE:0.5:24:775',
    'RRA:AVERAGE:0.5:288:797', 'RRA:MAX:0.5:1:600', 'RRA:MAX:0.5:6:700',
    'RRA:MAX:0.5:24:775', 'RRA:MAX:0.5:444:797', 'RRA:MIN:0.5:1:600',
    'RRA:MIN:0.5:6:700', 'RRA:MIN:0.5:24:775', 'RRA:MIN:0.5:444:797')
if rrd:
    print rrdtool.error()
Example #34
0
def get(self, community, version_snmp, ip, port, oid):
    errorIndication, errorStatus, errorIndex, varBinds = next(
        getCmd(SnmpEngine(), CommunityData(str(community),
                                           mpModel=version_snmp),
               UdpTransportTarget((str(ip), port)), ContextData(),
               ObjectType(ObjectIdentity(str(oid)))))
    if errorIndication:
        print(errorIndication)
    elif errorStatus:
        print('%s at %s' %
              (errorStatus.prettyPrint(),
               errorIndex and varBinds[int(errorIndex) - 1][0] or '?'))
    else:
        for varBind in varBinds:
            result = str(varBind).split("=")
            return result[1]


intcp = get("comunidadEquipo1_grupo4cm1", 1, "localhost", 161,
            "1.3.6.1.2.1.6.10.0")
outtcp = get("comunidadEquipo1_grupo4cm1", 1, "localhost", 161,
             "1.3.6.1.2.1.6.11.0")
query = "N:" + str(intcp) + ":" + str(outtcp) + ""
ret = rrdtool.create("parctica2.rrd", "--start", 'N',
                     "DS:intcp:COUNTER:600:U:U", "DS:outtcp:COUNTER:600:U:U",
                     "RRA:AVERAGE:0.5:1:24", "RRA:AVERAGE:0.5:6:10")

gra = rrdtool.graph("practica2.png", "--start", "N", "--end", "920808000",
                    "DEF:practica2.rrd:intcp:AVERAGE",
                    "DEF:practica2.rrd:outtcp:AVERAGE", "LINE1:myspeed#FF0000")
Example #35
0
sys.path.append('/usr/lib/cgi-bin/ng')
import config
from extractprofile import SocketProfile
import rrdtool

profId = 'stats/all'
rrdFileName = '/var/lib/profile-stats-logger/stats.rrd'

if not os.path.exists(rrdFileName):
    rrdtool.create(
        rrdFileName,
        '--step',
        '10',
        'DS:pcache_hit:DERIVE:60:0:U',
        'DS:pcache_miss_absent:DERIVE:60:0:U',
        'DS:pcache_miss_expired:DERIVE:60:0:U',
        'DS:pcache_miss_invalid:DERIVE:60:0:U',
        'RRA:AVERAGE:0.1:1:8640',  # 10s intervals for 24 hours
        'RRA:AVERAGE:0.1:30:8640',  # 5 min intervals for 1 month
        'RRA:AVERAGE:0.1:360:8640'  # 1 hour intervals for 1 year
    )

nextTime = math.floor(time.time() / 10) * 10 + 10

while True:
    t = time.time()
    while t < nextTime:
        time.sleep(nextTime - t)
        t = time.time()
    nextTime += 10
Example #36
0
#!/usr/bin/env python

import rrdtool

ret = rrdtool.create("netPred.rrd", "--start", 'N', "--step", '100',
                     "DS:inoctets:COUNTER:600:U:U",
                     "DS:outoctets:COUNTER:600:U:U", "RRA:AVERAGE:0.5:1:2016",
                     "RRA:HWPREDICT:1000:0.9:0.0035:288:3",
                     "RRA:SEASONAL:288:0.9:2", "RRA:DEVSEASONAL:288:0.9:2",
                     "RRA:DEVPREDICT:1000:4", "RRA:FAILURES:288:7:9:4")

if ret:
    print rrdtool.error()
Example #37
0
 def create(self, filename):
     rrdtool.create(filename, "--step", str(self.step), self.data_sources,
                    *self.archives)
Example #38
0
def main():
    codecs.getreader('utf-8')(sys.stdin)
    data = {}
    RULE_ORDER = ['DEF', 'VDEF', 'CDEF']
    EOF = False

    config_filename = '/etc/loxone-rrd.conf'
    log(u'Starting up')
    opts, args = getopt.getopt(sys.argv[1:], 'c:', ['config='])

    for o, a in opts:
        if o in ('-c', '--config'):
            config_filename = a

    config = load_config(config_filename)

    graph_interval = int(
        config.get('Parameters', {}).get('graph_interval', 120))
    log("Setting up graph generation interval: {}".format(graph_interval))
    t = threading.Thread(target=generate_graph,
                         kwargs={
                             'interval': graph_interval,
                             'config': config
                         })
    t.start()

    while not EOF:
        try:
            line = sys.stdin.readline()
        except (BaseException, Exception) as e:
            log("Error during read: {}".format(e))
            EOF = True
            break

        if line == '':
            EOF = True
            break
        line = line.strip()
        r = pattern.search(line)
        if not r:
            continue

        (date, data_name, value) = r.groups()
        data_name = unicode(data_name, 'utf-8')
        ts = time.mktime(
            datetime.datetime.strptime(r.group(1),
                                       "%Y-%m-%d %H:%M:%S").timetuple())

        if not config['Data'].get(data_name):
            log("Unknown data key: {}".format(data_name))
            continue

        fname = u'{}.rrd'.format(data_name).encode('utf-8')
        if not os.path.isfile(fname):
            log("Create new RRD database: {}".format(data_name))
            p = get_params(config['Data'][data_name])
            try:
                rrdtool.create([fname] + p)
            except Exception as e:
                log("Error creating RRD: {}".format(e))

        try:
            rrdtool.update(fname, '{}:{}'.format(ts, value))
        except Exception as e:
            log("Error updating RRD: {}".format(e))

    log("Exiting")
    t.join()
Example #39
0
	def _createRRD(self, hostname):

		self._step = 5
		self._rrdSize = 500/5
		self._predict = 250/5
		self._season = 125/5

		if True:#try:
			for fname in self._names:

				s = self._fname[fname]

				if fname == self._names[4]:

					for i in range(self._agents[hostname].getNumInterFs()):

						name = s.format(hostname, i, 'rrd')

						ret = rrdtool.create(name, 
									'--start', 'N', 
									'--step', str(self._step),
									'DS:in:COUNTER:600:0:U',
									'RRA:AVERAGE:0.5:1:' + str(self._rrdSize),
									'RRA:HWPREDICT:' + str(self._predict) + ':0.5:0.025:' + str(self._season) + ':3',
									'RRA:SEASONAL:' + str(self._season*2) + ':0.1:2',
									'RRA:DEVSEASONAL:' + str(self._season*2) + ':0.1:2',
									'RRA:DEVPREDICT:' + str(self._predict) + ':4',
									'RRA:FAILURES:' + str(self._season*2) + ':5:5:4',
									'DS:out:COUNTER:600:0:U',
									'RRA:AVERAGE:0.5:1:' + str(self._rrdSize))

						if ret:
							print name, rrdtool.error()

				elif fname == self._names[5]:
					#create ram
					name = s.format(hostname, 'rrd')
					ret = rrdtool.create(name, 
									'--start', 'N', 
									'--step', str(self._step),
									'DS:ram:GAUGE:600:0:U',
									'RRA:AVERAGE:0.5:2:' + str(self._rrdSize))
					if ret:
						print name, rrdtool.error()	

				elif fname == self._names[6]:
					#create cpu
					for i in range(self._agents[hostname].getNumCPUs()):

						name = s.format(hostname, i, 'rrd')

						ret = rrdtool.create(name, 
									'--start', 'N', 
									'--step', str(self._step),
									'DS:load:GAUGE:600:0:100',
									'RRA:AVERAGE:0.5:2:' + str(self._rrdSize))

						if ret:
							print name, rrdtool.error()

				elif fname == self._names[7]:
					#hdd
					name = s.format(hostname, 'rrd')
					ret = rrdtool.create(name, 
									'--start', 'N', 
									'--step', str(self._step),
									'DS:hdd:GAUGE:600:0:U',
									'RRA:AVERAGE:0.5:2:' + str(self._rrdSize))
					if ret:
						print name, rrdtool.error()	
				
				else:
					name = s.format(hostname, 'rrd')

					ret = rrdtool.create(name, 
									'--start', 'N', 
									'--step', str(self._step),
									'DS:in:COUNTER:600:0:U',
									'DS:out:COUNTER:600:0:U',
									'RRA:AVERAGE:0.5:2:' + str(self._rrdSize),
									'RRA:AVERAGE:0.5:2:' + str(self._rrdSize))
					if ret:
						print name, rrdtool.error()	

		else:#except (KeyError, rrdtool.OperationalError) as e:
			print 'Error'
Example #40
0
File: main.py Project: schit/mySHPI
# make 4M ramdisk for graph
os.popen('sudo mkdir /media/ramdisk')
os.popen('sudo mount -t tmpfs -o size=4M tmpfs /media/ramdisk')
#os.chdir('/media/ramdisk')


if not os.path.isfile('temperatures.rrd'):
    print('create rrd')
    rrdtool.create(
    "temperatures.rrd",
    "--step","60",
    "DS:act_temp:GAUGE:120:-127:127",
    "DS:gpu:GAUGE:120:-127:127",
    "DS:cpu:GAUGE:120:-127:127",
    "DS:atmega:GAUGE:120:-127:127",
    "DS:sht:GAUGE:120:-127:127",
    "DS:bmp280:GAUGE:120:-127:127",
    "DS:mlxamb:GAUGE:120:-127:127",
    "DS:mlxobj:GAUGE:120:-127:127",
    "DS:ntc:GAUGE:120:-127:127",
    "RRA:MAX:0.5:1:1500",
    "RRA:MAX:0.5:10:1500",
    "RRA:MAX:0.5:60:1500")



nextsensorcheck = 0
everysecond = 0
nexttm = 0
last_backlight_level = 0 
a = 0
#!/usr/bin/python

import sys
import rrdtool

ret = rrdtool.create("waterTemp.rrd", "--step", "300", "--start", '0',
                     "DS:watertemp:GAUGE:600:U:U", "RRA:AVERAGE:0.5:1:576",
                     "RRA:AVERAGE:0.5:6:672", "RRA:AVERAGE:0.5:24:732",
                     "RRA:AVERAGE:0.5:144:1460")

# 2 days of 5 mins averages
# 2 Weeks of 1/2 hour averages
# 2 Months of 2 hour averages
# 2 years of 12 hour averages

if ret:
    print rrdtool.error()
Example #42
0
rrd = rrdtool.create(
    'Flow.rrd',
    '--step',
    '300',  # 指定rrdtool每隔多长时间就收到一个值,默认为5分钟
    '--start',
    cur_time,  # 指定rrdtool第一条记录的起始时间,必须是timestamp的格式;

    # DT 定义数据源eth0_in (入流量)、eth0_out (出流量)用于定义数据源,用于存放脚本的结果的变量;
    # 类型都为COUNTER (递增);
    # 600秒为心跳值,其含义是600秒没有收到值, 则会用UNKNOWN代替;
    # 0为最小值;最大值用U代替, 表示不确定
    'DS:eth0_in:COUNTER:600:0:U',
    'DS:eth0_out:COUNTER:600:0:U',

    # RRA定义格式为[RRA:CF:xff:steps:rows],
    # CF定义了AVERAGE、MAX、MIN三种数据合并方式
    # xff定义为0.5, 表示一个CDP中的PDP值如超过一半值为UNKNOWN, 则该CDP的值就被标为UNKNOWN
    # 下列前4个RRA的定义说明如下, 其他定义与AVERAGE方式相似,
    # 区别是存最大值与最小值
    # 每隔5分钟 (1*300秒)存一次数据的平均值, 存600笔, 即2.08天
    # 每隔30分钟 (6*300秒)存一次数据的平均值, 存700笔, 即14.58天 (2周)
    # 每隔2小时 (24*300秒)存一次数据的平均值, 存775笔, 即64.58天 (2个月)
    # 每隔24小时 (288*300秒)存一次数据的平均值, 存797笔, 即797天 (2年)
    'RRA:AVERAGE:0.5:1:600',
    'RRA:AVERAGE:0.5:6:700',
    'RRA:AVERAGE:0.5:24:775',
    'RRA:AVERAGE:0.5:288:797',
    'RRA:MAX:0.5:1:600',
    'RRA:MAX:0.5:6:700',
    'RRA:MAX:0.5:24:775',
    'RRA:MAX:0.5:444:797',
    'RRA:MIN:0.5:1:600',
    'RRA:MIN:0.5:6:700',
    'RRA:MIN:0.5:24:775',
    'RRA:MIN:0.5:444:797')
def maintain_stats(init=False):
    # http://supportex.net/2011/09/rrd-python/
    # (https://jira.toolserver.org/browse/DRTRIGON-74)
    global localdir    # why is this needed here? nowhere else needed...?!?!!

    import platform, numpy, rrdtool    # for statistics '-stats'

    #rrd_fn = os.path.join(localdir, "stats-01-%s.rrd" % platform.platform())
    rrd_fn = os.path.join(localdir, "stats-01-%s.rrd" % platform.system())

    if init:
        ret = rrdtool.create(rrd_fn, "--step", "86400", "--start", '0',
         "DS:sum_start:GAUGE:144000:U:U",
         "DS:sum_end:GAUGE:144000:U:U",
         "DS:sum_diff:GAUGE:144000:U:U",
         "DS:bot_sum_disc:GAUGE:144000:U:U",
         "DS:bot_subster:GAUGE:144000:U:U",
         "DS:bot_catimages:GAUGE:144000:U:U",
         "DS:bot_uptime_sum_disc:GAUGE:144000:U:U",
         "DS:bot_uptime_subster:GAUGE:144000:U:U",
         "DS:bot_uptime_catimages:GAUGE:144000:U:U",
         "DS:msg_unknown:GAUGE:144000:U:U",
         "DS:msg_info:GAUGE:144000:U:U",
         "DS:msg_warning:GAUGE:144000:U:U",
         "DS:msg_error:GAUGE:144000:U:U",
         "DS:msg_critical:GAUGE:144000:U:U",
         "DS:msg_debug:GAUGE:144000:U:U",
         "DS:metric1:GAUGE:144000:U:U",
         "DS:metric2:GAUGE:144000:U:U",
         "DS:metric3:GAUGE:144000:U:U",
         "DS:metric4:GAUGE:144000:U:U",
         "DS:metric5:GAUGE:144000:U:U",
         "DS:sum_diff_inter:COMPUTE:sum_start,sum_end,-",
	 # (number of logfiles, quota, ...)
         "RRA:AVERAGE:0.5:1:600",
         "RRA:AVERAGE:0.5:6:700",
         "RRA:AVERAGE:0.5:24:775",
         "RRA:AVERAGE:0.5:288:797",
         "RRA:MIN:0.5:1:600",
         "RRA:MIN:0.5:6:700",
         "RRA:MIN:0.5:24:775",
         "RRA:MIN:0.5:444:797",
         "RRA:MAX:0.5:1:600",
         "RRA:MAX:0.5:6:700",
         "RRA:MAX:0.5:24:775",
         "RRA:MAX:0.5:444:797",
         "RRA:LAST:0.5:1:600",
         "RRA:LAST:0.5:6:700",
         "RRA:LAST:0.5:24:775",
         "RRA:LAST:0.5:444:797")
    else:
	(localdir, files, current) = oldlogfiles()
        stat, recent = logging_statistics(current, botcontinuous)
#        for item in current:
#            stat, recent = logging_statistics([item], botcontinuous)
#            if stat is None:
#                continue
#            end, start = numpy.array(stat['etiming']['end']), numpy.array(stat['etiming']['start'])
#            shape = min(end.shape[0], start.shape[0])
#            runtime = end[:shape]-start[:shape]-7200	# -2*60*60 because of time jump during 'set TZ'
#            if runtime.any() and (runtime.min() < 0):	# DST or not; e.g. ('CET', 'CEST')
#                runtime += 3600
#            uptime = numpy.array(runtime).sum()

        (bot_uptime_sum_disc, bot_uptime_subster, bot_uptime_catimages) = (0, 0, 0)
        (metric1, metric2, metric3, metric4, metric5) = (0, 0, 0, 0, 0)
        val = (ecount['start'], ecount['end'],  (ecount['start']-ecount['end']),
               ecount['sum_disc'], ecount['subster'], ecount['catimages'],
               bot_uptime_sum_disc, bot_uptime_subster, bot_uptime_catimages,
               mcount['unknown'], mcount['info'], mcount['warning'], mcount['error'], mcount['critical'], mcount['debug'],
               metric1, metric2, metric3, metric4, metric5,)

        # update
        ret = rrdtool.update(rrd_fn, ('N' + (':%s'*22)) % val);

        # show
        #for sched in ['hourly', 'daily', 'weekly', 'monthly']:
        for sched in ['daily', 'weekly', 'monthly']:
            fn  = "/home/drtrigon/public_html/DrTrigonBot/test-%s.png" % (sched)
#            ret = rrdtool.graph( fn, "--start", "-1%s" %(sched[0]), "--vertical-label=Num",
#                 '--watermark=DrTrigonBot.TS',
#                 "-w 800",
#                 "DEF:m1_num=%s:metric1:AVERAGE" % rrd_fn,
#                 "DEF:m2_num=%s:metric2:AVERAGE" % rrd_fn,
#                 "LINE1:m1_num#0000FF:metric1\\r",
#                 "LINE2:m2_num#00FF00:metric2\\r",
#                 "GPRINT:m1_num:AVERAGE:Avg m1\: %6.0lf ",
#                 "GPRINT:m1_num:MAX:Max m1\: %6.0lf \\r",
#                 "GPRINT:m2_num:AVERAGE:Avg m2\: %6.0lf ",
#                 "GPRINT:m2_num:MAX:Max m2\: %6.0lf \\r")
            ret = rrdtool.graph( fn, "--start", "-1%s" %(sched[0]), "--vertical-label=Num",
                 '--watermark=DrTrigonBot.TS',
                 "DEF:end_num=%s:sum_end:AVERAGE" % rrd_fn,
                 "DEF:start_num=%s:sum_start:AVERAGE" % rrd_fn,
                 "DEF:subster_num=%s:bot_subster:AVERAGE" % rrd_fn,
                 "DEF:sum_disc_num=%s:bot_sum_disc:AVERAGE" % rrd_fn,
                 "DEF:catimages_num=%s:bot_catimages:AVERAGE" % rrd_fn,
                 "LINE1:end_num#0000FF:end\\r",
                 "LINE2:start_num#00FF00:start\\r",
                 "LINE4:subster_num#00FF00:subster\\r",
                 "LINE5:sum_disc_num#00FF00:sum_disc\\r",
                 "LINE6:catimages_num#00FF00:catimages\\r",
                 "GPRINT:end_num:AVERAGE:Avg end\: %6.0lf ",
                 "GPRINT:end_num:MAX:Max end\: %6.0lf \\r",
                 "GPRINT:start_num:AVERAGE:Avg start\: %6.0lf ",
                 "GPRINT:start_num:MAX:Max start\: %6.0lf \\r")
Example #44
0
def main():
    try:
        argp = argparse.ArgumentParser(description=__doc__)
        argp.add_argument('rrdfile', help='The name of the RRD to use.')
        argp.add_argument(
            '-S',
            '--step',
            default=100,
            type=int,
            help=
            'Interval in seconds with which data will be fed into the RRD (default: 100 seconds). Will be used when creating a new RRD and as loop delay on continous reading.'
        )
        argp.add_argument('-C',
                          '--create',
                          action="store_true",
                          help='create new round-robin database')
        argp.add_argument(
            '-c',
            '--continuous',
            action="store_true",
            help=
            'Continuously reading system temperature and storing to rrd. Using --step as loop delay.'
        )
        argp.add_argument("-q",
                          "--quiet",
                          action="store_true",
                          help='Quiet mode. No output.')
        argp.add_argument('-v',
                          '--verbose',
                          action='count',
                          default=0,
                          help='Increase output verbosity.')
        argp.add_argument('-l',
                          '--locale',
                          default="de_DE",
                          help='Set time locale for logging output')
        #		argp.add_argument('--read-test', action="store_true",
        #						  help='just read cpu temp until Ctrl+C without using a RRD anyway.')
        args = argp.parse_args()

        if args.quiet:
            logging.basicConfig(level=99)
        elif args.verbose > 1:
            logging.basicConfig(level=logging.DEBUG)
        elif args.verbose == 1:
            logging.basicConfig(level=logging.INFO)
        else:
            logging.basicConfig(level=logging.WARNING)
        #else:
        #	logging.basicConfig(level=logging.ERROR)

        locale.setlocale(locale.LC_TIME, args.locale)
        _log.info("Locale is set to {0}".format(
            locale.getlocale(locale.LC_TIME)))

        if args.step > 300:
            _log.warning(
                "Step size {0} is too large! Reducing to maximum of 300 seconds."
                .format(args.step))
            step = 300
        elif args.step < 10:
            _log.warning(
                "Step size {0} is too small! In order not to poll thermal data file too often producing too much system load setting step size to minimum of 10 seconds."
                .format(args.step))
            step = 10
        else:
            _log.warning("Step size is set to {0} seconds.".format(args.step))
            step = args.step

        if args.create:
            if os.path.isfile(args.rrdfile):
                print("Cannot create {0}".format(args.rrdfile))
                print("Already exists!")
            else:
                a = int(round(300 / step))
                print("Creating {0} using a step size of {1} seconds..".format(
                    args.rrdfile, str(step)))
                rrdtool.create(
                    args.rrdfile,
                    "--step",
                    str(step),
                    "DS:temp:GAUGE:{0}:-20:110".format(step * 2),
                    # aggregate data points of 5 minutes and save for 24h
                    "RRA:AVERAGE:0.5:{0}:288".format(a),
                    "RRA:MIN:0.5:{0}:288".format(a),
                    "RRA:MAX:0.5:{0}:288".format(a),
                    # aggregate data points of 1 hour and save for 30 days
                    "RRA:AVERAGE:0.5:{0}:720".format(a * 12),
                    "RRA:MIN:0.5:{0}:720".format(a * 12),
                    "RRA:MAX:0.5:{0}:720".format(a * 12),
                    # aggregate data points of 1 day and save for 1 year
                    "RRA:AVERAGE:0.5:{0}:365".format(a * 288),
                    "RRA:MIN:0.5:{0}:365".format(a * 288),
                    "RRA:MAX:0.5:{0}:365".format(a * 288))
                print("Done.")


#		elif args.read_test:
#			print("Start reading...")
#			while True:
#				print("{0} °C".format(read_cputemp()))
#				time.sleep(5)
        else:
            if os.path.isfile(args.rrdfile):

                if args.continuous:
                    _log.info(
                        "Starting continuous reading system temperatue every {0} seconds"
                        .format(step))
                    while True:
                        t = update_rrd(args.rrdfile)
                        if t is not None:
                            _log.info("{0}: {1} °C".format(
                                time.strftime("%x %X"), t))
                        else:
                            _log.info("{0}: ---".format(
                                time.strftime("%x %X")))
                        time.sleep(step)
                else:
                    t = update_rrd(args.rrdfile)
                    print("Just once reading system temperatue: {0} °C".format(
                        t))

            else:
                _log.error("Cannot access {0}! File does not exist!".format(
                    args.rrdfile))

    except KeyboardInterrupt:
        print("\nAbbruch durch Benutzer Ctrl+C")
    except TypeError as e:
        exc_type, exc_obj, exc_tb = sys.exc_info()
        _log.error("Type Error: {0} in line {1}".format(e, exc_tb.tb_lineno))
    except RuntimeError as e:
        _log.error("RuntimeError: ", e)
    except Exception as e:
        exc_type, exc_obj, exc_tb = sys.exc_info()
        fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
        _log.error("Unexpected error {0}: {1} in {2} line {3}".format(
            exc_type, e, fname, exc_tb.tb_lineno))
    finally:
        print("Finally ended")
Example #45
0
def on_message(mosq, obj, msg):
    # Paho returns a byte string for message.payload. We need to decode it to get it in string form.
    payload = msg.payload.decode('UTF-8')
    logger.debug("Message received on topic: %s with payload: %s" %
                 (msg.topic, payload))

    pl = extract_float(payload)
    if pl == None:
        logger.debug("Unable to get float from payload: %s" % payload)
        return

    logger.info("Message received on topic " + msg.topic + " with QoS " +
                str(msg.qos) + " and payload %s " % str(pl))
    components = msg.topic.split("/")
    # Get the last part of the path
    file_name = components.pop()
    # append .info to info file name
    info_file_name = "%s.info" % file_name
    # append .rrd extension to database file
    file_name = "%s.rrd" % file_name
    #Get the root directory from the config
    dir_name = get_config_item("daemon", "data_dir", "/var/lib/mqtt2rrd/")
    # Append the path components to the root creating any missing directories
    while (len(components) > 0):
        dir_name = os.path.join(dir_name, components.pop(0))
        if not os.path.isdir(dir_name):
            os.mkdir(dir_name)
            logger.debug("Created directory: %s for topic: %s" %
                         (dir_name, msg.topic))

    file_path = os.path.join(dir_name, file_name)
    graph_name = msg.topic.replace("/", "_")
    graph_name = graph_name.replace(".", "_")
    if len(graph_name) > 19:
        graph_name = graph_name[:19]

    ds = "DS:%s:GAUGE:120:U:U" % graph_name
    ds = str(ds)

    if not os.path.exists(file_path):
        # Create the info file
        info = {
            'topic': msg.topic,
            'created': time.time(),
            'friendly_name': get_config_item(msg.topic, "friendly_name",
                                             msg.topic)
        }
        info_fpath = os.path.join(dir_name, info_file_name)
        f = open(info_fpath, "w")
        json.dump(info, f)
        f.close()
        # Create the RRD file
        try:
            step = get_config_item(msg.topic, "step", 60)
            RRAstr = get_config_item(
                msg.topic, "archives",
                "RRA:AVERAGE:0.5:2:30,RRA:AVERAGE:0.5:5:288,RRA:AVERAGE:0.5:30:336,RRA:AVERAGE:0.5:60:1488,RRA:AVERAGE:0.5:720:744,RRA:AVERAGE:0.5:1440:265"
            )

            RRAs = []
            for i in RRAstr.split(","):
                i = i.lstrip(" ")
                i = i.rstrip(" ")
                i = str(i)
                RRAs.append(i)

            logger.info("Creating RRD file: %s for topic: %s" %
                        (file_path, msg.topic))
            rrdtool.create(str(file_path), "--step", str(step), "--start", "0",
                           ds, *RRAs)

        except rrdtool.error as e:
            logger.error("Could not create RRD for topic: %s: %s" %
                         (ds, str(e)))
    try:
        logger.info("Updating: %s with value: %s" % (file_path, pl))
        rrdtool.update(str(file_path), str("N:%f" % pl))
    except rrdtool.error as e:
        logger.error("Could not log value: %s to RRD %s for topic: %s: %s" %
                     (pl, file_path, msg.topic, str(e)))
Example #46
0
try:
    with open(filename):
        pass
    print "Datenbankdatei gefunden: " + filename
    i = 1
except IOError:
    print "Ich erzeuge eine neue Datenbank: " + filename
    ret = rrdtool.create(
        "%s" % (filename),
        "--step",
        "%s" % (steps),
        "--start",
        '0',
        "DS:dht22_sensortemp:GAUGE:2000:U:U",
        "DS:dht22_sensorhum:GAUGE:2000:U:U",
        "DS:dht22_lat:GAUGE:2000:U:U",
        "DS:dht22_uml:GAUGE:2000:U:U",
        "DS:dht22_heat:GAUGE:2000:U:U",
        "DS:dht22_cool:GAUGE:2000:U:U",
        "DS:dht22_lbf:GAUGE:2000:U:U",
        "RRA:AVERAGE:0.5:1:2160",
        "RRA:AVERAGE:0.5:5:2016",
        "RRA:AVERAGE:0.5:15:2880",
        "RRA:AVERAGE:0.5:60:8760",
    )

    i = 1
writeVerbose('************************************************************')

settings = readSettings()
tempstart = int(time.time())
tempstart1 = tempstart
Example #47
0
import sys
import rrdtool

project_dir = "rrd"

ret = rrdtool.create("rrd/temps.rrd", "--step", "30", "--no-overwrite",
                     "DS:temp:GAUGE:240:-20:110", "RRA:AVERAGE:0.5:1:1200",
                     "RRA:MIN:0.5:12:2400", "RRA:MAX:0.5:12:2400",
                     "RRA:AVERAGE:0.5:12:2400", "RRA:LAST:0.5:1:10")

if ret:
    print rrdtool.error()
Example #48
0
from easysnmp import snmp_get
from easysnmp import exceptions as exce
import rrdtool

community = "public"
hostname = "localhost"
version = 1

session = Session(hostname=hostname, community=community, version=version)
if_num = int(session.get('ifNumber.0').value)

max_sleep_time = 5.0

if not os.path.isfile("rrdfiles/outoctets.rrd"):
    rrdtool.create('rrdfiles/outoctets.rrd', '--step', '5',
                   'DS:ifOutOctets:COUNTER:10:0:4294967295',
                   'RRA:AVERAGE:0.5:1:720', 'RRA:AVERAGE:0.5:12:300')
if not os.path.isfile("rrdfiles/inoctets.rrd"):
    rrdtool.create('rrdfiles/inoctets.rrd', '--step', '5',
                   'DS:ifInOctets:COUNTER:10:0:4294967295',
                   'RRA:AVERAGE:0.5:1:720', 'RRA:AVERAGE:0.5:12:300')

while True:
    initial_time = time.time()
    outBytes = 0
    inBytes = 0
    for i in range(1, if_num + 1):
        outBytes += int(session.get(f'ifOutOctets.{i}').value)
        inBytes += int(session.get(f'ifInOctets.{i}').value)
        #ricorda di non sommare la loopback (forse)
Example #49
0
    try:
        if os.path.isfile(rrdparms['file'] + ".rrd"):
            print("RRD file %s exists, skipping" % rrdparms['file'])
            continue
        rrd_params = list()
        print("creating: " + rrdparms['file'] + ".rrd")
        for sensor, params in SENSORS.iteritems():
            if params[0] == rrd:
                # TODO min:max
                rrd_params.append("DS:" + params[3] + ":GAUGE:300:U:U")
        if rrd_params:
            rrd_params += [
                "RRA:AVERAGE:0.5:1:576", "RRA:AVERAGE:0.5:2:2016",
                "RRA:AVERAGE:0.5:4:52560", "RRA:AVERAGE:0.5:24:175200",
                "RRA:MAX:0.5:1:576", "RRA:MAX:0.5:2:2016",
                "RRA:MAX:0.5:4:52560", "RRA:MAX:0.5:24:175200",
                "RRA:MIN:0.5:1:576", "RRA:MIN:0.5:2:2016",
                "RRA:MIN:0.5:4:52560", "RRA:MIN:0.5:24:175200"
            ]
            print(rrd_params)
            ret = rrdtool.create(rrdparms['file'] + ".rrd", "--step", "300",
                                 "--start", '0', *rrd_params)
            if ret:
                print(rrdtool.error())
        else:
            print("Skipping " + rrdparms['file'] + ", no sensors defined")
    except rrdtool.error as e:
        print("ERROR rrdtool: " + e.message)
    except Exception as e:
        print("ERROR " + sys.exc_info()[0])
Example #50
0
γ : 0.1

period : 10

'''

ret = rrdtool.create(
    "netP.rrd",
    "--start",
    'N',
    "--step",
    '300',
    "DS:inoctets:COUNTER:600:U:U",
    "DS:outoctets:COUNTER:600:U:U",
    "RRA:AVERAGE:0.5:1:20",
    "RRA:HWPREDICT:30:0.1:0.0035:10",
    #RRA:HWPREDICT:rows:alpha:beta:seasonal period[:rra-num]
    "RRA:SEASONAL:10:0.1:2",
    #RRA:SEASONAL:seasonal period:gamma:rra-num[:smoothing-window=fraction]
    "RRA:DEVSEASONAL:10:0.1:2",
    #RRA:DEVSEASONAL:seasonal period:gamma:rra-num[:smoothing-window=fraction]
    "RRA:DEVPREDICT:30:4",
    #RRA:DEVPREDICT:rows:rra-num
    "RRA:FAILURES:30:7:9:4"
    #RRA:FAILURES:rows:threshold:window length:rra-num
)

#HWPREDICT rra-num is the index of the SEASONAL RRA.
#SEASONAL rra-num is the index of the HWPREDICT RRA.
#DEVPREDICT rra-num is the index of the DEVSEASONAL RRA.
#DEVSEASONAL rra-num is the index of the HWPREDICT RRA.
#FAILURES rra-num is the index of the DEVSEASONAL RRA.
Example #51
0
def on_message(mosq, obj, msg):
    logger.debug("Message received on topic: %s with payload: %s." %
                 (msg.topic, msg.payload))

    pl = extract_float(msg.payload)
    if pl == None:
        logger.debug("Unable to get float from payload: %s" % msg.payload)
        return

    logger.info("Message received on topic " + msg.topic + " with QoS " +
                str(msg.qos) + " and payload %d " % pl)
    components = msg.topic.split("/")
    file_name = components.pop()
    info_file_name = "%s.info" % file_name
    file_name = "%s.rrd" % file_name
    dir_name = get_config_item("daemon", "data_dir", "/var/lib/mqtt2rrd/")
    while (len(components) > 0):
        dir_name = os.path.join(dir_name, components.pop(0))
        if not os.path.isdir(dir_name):
            os.mkdir(dir_name)
            logger.debug("Created directory: %s for topic: %s" %
                         (dir_name, msg.topic))

    file_path = os.path.join(dir_name, file_name)
    graph_name = msg.topic.replace("/", "_")
    graph_name = graph_name.replace(".", "_")
    if len(graph_name) > 19:
        graph_name = graph_name[:19]

    ds = "DS:val:GAUGE:300:U:U"  # % graph_name
    # ds = str(ds)

    if not os.path.exists(file_path):
        # Create the info file
        info = {
            'topic': msg.topic,
            'created': time.time(),
            'friendly_name': get_config_item(msg.topic, "friendly_name",
                                             msg.topic)
        }
        info_fpath = os.path.join(dir_name, info_file_name)
        f = open(info_fpath, "w")
        json.dump(info, f)
        f.close()
        # Create the RRD file
        try:
            step = get_config_item(msg.topic, "step", 60)
            RRAstr = get_config_item(
                msg.topic, "archives",
                "RRA:AVERAGE:0.5:2:720,RRA:AVERAGE:0.5:8:540,RRA:AVERAGE:0.5:12:840,RRA:AVERAGE:0.5:16:1260,RRA:AVERAGE:0.5:20:2160,RRA:AVERAGE:0.5:32:4050,RRA:AVERAGE:0.5:60:4272,RRA:AVERAGE:0.5:120:4380,RRA:AVERAGE:0.5:240:4272,RRA:AVERAGE:0.5:720:5475,RRA:AVERAGE:0.5:1440:3650"
            )

            RRAs = []
            for i in RRAstr.split(","):
                i = i.lstrip(" ")
                i = i.rstrip(" ")
                i = str(i)
                RRAs.append(i)

            logger.info("Creating RRD file: %s for topic: %s" %
                        (file_path, msg.topic))
            rrdtool.create(str(file_path), "--step", str(step), "--start", "0",
                           ds, *RRAs)

        except rrdtool.error as e:
            logger.error("Could not create RRD for topic: %s: %s" %
                         (ds, str(e)))
    try:
        logger.info("Updating: %s with value: %s" % (file_path, pl))
        rrdtool.update(str(file_path), str("N:%f" % float(pl)))
    except rrdtool.error as e:
        logger.error("Could not log value: %s to RRD %s for topic: %s: %s" %
                     (pl, file_path, msg.topic, str(e)))
Example #52
0
print("---- Data grab complete ----")

for serial, value, units, name, source_node in g:
    print(r"%2.3f : Found sensor %s with value %s %s and name %s" %
          (time(), serial, value, units, name))
    rrd = str(rrd_dir + serial + config.get("rrd", "ext"))

    if not os.path.isfile(rrd):
        #create rrd if none exists
        print("Creating new RRD " + rrd)
        rrdtool.create(
            rrd,
            "--step",
            "60",
            "DS:val:GAUGE:120:-100:100",  # Accept data between -100 and +100 as valid
            "RRA:AVERAGE:0.5:1:525600",  # A year of minutes
            "RRA:AVERAGE:0.5:60:8760",  # A year of hours
            "RRA:MAX:0.5:60:8760",  # A year of hours
            "RRA:MIN:0.5:60:8760",  # A year of hours
        )

    #update data
    rrdtool.update(rrd, "N:" + str(value))

    #store latest values
    try:
        (n, x, y, z, h, w, d) = sensors[serial]
    except:
        (n, x, y, z, h, w, d) = ("Auto-detected " + name, 0, 0, 0, 0, 0, 0)
        session.add(Probe(serial, n, x, y, z, h, w, d))
# PDP:Primary Data Point 。正常情况下每个 interval RRDtool 都会收到一个值;RRDtool 在收到脚本给来的值后会计算出另外一个值(例如平均值),这个 值就是 PDP ;这个值代表的一般是“xxx/秒”的含义。注意,该值不一定等于RRDtool 收到的那个值。除非是GAUGE ,可以看下面的例子就知道了
# CF:CF 就是 Consolidation Function 的缩写。也就是合并(统计)功能。有 AVERAGE、MAX、MIN、LAST 四种分别表示对多个PDP 进行取平均、取最大值、取最小值、取当前值四种类型。具体作用等到 update 操作时再说。
# CDP:Consolidation Data Point 。RRDtool 使用多个 PDP 合并为(计算出)一个 CDP。也就是执行上面 的CF 操作后的结果。这个值就是存入 RRA的数据,绘图时使用的也是这些数据

# 1、创建rrd数据库
rrd = rrdtool.create(
    'Flow.rrd',
    '--step',
    '300',
    '--start',
    cur_time,
    # 定义数据源eth0_in(流入量),eth0_out(流出量);类型都为COUNTER(递增);
    # 600s为心跳值,其含义为600s没有收到值,则会用UNKNOWN代替;0为最小值,最大值为U代替,表示不确定
    'DS:etho_in:COUNTER:600:0:U',
    'DS:etho_out:COUNTER:600:0:U',
    'RRA:AVERAGE:0.5:1:600',  # 1即300s,总共存600个
    'RRA:AVERAGE:0.5:6:700',
    'RRA:AVERAGE:0.5:24:775',
    'RRA:AVERAGE:0.5:28:797',
    'RRA:MAX:0.5:1:600',
    'RRA:MAX:0.5:6:700',
    'RRA:MAX:0.5:24:775',
    'RRA:MAX:0.5:28:797',
    'RRA:MIN:0.5:1:600',
    'RRA:MIN:0.5:6:700',
    'RRA:MIN:0.5:24:775',
    'RRA:MIN:0.5:28:797')
if rrd:
    print(rrdtool.error())

# 2、采用updatev()方法更新数据库
# update filename [--template|-t ds-name[:ds-name]...] N|timestamp:value[:value...] [timestamp:value[:value...] ...] 方法,
Example #54
0
parser.add_argument(
    "rrdfile",
    nargs='?',
    default=config.get('WeatherRadio', 'RRDSENSORSFILE'),
    help="RRD file holding all time series of the raw sensor data")
parser.add_argument("-s",
                    "--source",
                    help="Source file holding already captured data")

args = parser.parse_args()

rrd_args = [args.rrdfile, "--step", "300"]

if (args.source):
    rrd_args += ["--source", args.source]

# 5min raw values for 24 hours, 15 min for 7*24 hours, 1hour for 10 years.
ret = rrdtool.create(
    rrd_args, "DS:BME280_Temp:GAUGE:600:U:U", "DS:BME280_Pres:GAUGE:600:U:U",
    "DS:BME280_Hum:GAUGE:600:U:U", "DS:DHT_Temp:GAUGE:600:U:U",
    "DS:DHT_Hum:GAUGE:600:U:U", "DS:MLX90614_Tamb:GAUGE:600:U:U",
    "DS:MLX90614_Tobj:GAUGE:600:U:U", "DS:TSL2591_Lux:GAUGE:600:U:U",
    "RRA:AVERAGE:0.5:5m:24h", "RRA:AVERAGE:0.5:15m:7d",
    "RRA:AVERAGE:0.5:1h:1y", "RRA:AVERAGE:0.5:1d:10y", "RRA:MIN:0.5:5m:24h",
    "RRA:MIN:0.5:15m:7d", "RRA:MIN:0.5:1h:1y", "RRA:MIN:0.5:1d:10y",
    "RRA:MAX:0.5:5m:24h", "RRA:MAX:0.5:15m:7d", "RRA:MAX:0.5:1h:1y",
    "RRA:MAX:0.5:1d:10y")

if ret:
    print(rrdtool.error())
Example #55
0
rrdtoolpath = HaloRadio.conf['cron.rrdtool_path']

Time = int(time.time())
rrdfilename = "%s/halostat.rrd" % ( rrddir )
pngfileprefix= "%s/halostat-" % ( pngdir )

try:
	os.stat( rrdfilename )
except OSError:
	rrdtool.create( rrdfilename,
		"-b %d" % ( Time - 300 ),
		"-s 300",
		"DS:WebUsers:GAUGE:600:0:1024",
		"DS:Listeners:GAUGE:600:0:1024",
		"DS:QueueLen:GAUGE:600:0:10240",
		"RRA:AVERAGE:0.5:1:288",
		"RRA:AVERAGE:0.5:7:288",
		"RRA:MAX:0.5:7:288",
		"RRA:AVERAGE:0.5:31:288",
		"RRA:MAX:0.5:31:288",
		"RRA:AVERAGE:0.5:365:288",
		"RRA:MAX:0.5:365:288",
		)

import HaloRadio.SessionListMaker as SessionListMaker
slm = SessionListMaker.SessionListMaker()
slm.GetActive()
WebUsers = len(slm.list)

import HaloRadio.Util as Util
Listeners = Util.GetListeners()
Example #56
0
    import rrdtool

    #rrd_fn = "quota-%s.rrd" % platform.platform()
    rrd_fn = "quota-%s.rrd" % platform.system()

    if '-rrdinit' in sys.argv:
        ret = rrdtool.create(
            rrd_fn,
            "--step",
            "86400",
            "--start",
            '0',
            "DS:metric1:GAUGE:144000:U:U",
            "DS:metric2:GAUGE:144000:U:U",
            "RRA:AVERAGE:0.5:1:600",
            "RRA:AVERAGE:0.5:6:700",
            "RRA:AVERAGE:0.5:24:775",
            "RRA:AVERAGE:0.5:288:797",
            #         "RRA:MIN:0.5:1:600",
            #         "RRA:MIN:0.5:6:700",
            #         "RRA:MIN:0.5:24:775",
            #         "RRA:MIN:0.5:444:797",
            "RRA:MAX:0.5:1:600",
            "RRA:MAX:0.5:6:700",
            "RRA:MAX:0.5:24:775",
            "RRA:MAX:0.5:444:797")
    else:
        # update
        (metric1, metric2) = (percent, alarm)
        ret = rrdtool.update(rrd_fn, 'N:%s:%s' % (metric1, metric2))

        # show
Example #57
0
import rrdtool
ret = rrdtool.create("trend.rrd",
                     "--start",'N',
                     "--step",'60',
                     "DS:CPUload:GAUGE:600:U:U",
                     "RRA:AVERAGE:0.5:1:24")
if ret:
    print (rrdtool.error())
Example #58
0
    # Strip off the header and CRC then convert it using the unit function pointer
    data = rec[3:-2]
    return v.unit(combineBytes(data), v.times)


if __name__ == "__main__":
    """
    Test getting data from the Commander and print it to the screen
    """
    rrdfile = os.path.expanduser("~/solarDb.rrd")
    print rrdfile
    if not os.path.exists(rrdfile):
        ret = rrdtool.create(
            rrdfile, "--step", "1", "--start", '0', "DS:0x3000:GAUGE:2000:U:U",
            "DS:0x3001:GAUGE:2000:U:U", "DS:0x331A:GAUGE:2000:U:U",
            "RRA:AVERAGE:0.5:1s:10d", "RRA:AVERAGE:0.5:1m:90d",
            "RRA:AVERAGE:0.5:1h:18M", "RRA:AVERAGE:0.5:1d:10y",
            "RRA:MAX:0.5:1s:10d", "RRA:MAX:0.5:1m:90d", "RRA:MAX:0.5:1h:18M",
            "RRA:MAX:0.5:1d:10y")
        print "Created", os.path.exists(rrdfile)

    ser = getRs485()

    try:
        # The ID of the device we are going to communicate with.
        deviceId = 0x01
        for _ in xrange(1):
            toLog = {}
            for addr, v in sorted(mappings.RegistersA.iteritems()):
                value = communicate(ser, deviceId, addr, v, debug=False)
                print "%s \"%s\": %s" % (hex(addr), v.name, value)
args=parser.parse_args()

# 5min raw values for 24 hours, 15 min for 7*24 hours, 1hour for 1 year,
# 1day dor 10 years.
ret = rrdtool.create(args.outfile, "-r", args.infile, "--step", "300",
                     "DS:Temperature=Temperature[1]:GAUGE:600:U:U",
                     # pressure data ignored since we change to sea level
		     "DS:Pressure=Pressure[1]:GAUGE:600:U:U",
                     "DS:Humidity=Humidity[1]:GAUGE:600:U:U",
                     "DS:CloudCover=CloudCover[1]:GAUGE:600:U:U",
                     "DS:SkyTemperature=SkyTemperature[1]:GAUGE:600:U:U",
                     "DS:DewPoint=DewPoint[1]:GAUGE:600:U:U",
                     "DS:SQM=SQM[1]:GAUGE:600:U:U",
		     "DS:WindSpeed=WindSpeed[1]:GAUGE:600:U:U",
		     "DS:WindGust:GAUGE:600:U:U",
		     "DS:WindDirection=WindDirection[1]:GAUGE:600:U:U",
                     "RRA:AVERAGE:0.5:1:288",
                     "RRA:AVERAGE:0.5:3:672",
                     "RRA:AVERAGE:0.5:12:8760",
                     "RRA:AVERAGE:0.5:288:3650",
                     "RRA:MIN:0.5:1:288",
                     "RRA:MIN:0.5:3:672",
                     "RRA:MIN:0.5:12:8760",
                     "RRA:MIN:0.5:288:3650",
                     "RRA:MAX:0.5:1:288",
                     "RRA:MAX:0.5:5:672",
                     "RRA:MAX:0.5:12:8760",
                     "RRA:MAX:0.5:288:3650")


if ret:
    print rrdtool.error()
Example #60
0
            #  xff: fraction of <nsteps> that can have UNKNOWN as the value
            #  nsteps: number of steps used for calculation
            #  nrows: number of records to keep

            start = (int(time.time()) / INTERVAL - 1) * INTERVAL

            dataDefs = [
                rrdFile, '--start',
                str(start), '--step',
                str(INTERVAL)
            ]
            for c in JOB_COUNTERS:
                dataDefs.append('DS:' + c + ':GAUGE:600:0:U')
            dataDefs.append('RRA:LAST:0:1:' + str(3600 / INTERVAL * 24 * 7))

            rrdtool.create(*tuple(dataDefs))

            try:
                # change selinux context of the RRD so that it can be read by a apache-invoked PHP script
                selinux.chcon(rrdFile,
                              'unconfined_u:object_r:httpd_var_run_t:s0')
            except:
                pass

        try:
            rrdtool.update(rrdFile, str(timestamp) + ':' + str(counts))
        except:
            pass

    if args.graphDir:
        if ADD_MAX_SLOTS: