def show_all_metrics(self):
if self.__is_zipkin:
start_time = time.time()
start_timestamp = my_time.to_unix_time_millis(
self.__start_date_time_str)
end_timestamp = my_time.to_unix_time_millis(
self.__end_date_time_str)
self.view.display_time(
'start_time:',
my_time.from_timestamp_to_datetime(start_timestamp),
start_timestamp)
self.view.display_time(
'end_time:', my_time.from_timestamp_to_datetime(end_timestamp),
end_timestamp)
timestamps = my_time.timestamp_millis_split(
start_timestamp, end_timestamp)
service_names = zipkin.get_services()
timestamps = my_list.tuple_list(timestamps)
print(len(timestamps))
for timestamp_tuple in timestamps:
cl.process_all_metrics_in_time(service_names,
timestamp_tuple[0],
timestamp_tuple[1])
self.view.display_message(
'Time processing',
'finish in {} seconds'.format(time.time() - start_time))
def service_call_count(dependencies, start_timestamp, end_timestamp):
graph_processor.generate_graph_from_zipkin(dependencies, start_timestamp,
end_timestamp)
service_in_edge_call_count = graph_processor.in_edges_call_count()
time_series_db.send_numeric_metrics(
'call_count_in', service_in_edge_call_count,
int((start_timestamp + end_timestamp) / 2))
service_out_edge_call_count = graph_processor.out_edges_call_count()
time_series_db.send_numeric_metrics(
'call_count_out', service_out_edge_call_count,
int((start_timestamp + end_timestamp) / 2))
service_edge_call_count = my_dict.merge_dicts(service_in_edge_call_count,
service_out_edge_call_count)
time_series_db.send_numeric_metrics(
'call_count', service_edge_call_count,
int((start_timestamp + end_timestamp) / 2))
sorted_service_edge_call_count = my_dict.sort(service_edge_call_count)
most_popular_service = list(sorted_service_edge_call_count.keys())[0]
return [
'Most popular service from {} to {} (Call Count)'.format(
my_time.from_timestamp_to_datetime(start_timestamp),
my_time.from_timestamp_to_datetime(end_timestamp)),
most_popular_service
]
def show_morphology_analysis_in_time(self):
if self.__is_zipkin:
start_time = time.time()
start_timestamp = my_time.to_unix_time_millis(
self.__start_date_time_str)
end_timestamp = my_time.to_unix_time_millis(
self.__end_date_time_str)
self.view.display_time(
'start_time:',
my_time.from_timestamp_to_datetime(start_timestamp),
start_timestamp)
self.view.display_time(
'end_time:', my_time.from_timestamp_to_datetime(end_timestamp),
end_timestamp)
timestamps = my_time.timestamp_millis_split(
start_timestamp, end_timestamp)
timestamps = my_list.tuple_list(timestamps)
for timestamp_1, timestamp_2 in timestamps:
dependencies = zipkin.get_dependencies(end_ts=timestamp_2,
lookback=timestamp_2 -
timestamp_1)
message = cl.service_morphology(dependencies, timestamp_1,
timestamp_2)
self.view.display_message(message[0], message[1])
self.view.display_message(
'Time processing',
'finish in {} seconds'.format(time.time() - start_time))
def show_service_status_codes_analysis(self):
if self.__is_zipkin:
start_time = time.time()
start_timestamp = my_time.to_unix_time_millis(
self.__start_date_time_str)
end_timestamp = my_time.to_unix_time_millis(
self.__end_date_time_str)
self.view.display_time(
'start_time:',
my_time.from_timestamp_to_datetime(start_timestamp),
start_timestamp)
self.view.display_time(
'end_time:', my_time.from_timestamp_to_datetime(end_timestamp),
end_timestamp)
service_names = zipkin.get_services()
for service_name in service_names:
traces = zipkin.get_traces(service_name=service_name,
end_ts=end_timestamp,
lookback=end_timestamp -
start_timestamp)
message = cl.service_status_codes(service_name, traces,
start_timestamp,
end_timestamp)
self.view.display_message(message[0], message[1])
self.view.display_message(
'Time processing',
'finish in {} seconds'.format(time.time() - start_time))
def show_most_popular_service_call_count(self):
if self.__is_zipkin:
start_time = time.time()
start_timestamp = my_time.to_unix_time_millis(
self.__start_date_time_str)
end_timestamp = my_time.to_unix_time_millis(
self.__end_date_time_str)
self.view.display_time(
'start_time:',
my_time.from_timestamp_to_datetime(start_timestamp),
start_timestamp)
self.view.display_time(
'end_time:', my_time.from_timestamp_to_datetime(end_timestamp),
end_timestamp)
dependencies = zipkin.get_dependencies(end_ts=end_timestamp,
lookback=end_timestamp -
start_timestamp)
message = cl.service_call_count(dependencies, start_timestamp,
end_timestamp)
self.view.display_message(message[0], message[1])
self.view.display_message(
'Time processing',
'finish in {} seconds'.format(time.time() - start_time))
def service_neighbours(dependencies, start_timestamp, end_timestamp):
graph_processor.generate_graph_from_zipkin(dependencies, start_timestamp,
end_timestamp)
return [
'All service neighbors from {} to {}'.format(
my_time.from_timestamp_to_datetime(start_timestamp),
my_time.from_timestamp_to_datetime(end_timestamp)),
graph_processor.neighbors()
]
def service_morphology(dependencies, start_timestamp, end_timestamp,
previous_graph):
current_graph = graph_processor.generate_graph_from_zipkin(
dependencies, start_timestamp, end_timestamp)
current_graph.name = '{}_{}'.format(start_timestamp, end_timestamp)
graph_db.insert_graph(start_timestamp, end_timestamp,
list(current_graph.edges(data=True)),
graph_db.graph_db)
if previous_graph:
graph_diff = graph_processor.graphs_difference(previous_graph,
current_graph)
graph_db.insert_graph(start_timestamp, end_timestamp,
list(graph_diff.edges(data=True)),
graph_db.graph_diff_db)
graph_variance = graph_processor.graphs_variance(
previous_graph, current_graph)
time_series_db.send_numeric_metric(
['graph_gain_variance'], graph_variance.get('gain'),
int((start_timestamp + end_timestamp) / 2))
time_series_db.send_numeric_metric(
['graph_loss_variance'], graph_variance.get('loss'),
int((start_timestamp + end_timestamp) / 2))
time_series_db.send_numeric_metric(
['graph_variance'],
graph_variance.get('gain') - graph_variance.get('loss'),
int((start_timestamp + end_timestamp) / 2))
message = [
'System Morphology from {} to {}'.format(
my_time.from_timestamp_to_datetime(start_timestamp),
my_time.from_timestamp_to_datetime(end_timestamp)),
'\nprevious_graph.Nodes:{}\nprevious_graph.Edges:{}'
'\nprevious_graph.NodesLen:{}\nprevious_graph.EdgesLen:{}'
'\ncurrent_graph.Nodes:{}\ncurrent_graph.Edges:{}'
'\ncurrent_graph.NodesLen:{}\ncurrent_graph.EdgesLen:{}'
'\ngraph_diff.Nodes:{}\ngraph_diff.Edges:{}'
'\ngraph_diff.NodesLen:{}\ngraph_diff.EdgesLen:{}'.format(
previous_graph.nodes, previous_graph.edges(data=True),
len(previous_graph.nodes),
len(previous_graph.edges), current_graph.nodes,
current_graph.edges(data=True), len(current_graph.nodes),
len(current_graph.edges), graph_diff.nodes,
graph_diff.edges(data=True), len(graph_diff.nodes),
len(graph_diff.edges))
]
else:
previous_graph = current_graph.copy()
message = ['NO PREVIOUS GRAPH!', '']
return message, previous_graph
def process_all_metrics_in_time(service_names, timestamp_1, timestamp_2):
global g_previous_graph
message = list()
dependencies = zipkin.get_dependencies(end_ts=timestamp_2,
lookback=timestamp_2 - timestamp_1)
if not dependencies:
message.append([
'No services from {} to {}'.format(
my_time.from_timestamp_to_datetime(timestamp_1),
my_time.from_timestamp_to_datetime(timestamp_2)),
'Can\'t perform calculation!'
])
else:
message.append(
service_neighbours(dependencies, timestamp_1, timestamp_2))
message.append(service_degree(dependencies, timestamp_1, timestamp_2))
message.append(
service_call_count(dependencies, timestamp_1, timestamp_2))
message, g_previous_graph = service_morphology(dependencies,
timestamp_1,
timestamp_2,
g_previous_graph)
message.append(message)
for service_name in service_names:
traces = zipkin.get_traces(service_name=service_name,
end_ts=timestamp_2,
lookback=timestamp_2 - timestamp_1)
if not traces:
message.append([
'No traces found from {} to {} for service {}'.format(
my_time.from_timestamp_to_datetime(timestamp_1),
my_time.from_timestamp_to_datetime(timestamp_2),
service_name), '\nCan\'t calculate service status codes'
])
else:
span_trees = my_trace.generate_span_trees(traces)
trace_metrics_data = my_trace.extract_metrics(span_trees)
message.append(
service_status_codes(service_name, traces, timestamp_1,
timestamp_2))
# trace_quality_analysis(service_name, trace_metrics_data)
message.append(
service_response_time_analysis(service_name,
trace_metrics_data, timestamp_1,
timestamp_2))
print(message)
def service_status_codes(service_name, traces, start_timestamp, end_timestamp):
status_codes = my_trace.get_status_codes(traces)
status_codes_percentage = my_dict.calc_percentage(status_codes)
time_series_db.send_numeric_metrics(
'status_code.{}'.format(service_name), status_codes_percentage,
int((start_timestamp + end_timestamp) / 2))
return [
'Status Codes from {} to {}'.format(
my_time.from_timestamp_to_datetime(start_timestamp),
my_time.from_timestamp_to_datetime(end_timestamp)),
'\nservice_name: {}'
'\nstatus_codes: {}'
'\nstatus_codes_percentage: {}'.format(
service_name, my_dict.sort(status_codes),
my_dict.sort(status_codes_percentage))
]
def trace_quality_analysis(traces, service_name: str, timestamp_1,
timestamp_2):
span_trees = my_trace.generate_span_trees(traces)
trace_metrics_data = my_trace.extract_metrics(span_trees)
x_values = list(trace_metrics_data.coverability_count.keys())
y_values = my_dict.filter(trace_metrics_data.coverability_count,
'value').values()
my_files.save_dict(
os.path.join(my_files.TRACE_COV_PROJECT_DIRECTORY,
service_name + '.csv'), dict(zip(x_values, y_values)))
return [
'Trace quality analysis from {} to {} for service {} completed.'.
format(my_time.from_timestamp_to_datetime(timestamp_1),
my_time.from_timestamp_to_datetime(timestamp_2),
service_name), 'OK!'
]
def service_response_time_analysis(service_name: str, trace_metrics_data,
start_timestamp, end_timestamp):
if trace_metrics_data.response_time_avg is not -1:
response_time_avg = trace_metrics_data.response_time_avg
time_series_db.send_numeric_metric(
['response_time_avg', service_name], response_time_avg,
int((start_timestamp + end_timestamp) / 2))
return [
'Response time analysis from {} to {} for service {}\nAVG: {}'.
format(my_time.from_timestamp_to_datetime(start_timestamp),
my_time.from_timestamp_to_datetime(end_timestamp),
service_name, response_time_avg), 'Analysis completed!'
]
else:
return [
'No data found from {} to {} for service {}'.format(
my_time.from_timestamp_to_datetime(start_timestamp),
my_time.from_timestamp_to_datetime(end_timestamp),
service_name), '\nCan\'t perform response time analysis'
]
def service_degree(dependencies, start_timestamp, end_timestamp):
graph_processor.generate_graph_from_zipkin(dependencies, start_timestamp,
end_timestamp)
service_degrees = graph_processor.degrees()
service_in_degrees = graph_processor.degrees('in')
service_out_degrees = graph_processor.degrees('out')
time_series_db.send_numeric_metrics(
'degree', service_degrees, int((start_timestamp + end_timestamp) / 2))
time_series_db.send_numeric_metrics(
'degree_in', service_in_degrees,
int((start_timestamp + end_timestamp) / 2))
time_series_db.send_numeric_metrics(
'degree_out', service_out_degrees,
int((start_timestamp + end_timestamp) / 2))
most_popular_service = service_degrees[0]
return [
'Most popular service from {} to {} (Degrees)'.format(
my_time.from_timestamp_to_datetime(start_timestamp),
my_time.from_timestamp_to_datetime(end_timestamp)),
most_popular_service
]
def test_from_timestamp_to_datetime(self):
""" Test from_timestamp_to_datetime function. """
self.assertEqual(my_time.from_timestamp_to_datetime(self.__unix_timestamp, 's')._repr_base, self.__date_time)
self.assertEqual(my_time.from_timestamp_to_datetime(self.__unix_timestamp_millis)._repr_base, self.__date_time)