"""Implementation of graphs for trending data.
"""
+import logging
import plotly.graph_objects as go
import pandas as pd
from ..utils.constants import Constants as C
-from ..utils.utils import classify_anomalies, get_color, get_hdrh_latencies
+from ..utils.utils import get_color, get_hdrh_latencies
+from ..utils.anomalies import classify_anomalies
def select_trending_data(data: pd.DataFrame, itm: dict) -> pd.DataFrame:
name: str,
df: pd.DataFrame,
color: str,
- norm_factor: float
+ nf: float
) -> list:
"""Generate the trending traces for the trending graph.
:param name: The test name to be displayed as the graph title.
:param df: Data frame with test data.
:param color: The color of the trace (samples and trend line).
- :param norm_factor: The factor used for normalization of the results to
+ :param nf: The factor used for normalization of the results to
CPU frequency set to Constants.NORM_FREQUENCY.
:type ttype: str
:type name: str
:type df: pandas.DataFrame
:type color: str
- :type norm_factor: float
+ :type nf: float
:returns: Traces (samples, trending line, anomalies)
:rtype: list
"""
if df.empty:
return list(), list()
- x_axis = df["start_time"].tolist()
- if ttype == "latency":
- y_data = [(v / norm_factor) for v in df[C.VALUE[ttype]].tolist()]
- else:
- y_data = [(v * norm_factor) for v in df[C.VALUE[ttype]].tolist()]
- units = df[C.UNIT[ttype]].unique().tolist()
-
- anomalies, trend_avg, trend_stdev = classify_anomalies(
- {k: v for k, v in zip(x_axis, y_data)}
- )
-
hover = list()
customdata = list()
customdata_samples = list()
- for idx, (_, row) in enumerate(df.iterrows()):
- d_type = "trex" if row["dut_type"] == "none" else row["dut_type"]
+ name_lst = name.split("-")
+ for _, row in df.iterrows():
+ h_tput, h_band, h_lat = str(), str(), str()
+ if ttype in ("mrr", "mrr-bandwidth"):
+ h_tput = (
+ f"tput avg [{row['result_receive_rate_rate_unit']}]: "
+ f"{row['result_receive_rate_rate_avg'] * nf:,.0f}<br>"
+ f"tput stdev [{row['result_receive_rate_rate_unit']}]: "
+ f"{row['result_receive_rate_rate_stdev'] * nf:,.0f}<br>"
+ )
+ if pd.notna(row["result_receive_rate_bandwidth_avg"]):
+ h_band = (
+ f"bandwidth avg "
+ f"[{row['result_receive_rate_bandwidth_unit']}]: "
+ f"{row['result_receive_rate_bandwidth_avg'] * nf:,.0f}"
+ "<br>"
+ f"bandwidth stdev "
+ f"[{row['result_receive_rate_bandwidth_unit']}]: "
+ f"{row['result_receive_rate_bandwidth_stdev']* nf:,.0f}"
+ "<br>"
+ )
+ elif ttype in ("ndr", "ndr-bandwidth"):
+ h_tput = (
+ f"tput [{row['result_ndr_lower_rate_unit']}]: "
+ f"{row['result_ndr_lower_rate_value'] * nf:,.0f}<br>"
+ )
+ if pd.notna(row["result_ndr_lower_bandwidth_value"]):
+ h_band = (
+ f"bandwidth [{row['result_ndr_lower_bandwidth_unit']}]:"
+ f" {row['result_ndr_lower_bandwidth_value'] * nf:,.0f}"
+ "<br>"
+ )
+ elif ttype in ("pdr", "pdr-bandwidth", "latency"):
+ h_tput = (
+ f"tput [{row['result_pdr_lower_rate_unit']}]: "
+ f"{row['result_pdr_lower_rate_value'] * nf:,.0f}<br>"
+ )
+ if pd.notna(row["result_pdr_lower_bandwidth_value"]):
+ h_band = (
+ f"bandwidth [{row['result_pdr_lower_bandwidth_unit']}]:"
+ f" {row['result_pdr_lower_bandwidth_value'] * nf:,.0f}"
+ "<br>"
+ )
+ if pd.notna(row["result_latency_forward_pdr_50_avg"]):
+ h_lat = (
+ f"latency "
+ f"[{row['result_latency_forward_pdr_50_unit']}]: "
+ f"{row['result_latency_forward_pdr_50_avg'] / nf:,.0f}"
+ "<br>"
+ )
+ elif ttype in ("hoststack-cps", "hoststack-rps",
+ "hoststack-cps-bandwidth",
+ "hoststack-rps-bandwidth", "hoststack-latency"):
+ h_tput = (
+ f"tput [{row['result_rate_unit']}]: "
+ f"{row['result_rate_value'] * nf:,.0f}<br>"
+ )
+ h_band = (
+ f"bandwidth [{row['result_bandwidth_unit']}]: "
+ f"{row['result_bandwidth_value'] * nf:,.0f}<br>"
+ )
+ h_lat = (
+ f"latency [{row['result_latency_unit']}]: "
+ f"{row['result_latency_value'] / nf:,.0f}<br>"
+ )
+ elif ttype in ("hoststack-bps", ):
+ h_band = (
+ f"bandwidth [{row['result_bandwidth_unit']}]: "
+ f"{row['result_bandwidth_value'] * nf:,.0f}<br>"
+ )
hover_itm = (
+ f"dut: {name_lst[0]}<br>"
+ f"infra: {'-'.join(name_lst[1:5])}<br>"
+ f"test: {'-'.join(name_lst[5:])}<br>"
f"date: {row['start_time'].strftime('%Y-%m-%d %H:%M:%S')}<br>"
- f"<prop> [{row[C.UNIT[ttype]]}]: {y_data[idx]:,.0f}<br>"
- f"<stdev>"
- f"<additional-info>"
- f"{d_type}-ref: {row['dut_version']}<br>"
+ f"{h_tput}{h_band}{h_lat}"
+ f"{row['dut_type']}-ref: {row['dut_version']}<br>"
f"csit-ref: {row['job']}/{row['build']}<br>"
f"hosts: {', '.join(row['hosts'])}"
)
- if ttype == "mrr":
- stdev = (
- f"stdev [{row['result_receive_rate_rate_unit']}]: "
- f"{row['result_receive_rate_rate_stdev']:,.0f}<br>"
- )
- else:
- stdev = str()
- if ttype in ("hoststack-cps", "hoststack-rps"):
- add_info = (
- f"bandwidth [{row[C.UNIT['hoststack-bps']]}]: "
- f"{row[C.VALUE['hoststack-bps']]:,.0f}<br>"
- f"latency [{row[C.UNIT['hoststack-lat']]}]: "
- f"{row[C.VALUE['hoststack-lat']]:,.0f}<br>"
- )
- else:
- add_info = str()
- hover_itm = hover_itm.replace(
- "<prop>", "latency" if ttype == "latency" else "average"
- ).replace("<stdev>", stdev).replace("<additional-info>", add_info)
hover.append(hover_itm)
if ttype == "latency":
customdata_samples.append(get_hdrh_latencies(row, name))
)
customdata.append({"name": name})
+ x_axis = df["start_time"].tolist()
+ if "latency" in ttype:
+ y_data = [(v / nf) for v in df[C.VALUE[ttype]].tolist()]
+ else:
+ y_data = [(v * nf) for v in df[C.VALUE[ttype]].tolist()]
+ units = df[C.UNIT[ttype]].unique().tolist()
+
+ try:
+ anomalies, trend_avg, trend_stdev = classify_anomalies(
+ {k: v for k, v in zip(x_axis, y_data)}
+ )
+ except ValueError as err:
+ logging.error(err)
+ return list(), list()
+
hover_trend = list()
for avg, stdev, (_, row) in zip(trend_avg, trend_stdev, df.iterrows()):
- d_type = "trex" if row["dut_type"] == "none" else row["dut_type"]
hover_itm = (
+ f"dut: {name_lst[0]}<br>"
+ f"infra: {'-'.join(name_lst[1:5])}<br>"
+ f"test: {'-'.join(name_lst[5:])}<br>"
f"date: {row['start_time'].strftime('%Y-%m-%d %H:%M:%S')}<br>"
f"trend [{row[C.UNIT[ttype]]}]: {avg:,.0f}<br>"
f"stdev [{row[C.UNIT[ttype]]}]: {stdev:,.0f}<br>"
- f"{d_type}-ref: {row['dut_version']}<br>"
+ f"{row['dut_type']}-ref: {row['dut_version']}<br>"
f"csit-ref: {row['job']}/{row['build']}<br>"
f"hosts: {', '.join(row['hosts'])}"
)
"symbol": "circle",
},
text=hover,
- hoverinfo="text+name",
+ hoverinfo="text",
showlegend=True,
legendgroup=name,
customdata=customdata_samples
"color": color,
},
text=hover_trend,
- hoverinfo="text+name",
+ hoverinfo="text",
showlegend=False,
legendgroup=name,
customdata=customdata
anomaly_y.append(trend_avg[idx])
anomaly_color.append(C.ANOMALY_COLOR[anomaly])
hover_itm = (
+ f"dut: {name_lst[0]}<br>"
+ f"infra: {'-'.join(name_lst[1:5])}<br>"
+ f"test: {'-'.join(name_lst[5:])}<br>"
f"date: {x_axis[idx].strftime('%Y-%m-%d %H:%M:%S')}<br>"
f"trend [pps]: {trend_avg[idx]:,.0f}<br>"
f"classification: {anomaly}"
y=anomaly_y,
mode="markers",
text=hover,
- hoverinfo="text+name",
+ hoverinfo="text",
showlegend=False,
legendgroup=name,
name=name,
fig_tput = None
fig_lat = None
+ fig_band = None
y_units = set()
for idx, itm in enumerate(sel):
df = select_trending_data(data, itm)
if normalize:
phy = itm["phy"].split("-")
topo_arch = f"{phy[0]}-{phy[1]}" if len(phy) == 4 else str()
- norm_factor = (C.NORM_FREQUENCY / C.FREQUENCY[topo_arch]) \
+ norm_factor = (C.NORM_FREQUENCY / C.FREQUENCY.get(topo_arch, 1.0)) \
if topo_arch else 1.0
else:
norm_factor = 1.0
fig_tput = go.Figure()
fig_tput.add_traces(traces)
- if itm["testtype"] == "pdr":
+ if ttype in ("ndr", "pdr", "mrr", "hoststack-cps", "hoststack-rps"):
traces, _ = _generate_trending_traces(
- "latency",
+ f"{ttype}-bandwidth",
+ itm["id"],
+ df,
+ get_color(idx),
+ norm_factor
+ )
+ if traces:
+ if not fig_band:
+ fig_band = go.Figure()
+ fig_band.add_traces(traces)
+
+ if ttype in ("pdr", "hoststack-cps", "hoststack-rps"):
+ traces, _ = _generate_trending_traces(
+ "latency" if ttype == "pdr" else "hoststack-latency",
itm["id"],
df,
get_color(idx),
fig_layout["yaxis"]["title"] = \
f"Throughput [{'|'.join(sorted(y_units))}]"
fig_tput.update_layout(fig_layout)
+ if fig_band:
+ fig_band.update_layout(layout.get("plot-trending-bandwidth", dict()))
if fig_lat:
fig_lat.update_layout(layout.get("plot-trending-lat", dict()))
- return fig_tput, fig_lat
+ return fig_tput, fig_band, fig_lat
-def graph_tm_trending(data: pd.DataFrame, layout: dict) -> list:
+def graph_tm_trending(
+ data: pd.DataFrame,
+ layout: dict,
+ all_in_one: bool=False
+ ) -> list:
"""Generates one trending graph per test, each graph includes all selected
metrics.
:param data: Data frame with telemetry data.
:param layout: Layout of plot.ly graph.
+ :param all_in_one: If True, all telemetry traces are placed in one graph,
+ otherwise they are split to separate graphs grouped by test ID.
:type data: pandas.DataFrame
:type layout: dict
+ :type all_in_one: bool
:returns: List of generated graphs together with test names.
list(tuple(plotly.graph_objects.Figure(), str()), tuple(...), ...)
:rtype: list
"""
+ if data.empty:
+ return list()
- def _generate_graph(
+ def _generate_traces(
data: pd.DataFrame,
test: str,
- layout: dict
- ) -> go.Figure:
+ all_in_one: bool,
+ color_index: int
+ ) -> list:
"""Generates a trending graph for given test with all metrics.
:param data: Data frame with telemetry data for the given test.
:param test: The name of the test.
- :param layout: Layout of plot.ly graph.
+ :param all_in_one: If True, all telemetry traces are placed in one
+ graph, otherwise they are split to separate graphs grouped by
+ test ID.
+ :param color_index: The index of the test used if all_in_one is True.
:type data: pandas.DataFrame
:type test: str
- :type layout: dict
- :returns: A trending graph.
- :rtype: plotly.graph_objects.Figure
+ :type all_in_one: bool
+ :type color_index: int
+ :returns: List of traces.
+ :rtype: list
"""
- graph = None
traces = list()
- for idx, metric in enumerate(data.tm_metric.unique()):
+ metrics = data.tm_metric.unique().tolist()
+ for idx, metric in enumerate(metrics):
if "-pdr" in test and "='pdr'" not in metric:
continue
if "-ndr" in test and "='ndr'" not in metric:
hover.append(
f"date: "
f"{row['start_time'].strftime('%Y-%m-%d %H:%M:%S')}<br>"
- f"value: {y_data[i]:,.0f}<br>"
+ f"value: {y_data[i]:,.2f}<br>"
f"{rate}"
f"{row['dut_type']}-ref: {row['dut_version']}<br>"
f"csit-ref: {row['job']}/{row['build']}<br>"
hover_trend.append(
f"date: "
f"{row['start_time'].strftime('%Y-%m-%d %H:%M:%S')}<br>"
- f"trend: {avg:,.0f}<br>"
- f"stdev: {stdev:,.0f}<br>"
+ f"trend: {avg:,.2f}<br>"
+ f"stdev: {stdev:,.2f}<br>"
f"{row['dut_type']}-ref: {row['dut_version']}<br>"
f"csit-ref: {row['job']}/{row['build']}"
)
else:
anomalies = None
- color = get_color(idx)
+ if all_in_one:
+ color = get_color(color_index * len(metrics) + idx)
+ metric_name = f"{test}<br>{metric}"
+ else:
+ color = get_color(idx)
+ metric_name = metric
+
traces.append(
go.Scatter( # Samples
x=x_axis,
y=y_data,
- name=metric,
+ name=metric_name,
mode="markers",
marker={
"size": 5,
text=hover,
hoverinfo="text+name",
showlegend=True,
- legendgroup=metric
+ legendgroup=metric_name
)
)
if anomalies:
go.Scatter( # Trend line
x=x_axis,
y=trend_avg,
- name=metric,
+ name=metric_name,
mode="lines",
line={
"shape": "linear",
text=hover_trend,
hoverinfo="text+name",
showlegend=False,
- legendgroup=metric
+ legendgroup=metric_name
)
)
anomaly_color.append(C.ANOMALY_COLOR[anomaly])
hover_itm = (
f"date: {x_axis[idx].strftime('%Y-%m-%d %H:%M:%S')}"
- f"<br>trend: {trend_avg[idx]:,.0f}"
+ f"<br>trend: {trend_avg[idx]:,.2f}"
f"<br>classification: {anomaly}"
)
hover.append(hover_itm)
text=hover,
hoverinfo="text+name",
showlegend=False,
- legendgroup=metric,
- name=metric,
+ legendgroup=metric_name,
+ name=metric_name,
marker={
"size": 15,
"symbol": "circle-open",
)
)
- if traces:
- graph = go.Figure()
- graph.add_traces(traces)
- graph.update_layout(layout.get("plot-trending-telemetry", dict()))
-
- return graph
-
+ unique_metrics = set()
+ for itm in metrics:
+ unique_metrics.add(itm.split("{", 1)[0])
+ return traces, unique_metrics
tm_trending_graphs = list()
+ graph_layout = layout.get("plot-trending-telemetry", dict())
- if data.empty:
- return tm_trending_graphs
+ if all_in_one:
+ all_traces = list()
- for test in data.test_name.unique():
+ all_metrics = set()
+ all_tests = list()
+ for idx, test in enumerate(data.test_name.unique()):
df = data.loc[(data["test_name"] == test)]
- graph = _generate_graph(df, test, layout)
- if graph:
- tm_trending_graphs.append((graph, test, ))
-
- return tm_trending_graphs
+ traces, metrics = _generate_traces(df, test, all_in_one, idx)
+ if traces:
+ all_metrics.update(metrics)
+ if all_in_one:
+ all_traces.extend(traces)
+ all_tests.append(test)
+ else:
+ graph = go.Figure()
+ graph.add_traces(traces)
+ graph.update_layout(graph_layout)
+ tm_trending_graphs.append((graph, [test, ], ))
+
+ if all_in_one:
+ graph = go.Figure()
+ graph.add_traces(all_traces)
+ graph.update_layout(graph_layout)
+ tm_trending_graphs.append((graph, all_tests, ))
+
+ return tm_trending_graphs, list(all_metrics)