def graphJavaAverageGCTime(self,ipAddress,serviceName,period='-6h'):
		rrdtool.graph(self.static_path,'--start',period,"--vertical-label=Unit second",
		"--x-grid","MINUTE:12:HOUR:1:HOUR:1:0:%H", "--no-gridfit","--slope-mode",
		"--width","785 ","--height","230","--title","Java Average GC Time",
		"--color", "ARROW#FFFFFF", "--color", "AXIS#FFFFFF", "--color", "BACK#333333",
		"--color", "CANVAS#333333", "--color", "FONT#FFFFFF", "--color", "FRAME#AAAAAA", 
		"--color", "MGRID#CCCCCC", "--color", "SHADEA#000000", "--color", "SHADEB#111111",
		"DEF:YGCT_avg="+self.rrdfile+":YGCT_avg:AVERAGE",
		"DEF:FGCT_avg="+self.rrdfile+":FGCT_avg:AVERAGE",
		"DEF:GCT_avg="+self.rrdfile+":GCT_avg:AVERAGE",
		"LINE1:YGCT_avg#0E0BEE:YGCT_avg",
		"GPRINT:YGCT_avg:MAX:Max\: %5.3lf %S",
		"GPRINT:YGCT_avg:AVERAGE:Avg\: %5.3lf %S",
		"GPRINT:YGCT_avg:LAST:Current\: %5.3lf %S",
		"GPRINT:YGCT_avg:MIN:Min\: %5.3lf %S\\n",

		"LINE1:FGCT_avg#00FF00:FGCT_avg",
		"GPRINT:FGCT_avg:MAX:Max\: %5.3lf %S",
		"GPRINT:FGCT_avg:AVERAGE:Avg\: %5.3lf %S",
		"GPRINT:FGCT_avg:LAST:Current\: %5.3lf %S",
		"GPRINT:FGCT_avg:MIN:Min\: %5.3lf %S\\n",

		"LINE1:GCT_avg#FF0000:GCT_avg",
		"GPRINT:GCT_avg:MAX:Max\: %5.3lf %S",
		"GPRINT:GCT_avg:AVERAGE:Avg\: %5.3lf %S",
		"GPRINT:GCT_avg:LAST:Current\: %5.3lf %S",
		"GPRINT:GCT_avg:MIN:Min\: %5.3lf %S\\n",
		"COMMENT: \\n" ,
		"COMMENT:                    " ,
		"COMMENT:"+ipAddress+" & "+serviceName+""
		)
Beispiel #2
0
def graph_net(instance, duration):
    """
    Creates a graph of network usage for the specified instance and duration.
    """
    path = instance.get_rrd_path()
    filename = os.path.join(path, 'net-%s.png' % duration)

    rrdtool.graph(
        filename,
        '--disable-rrdtool-tag',
        '--imgformat', 'PNG',
        '--width', '400',
        '--height', '120',
        '--start', 'now-%s' % duration,
        '--vertical-label', 'bytes/s',
        '--logarithmic',
        '--units', 'si',
        '--lower-limit', '1000',
        '--rigid',
        'DEF:rx=%s:rx:AVERAGE' % os.path.join(path, 'net.rrd'),
        'DEF:tx=%s:tx:AVERAGE' % os.path.join(path, 'net.rrd'),
        'AREA:rx#00FF00:In traffic',
        'LINE1:tx#0000FF:Out traffic',)

    store_graph(instance.instance_id, filename)
Beispiel #3
0
def createRRDImage(path, initial_time, name):
    rrdtool.graph(path + "/trafico.png", "--start", initial_time,
                  "--title=" + name, "--vertical-label=Entrantes",
                  "DEF:inoctets=" + path + "/trafico.rrd:inoctets:AVERAGE",
                  "DEF:outoctets=" + path + "/trafico.rrd:outoctets:AVERAGE",
                  "AREA:inoctets#00FF00:In traffic",
                  "LINE1:outoctets#0000FF:Out Salientes\r")
Beispiel #4
0
def dItem04(data):
    pngname = str(data['pname'])
    start = data['stime']
    graphname = str(data['gname'] + "(" + data['host'] + ")" + "(" +
                    data['flag'] + ")")
    DEFa = str(r"DEF:a=" + data['rrdpath'] + r':' + data['pitem'][0] +
               r":AVERAGE")
    DEFb = str(r"DEF:b=" + data['rrdpath'] + r':' + data['pitem'][1] +
               r":AVERAGE")
    DEFc = str(r"DEF:c=" + data['rrdpath'] + r':' + data['pitem'][2] +
               r":AVERAGE")
    DEFd = str(r"DEF:d=" + data['rrdpath'] + r':' + data['pitem'][3] +
               r":AVERAGE")
    unit = str(data['unit'])
    if not unit:
        unit = ' '
    if data['cols'] or data['itypes']:
        if not data['cols']:
            dtypea = str(data['itypes'][0][0] + r":a#00CF00FF:" +
                         data['pitem'][0][1])
            dtypeb = str(data['itypes'][0][1] + r":b#002A97FF:" +
                         data['pitem'][1][1])
        elif not data['itypes']:
            dtypea = str(r"AREA:a" + data['cols'][0][0] + r":" +
                         data['pitem'][0][1])
            dtypeb = str(r"LINE2:b" + data['cols'][0][1] + r":" +
                         data['pitem'][1][1])
        else:
            dtypea = str(data['itypes'][0][0] + r":a" + data['cols'][0][0] +
                         r":" + data['pitem'][0][1])
            dtypeb = str(data['itypes'][0][1] + r":b" + data['cols'][0][1] +
                         r":" + data['pitem'][1][1])
    else:
        dtypea = str(r"LINE1:a#008000:" + data['pitem'][0])
        dtypeb = str(r"LINE1:b#FF0000:" + data['pitem'][1])
        dtypec = str(r"LINE1:c#FFD700:" + data['pitem'][2])
        dtyped = str(r"LINE1:d#4169E1:" + data['pitem'][3])
    maxa = 'GPRINT:a:MAX:Max\:%.2lf %s'
    mina = 'GPRINT:a:MIN:Min\:%.2lf %s'
    avga = 'GPRINT:a:AVERAGE:Avg\:%.2lf %s'
    nowa = 'GPRINT:a:LAST:Now\:%.2lf %s'
    maxb = 'GPRINT:b:MAX:Max\:%.2lf %s'
    minb = 'GPRINT:b:MIN:Min\:%.2lf %s'
    avgb = 'GPRINT:b:AVERAGE:Avg\:%.2lf %s'
    nowb = 'GPRINT:b:LAST:Now\:%.2lf %s'
    maxc = 'GPRINT:c:MAX:Max\:%.2lf %s'
    minc = 'GPRINT:c:MIN:Min\:%.2lf %s'
    avgc = 'GPRINT:c:AVERAGE:Avg\:%.2lf %s'
    nowc = 'GPRINT:c:LAST:Now\:%.2lf %s'
    maxd = 'GPRINT:d:MAX:Max\:%.2lf %s'
    mind = 'GPRINT:d:MIN:Min\:%.2lf %s'
    avgd = 'GPRINT:d:AVERAGE:Avg\:%.2lf %s'
    nowd = 'GPRINT:d:LAST:Now\:%.2lf %s'
    rrdtool.graph(pngname, '-w', '600', '-h', '144', '-l', '0', '-s', start,
                  '-t', graphname, '-v', unit, DEFa, DEFb, DEFc, DEFd,
                  'COMMENT: \\n', dtypea, nowa, avga, mina, maxa,
                  'COMMENT: \\n', dtypeb, nowb, avgb, minb, maxb,
                  'COMMENT: \\n', dtypec, nowc, avgc, minc, maxc,
                  'COMMENT: \\n', dtyped, nowd, avgd, mind, maxd,
                  'COMMENT: \\n')
 def renderGraphs(self, startTime, endTime):
     rrdtool.graph(
         self.resourceFolder + '/ifOutNUcastPkts.png', '--start',
         str(startTime), '--end', str(endTime),
         '--vertical-label=Packets/s', 'DEF:{0}={1}:{2}:{3}'.format(
             'outnucast', self.resourceFolder + '/' + DB_FILENAME,
             'ifOutNUcastPkts', 'AVERAGE'),
         'AREA:outnucast#0000FF:Paquetes Multicast Enviados')
     rrdtool.graph(
         self.resourceFolder + '/ipOutRequests.png', '--start',
         str(startTime), '--end', str(endTime),
         '--vertical-label=Packets/s', 'DEF:{0}={1}:{2}:{3}'.format(
             'ipout', self.resourceFolder + '/' + DB_FILENAME,
             'ipOutRequests', 'AVERAGE'),
         'AREA:ipout#00FF00:Solicitudes IP')
     rrdtool.graph(
         self.resourceFolder + '/icmpInMsgs.png', '--start', str(startTime),
         '--end', str(endTime), '--vertical-label=ICMP Msgs/s',
         'DEF:{0}={1}:{2}:{3}'.format(
             'icmp', self.resourceFolder + '/' + DB_FILENAME, 'icmpInMsgs',
             'AVERAGE'), 'AREA:icmp#FF0000:Mensajes ICMP')
     rrdtool.graph(
         self.resourceFolder + '/tcpRetransSegs.png', '--start',
         str(startTime), '--end', str(endTime),
         '--vertical-label=TCP Retrans/s', 'DEF:{0}={1}:{2}:{3}'.format(
             'tcpret', self.resourceFolder + '/' + DB_FILENAME,
             'tcpRetransSegs', 'AVERAGE'),
         'AREA:tcpret#000000:Segmentos TCP Retransmitidos')
     rrdtool.graph(
         self.resourceFolder + '/udpOutDatagrams.png', '--start',
         str(startTime), '--end', str(endTime),
         '--vertical-label=UDP Datagrams/s', 'DEF:{0}={1}:{2}:{3}'.format(
             'udpout', self.resourceFolder + '/' + DB_FILENAME,
             'udpOutDatagrams', 'AVERAGE'),
         'AREA:udpout#777777:Datagramas enviados.')
Beispiel #6
0
def generate_cpu(png, db, core):
    # Rewrite this
    rrdtool.graph(
        png,
        "--start",
        "end-6h",
        "--title",
        "Load: " + core,
        "-h",
        "150",
        "--width",
        "400",
        "--vertical-label=Percents",
        "--slope-mode",
        "--dynamic-labels",
        "--watermark=OpenSAN2",
        "--lower-limit",
        "0",
        "-E",
        "-i",
        "-r",
        "--upper-limit",
        "100",
        "DEF:sys=" + db + ":sys:AVERAGE",
        "DEF:user="******":user:AVERAGE",
        "CDEF:s=sys,100,/",
        "CDEF:u=user,100,/",
        "CDEF:su=u,s,+",
        "AREA:su#0000FF:User",
        "AREA:s#FF0000:System",
    )
