2
0
mirror of https://github.com/munin-monitoring/contrib.git synced 2018-11-08 00:59:34 +01:00
contrib-munin/tools/profiling/munin-profile-node.py
2013-02-27 09:06:34 +01:00

101 lines
3.2 KiB
Python
Executable File

#!/usr/bin/python
# Copyright (C) 2013 Helmut Grohne <helmut@subdivi.de>
# License: GPLv2 like the rest of munin
"""
Usage:
tcpdump -npi lo "tcp port 4949" -w munin.pcap
# wait for one munin run, then press Ctrl-C
./munin-profile-node.py munin.pcap
"""
import collections
import sys
from scapy.utils import rdpcap
import scapy.layers.l2
from scapy.layers.inet import IP, TCP
class ConnectionProfile:
"""
@ivar times: mapping of commands to durations waiting for answers in
seconds
@type times: {str: [float]}
@ivar idles: list of durations waiting for client in seconds
@type idles: [float]
"""
def __init__(self):
self.times = dict()
self.idles = []
self.curcommand = None
self.commandstart = None
def handle_to_node(self, timestamp, line):
if self.curcommand is None and self.commandstart is not None:
self.idles.append(timestamp - self.commandstart)
self.curcommand = line
self.commandstart = timestamp
def handle_from_node(self, timestamp, line):
if line != ".":
return
if self.curcommand is None:
return
duration = timestamp - self.commandstart
self.times.setdefault(self.curcommand, []).append(duration)
self.curcommand = None
self.commandstart = timestamp
class MuninProfiler:
def __init__(self):
self.to_node = ""
self.from_node = ""
self.connprof = collections.defaultdict(ConnectionProfile)
def handle_packet(self, packet):
payload = str(packet[TCP].payload)
if not payload:
return
if packet[TCP].dport == 4949:
self.to_node += payload
conn = (packet[IP].src, packet[TCP].sport, packet[IP].dst)
elif packet[TCP].sport == 4949:
self.from_node += payload
conn = (packet[IP].dst, packet[TCP].dport, packet[IP].src)
else:
return
lines = self.to_node.split("\n")
self.to_node = lines.pop()
for line in lines:
self.connprof[conn].handle_to_node(packet.time, line)
lines = self.from_node.split("\n")
self.from_node = lines.pop()
for line in lines:
self.connprof[conn].handle_from_node(packet.time, line)
@property
def times(self):
times = dict()
for prof in self.connprof.values():
for com, durations in prof.times.items():
times.setdefault(com, []).extend(durations)
return times
@property
def idles(self):
return sum((prof.idles for prof in self.connprof.values()), [])
def main():
mp = MuninProfiler()
for pkt in rdpcap(sys.argv[1]):
mp.handle_packet(pkt)
print("Client idle time during connection: %.2fs" % sum(mp.idles))
times = [(key, sum(value)) for key, value in mp.times.items()]
times.sort(key=lambda tpl: -tpl[1])
total = sum(value for key, value in times)
print("Total time waiting for the node: %.2fs" % total)
print("Top 10 plugins using most of the time")
for key, value in times[:10]:
print("%-40s: %.2fs (%d%%)" % (key, value, 100 * value / total))
if __name__ == '__main__':
main()