def get(self):
user = users.get_current_user()
# We use app.yaml to configure overall authentication
if not validate_user(user.email()):
self.redirect(users.create_login_url(self.request.uri))
start = time.time()
key = self.request.get("key")
gc_data = gc_datastore.get_data(key)
#need to sort results
# We regenerate summary stats with each invocation
summary_stats = SummaryStats(gc_data).stats
q = db.GqlQuery("SELECT * FROM GraphModel " +
"WHERE ANCESTOR IS :1 ", key)
results = q.fetch(6)
for entry in results:
if entry.graph_type == graph.RAW_CSV_DATA:
results_csv_key = str(entry.blob_key.key())
elif entry.graph_type == graph.YG_GC_MEMORY:
yg_memory_key = str(entry.blob_key.key())
elif entry.graph_type == graph.GC_DURATION:
gc_duration_key = str(entry.blob_key.key())
elif entry.graph_type == graph.MEMORY_RECLAIMED:
gc_reclaimed_key = str(entry.blob_key.key())
elif entry.graph_type == graph.FULL_GC_MEMORY:
full_memory_key = str(entry.blob_key.key())
elif entry.graph_type == graph.MEMORY_UTIL_POST:
memory_util_post_key = str(entry.blob_key.key())
duration = time.time() - start
# Pass the key to our results, as the data will be obtained via a
template_values = {
'user': user,
'logout': users.create_logout_url("/"),
'name': '/uploads',
'duration': duration,
'results_key': results_csv_key,
'summary_stats': summary_stats,
'gc_results': gc_data,
'yg_memory_key': yg_memory_key,
'full_memory_key': full_memory_key,
'gc_duration_key': gc_duration_key,
'gc_reclaimed_key': gc_reclaimed_key,
'memory_util_post_key': memory_util_post_key
}
template = jinja_environment.get_template(
'static/templates/results.html')
self.response.out.write(template.render(template_values))
def test_generate_stats(self):
"""Test the generation of stats result set"""
yg_gc1 = parsegc.generate_yg_gc_entry("50.0", "50.0", "ParNew", "2",
"1", "4", "0.12345", "2048",
"1024", "4096", "2.12345", "1.0",
"1.50", "2.1")
yg_gc2 = parsegc.generate_yg_gc_entry("100.25", "100.25", "ParNew",
"3", "2", "8", "0.12345", "8192",
"5120", "16384", "3.12345",
"1.5", "2.0", "3.1")
full_gc = parsegc.generate_full_gc_entry("200.5", "200.5", "Tenured",
"20", "10", "40", "0.23456",
"8192", "5120", "16384",
"200", "100", "400", "3.1234",
"1.9", "0.05", "3.11")
system_gc = parsegc.generate_full_gc_entry("250.75", "250.75",
"Tenured", "30", "20", "80",
"0.23456", "8192", "4096",
"8192", "300", "200", "800",
"4.0912", "1.98", "2.1",
"4.09", "System")
gc_data = [yg_gc1, yg_gc2, full_gc, system_gc]
results = SummaryStats(gc_data).stats
expected = {}
expected['Total Events'] = len(gc_data)
expected['Elapsed Time'] = '200.750 secs'
expected['Time spent in Full GC'] = '7.215 secs'
expected['Time spent in YG GC'] = '5.247 secs'
expected['Heap Start / End (Peak)'] = '4 MB / 8 MB (16 MB)'
expected['YG Start / End (Peak)'] = '4 KB / 8 KB (8 KB)'
expected['Tenured Start / End (Peak)'] = '40 KB / 80 KB (80 KB)'
expected['Perm Start / End (Peak)'] = '400 KB / 800 KB (800 KB)'
expected['Heap Growth'] = '4 MB'
expected['YG Growth'] = '4 KB'
expected['Tenured Growth'] = '40 KB'
expected['Perm Growth'] = '400 KB'
expected['Avg YG Reclaimed'] = '1 KB'
expected['Avg Tenured Reclaimed'] = '10 KB'
self.assertEqual(results, expected)
def post(self):
user = users.get_current_user()
# We use app.yaml to configure overall authentication
if not validate_user(user.email()):
self.redirect(users.create_login_url(self.request.uri))
start = time.time()
#file = self.request.body_file
file = self.request.params["gclog"].file
log_key = LogData(
filename=self.request.POST["gclog"].filename,
notes=self.request.get("notes")).put()
parser = ParseGCLog()
gc_results = parser.parse_data(file)
if len(gc_results) > 0:
# Generate summary stats for results page
summary_stats = SummaryStats(gc_results).stats
# persist gc data - too slow at present with large datasets
gc_datastore.store_data(log_key, gc_results)
# persist all CSV data we generate to the store so we
# won't have to regenerate later
blob_writer = BlobResultWriter()
results_csv_key = graph.generate_cached_graph(log_key,
graph.RAW_CSV_DATA,
gc_results,
blob_writer)
yg_memory_blob_key = graph.generate_cached_graph(log_key,
graph.YG_GC_MEMORY,
gc_results,
blob_writer)
full_memory_blob_key = graph.generate_cached_graph(log_key,
graph.FULL_GC_MEMORY,
gc_results,
blob_writer)
gc_duration_blob_key = graph.generate_cached_graph(log_key,
graph.GC_DURATION,
gc_results,
blob_writer)
gc_reclaimed_blob_key = graph.generate_cached_graph(log_key,
graph.MEMORY_RECLAIMED,
gc_results,
blob_writer)
memory_util_post_blob_key = graph.generate_cached_graph(log_key,
graph.MEMORY_UTIL_POST,
gc_results,
blob_writer)
duration = time.time() - start
# Pass the key to our results, as the data will be obtained via a
template_values = {
'user': user,
'logout': users.create_logout_url("/"),
'duration': duration,
'name': '/uploads',
'results_key': str(results_csv_key),
'summary_stats': summary_stats,
'gc_results': gc_results,
'yg_memory_key': str(yg_memory_blob_key),
'full_memory_key': str(full_memory_blob_key),
'gc_duration_key': str(gc_duration_blob_key),
'gc_reclaimed_key': str(gc_reclaimed_blob_key),
'memory_util_post_key': str(memory_util_post_blob_key)
}
template = jinja_environment.get_template(
'static/templates/results.html')
else:
template_values = {
'user': user,
'logout': users.create_logout_url("/")
}
template = jinja_environment.get_template(
'static/templates/error.html')
self.response.out.write(template.render(template_values))