Beispiel #7
0
def graph_net(rrd):
    ifaces = interfaces()
    for i in ifaces:
        png = png_path + i + "." + rrd["net"] + ".png"
        db = db_path + i + "." + rrd["net"]
        rrdtool.graph(
            png,
            "--start",
            "end-6h",
            "--title",
            "Network interface " + i,
            "-h",
            "150",
            "--width",
            "400",
            "--vertical-label=bits/s",
            "--slope-mode",
            "-m",
            "1",
            "--dynamic-labels",
            "--watermark=OpenSAN2",
            "--lower-limit",
            "0",
            "-E",
            "-i",
            "-r",
            "DEF:in=" + db + ":in:AVERAGE",
            "DEF:out=" + db + ":out:AVERAGE",
            "LINE1:out#FF0000:out",
            "LINE2:in#0000FF:in",
        )
def get_gyroscope_graph():

    HOUR = 3600
    fd, path = tempfile.mkstemp('.png')

    rrdtool.graph(path,
                  '--imgformat',
                  'PNG',
                  '--width',
                  '640',
                  '--height',
                  '300',
                  '--start',
                  "-%i" % HOUR,
                  '--end',
                  "-1",
                  '--vertical-label',
                  'Gyroscope values',
                  '--title',
                  'Hourly gyroscope',
                  'DEF:x=%s:x:AVERAGE' % RRDFILE,
                  'DEF:y=%s:y:AVERAGE' % RRDFILE,
                  'DEF:z=%s:z:AVERAGE' % RRDFILE,
                  'DEF:rx=%s:rx:AVERAGE' % RRDFILE,
                  'DEF:ry=%s:ry:AVERAGE' % RRDFILE,
                  'DEF:rz=%s:rz:AVERAGE' % RRDFILE,
                  'LINE:x#990033:X axis',
                  'LINE:y#339900:Y axis',
                  'LINE:z#003399:Z axis',
                  'LINE:rx#999933:X rotation',
                  'LINE:ry#339999:Y rotation',
                  'LINE:rz#993399:Z rotation', )

    return path
Beispiel #9
0
def last_hour(host):
	host = str(host)
	print host
	rrdtool.graph("images/last_hour_"+host+".png","-a", "PNG", "--slope-mode", "--start", "end-1h", "--width", "900", "--title", "Ping Statistics","--vertical-label", "Time(ms)",
	"DEF:pa=database/"+host+".rrd:pavg:AVERAGE",
	"AREA:pa#800000:Ping Average"
	)
Beispiel #10
0
def render(fname):
    print "Rendering new image."
    info = rrdtool.info(fname)
    for i in info:
	print "{} : {}".format(i,info[i])

    DAY = 86400
    DAYS_5 = DAY * 5
    YEAR = 365 * DAY
    rrdtool.graph('image-temp.png',
              '--imgformat', 'PNG',
              '--width', '540',
              '--height', '100',
              '--start', "-%i" % DAY,
              '--end', "-1",
              '--vertical-label', 'Temperature C',
              '--title', 'Temperature over last 24h',
              '--lower-limit', '0',
              'DEF:temp=%s:sensor1-temp:AVERAGE' % fname ,
              'VDEF:tempavg=temp,AVERAGE' ,
              'VDEF:tempmax=temp,MAXIMUM' ,
              'VDEF:tempmin=temp,MINIMUM' ,
              'AREA:temp#01DF01:Temperature' ,
              'LINE:tempmax#FF0000:Max' ,
              r'GPRINT:tempmin:Min\: %6.1lf C' ,
              r'GPRINT:tempmax:Max\: %6.1lf C' ,
              r'GPRINT:tempavg:Avg\: %6.1lf C' ,
	      r'GPRINT:temp:LAST:Cur\: %5.2lf C' ,
              )
Beispiel #11
0
def draw_net_ts_w(hostname):
    fname = os.path.join(settings.RRD_PREFIX, os.path.basename(hostname),
                         "interface", "if_octets-eth0.rrd")
    outfname = os.path.join(settings.GRAPH_PREFIX,
                            os.path.basename(hostname) + "-net-weekly.png")
    try:
        rrdtool.graph(
            outfname,
            "-s",
            "-1w",
            "-e",
            "-20s",
            #"-t", "Network traffic",
            "--units",
            "si",
            "-v",
            "Bits/s",
            #"--lazy",
            "COMMENT:\t\t\tAverage network traffic\\n",
            "DEF:rx=%s:rx:AVERAGE" % fname,
            "DEF:tx=%s:tx:AVERAGE" % fname,
            "CDEF:rxbits=rx,8,*",
            "CDEF:txbits=tx,8,*",
            "LINE1:rxbits#00ff00:Incoming",
            "GPRINT:rxbits:AVERAGE:\t%4.0lf%sbps\t\g",
            "LINE1:txbits#0000ff:Outgoing",
            "GPRINT:txbits:AVERAGE:\t%4.0lf%sbps\\n")
    except rrdtool.error, e:
        raise InternalError(str(e))
Beispiel #12
0
def createMemoryGraphs(rrd=None):
    watermark = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f - CEST")

    dictionary = {
        'MEMORY_Memory_1h.png' : '-1h',
        'MEMORY_Memory_12h.png' : '-12h',
        'MEMORY_Memory_1d.png' : '-1d',
        'MEMORY_Memory_1w.png' : '-1w',
        'MEMORY_Memory_1m.png' : '-1m'
    }

    for key, value in dictionary.iteritems():
        print key, value
        rrdtool.graph(key,
            '--imgformat', 'PNG',
            '--slope-mode',
            '--width', '500',
            '--height', '150',
            '--start', '%s' % value,
            '--end', 'now',
            '--vertical-label', 'Byte',
            '--title', 'MEMORY - Virtual memory',
            '--alt-y-grid', '--rigid',
            '--watermark', watermark,
            'DEF:mem_total=%s:VmemTotal:AVERAGE' % rrd,
            'DEF:mem_used=%s:VmemUsed:AVERAGE' % rrd,
            'DEF:mem_free=%s:VmemFree:AVERAGE' % rrd,
            'DEF:mem_buffers=%s:VmemBuffers:AVERAGE' % rrd,
            'LINE1:mem_total#000000:mem_total',
            'LINE2:mem_used#D7CC00:mem_used',
            'LINE2:mem_free#00CC00:mem_free',
            'LINE2:mem_buffers#D73600:mem_buffers'
            )
Beispiel #13
0
def data(version, host, period):
    if version == '0':
        if host not in _hosts(version):
            flask.abort(404)

        if period not in PERIODS:
            flask.abort(404)
        parameters = flask.request.args.get('parameters', None)
        if parameters is not None:
            parameters = parameters.split(',')
            for i in parameters:
                if i not in PARAMETERS:
                    flask.abort(404)
        else:
            parameters = PARAMETERS
        data_format = flask.request.args.get('format', 'png')
        if data_format not in ['png']:
            flask.abort(404)
        RESOLUTIONS = {
            '6h': 6 * 60 * 60 / RRDKeeper.POINTS_PER_GRAPH,
            '1d': 24 * 60 * 60 / RRDKeeper.POINTS_PER_GRAPH,
            '1w': 7 * 24 * 60 * 60 / RRDKeeper.POINTS_PER_GRAPH,
            '1m': 30 * 24 * 60 * 60 / RRDKeeper.POINTS_PER_GRAPH, 
            '1y': 365 * 24 * 60 * 60 / RRDKeeper.POINTS_PER_GRAPH
            }
        if data_format == 'png':
            width = flask.request.args.get('width', 400)
            height = flask.request.args.get('height', 400)
            img_file = tempfile.NamedTemporaryFile(mode='rb', dir='/tmp')
            args = [img_file.name, 
                    '--start', 'end-%s' % period, 
                    '--step', RESOLUTIONS[period], 
                    '-h', height, 
                    '-w', width]
            if 'title' in flask.request.args:
                args.extend(['--title', flask.request.args['title']])
            db = MySQLdb.connect(**app.config['ZABBIX_PROXY_DB'])
            c = db.cursor()
            c.execute('SELECT hostid FROM hosts WHERE host = %s', [host])
            r = c.fetchone()
            if r is None:
                flask.abort(404)
            hostid = r[0]
            for i, ds_name in enumerate(parameters):
                fname = RRDKeeper.fname(
                    os.path.abspath(
                        flask.current_app.config['ZABBIX_PROXY_TMP']),
                    str(hostid),
                    ds_name)
                if os.path.exists(fname):
                    args.extend([
                            'DEF:%s=%s:%s:AVERAGE' % (ds_name, fname, ds_name),
                            'LINE1:%s#%s:"%s"' % (ds_name, COLORS[i], ds_name)])
            args = map(str, args)
            rrdtool.graph(*args)
            response = flask.make_response(img_file.read())
            img_file.close()
            response.headers['Content-Type'] = 'image/png'
            return response
    flask.abort(404)
Beispiel #14
0
def packages(**kwargs):
    path = str(kwargs['path'])
    rrd = kwargs['rrd']

    rrdtool.graph(
        path,
        '--imgformat', 'PNG',
        '--width', kwargs['width'],
        '--height', kwargs['height'],
        kwargs['graph-mode'],
        '--color', 'CANVAS#FFFFFF00',
        '--color', 'BACK#FFFFFF00',

        '--start', kwargs['start'],
        '--end', kwargs['end'],
        '--vertical-label', kwargs['vertical-label'],
        '--title', kwargs['title'],
        '--lower-limit', '0',
        'DEF:n_packages_gentoo=%s:n_packages_gentoo:AVERAGE' % rrd,
        'DEF:n_packages_overlay=%s:n_packages_overlay:AVERAGE' % rrd,
        'DEF:n_packages_outdated=%s:n_packages_outdated:AVERAGE' % rrd,
        'LINE1.25:n_packages_gentoo#008000:Gentoo',
        'LINE1.25:n_packages_overlay#0B17FD:Overlay',
        'LINE1.25:n_packages_outdated#FF0000:Outdated'
    )
Beispiel #15
0
    def make_image(self, prefix, period):
        super(HDDUsage, self).make_image(prefix, period)
        rrdtool.graph(
            "%s_%s.png" % (prefix, period),
            "-s -1%s" % period,
            "-t usage on %s :: %s" % (self.device, self.name),
            "--lazy",
            "-h", "300", "-w", "700", "--full-size-mode", "-T", "10",
            "-l 0",
            "-b", "1024",
            "-a", "PNG",
            "-v hdd usage",
            "DEF:used=%s:used:AVERAGE" % self.FILE_NAME % self.clean_device,
            "DEF:free=%s:free:AVERAGE" % self.FILE_NAME % self.clean_device,
            "CDEF:total=used,free,+",

            "AREA:free#000099:Free",
            "GPRINT:free:MIN:     Min\\: %6.2lf %S",
            "GPRINT:free:AVERAGE:\\tAvg\\: %6.2lf %S",
            "GPRINT:free:MAX:\\tMax\\: %6.2lf %S",
            "GPRINT:free:LAST:\\tCurrent\\: %6.2lf %S \\n",

            "STACK:used#FF9C0F:Used",
            "GPRINT:used:MIN:     Min\\: %6.2lf %S",
            "GPRINT:used:AVERAGE:\\tAvg\\: %6.2lf %S",
            "GPRINT:used:MAX:\\tMax\\: %6.2lf %S",
            "GPRINT:used:LAST:\\tCurrent\\: %6.2lf %S \\n",

            "LINE2:total#FF0000:Total",
            "GPRINT:total:MIN:    Min\\: %6.2lf %S",
            "GPRINT:total:AVERAGE:\\tAvg\\: %6.2lf %S",
            "GPRINT:total:MAX:\\tMax\\: %6.2lf %S",
            "GPRINT:total:LAST:\\tCurrent\\: %6.2lf %S \\n",
        )
