def test_munin_output(self):
cfg = self.make_basic_cfg()
plugin = self.create_plugin(cfg)
jsfr = JSONFileReporter(output_file=self.filename)
register_reporter(jsfr)
test1 = EventCounter("test1")
register_counter(test1)
try:
test1.report_event("test1", "value", 2)
output_report()
plugin.output_data(cfg)
self.assertEqual(self.get_last_plugin_output(), ["multigraph test", "test1.value 2"])
plugin.max_file_age_in_seconds = 0.00001
self.clear_last_plugin_output()
plugin.output_data(cfg)
self.assertEqual(self.get_last_plugin_output(), [])
plugin.max_file_age_in_seconds = None
plugin.output_data(cfg)
self.assertEqual(self.get_last_plugin_output(), ["multigraph test", "test1.value 2"])
os.unlink(self.filename)
finally:
unregister_counter(counter=test1)
unregister_reporter(jsfr)
def test_basic_reporter(self):
test1 = EventCounter("test1", events=["test_event"])
register_counter(test1)
v = SimpleValueReporter()
register_reporter(v)
start_auto_reporting(0.01)
try:
test1.report_event("test_event", "value", 2)
sleep(0.1)
self.assertEqual(v.values_wo_metadata, {"test1": 2})
test1.report_event("test_event", "value", 1)
sleep(0.05)
self.assertEqual(v.values_wo_metadata, {"test1": 3})
stop_auto_reporting()
test1.report_event("test_event", "value", 1)
sleep(0.05)
self.assertEqual(v.values_wo_metadata, {"test1": 3})
finally:
unregister_counter(counter=test1)
unregister_reporter(v)
def test_perf_frequency(self):
class FakeFrequencyCounter(FrequencyCounter):
i = 0
def _get_current_time(self):
self.i = self.i + 1
return self.i
c = FakeFrequencyCounter("c", events=["f", "c"], window_size=10)
register_counter(c)
try:
@frequency(auto_add_counter=None)
def f():
pass
@frequency("c")
def g():
pass
f()
g()
self.assertEquals(c.get_value().value, 0.5)
finally:
unregister_counter(counter=c)
def test_one_counter_multiple_events(self):
test = TotalCounter("test", events=["test1", "test2"])
register_counter(test)
test.report_event("test1", "value", 1)
test.report_event("test2", "value", 2)
self.assertEquals(test.get_value().value, 3)
unregister_counter(counter=test)
def test_perf_time(self):
c = AverageTimeCounter("c")
c.timer = FakeThreadLocalTimer()
register_counter(c)
try:
@time(name="c")
def f():
c.timer._get_current_time() # advances time -> just like sleep 1
pass
f()
f()
self.assertEqual(c.get_value().value, 2)
finally:
unregister_counter(counter=c)
def test_multiple_counters_one_event(self):
test1 = TotalCounter("test1", events=["test"])
register_counter(test1)
test2 = TotalCounter("test2", events=["test"])
register_counter(test2)
v = SimpleValueReporter()
register_reporter(v)
report_value("test", 1)
output_report()
self.assertEquals(v.values_wo_metadata, dict(test1=1, test2=1))
unregister_counter(counter=test1)
unregister_counter(counter=test2)
unregister_reporter(reporter=v)
def test_json_output(self):
filename = "/tmp/json_test.txt"
jsfr = JSONFileReporter(output_file=filename)
test1 = EventCounter("test1")
register_counter(test1)
register_reporter(jsfr)
try:
test1.report_event("test1", "value", 2)
output_report()
report = JSONFileReporter.safe_read(filename)
report = dict([(k, v) for k, v in report.iteritems() if not k.startswith("__")])
self.assertEqual(report, {"test1": 2})
os.unlink(filename)
finally:
unregister_counter(counter=test1)
unregister_reporter(jsfr)
def test_frequency_cleans(self):
c = FrequencyCounter("c", events=["f", "c"], window_size=0.5)
register_counter(c)
try:
@frequency(auto_add_counter=None)
def f():
pass
@frequency("c")
def g():
pass
g()
f()
self.assertTrue(c.get_value().value > 0)
sleep(0.7)
#self.assertEqual(c.get_value().value, None)
finally:
unregister_counter(counter=c)
def test_basic_collection(self):
test1 = TotalCounter("test1")
register_counter(test1)
test2 = TotalCounter("test2")
register_counter(test2)
v = SimpleValueReporter()
register_reporter(v)
report_value("test1", 1)
report_value("test2", 2)
output_report()
self.assertTrue("__collection_time__" in v.last_values)
self.assertEquals(v.values_wo_metadata,dict(test1=1,test2=2))
unregister_counter(counter=test1)
unregister_counter(counter=test2)
unregister_reporter(reporter=v)
def test_counted_func(self):
c = EventCounter("c")
register_counter(c)
try:
@count("c")
def f():
pass
f()
f()
f()
self.assertEqual(c.get_value().value, 3L)
c.clear()
self.assertEqual(c.get_value().value, 0L)
f()
self.assertEqual(c.get_value().value, 1L)
finally:
unregister_counter(counter=c)
def __init__(self, RP=None):
"""
:param output_file: a file name to which the reports will be written.
"""
super(BaseReporter, self).__init__()
# start_new_thread(self.serv_results, ())
def serv_results(self):
listener = Listener("/tmp/rpssock")
conn = listener.accept()
conn.send_bytes(self.RPS)
conn.close()
def output_values(self, counter_values):
#not sure but probably this method will be called from PyCounter's "leader" collector process
if counter_values['requests_frequency'] and counter_values[
'requests_frequency'] > 0:
self.RPS = str(counter_values['requests_frequency'])
self.serv_results()
rps_counter = counters.FrequencyCounter(
"requests_frequency", window_size=2) # not working when set to 1
register_counter(rps_counter)
reporter = SocketReporter()
# json_reporter = JSONFileReporter("/tmp/pyc.json")
# register_reporter(json_reporter)
register_reporter(reporter)
start_auto_reporting(seconds=1)
configure_multi_process_collection()
# self.request is the TCP socket connected to the client
self.data = self.request.recv(1024).strip()
print "%s wrote:" % self.client_address[0]
print self.data
# measure the average length of data
report_value("requests_data_len",len(self.data))
# just send back the same data, but upper-cased
self.request.send(self.data.upper())
if __name__ == "__main__":
HOST, PORT = "localhost", 9999
JSONFile = "/tmp/server.counters.json"
data_len_counter = counters.TotalCounter("requests_data_len") # create the counter
register_counter(data_len_counter) # register it, so it will start processing events
reporter = reporters.JSONFileReporter(output_file=JSONFile)
register_reporter(reporter)
start_auto_reporting()
# Create the server, binding to localhost on port 9999
server = SocketServer.TCPServer((HOST, PORT), MyTCPHandler)
# Activate the server; this will keep running until you
# interrupt the program with Ctrl-C
server.serve_forever()
Serves reports using multiprocessing.Listener (to StatsGenerator)
"""
def __init__(self, RP=None):
"""
:param output_file: a file name to which the reports will be written.
"""
super(BaseReporter, self).__init__()
# start_new_thread(self.serv_results, ())
def serv_results(self):
listener = Listener("/tmp/rpssock")
conn = listener.accept()
conn.send_bytes(self.RPS)
conn.close()
def output_values(self, counter_values):
#not sure but probably this method will be called from PyCounter's "leader" collector process
if counter_values['requests_frequency'] and counter_values['requests_frequency'] > 0:
self.RPS = str(counter_values['requests_frequency'])
self.serv_results()
rps_counter = counters.FrequencyCounter("requests_frequency", window_size=2) # not working when set to 1
register_counter(rps_counter)
reporter = SocketReporter()
# json_reporter = JSONFileReporter("/tmp/pyc.json")
# register_reporter(json_reporter)
register_reporter(reporter)
start_auto_reporting(seconds=1)
configure_multi_process_collection()