Beispiel #16
0
def plot_net(img_path, rrd_path, opt, tz=None):
    color_ibound_line = '#CF0000FF'
    color_ibound_area = '#CF000030'
    color_obound_line = '#0000CFFF'
    color_obound_area = '#0000CF30'

    title = 'Network usage'
    label = 'Bits per sercond'

    base = _base(img_path, title, label, opt, tz)
    base += ('--lower-limit', '0')

    addition = (
        'DEF:in=%s:in:AVERAGE' % rrd_path, 'DEF:out=%s:out:AVERAGE' % rrd_path,
        'CDEF:in_bits=in,8,*', 'CDEF:out_bits=out,8,*',
        'VDEF:in_last=in_bits,LAST', 'VDEF:in_avg=in_bits,AVERAGE',
        'VDEF:in_max=in_bits,MAXIMUM', 'VDEF:out_last=out_bits,LAST',
        'VDEF:out_avg=out_bits,AVERAGE', 'VDEF:out_max=out_bits,MAXIMUM',
        'COMMENT:<b><tt>          Current   Average   Maximum</tt></b>\\l',
        'LINE1:in_bits%s:<tt>In    </tt>' % color_ibound_line,
        'AREA:in_bits%s:' % color_ibound_area,
        'GPRINT:in_last:<tt>%4.1lf%s</tt>\\t',
        'GPRINT:in_avg:<tt>%4.1lf%s</tt>\\t',
        'GPRINT:in_max:<tt>%4.1lf%s</tt>\l',
        'LINE1:out_bits%s:<tt>Out   </tt>' % color_obound_line,
        'AREA:out_bits%s:' % color_obound_area,
        'GPRINT:out_last:<tt>%4.1lf%s</tt>\\t',
        'GPRINT:out_avg:<tt>%4.1lf%s</tt>\\t',
        'GPRINT:out_max:<tt>%4.1lf%s</tt>\l')
    rrdtool.graph(*(base + addition))
Beispiel #17
0
 def make_image(self, prefix, period):
     super(NetworkStat, self).make_image(prefix, period)
     rrdtool.graph(
         "%s_%s.png" % (prefix, period),
         "-s -1%s" % period,
         "-t traffic on %s :: %s" % (self.device, self.name),
         "--lazy",
         "-h", "300", "-w", "700", "--full-size-mode", "-T", "10",
         "-l 0", "-b", "1024",
         "-a", "PNG",
         "-v bytes/sec",
         "DEF:in=%s:in:AVERAGE" % self.FILE_NAME % self.device,
         "DEF:out=%s:out:AVERAGE" % self.FILE_NAME % self.device,
         "CDEF:out_neg=out,-1,*",
         "TEXTALIGN:left",
         "AREA:in#32CD32:Incoming",
         "LINE1:in#336600",
         "GPRINT:in:MAX:  Max\\: %5.1lf %s",
         "GPRINT:in:AVERAGE: Avg\\: %5.1lf %S",
         "GPRINT:in:LAST: Current\\: %5.1lf %Sbytes/sec\\n",
         "AREA:out_neg#4169E1:Outgoing",
         "LINE1:out_neg#0033CC",
         "GPRINT:out:MAX:  Max\\: %5.1lf %S",
         "GPRINT:out:AVERAGE: Avg\\: %5.1lf %S",
         "GPRINT:out:LAST: Current\\: %5.1lf %Sbytes/sec",
         "HRULE:0#000000"
     )
Beispiel #18
0
def graph(data_dir, target_dir):
	png_path = os.path.join(target_dir, 'memory.png')
	rrd_path = os.path.join(data_dir, 'memory.rrd')
	rrdtool.graph(png_path,
	              '--imgformat', 'PNG',
	              '--title', 'Memory stats',
	              '--vertical-label', 'RAM',
	              '--width', '600',
	              '--height', '400',
	              '--lower-limit', '0',

	              'DEF:used='+rrd_path+':used:AVERAGE',
	              'DEF:cached='+rrd_path+':cached:AVERAGE',
	              'DEF:buffers='+rrd_path+':buffers:AVERAGE',
	              'DEF:free='+rrd_path+':free:AVERAGE',
	              'DEF:total='+rrd_path+':total:AVERAGE',

	              'VDEF:usedavg=used,AVERAGE',
	              'VDEF:usedmax=used,MAXIMUM',
	              'VDEF:usedmin=used,MINIMUM',
	              'VDEF:cachedavg=cached,AVERAGE',
	              'VDEF:cachedmax=cached,MAXIMUM',
	              'VDEF:cachedmin=cached,MINIMUM',
	              'VDEF:buffersavg=buffers,AVERAGE',
	              'VDEF:buffersmax=buffers,MAXIMUM',
	              'VDEF:buffersmin=buffers,MINIMUM',
	              'VDEF:freeavg=free,AVERAGE',
	              'VDEF:freemax=free,MAXIMUM',
	              'VDEF:freemin=free,MINIMUM',
	              'VDEF:totalavg=total,AVERAGE',
	              'VDEF:totalmax=total,MAXIMUM',
	              'VDEF:totalmin=total,MINIMUM',

	              'COMMENT:             Average   Maximum   Minimum\l',

	              'AREA:used#F00:Used   ',
	              'GPRINT:usedavg:%7.2lfM',
	              'GPRINT:usedmax:%7.2lfM',
	              'GPRINT:usedmin:%7.2lfM\l',

	              'AREA:cached#00F:Cached :STACK',
	              'GPRINT:cachedavg:%7.2lfM',
	              'GPRINT:cachedmax:%7.2lfM',
	              'GPRINT:cachedmin:%7.2lfM\l',

	              'AREA:buffers#0F0:Buffers:STACK',
	              'GPRINT:buffersavg:%7.2lfM',
	              'GPRINT:buffersmax:%7.2lfM',
	              'GPRINT:buffersmin:%7.2lfM\l',

	              'AREA:free#555:Free   :STACK',
	              'GPRINT:freeavg:%7.2lfM',
	              'GPRINT:freemax:%7.2lfM',
	              'GPRINT:freemin:%7.2lfM\l',

	              'LINE2:total#000:Total  ',
	              'GPRINT:totalavg:%7.2lfM',
	              'GPRINT:totalmax:%7.2lfM',
	              'GPRINT:totalmin:%7.2lfM',
	)
Beispiel #19
0
def graph_mem(rrd, db_type):
    png = png_path + rrd[db_type] + ".png"
    db = db_path + rrd[db_type]
    rrdtool.graph(
        png,
        "--start",
        "-16000",
        "--width",
        "300",
        "-h",
        "150",
        "--vertical-label=Gb",
        "--watermark=OpenSAN2",
        "-r",
        "--dynamic-labels",
        "--lower-limit",
        "0",
        "-E",
        "-i",
        "-r",
        "DEF:total=" + db + ":total:AVERAGE",
        "DEF:free=" + db + ":free:AVERAGE",
        "DEF:cached=" + db + ":cached:AVERAGE",
        "DEF:buffered=" + db + ":buffers:AVERAGE",
        "DEF:used=" + db + ":used:AVERAGE",
        "CDEF:mbuffered=used,buffered,+",
        "CDEF:mc=cached,buffered,-",
        "CDEF:mcached=mc,used,+",
        "CDEF:mfree=free,mbuffered,+",
        "AREA:total#00FF00:Free memory",
        # "AREA:mfree#00FF00:Free memory" ,
        "AREA:mcached#00fff0: Cached memory",
        "AREA:mbuffered#ffff00:Buffered memory",
        "AREA:used#aa0000:Used memory",
    )
Beispiel #20
0
def graph_cpu_info(db_directory, img_directory):
    db_location = os.path.join(db_directory, 'cpu_usage.rrd')
    img_location = os.path.join(img_directory, 'cpu_usage.png')
    rrdtool.graph(  img_location,
                    '--width', '1080',
                    '--height', '300',
                    '--start', GRAPH_START,
                    '--end', GRAPH_END,
                    '--vertical-label', '%',
                    '--title', 'CPU usage',
                    '--lower-limit', '0',
                    '--upper-limit', '100',
                    'DEF:cpu_user='******':user:AVERAGE',
                    'DEF:cpu_system='+db_location+':system:AVERAGE',
                    'DEF:cpu_idle='+db_location+':idle:AVERAGE',
                    'DEF:cpu_nice='+db_location+':nice:AVERAGE',
                    'CDEF:p_cpu_user=100,cpu_user,cpu_user,cpu_system,+,cpu_idle,+,cpu_nice,+,/,*',
                    'CDEF:p_cpu_system=100,cpu_system,cpu_user,cpu_system,+,cpu_idle,+,cpu_nice,+,/,*',
                    'CDEF:p_cpu_idle=100,cpu_idle,cpu_user,cpu_system,+,cpu_idle,+,cpu_nice,+,/,*',
                    'CDEF:p_cpu_nice=100,cpu_nice,cpu_user,cpu_system,+,cpu_idle,+,cpu_nice,+,/,*',
                    'LINE1:p_cpu_user#00FF00:User CPU percentage',
                    'LINE1:p_cpu_system#FF0000:System CPU percentage',
                    'LINE1:p_cpu_idle#070070:Idle CPU percentage',
                    'LINE1:p_cpu_nice#0000FF:Nice CPU percentage',
                    )
def draw_net_ts(hostname, iface='eth0', start=None, end=None):
    fname = os.path.join(RRD_PREFIX, os.path.basename(hostname), "interface-" + iface, "if_octets.rrd")
#def draw_net_ts(hostname, start=None, end=None):
#    fname = os.path.join(RRD_PREFIX, os.path.basename(hostname), "interface-eth0", "if_octets.rrd")
    outfname = os.path.join(GRAPH_PREFIX, os.path.basename(hostname) + "-net.png")
    if not start:
        start = "-1d"
    start = str(start)
    if not end:
        end = "-20s"
    end = str(end)
    try:
        rrdtool.graph(outfname, "-s", "%s"%start, "-e", "%s"%end,
                  "-t", "%s" %iface,
                  "--units", "si",
                  "-v", "Bits/s",
                  #"--lazy",
                  "COMMENT:\t\t\tAverage network traffic\\n",
                  "DEF:rx=%s:rx:AVERAGE" % fname,
                  "DEF:tx=%s:tx:AVERAGE" % fname,
                  "CDEF:rxbits=rx,8,*",
                  "CDEF:txbits=tx,8,*",
                  "LINE1:rxbits#00ff00:Incoming",
                  "GPRINT:rxbits:AVERAGE:\t%4.0lf%sbps\t\g",
                  "LINE1:txbits#0000ff:Outgoing",
                  "GPRINT:txbits:AVERAGE:\t%4.0lf%sbps\\n")
    except rrdtool.error, e:
        raise InternalError(str(e))
Beispiel #22
0
 def make_graphs(self):
     """Generate daily, weekly, monthly and yearly graphics."""
     height = str(properties["height"])
     width = str(properties["width"])
     refresh = properties["refresh"]
     background = properties["background"]
     border = properties["border"]
     
     for interval in ("1day", "1week", "1month", "1year"):
         rrdtool.graph("%s/graph-%s.png" % (self.graphs_dir, interval), 
                       "--start", "-%s" % interval,
                       "--end", "-%d" % refresh,  # because the last data point is still unknown
                       "--title", "%s - sectors read/written" % self.name,
                       "--lazy",
                       "--base", "1000",
                       "--height", height,
                       "--width", width,
                       "--lower-limit", "0",
                       "--upper-limit", "1.0",
                       "--imgformat", "PNG",
                       "--vertical-label", "operations/sec",
                       "--color", "BACK%s" % background,
                       "--color", "SHADEA%s" % border,
                       "--color", "SHADEB%s" % border,
                       "DEF:reads=%s:sector_reads:AVERAGE" % self.database,
                       "DEF:writes=%s:sector_writes:AVERAGE" % self.database,
                       "AREA:reads#a0df05:Reads ",
                       "GPRINT:reads:LAST:\\: %9.1lf op/sec (now)",
                       "GPRINT:reads:MAX:%9.1lf op/sec (max)",
                       "GPRINT:reads:AVERAGE:%9.1lf op/sec (avg)\\n",
                       "LINE1:writes#808080:Writes",
                       "GPRINT:writes:LAST:\\: %9.1lf op/sec (now)",
                       "GPRINT:writes:MAX:%9.1lf op/sec (max)",
                       "GPRINT:writes:AVERAGE:%9.1lf op/sec (avg)")
Beispiel #23
0
def dItem01(data):
    pngname = str(data['pname'])
    start = data['stime']
    graphname = str(data['gname'] + "(" + data['host'] + ")" + "(" +
                    data['flag'] + ")")
    DEF = str(r"DEF:a=" + data['rrdpath'] + r':' + data['pitem'][0] +
              r":AVERAGE")
    if data['cols'] or data['itypes']:
        if not data['cols']:
            dtype = str(data['itypes'][0][0] + r":a#EAAF00FF:" +
                        data['pitem'][0][1])
        elif not data['itypes']:
            dtype = str(r"AREA:a" + data['cols'][0][0] + r":" +
                        data['pitem'][0][1])
        else:
            dtype = str(data['itypes'][0][0] + r":a" + data['cols'][0][0] +
                        r":" + data['pitem'][0][1])
    else:
        dtype = str(r"AREA:a#EAAF00FF:" + data['pitem'][0])
    unit = str(data['unit'])
    if not unit:
        unit = ' '
    max = 'GPRINT:a:MAX:Max\:%.2lf %s'
    min = 'GPRINT:a:MIN:Min\:%.2lf %s'
    avg = 'GPRINT:a:AVERAGE:Avg\:%.2lf %s'
    now = 'GPRINT:a:LAST:Now\:%.2lf %s'
    rrdtool.graph(pngname, '-w', '600', '-h', '144', '-l', '0', '-s', start,
                  '-t', graphname, '-v', unit, DEF, 'COMMENT: \\n', dtype, now,
                  avg, min, max, 'COMMENT: \\n')
Beispiel #24
0
def make_graph(db, duration):
    base_db, ext = os.path.splitext(db)
    text_label = ['Temperature C', '%', 'hectopascals']
    data = ['temp', 'hum', 'pres']
    for i in range(0, 3):
        filename = base_db + '_' + data[i] + '_' + duration + '.png'
        title = base_db + ' ' + data[i] + ' ' + duration + '\n(UTC)'
        rrdtool.graph(
            filename,
            '--imgformat',
            'PNG',
            '--width',
            '750',
            '--height',
            '250',
            '--start',
            duration,
            #'--left-axis-format','%.1f',
            '--vertical-label',
            text_label[i],
            '--title',
            title,
            'DEF:val_ave=' + db + ':' + data[i] + ':AVERAGE',
            'LINE1:val_ave#444444',
            'GPRINT:val_ave:LAST:Last Reading\: %2.2lf')
    return
Beispiel #25
0
def timegraph_rrd(options):
    """
    Invokes rrd_graph with the given options and returns the image data.
    """
    image_file = tempfile.NamedTemporaryFile()
    rrdtool.graph([str(image_file.name)] + [ force_unicode(x).encode('utf-8') for x in options ])
    return image_file.read()
Beispiel #26
0
def updateGraph(lastUpdated, awsS3Bucket, awsS3Key, graphPath):
    global temperature, pressure, humidity
    if (time.time() - lastUpdated > 300):
        logger.info("Updating Graph...")
        rrdtool.graph(
            graphPath, '--imgformat', 'PNG', '--width', '500', '--height',
            '200', '--start', "-10492000", '--end', "-1", '--right-axis',
            '1:950', '--title', nodeName +
            ' 120 Day - Temperature, Humidity, Pressure', '--watermark',
            'Generated at ' + strftime("%m-%d-%Y %H:%M:%S", time.localtime()),
            "DEF:temperature_raw=" + rrdFile + ":temperature:AVERAGE",
            "DEF:pressure=" + rrdFile + ":pressure:AVERAGE",
            "DEF:humidity=" + rrdFile + ":humidity:AVERAGE",
            "CDEF:scaled_pressure=pressure,950,-",
            "COMMENT:Last\: Temperature - " + str(temperature) +
            ", Pressure - " + str(pressure) + ", Humidity - " + str(humidity) +
            "%", "LINE1:humidity#00FF00:Humidity       ",
            'GPRINT:humidity:LAST:Last\:%5.2lf %s',
            "GPRINT:humidity:AVERAGE:Avg\:%5.2lf %s",
            "GPRINT:humidity:MAX:Max\:%5.2lf %s",
            "GPRINT:humidity:MIN:Min\:%5.2lf %s\\n",
            "LINE2:scaled_pressure#0000FF:Pressure hpa   ",
            "GPRINT:pressure:LAST:Last\:%5.3lf %s",
            "GPRINT:pressure:AVERAGE:Avg\:%5.3lf %s",
            "GPRINT:pressure:MAX:Max\:%5.3lf %s",
            "GPRINT:pressure:MIN:Min\:%5.3lf %s\\n",
            "LINE1:temperature_raw#FF0000:Temperature    ",
            "GPRINT:temperature_raw:LAST:Last\:%5.2lf %s",
            "GPRINT:temperature_raw:AVERAGE:Avg\:%5.2lf %s",
            "GPRINT:temperature_raw:MAX:Max\:%5.2lf %s",
            "GPRINT:temperature_raw:MIN:Min\:%5.2lf %s\\n",
            '--right-axis-format', '%1.1lf')
        s3Upload(awsS3Bucket, awsS3Key, graphPath)
        return time.time()
    return lastUpdated
Beispiel #27
0
def graph_disk(instance, duration):
    """
    Creates a graph of disk usage for the specified duration.
    """
    path = instance.get_rrd_path()
    filename = os.path.join(path, 'disk-%s.png' % duration)

    rrdtool.graph(
        filename,
        '--disable-rrdtool-tag',
        '--imgformat', 'PNG',
        '--width', '400',
        '--height', '120',
        '--start', 'now-%s' % duration,
        '--vertical-label', 'bytes/s',
        '--logarithmic',
        '--units', 'si',
        '--lower-limit', '1000',
        '--rigid',
        'DEF:rd=%s:rd:AVERAGE' % os.path.join(path, 'disk.rrd'),
        'DEF:wr=%s:wr:AVERAGE' % os.path.join(path, 'disk.rrd'),
        'AREA:rd#00FF00:Read',
        'LINE1:wr#0000FF:Write',)

    store_graph(instance.instance_id, filename)
Beispiel #28
0
def scheddwarning(basedir, interval, request):
    fd, pngpath = tempfile.mkstemp(".png")
    fname = os.path.join(basedir, request, "request.rrd")
    if not os.path.exists(fname):
        raise ValueError("No information present (request=%s)" % request)
    rrdtool.graph(pngpath,
                  "--imgformat", "PNG",
                  "--width", "250",
                  "--start", "-1%s" % get_rrd_interval(interval),
                  "--vertical-label", "Jobs",
                  "--lower-limit", "0",
                  "--title", "Scheduler %s status" % request,
                  "DEF:OK=%s:OK:AVERAGE" % fname,
                  "DEF:WARNING=%s:WARNING:AVERAGE" % fname,
                  "DEF:CRITICAL=%s:CRITICAL:AVERAGE" % fname,
                  "DEF:UNKNOWN=%s:UNKNOWN:AVERAGE" % fname,
                  "AREA:OK#00FF00:OK",
                  "AREA:WARNING#FFFF00:WARNING",
                  "AREA:CRITICAL#FF0000:CRITICAL",
                  "AREA:UNKNOWN#000000:UNKNOWN",
                  "COMMENT:\\n",
                  "COMMENT:              cur\\n",
                  "COMMENT:OK         ",
                  "GPRINT:OK:LAST:%-6.0lf",
                  "COMMENT:\\n",
                  "COMMENT:WARNING    ",
                  "GPRINT:WARNING:LAST:%-6.0lf",
                  "COMMENT:\\n",
                  "COMMENT:CRITICAL   ",
                  "GPRINT:CRITICAL:LAST:%-6.0lf",
                  "COMMENT:\\n",
                  "COMMENT:UNKNOWN    ",
                  "GPRINT:UNKNOWN:LAST:%-6.0lf\\n",
                  )
    return clean_and_return(fd, pngpath)
Beispiel #29
0
def plot_snum(img_path, rrd_path, opt, tz=None):
    color_running_servers_line = '#00CF00FF'
    color_running_servers_area = '#00CF0044'

    title = 'Servers count'
    label = 'Servers'

    base = _base(img_path, title, label, opt, tz)
    base += ('--lower-limit', '0', '--y-grid', '1:1', '--units-exponent', '0')

    addition = (
        'DEF:s_running=%s:s_running:AVERAGE' % rrd_path,
        'VDEF:s_running_last=s_running,LAST',
        'VDEF:s_running_avg=s_running,AVERAGE',
        'VDEF:s_running_max=s_running,MAXIMUM',
        'VDEF:s_running_min=s_running,MINIMUM',

        'COMMENT:<b><tt>                      Current    Average   Maximum   Minimum</tt></b>\l',

        'LINE1:s_running%s:<tt>Running servers    </tt>' % color_running_servers_line,
        'AREA:s_running%s:' % color_running_servers_area,
        'GPRINT:s_running_last:<tt>%3.0lf</tt>\\t',
        'GPRINT:s_running_avg:<tt>%3.0lf</tt>\\t',
        'GPRINT:s_running_max:<tt>%3.0lf</tt>\\t',
        'GPRINT:s_running_min:<tt>%3.0lf</tt>\l'
    )
    rrdtool.graph(*(base + addition))
Beispiel #30
0
def plot_month():
    graph="/home/pi/var/sk2gj-temp-m.png"
    rrdtool.graph(graph, 
                  '--start', 'end - 1 month', 
                  '--title', 'Temperatur vid SK2GJ', '--vertical-label', u'\xb0C',
                  '--lower-limit', '-40',
                  '--upper-limit', '30', 
                  'DEF:utemax=%s:ute:MAX' % db,
                  'DEF:uteavg=%s:ute:AVERAGE' % db, 
                  'DEF:utemin=%s:ute:MIN' % db, 
                  'DEF:innemax=%s:inne:MAX' % db, 
                  'DEF:inneavg=%s:inne:AVERAGE' % db,
                  'DEF:innemin=%s:inne:MIN' % db, 
                  'CDEF:ute=utemin,utemax,-',
                  'CDEF:inne=innemin,innemax,-',
                  'VDEF:uteminnu=utemin,MINIMUM',
                  'VDEF:utemaxnu=utemax,MAXIMUM',
                  'VDEF:inneminnu=innemin,MINIMUM',
                  'VDEF:innemaxnu=innemax,MAXIMUM',
                  'LINE1:utemin#0000FF',
                  'AREA:ute#CCCCF0::STACK',
                  'LINE2:uteavg#0000FF:Ute',
                  'GPRINT:uteminnu:Min %4.1lf',
                  'GPRINT:utemaxnu:Max %4.1lf',
                  'LINE1:utemax#0000FF',
                  'LINE1:innemin#00FF00',
                  'AREA:inne#CCF0CC::STACK',
                  'LINE2:inneavg#00FF00:Inne',
                  'GPRINT:inneminnu:Min %4.1lf',
                  'GPRINT:innemaxnu:Max %4.1lf',
                  'LINE1:innemax#00FF00',
                  )
Beispiel #31
0
def request_starvation(basedir, interval, request):
    fd, pngpath = tempfile.mkstemp(".png")
    fname = os.path.join(basedir, request, "request.rrd")
    if not os.path.exists(fname):
        raise ValueError("No starvation information present (request=%s)" % request)
    rrdtool.graph(pngpath,
            "--imgformat", "PNG",
            "--width", "250",
            "--start", "-1%s" % get_rrd_interval(interval),
            "--vertical-label", "Jobs",
            "--lower-limit", "0",
            "--title", "Request %s Starvation" % request,
            "DEF:LowerPrioRunning=%s:LowerPrioRunning:AVERAGE" % fname,
            "DEF:HigherPrioIdle=%s:HigherPrioIdle:AVERAGE" % fname,
            "LINE1:LowerPrioRunning#000000:LowerPrioRunning",
            "LINE2:HigherPrioIdle#FF0000:HigherPrioIdle",
            "COMMENT:\\n",
            "COMMENT:                       max     avg     cur\\n",
            "COMMENT:LowerPrioRunning    ",
            "GPRINT:LowerPrioRunning:MAX:%-6.0lf",
            "GPRINT:LowerPrioRunning:AVERAGE:%-6.0lf",
            "GPRINT:LowerPrioRunning:LAST:%-6.0lf",
            "COMMENT:\\n",
            "COMMENT:HigherPrioIdle      ",
            "GPRINT:HigherPrioIdle:MAX:%-6.0lf",
            "GPRINT:HigherPrioIdle:AVERAGE:%-6.0lf",
            "GPRINT:HigherPrioIdle:LAST:%-6.0lf\\n",
            )
    return clean_and_return(fd, pngpath)
Beispiel #32
0
  def _MakeGraphs(self):
    for type, variable, title in self._variables:
      output_file = os.path.join(self._directory, '%s.png' % variable)
      rrdtool.graph(output_file,
                    '--imgformat', 'PNG',
                    '--title', title,
                    '--start', 'end-30s',
                    'DEF:%s=%s:%s:AVERAGE' %
                      (variable, self._rrd_file, variable),
                    'LINE1:%s#FF0000' % variable)

    variables = set([ x for _, x, _ in self._variables])
    for cdef_name, function, title in self._cdefs:
      output_file = os.path.join(self._directory, '%s.png' % cdef_name)
      values = function.split(',')
      used_variables = set(values).intersection(variables)
      defs = []
      for variable in used_variables:
        defs.append('DEF:%s=%s:%s:AVERAGE' %
                    (variable, self._rrd_file, variable))

      rrdtool.graph(output_file,
                    '--imgformat', 'PNG',
                    '--title', title,
                    '--start', 'end-30s',
                    defs,
                    'CDEF:%s=%s' %
                      (cdef_name, function),
                    'LINE1:%s#FF0000' % cdef_name)
Beispiel #33
0
 def graph(self,):
     '''
     根据 memory user 数据库绘图
     '''
     rrdtool.graph(self.picture_name, "--start", self.picture_show_time,
                   # "--x-grid", "MINUTE:5:MINUTE:15:MINUTE:15:0:%H:%M",
                   "--x-grid", "MINUTE:20:HOUR:1:HOUR:2:0:%H:%M",
                   "--width", self.picture_width, "--height", self.picture_height, "--title", self.picture_title,
                   "--vertical-label= MemoryUse ", "--lower-limit", "0.1",
                   "DEF:total_memory=%s:total:LAST" % self.rrd_name,             # 指定总内存数据源DS及CF
                   "DEF:availabel_memory=%s:availabel:LAST" % self.rrd_name,     # 指定可用内存数据源DS及CF
                   # "HRULE:4018638848#008000:Alarm value",                      # 绘制水平线,作为告警线,阈值为xx
                   "CDEF:total_memorys=total_memory,1073741824,/",
                   "CDEF:availabel_memorys=availabel_memory,1073741824,/",
                   "COMMENT:\\r",                                                 # 在网格下方输出一个换行符
                   "AREA:total_memory#90EE90:Total memory \:",                    # 总内存线
                   "GPRINT:total_memorys:AVERAGE: %4.2lf GB \\r",                    # 最新值
                   "COMMENT:              Last           Min           Average          Max                       \
                   \\r",
                   "AREA:availabel_memory#00FFFF:Availabel memory",
                   "GPRINT:availabel_memorys:LAST: %4.2lf GB",                   # 最新值
                   "COMMENT:   ",
                   "GPRINT:availabel_memorys:MIN: %4.2lf GB",                    # 最小值
                   "COMMENT:   ",
                   "GPRINT:availabel_memorys:AVERAGE: %3.2lf GB",                # 平均值
                   "COMMENT:   ",
                   "GPRINT:availabel_memorys:MAX: %5.2lf GB                                         \\r",
                   "COMMENT:\\r",)  # 在网格下方输出一个换行符
Beispiel #34
0
def graph_overall(prefix,start_time,end_time,vrules,peak_interval_id=None,peak_average=0.0):

    length = int(end_time) - int(start_time)

    units, multiplier, direction = units_et_al_by_prefix(prefix)

#    print units,multiplier,direction
#    print "Vrules",vrules

    interval_specs = []
    if peak_interval_id:
        interval_specs = [ 'DEF:bar=%s_intervals.rrd:avg:AVERAGE' % prefix,
                           'CDEF:intvl=bar,%s,*' % multiplier,
                           'LINE2:intvl#0F0F0F40:Interval average. Peak of %.3f during interval %d' % (peak_average, peak_interval_id) ]

    rrdtool.graph(prefix + "_overall.svg", '--imgformat', 'SVG',
                  '--start', str(int(start_time)),
                  '--end', str(int(end_time)),
                  '-w','%d' % max(800,length),'-h','400',
                  '--right-axis', '1:0',
                  vrules,
                  '--font', 'DEFAULT:0:Helvetica',
                  '-t', 'Overall %s' % prefix,
                  '-v', '%s %s' % (direction,units),
                  'DEF:foo=%s_overall.rrd:mbps:AVERAGE' % prefix,
                  'CDEF:bits=foo,%s,*' % multiplier,
                  'LINE2:bits#00FF0080:%s' % units,
                  interval_specs)
Beispiel #35
0
def graph_net(instance, duration):
    """
    Creates a graph of network usage for the specified instance and duration.
    """
    path = instance.get_rrd_path()
    filename = os.path.join(path, 'net-%s.png' % duration)

    rrdtool.graph(
        filename,
        '--disable-rrdtool-tag',
        '--imgformat',
        'PNG',
        '--width',
        '400',
        '--height',
        '120',
        '--start',
        'now-%s' % duration,
        '--vertical-label',
        'bytes/s',
        '--logarithmic',
        '--units',
        'si',
        '--lower-limit',
        '1000',
        '--rigid',
        'DEF:rx=%s:rx:AVERAGE' % os.path.join(path, 'net.rrd'),
        'DEF:tx=%s:tx:AVERAGE' % os.path.join(path, 'net.rrd'),
        'AREA:rx#00FF00:In traffic',
        'LINE1:tx#0000FF:Out traffic',
    )

    store_graph(instance.instance_id, filename)
Beispiel #36
0
def graph_Network_temp(kname, ip):
    # create graphs that track numbers of bytes sent + recent
    path_bytes = "/var/sys_monitoring/network_temp_" + str(kname) + "_" + datetime.datetime.now().strftime(
        '%Y-%m-%d') + ".png"
    def1 = "DEF:sent=/var/sys_monitoring/network_temp_" + str(kname) + "_" + datetime.datetime.now().strftime(
        '%Y-%m-%d') + ".rrd:sent:LAST"
    def2 = "DEF:recv=/var/sys_monitoring/network_temp_" + str(kname) + "_" + datetime.datetime.now().strftime(
        '%Y-%m-%d') + ".rrd:recv:LAST"
    def3 = "DEF:sent_per_sec=/var/sys_monitoring/network_temp_" + str(kname) + "_" + datetime.datetime.now().strftime(
        '%Y-%m-%d') + ".rrd:sent_per_sec:LAST"
    def4 = "DEF:recv_per_sec=/var/sys_monitoring/network_temp_" + str(kname) + "_" + datetime.datetime.now().strftime(
        '%Y-%m-%d') + ".rrd:recv_per_sec:LAST"
    cm_ip = "COMMENT:" + ip;
    file_path = path_bytes[:-3] + "rrd" 
    if os.path.isfile(file_path):
    	rrdtool.graph(path_bytes, '--imgformat', 'PNG',
                  '--width', '1274',
                  '--height', '346',
                  '--start', '-1d',
                  '--end', str(int(time.time())),
                  '--vertical-label', 'bytes',
                  '--title', str(kname), def1, def2, def4, def4,
                  'AREA1:sent#004F00:sent',
                  'AREA1:recv#ff69b4:recv',
                  'LINE1:sent_per_sec#004F00:sent_per_sec',
                  'LINE1:recv_per_sec#ff69b4:recv_per_sec',
                    cm_ip)
    	createLog("Created " + path_bytes)
Beispiel #37
0
def plot_snum(img_path, rrd_path, opt, tz=None):
    color_running_servers_line = '#00CF00FF'
    color_running_servers_area = '#00CF0044'
    if tz:
        utc = datetime.datetime.utcnow()
        time_string = pytz.timezone(tz).fromutc(utc).strftime(
            '%b %d, %Y %H:%M:%S %z')
    else:
        time_string = time.strftime('%b %d, %Y %H:%M:%S %z')
    rrdtool.graph(
        img_path, '--imgformat', 'PNG', '--step', opt['step'],
        '--pango-markup', '--vertical-label', 'Servers', '--title',
        'Servers count (%s)' % time_string, '--alt-autoscale-max',
        '--alt-autoscale-min', '--lower-limit', '0', '--y-grid', '1:1',
        '--units-exponent', '0', '--rigid', '--no-gridfit', '--slope-mode',
        '--x-grid', opt['x_grid'], '--end', opt['end'], '--start',
        opt['start'], '--width', '440', '--height', '100',
        '--font-render-mode', 'normal', '--border', '0', '--color',
        'BACK#FFFFFF', 'DEF:s_running=%s:s_running:AVERAGE' % rrd_path,
        'VDEF:s_running_last=s_running,LAST',
        'VDEF:s_running_avg=s_running,AVERAGE',
        'VDEF:s_running_max=s_running,MAXIMUM',
        'VDEF:s_running_min=s_running,MINIMUM',
        'COMMENT:<b><tt>                      Current    Average   Maximum   Minimum</tt></b>\l',
        'LINE1:s_running%s:<tt>Running servers    </tt>' %
        color_running_servers_line, 'AREA:s_running%s:' %
        color_running_servers_area, 'GPRINT:s_running_last:<tt>%3.0lf</tt>\\t',
        'GPRINT:s_running_avg:<tt>%3.0lf</tt>\\t',
        'GPRINT:s_running_max:<tt>%3.0lf</tt>\\t',
        'GPRINT:s_running_min:<tt>%3.0lf</tt>\l')
Beispiel #38
0
def priority_summary_graph(basedir, interval, jobType):
    fd, pngpath = tempfile.mkstemp(".png")
    fname = os.path.join(basedir, "priorities-%s.rrd" % jobType.lower())
    if not os.path.exists(fname):
        raise ValueError("No information present" % site)
    rrdtool.graph(pngpath,
                  "--imgformat", "PNG",
                  "--width", "250",
                  "--start", "-1%s" % get_rrd_interval(interval),
                  "--vertical-label", "Jobs",
                  "--lower-limit", "0",
                  "--title", "%s Job Priority" % jobType,
                  'DEF:R0=%s:R0:AVERAGE' % fname,
                  'DEF:R1=%s:R1:AVERAGE' % fname,
                  'DEF:R2=%s:R2:AVERAGE' % fname,
                  'DEF:R3=%s:R3:AVERAGE' % fname,
                  'DEF:R4=%s:R4:AVERAGE' % fname,
                  'DEF:R5=%s:R5:AVERAGE' % fname,
                  'DEF:R6=%s:R6:AVERAGE' % fname,
                  'DEF:R7=%s:R7:AVERAGE' % fname,
                  'AREA:R0#ff0000:High Priority',
                  'AREA:R1#ff7f00:Block 1 (110k):STACK',
                  'AREA:R2#ffff00:Block 2 (90k):STACK',
                  'AREA:R3#00ff00:Block 3 (85k):STACK',
                  'AREA:R4#0000ff:Block 4 (80k):STACK',
                  'AREA:R5#6600ff:Block 5 (70k):STACK',
                  'AREA:R6#8800ff:Block 6 (63k):STACK',
                  'AREA:R7#000000:Low Priority:STACK')
    return clean_and_return(fd, pngpath)
Beispiel #39
0
    def generate(self):
        """
        Call rrdgraph to generate the graph on a temp file

        Returns:
            str - path to the image
        """

        starttime = '1%s' % (self.unit[0], )
        if self.step == 0:
            endtime = 'now'
        else:
            endtime = 'now-%d%s' % (self.step, self.unit[0], )

        fh, path = tempfile.mkstemp()
        args = [
            path,
            '--imgformat', self.imgformat,
            '--vertical-label', str(self.get_vertical_label()),
            '--title', str(self.get_title()),
            '--lower-limit', '0',
            '--end', endtime,
            '--start', 'end-%s' % starttime, '-b', '1024',
        ]
        args.extend(self.graph())
        rrdtool.graph(*args)
        return fh, path
Beispiel #40
0
def subtask(basedir, interval, request, subtask):
    fd, pngpath = tempfile.mkstemp(".png")
    fname = os.path.join(basedir, request, subtask, "subtask.rrd")
    if not os.path.exists(fname):
        raise ValueError("No information present (request=%s, subtask=%s)" % (request, subtask))
    rrdtool.graph(pngpath,
            "--imgformat", "PNG",
            "--width", "250",
            "--start", "-1%s" % get_rrd_interval(interval),
            "--vertical-label", "Jobs",
            "--lower-limit", "0",
            "--title", "Subtask %s Job Counts" % subtask,
            "DEF:Running=%s:Running:AVERAGE" % fname,
            "DEF:Idle=%s:Idle:AVERAGE" % fname,
            "LINE1:Running#000000:Running",
            "LINE2:Idle#FF0000:Idle",
            "COMMENT:%s" % subtask,
            "COMMENT:\\n",
            "COMMENT:           max     avg     cur\\n",
            "COMMENT:Running ",
            "GPRINT:Running:MAX:%-6.0lf",
            "GPRINT:Running:AVERAGE:%-6.0lf",
            "GPRINT:Running:LAST:%-6.0lf",
            "COMMENT:\\n",
            "COMMENT:Idle    ",
            "GPRINT:Idle:MAX:%-6.0lf",
            "GPRINT:Idle:AVERAGE:%-6.0lf",
            "GPRINT:Idle:LAST:%-6.0lf\\n",
            )
    return clean_and_return(fd, pngpath)
Beispiel #41
0
def request_held(basedir, interval, request, site):
    fd, pngpath = tempfile.mkstemp(".png")
    fname = ""
    if request:
        fname = os.path.join(basedir, site, "%s.rrd" % request)
    else:
        fname = os.path.join(basedir, "%s.rrd" % site)
    if not os.path.exists(fname):
        raise ValueError("No information present (request=%s, site=%s)" % (request, site))
    rrdtool.graph(pngpath,
            "--imgformat", "PNG",
            "--width", "250",
            "--start", "-1%s" % get_rrd_interval(interval),
            "--vertical-label", "Jobs",
            "--lower-limit", "0",
            "--title", "%s Held Counts" % site,
            "DEF:Held=%s:Held:AVERAGE" % fname,
            "DEF:MaxHeld=%s:MaxHeld:AVERAGE" % fname,
            "LINE1:Held#FF0000:Held",
            "LINE2:MaxHeld#0000FF:MaxHeld",
            "COMMENT:%s" % site,
            "COMMENT:\\n",
            "COMMENT:           max     avg     cur\\n",
            "COMMENT:Held    ",
            "GPRINT:Held:MAX:%-6.0lf",
            "GPRINT:Held:AVERAGE:%-6.0lf",
            "GPRINT:Held:LAST:%-6.0lf",
            "COMMENT:\\n",
            "COMMENT:MaxHeld ",
            "GPRINT:MaxHeld:MAX:%-6.0lf",
            "GPRINT:MaxHeld:AVERAGE:%-6.0lf",
            "GPRINT:MaxHeld:LAST:%-6.0lf\\n",
            )
    return clean_and_return(fd, pngpath)
Beispiel #42
0
def site_util(basedir, interval, site):
    fd, pngpath = tempfile.mkstemp(".png")
    fname = os.path.join(basedir, "%s-UTIL.rrd" % site)
    if not os.path.exists(fname):
        fname = os.path.join(basedir, "empty.rrd")
        if not os.path.exists(fname):
            raise ValueError("No information present (site=%s)" % site)
    rrdtool.graph(pngpath,
            "--imgformat", "PNG",
            "--width", "250",
            "--start", "-1%s" % get_rrd_interval(interval),
            "--vertical-label", "Jobs",
            "--lower-limit", "0",
            "--title", "%s Max Running Achieved" % site,
            "DEF:Running=%s:Running:AVERAGE" % fname,
            "DEF:MaxRunning=%s:MaxRunning:AVERAGE" % fname,
            "LINE1:Running#000000:Running",
            "LINE2:MaxRunning#0000FF:MaxRunning",
            "COMMENT:%s" % site,
            "COMMENT:\\n",
            "COMMENT:              max     avg     cur\\n",
            "COMMENT:Running    ",
            "GPRINT:Running:MAX:%-6.0lf",
            "GPRINT:Running:AVERAGE:%-6.0lf",
            "GPRINT:Running:LAST:%-6.0lf",
            "COMMENT:\\n",
            "COMMENT:MaxRunning ",
            "GPRINT:MaxRunning:MAX:%-6.0lf",
            "GPRINT:MaxRunning:AVERAGE:%-6.0lf",
            "GPRINT:MaxRunning:LAST:%-6.0lf\\n",
            )
    return clean_and_return(fd, pngpath)
Beispiel #43
0
def graph_overall(prefix,start_time,end_time,vrules,peak_interval_id=None,peak_average=0.0,major_interval=60,annotation=None,override=None):

    length = int(end_time) - int(start_time)

    xgrid_setting = 'SECOND:%d:SECOND:%d:SECOND:%d:0:%%X' % (major_interval/2, major_interval, major_interval)

    units, multiplier, direction = units_et_al_by_prefix(prefix)

#    print units,multiplier,direction
#    print "Vrules",vrules

    interval_specs = []
    if peak_interval_id:
        interval_specs = [ 'DEF:bar=%s_intervals.rrd:avg:AVERAGE' % prefix,
                           'CDEF:intvl=bar,%s,*' % multiplier,
                           'LINE2:intvl#0F0F0F40:Interval average. Peak of %.3f during interval %d' % (peak_average, peak_interval_id) ]

    title = "Overall %s" % (override if override else prefix)
    if annotation:
        title = "Overall %s %s" % ((override if override else prefix), annotation)

    rrdtool.graph(prefix + "_overall.svg", '--imgformat', 'SVG',
                  '--start', str(int(start_time)),
                  '--end', str(int(end_time)),
                  '-w','%d' % max(800,length),'-h','400',
                  '--right-axis', '1:0',
                  '--x-grid', xgrid_setting,
                  vrules,
                  '--font', 'DEFAULT:0:Helvetica',
                  '-t', title,
                  '-v', '%s %s' % (direction,units),
                  'DEF:foo=%s_overall.rrd:mbps:AVERAGE' % prefix,
                  'CDEF:bits=foo,%s,*' % multiplier,
                  'LINE2:bits#00FF0080:%s' % units,
                  interval_specs)
Beispiel #44
0
def graph_Memory():
    path = "/var/sys_monitoring/memory_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".png"
    def1 = "DEF:used=/var/sys_monitoring/memory_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:used:LAST"
    def2 = "DEF:percent=/var/sys_monitoring/memory_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:percent:LAST"
    def3 = "DEF:active=/var/sys_monitoring/memory_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:active:LAST"
    def4 = "DEF:inactive=/var/sys_monitoring/memory_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:inactive:LAST"
    def5 = "DEF:buffers=/var/sys_monitoring/memory_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:buffers:LAST"
    def6 = "DEF:cached=/var/sys_monitoring/memory_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:cached:LAST"
    def7 = "DEF:available=/var/sys_monitoring/memory_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:available:LAST"
    def8 = "DEF:free=/var/sys_monitoring/memory_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:free:LAST"
    def9 = "DEF:shared=/var/sys_monitoring/memory_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:shared:LAST"
    file_path = path[:-3] + "rrd"
    if os.path.isfile(file_path):
    	rrdtool.graph(path, '--imgformat', 'PNG',
                  '--width', '1274',
                  '--height', '346',
                  '--start', '-1d',
                  '--end', str(int(time.time())),
                  '--vertical-label', 'bytes',
                  '--title', 'Memory Allocation',
                  def1, def2, def3, def4, def5, def6, def7, def8, def9,
                  'AREA:used#e6194B:used',
                  'LINE1:percent#42d4f4:percent',
                  'AREA:active#3cb44b:active:STACK',
                  'AREA:inactive#f032e6:inactive:STACK',
                  'AREA:buffers#ffe119:buffers:STACK',
                  'AREA:cached#4363d8:cached:STACK',
                  'AREA:available#a9a9a9:available:STACK',
                  'AREA:free#ffffff:free:STACK',
                  'AREA:shared#911eb4:shared:STACK')
    	createLog("Created " + path)
Beispiel #45
0
def graph_individual(prefix,start_time,end_time,vrules,major_interval=60,annotation=None,override=None):

    units, multiplier, direction = units_et_al_by_prefix(prefix)

    length = int(end_time) - int(start_time)


    for individual in glob.glob(prefix+"*.rrd"):
        basename = individual.strip(".rrd")

        title = "%s %s" % (basename,(override if override else prefix))
        if annotation:
            title = "%s %s %s" % (basename, (override if override else prefix), annotation)

        try:
            rrdtool.graph(basename + ".svg",
                          '--imgformat','SVG',
                          '--start', str(int(start_time)),
                          '--end', str(int(end_time)),
                          '--font',  'DEFAULT:0:Helvetica',
                          '-w', '%d' % max(800,length), '-h', '400',
                          '--right-axis', '1:0',
                          vrules,
                          '-t', title,
                          '-v', '%s %s' % (direction, units),
                          'DEF:foo=%s.rrd:mbps:AVERAGE' % basename,
                          'CDEF:bits=foo,%s,*' % multiplier,
                          'LINE2:bits#00FF0080:%s' % units)
        except:
            # at some point we should make certain this was for the
            # "intervals" rrd file but until then just pass
            pass
Beispiel #46
0
def graph_Swap():
    path = "/var/sys_monitoring/swap_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".png"
    def1 = "DEF:total=/var/sys_monitoring/swap_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:total:LAST"
    def2 = "DEF:used=/var/sys_monitoring/swap_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:used:LAST"
    def3 = "DEF:free=/var/sys_monitoring/swap_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:free:LAST"
    def4 = "DEF:percent=/var/sys_monitoring/swap_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:percent:LAST"
    def5 = "DEF:sin=/var/sys_monitoring/swap_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:sin:LAST"
    def6 = "DEF:sout=/var/sys_monitoring/swap_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:sout:LAST"
    file_path = path[:-3] + "rrd"
    if os.path.isfile(file_path):
    	rrdtool.graph(path, '--imgformat', 'PNG',
                  '--width', '1274',
                  '--height', '346',
                  '--start', '-1d',
                  '--end', str(int(time.time())),
                  '--vertical-label', 'bytes',
                  '--title', 'Swap Memory Allocation',
                  def1, def2, def3, def4, def5, def6,
                  'AREA:total#a9a9a9:total',
                  'AREA:used#e6194B:used:STACK',
                  'AREA:free#ffffff:free:STACK',
                  'LINE1:percent#000000:percent',
                  'AREA:sin#ffe119:sin:STACK',
                  'AREA:sout#4363d8:sout:STACK')
    	createLog("Created " + path)
Beispiel #47
0
def plot_io_ops(img_path, rrd_path, opt, tz=None):
    color_r = '#ff0000'
    color_w = '#0000ff'
    if tz:
        utc = datetime.datetime.utcnow()
        time_string = pytz.timezone(tz).fromutc(utc).strftime(
            '%b %d, %Y %H:%M:%S %z')
    else:
        time_string = time.strftime('%b %d, %Y %H:%M:%S %z')
    rrdtool.graph(
        img_path, '--imgformat', 'PNG', '--step', opt['step'],
        '--pango-markup', '--vertical-label', 'Operations per second',
        '--title', 'Disk I/O (%s)' % time_string, '--lower-limit', '0',
        '--alt-autoscale-max', '--alt-autoscale-min', '--rigid',
        '--no-gridfit', '--slope-mode', '--x-grid', opt['x_grid'], '--end',
        opt['end'], '--start', opt['start'], '--width', '440', '--height',
        '100', '--font-render-mode', 'normal', '--border', '0', '--color',
        'BACK#FFFFFF', 'DEF:read=%s:read:AVERAGE' % rrd_path,
        'DEF:write=%s:write:AVERAGE' % rrd_path, 'VDEF:read_last=read,LAST',
        'VDEF:read_avg=read,AVERAGE', 'VDEF:read_max=read,MAXIMUM',
        'VDEF:write_last=write,LAST', 'VDEF:write_avg=write,AVERAGE',
        'VDEF:write_max=write,MAXIMUM',
        'COMMENT:<b><tt>             Current    Average   Maximum</tt></b>\\l',
        'AREA:write%s:<tt>Writes     </tt>' % color_w,
        'GPRINT:write_last:<tt>%4.1lf%s</tt>\\t',
        'GPRINT:write_avg:<tt>%4.1lf%s</tt>\\t',
        'GPRINT:write_max:<tt>%4.1lf%s</tt>\l',
        'AREA:read%s:<tt>Reads     </tt>' % color_r,
        'GPRINT:read_last:<tt>%4.1lf%s</tt>\\t',
        'GPRINT:read_avg:<tt>%4.1lf%s</tt>\\t',
        'GPRINT:read_max:<tt>%4.1lf%s</tt>\l')
Beispiel #48
0
def graph_CPU(cpu_num):
    cpu_name = "CPU" + str(cpu_num)
    path = "/var/sys_monitoring/" + cpu_name + "_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".png"
    def1 = "DEF:user=/var/sys_monitoring/" + cpu_name + "_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:user:LAST"
    def2 = "DEF:nice=/var/sys_monitoring/" + cpu_name + "_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:nice:LAST"
    def3 = "DEF:system=/var/sys_monitoring/" + cpu_name + "_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:system:LAST"
    def4 = "DEF:idle=/var/sys_monitoring/" + cpu_name + "_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:idle:LAST"
    def5 = "DEF:iowait=/var/sys_monitoring/" + cpu_name + "_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:iowait:LAST"
    def6 = "DEF:irq=/var/sys_monitoring/" + cpu_name + "_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:irq:LAST"
    def7 = "DEF:softirq=/var/sys_monitoring/" + cpu_name + "_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:softirq:LAST"
    def8 = "DEF:steal=/var/sys_monitoring/" + cpu_name + "_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:steal:LAST"
    def9 = "DEF:guest=/var/sys_monitoring/" + cpu_name + "_" + datetime.datetime.now().strftime('%Y-%m-%d') + ".rrd:guest:LAST"
    file_path = path[:-3] + "rrd"  
    if os.path.isfile(file_path):
    	rrdtool.graph(path, '--imgformat', 'PNG',
                  '--width', '1274',
                  '--height', '346',
                  '--start', '-1d',
                  '--end', str(int(time.time())),
                  '--vertical-label', 'percent',
                  '--title', 'Processors Usage',
                  def1, def2, def3, def4, def5, def6, def7, def8, def9,
                  'AREA:user#e6194B:user',
                  'AREA:nice#42d4f4:nice:STACK',
                  'AREA:system#3cb44b:system:STACK',
                  'AREA:idle#f032e6:idle:STACK',
                  'AREA:iowait#ffe119:iowait:STACK',
                  'AREA:irq#4363d8:irq:STACK',
                  'AREA:softirq#a9a9a9:softirq:STACK',
                  'AREA:steal#800000:steal:STACK',
                  'AREA:guest#911eb4:guest:STACK')
    	createLog("Created " + path)
Beispiel #49
0
def graph_cpu(instance, duration):
    """
    Creates a graph of cpu usage for the specified instance and duration.
    """
    path = instance.get_rrd_path()
    filename = os.path.join(path, 'cpu-%s.png' % duration)

    rrdtool.graph(
        filename,
        '--disable-rrdtool-tag',
        '--imgformat',
        'PNG',
        '--width',
        '400',
        '--height',
        '120',
        '--start',
        'now-%s' % duration,
        '--vertical-label',
        '% cpu used',
        '-l',
        '0',
        '-u',
        '100',
        'DEF:cpu=%s:cpu:AVERAGE' % os.path.join(path, 'cpu.rrd'),
        'AREA:cpu#eacc00:% CPU',
    )

    store_graph(instance.instance_id, filename)
Beispiel #50
0
def GenerateSwapGraph():
    free = "/var/db/collectd/rrd/localhost/swap/swap-free.rrd"
    used = "/var/db/collectd/rrd/localhost/swap/swap-used.rrd"
    file = "swap"

    for time in times:
        graphfile = os.path.join(GRAPHDIR, "%s-%s.png" % (file, time))
        rrdtool.graph(graphfile,
        '--imgformat', 'PNG',
        '--vertical-label', 'Bytes',
        '--title', 'Swap Utilization',
        '--lower-limit', '0',
        '--end', 'now',
        '--start', 'end-%s' % time,
        'DEF:min0=%s:value:MIN' % free,
        'DEF:avg0=%s:value:AVERAGE' % free,
        'DEF:max0=%s:value:MAX' % free,
        'DEF:min1=%s:value:MIN' % used,
        'DEF:avg1=%s:value:AVERAGE' % used,
        'DEF:max1=%s:value:MAX' % used,
        'CDEF:cdef1=avg1,UN,0,avg1,IF',
        'CDEF:cdef0=avg0,UN,0,avg0,IF,cdef1,+',
        'AREA:cdef0#bff7bf',
        'AREA:cdef1#ffbfbf',
        'LINE1:cdef0#00e000:Free  ',
        'GPRINT:min0:MIN:%5.1lf%s Min,',
        'GPRINT:avg0:AVERAGE:%5.1lf%s Avg,',
        'GPRINT:max0:MAX:%5.1lf%s Max,',
        'GPRINT:avg0:LAST:%5.1lf%s Last\l',
        'LINE1:cdef1#ff0000:Used  ',
        'GPRINT:min1:MIN:%5.1lf%s Min,',
        'GPRINT:avg1:AVERAGE:%5.1lf%s Avg,',
        'GPRINT:max1:MAX:%5.1lf%s Max,',
        'GPRINT:avg1:LAST:%5.1lf%s Last\l'
        )
Beispiel #51
0
def graph_disk(instance, duration):
    """
    Creates a graph of disk usage for the specified duration.
    """
    path = instance.get_rrd_path()
    filename = os.path.join(path, 'disk-%s.png' % duration)

    rrdtool.graph(
        filename,
        '--disable-rrdtool-tag',
        '--imgformat',
        'PNG',
        '--width',
        '400',
        '--height',
        '120',
        '--start',
        'now-%s' % duration,
        '--vertical-label',
        'bytes/s',
        '--logarithmic',
        '--units',
        'si',
        '--lower-limit',
        '1000',
        '--rigid',
        'DEF:rd=%s:rd:AVERAGE' % os.path.join(path, 'disk.rrd'),
        'DEF:wr=%s:wr:AVERAGE' % os.path.join(path, 'disk.rrd'),
        'AREA:rd#00FF00:Read',
        'LINE1:wr#0000FF:Write',
    )

    store_graph(instance.instance_id, filename)
Beispiel #52
0
def wn_status(request):
    rrd_name = os.path.join(BASE_DIR, "rrddatas/gw.rrd")
    fd, path = tempfile.mkstemp('.png')
    # 时间格式中的 : 也要转义
    dtime = datetime.datetime.strftime(datetime.datetime.now(),
                                       "%Y-%m-%d %H\:%M\:%S")
    rrdtool.graph(
        path, '--start', "-12h", "-t", "渭南网关带宽", "-w", "600", "-h", "200",
        'DEF:value1={0}:wan_rx:AVERAGE'.format(rrd_name),
        'DEF:value2={0}:wan_tx:AVERAGE'.format(rrd_name),
        'AREA:value1#00ff00: rx', 'LINE:value2#ff0000: tx', "COMMENT:\\n",
        'AREA:value1#00ff00:下载', 'GPRINT:value1:LAST:当前\:%8.0lf',
        'GPRINT:value1:AVERAGE:平均\:%8.0lf', 'GPRINT:value1:MAX:最大\:%8.0lf',
        'GPRINT:value1:MIN:最小\:%8.0lf', "COMMENT:\\n",
        'LINE2:value2#4433ff:上传', 'GPRINT:value2:LAST:当前\:%8.0lf',
        'GPRINT:value2:AVERAGE:平均\:%8.0lf', 'GPRINT:value2:MAX:最大\:%8.0lf',
        'GPRINT:value2:MIN:最小\:%8.0lf', "COMMENT:\\n", "COMMENT:Date " + dtime)

    im = Image.open(path)
    out = cStringIO.StringIO()
    im.save(out, format='png')
    room = out.getvalue()
    out.close()
    os.remove(path)
    return HttpResponse(room, 'image/png')
def dItem02(data):
    pngname = str(data['pname'])
    start = data['stime']
    graphname = str(data['gname']  + "(" + data['host'] + ")" + "(" + data['flag'] + ")")
    DEFa = str(r"DEF:a="+data['rrdpath']+r':'+data['pitem'][0]+r":AVERAGE")
    DEFb = str(r"DEF:b="+data['rrdpath']+r':'+data['pitem'][1]+r":AVERAGE")
    unit = str(data['pitem'][0][2])
    if not unit:
        unit = ' '
    if data['cols'] or data['itypes']:
        if not data['cols']:
            dtypea = str(data['itypes'][0][0]+r":a#00CF00FF:"+data['pitem'][0][1])
            dtypeb = str(data['itypes'][0][1]+r":b#002A97FF:"+data['pitem'][1][1])
        elif not data['itypes']:
            dtypea = str(r"AREA:a"+data['cols'][0][0]+r":"+data['pitem'][0][1])
            dtypeb = str(r"LINE1:b"+data['cols'][0][1]+r":"+data['pitem'][1][1])
        else:
            dtypea = str(data['itypes'][0][0]+r":a"+data['cols'][0][0]+r":"+data['pitem'][0][1])
            dtypeb = str(data['itypes'][0][1]+r":b"+data['cols'][0][1]+r":"+data['pitem'][1][1])
    else:
        dtypea = str(r"AREA:a#00CF00FF:"+data['pitem'][0])
        dtypeb = str(r"LINE1:b#002A97FF:"+data['pitem'][1])
    maxa = 'GPRINT:a:MAX:Max\:%.2lf %s'
    mina = 'GPRINT:a:MIN:Min\:%.2lf %s'
    avga = 'GPRINT:a:AVERAGE:Avg\:%.2lf %s'
    nowa = 'GPRINT:a:LAST:Now\:%.2lf %s'
    maxb = 'GPRINT:b:MAX:Max\:%.2lf %s'
    minb = 'GPRINT:b:MIN:Min\:%.2lf %s'
    avgb = 'GPRINT:b:AVERAGE:Avg\:%.2lf %s'
    nowb = 'GPRINT:b:LAST:Now\:%.2lf %s'
    rrdtool.graph(pngname, '-w', '600', '-h', '144', '-l', '0', '-s', start,
                '-t', graphname, '-v', unit, DEFa, DEFb, 'COMMENT: \\n', dtypea, nowa, avga, mina, maxa, 'COMMENT: \\n',
                dtypeb, nowb, avgb, minb, maxb, 'COMMENT: \\n')
def last_24hour(host, color):
    host = str(host)
    rrdtool.graph("images/last_24hour_" + host + ".png", "-a", "PNG",
                  "--slope-mode", "--width", "900", "--height", "200",
                  "--title", "Ping Statistics", "--vertical-label", "Time(ms)",
                  "DEF:pa=database/" + host + ".rrd:pavg:AVERAGE",
                  "AREA:pa" + color + ":Ping Average")
Beispiel #55
0
 def graph(self):
     '''
     根据网卡数据库绘图
     '''
     rrdtool.graph(self.picture_name, "--start", self.picture_show_time, "--vertical-label=Bytes/s",
                   "--x-grid", "MINUTE:20:HOUR:1:HOUR:2:0:%H:%M",
                   "--width", self.picture_width, "--height", self.picture_height, "--title", self.picture_title,
                   "DEF:inoctets=%s:eth0_in:LAST" % self.rrd_name,           # 指定网卡入流量数据源DS及CF
                   "DEF:outoctets=%s:eth0_out:LAST" % self.rrd_name,         # 指定网卡出流量数据源DS及CF
                   "CDEF:total=inoctets,outoctets,+",                        # 通过CDEF合并网卡出入流量,得出总流量total
                   "LINE1:total#FF8833:Total traffic",                       # 以线条方式绘制总流量
                   "AREA:inoctets#00FF00:In traffic",                        # 以面积方式绘制入流量
                   "LINE1:outoctets#0000FF:Out traffic",                     # 以线条方式绘制出流量
                   "HRULE:10485760#FF0000:Alarm value\\r",                       # 绘制水平线,作为告警线,阈值为6.1k
                   "CDEF:inbytes=inoctets",
                   "CDEF:outbytes=outoctets",
                   "COMMENT:\\r",                                            # 在网格下方输出一个换行符
                   "GPRINT:inbytes:LAST:LAST IN\: %8.2lf %Sb/s",          # 绘制流入流量平均值
                   "COMMENT:    ",
                   "GPRINT:inbytes:AVERAGE:AVERAGE IN\: %8.2lf %Sb/s",         # 平均值
                   "COMMENT:    ",
                   "GPRINT:inbytes:MAX:MAX IN\: %8.2lf %Sb/s",             # 最大值
                   "COMMENT:    ",
                   "GPRINT:inbytes:MIN:MIN IN\: %8.2lf %Sb/s\\r",          # 最小值
                   "COMMENT:    ",
                   "GPRINT:outbytes:LAST:LAST OUT\: %8.2lf %Sb/s",         # 绘制流出流量平均值
                   "COMMENT:   ",
                   "GPRINT:outbytes:AVERAGE:AVERAGE OUT\: %8.2lf %Sb/s",
                   "COMMENT:   ",
                   "GPRINT:outbytes:MAX:MAX OUT\: %8.2lf %Sb/s",
                   "COMMENT:   ",
                   "GPRINT:outbytes:MIN:MIN OUT\: %8.2lf %Sb/s\\r")
def graph_individual(prefix,start_time,end_time,vrules,major_interval=60):

    units, multiplier, direction = units_et_al_by_prefix(prefix)

    length = int(end_time) - int(start_time)

    for individual in glob.glob(prefix+"*.rrd"):
        basename = individual.strip(".rrd")
        try:
            rrdtool.graph(basename + ".svg",
                          '--imgformat','SVG',
                          '--start', str(int(start_time)),
                          '--end', str(int(end_time)),
                          '--font',  'DEFAULT:0:Helvetica',
                          '-w', '%d' % max(800,length), '-h', '400',
                          '--right-axis', '1:0',
                          vrules,
                          '-t', '%s %s' % (basename,prefix),
                          '-v', '%s %s' % (direction, units),
                          'DEF:foo=%s.rrd:mbps:AVERAGE' % basename,
                          'CDEF:bits=foo,%s,*' % multiplier,
                          'LINE2:bits#00FF0080:%s' % units)
        except:
            # at some point we should make certain this was for the
            # "intervals" rrd file but until then just pass
            pass
Beispiel #57
0
def mongodb_memory_graph(start, end, rrd_path, output_file):
    """Create a graph image for mongo memory usage."""
    rrd_file = os.path.join(rrd_path, 'mongodb_memory.rrd')
    with EnvironmentVariable('TZ', 'UTC'):
        rrdtool.graph(
            output_file,
            '--start', str(start),
            '--end', str(end),
            '--full-size-mode',
            '-w', '800',
            '-h', '600',
            '-n', 'DEFAULT:0:Bitstream Vera Sans',
            '-v', 'Memory',
            '--alt-autoscale-max',
            '-t', 'MongoDB Memory Usage',
            'DEF:vsize_avg={}:vsize:AVERAGE'.format(rrd_file),
            'CDEF:vsize_nnl=vsize_avg,UN,0,vsize_avg,IF',
            'DEF:res_avg={}:res:AVERAGE'.format(rrd_file),
            'CDEF:res_nnl=res_avg,UN,0,res_avg,IF',
            'CDEF:vsize_stk=vsize_nnl',
            'CDEF:res_stk=res_nnl,vsize_stk,+',
            'AREA:vsize_stk#bff7bf80',
            'LINE1:vsize_stk#00E000: vsize',
            'AREA:res_stk#bfbfff80',
            'LINE1:res_stk#0000FF: res')
def updateDb(sid):
	sid = str(sid)
	cnx = mysql.connector.connect(user='******', password='******', host='localhost', database='iisc')
	cursor = cnx.cursor()
	cursor.execute("select down,up from speedtest where sid='%s'" % sid)
	for i in cursor:
		up = str(i[1])
		down = str(i[0])
		rrdtool.update("speedtest/database/"+sid+".rrd", "--template", "up:dw", "N:%s:%s" % (up,down))
	cursor.close()
	cnx.close()
	rrdtool.graph("speedtest/images/"+sid+"_1d.png",
	"--slope-mode", "--start", "-86400", "--end", "now",
	"--width", "900", "--height", "200",
	"-a", "PNG", "--title", "Internet Speed (24 Hours)",
	"--vertical-label", "Mbit", "--watermark", "`date`",
	"--lower-limit", "0",
	"--x-grid", "MINUTE:10:HOUR:1:MINUTE:120:0:%R",
	"--alt-y-grid", "--rigid",
	"DEF:up=speedtest/database/"+sid+".rrd:up:MAX",
	"DEF:dw=speedtest/database/"+sid+".rrd:dw:MAX",
	"LINE1:dw#FF6600:Download",
	"GPRINT:dw:LAST:Cur\: %5.2lf",
	"GPRINT:dw:AVERAGE:Avg\: %5.2lf",
	"GPRINT:dw:MAX:Max\: %5.2lf",
	"GPRINT:dw:MIN:Min\: %5.2lf",
	"LINE2:up#003366:Upload",
	"GPRINT:up:LAST:Cur\: %5.2lf",
        "GPRINT:up:AVERAGE:Avg\: %5.2lf",
        "GPRINT:up:MAX:Max\: %5.2lf",
        "GPRINT:up:MIN:Min\: %5.2lf")