1 # Copyright (c) 2018 Cisco and/or its affiliates.
2 # Licensed under the Apache License, Version 2.0 (the "License");
3 # you may not use this file except in compliance with the License.
4 # You may obtain a copy of the License at:
6 # http://www.apache.org/licenses/LICENSE-2.0
8 # Unless required by applicable law or agreed to in writing, software
9 # distributed under the License is distributed on an "AS IS" BASIS,
10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 # See the License for the specific language governing permissions and
12 # limitations under the License.
14 """Generation of Continuous Performance Trending and Analysis.
21 import plotly.offline as ploff
22 import plotly.graph_objs as plgo
23 import plotly.exceptions as plerr
27 from collections import OrderedDict
28 from utils import find_outliers, archive_input_data, execute_command
31 # Command to build the html format of the report
32 HTML_BUILDER = 'sphinx-build -v -c conf_cpta -a ' \
35 '-D version="Generated on {date}" ' \
39 # .css file for the html format of the report
40 THEME_OVERRIDES = """/* override table width restrictions */
42 max-width: 1200px !important;
46 COLORS = ["SkyBlue", "Olive", "Purple", "Coral", "Indigo", "Pink",
47 "Chocolate", "Brown", "Magenta", "Cyan", "Orange", "Black",
48 "Violet", "Blue", "Yellow"]
51 def generate_cpta(spec, data):
52 """Generate all formats and versions of the Continuous Performance Trending
55 :param spec: Specification read from the specification file.
56 :param data: Full data set.
57 :type spec: Specification
61 logging.info("Generating the Continuous Performance Trending and Analysis "
64 ret_code = _generate_all_charts(spec, data)
66 cmd = HTML_BUILDER.format(
67 date=datetime.date.today().strftime('%d-%b-%Y'),
68 working_dir=spec.environment["paths"]["DIR[WORKING,SRC]"],
69 build_dir=spec.environment["paths"]["DIR[BUILD,HTML]"])
72 with open(spec.environment["paths"]["DIR[CSS_PATCH_FILE]"], "w") as \
74 css_file.write(THEME_OVERRIDES)
76 with open(spec.environment["paths"]["DIR[CSS_PATCH_FILE2]"], "w") as \
78 css_file.write(THEME_OVERRIDES)
80 archive_input_data(spec)
87 def _select_data(in_data, period, fill_missing=False, use_first=False):
88 """Select the data from the full data set. The selection is done by picking
89 the samples depending on the period: period = 1: All, period = 2: every
90 second sample, period = 3: every third sample ...
92 :param in_data: Full set of data.
93 :param period: Sampling period.
94 :param fill_missing: If the chosen sample is missing in the full set, its
95 nearest neighbour is used.
96 :param use_first: Use the first sample even though it is not chosen.
97 :type in_data: OrderedDict
99 :type fill_missing: bool
100 :type use_first: bool
101 :returns: Reduced data.
105 first_idx = min(in_data.keys())
106 last_idx = max(in_data.keys())
111 data_dict[first_idx] = in_data[first_idx]
112 while idx >= first_idx:
113 data = in_data.get(idx, None)
116 threshold = int(round(idx - period / 2)) + 1 - period % 2
117 idx_low = first_idx if threshold < first_idx else threshold
118 threshold = int(round(idx + period / 2))
119 idx_high = last_idx if threshold > last_idx else threshold
125 while flag_l or flag_h:
126 if idx + inc > idx_high:
129 idx_lst.append(idx + inc)
130 if idx - inc < idx_low:
133 idx_lst.append(idx - inc)
137 if i in in_data.keys():
138 data_dict[i] = in_data[i]
141 data_dict[idx] = data
144 return OrderedDict(sorted(data_dict.items(), key=lambda t: t[0]))
147 def _evaluate_results(in_data, trimmed_data, window=10):
148 """Evaluates if the sample value is regress, normal or progress compared to
149 previous data within the window.
150 We use the intervals defined as:
151 - regress: less than median - 3 * stdev
152 - normal: between median - 3 * stdev and median + 3 * stdev
153 - progress: more than median + 3 * stdev
155 :param in_data: Full data set.
156 :param trimmed_data: Full data set without the outliers.
157 :param window: Window size used to calculate moving median and moving stdev.
158 :type in_data: pandas.Series
159 :type trimmed_data: pandas.Series
161 :returns: Evaluated results.
166 win_size = in_data.size if in_data.size < window else window
167 results = [0.0, ] * win_size
168 median = in_data.rolling(window=win_size).median()
169 stdev_t = trimmed_data.rolling(window=win_size, min_periods=2).std()
170 m_vals = median.values
171 s_vals = stdev_t.values
172 d_vals = in_data.values
173 for day in range(win_size, in_data.size):
174 if np.isnan(m_vals[day - 1]) or np.isnan(s_vals[day - 1]):
176 elif d_vals[day] < (m_vals[day - 1] - 3 * s_vals[day - 1]):
178 elif (m_vals[day - 1] - 3 * s_vals[day - 1]) <= d_vals[day] <= \
179 (m_vals[day - 1] + 3 * s_vals[day - 1]):
186 median = np.median(in_data)
187 stdev = np.std(in_data)
188 if in_data.values[-1] < (median - 3 * stdev):
190 elif (median - 3 * stdev) <= in_data.values[-1] <= (
200 def _generate_trending_traces(in_data, build_info, period, moving_win_size=10,
201 fill_missing=True, use_first=False,
202 show_moving_median=True, name="", color=""):
203 """Generate the trending traces:
205 - moving median (trending plot)
206 - outliers, regress, progress
208 :param in_data: Full data set.
209 :param build_info: Information about the builds.
210 :param period: Sampling period.
211 :param moving_win_size: Window size.
212 :param fill_missing: If the chosen sample is missing in the full set, its
213 nearest neighbour is used.
214 :param use_first: Use the first sample even though it is not chosen.
215 :param show_moving_median: Show moving median (trending plot).
216 :param name: Name of the plot
217 :param color: Name of the color for the plot.
218 :type in_data: OrderedDict
219 :type build_info: dict
221 :type moving_win_size: int
222 :type fill_missing: bool
223 :type use_first: bool
224 :type show_moving_median: bool
227 :returns: Generated traces (list) and the evaluated result (float).
228 :rtype: tuple(traces, result)
232 in_data = _select_data(in_data, period,
233 fill_missing=fill_missing,
236 data_x = ["{0}/{1}".format(key, build_info[str(key)][1].split("~")[-1])
237 for key in in_data.keys()]
239 data_x = [key for key in in_data.keys()]
240 data_y = [val for val in in_data.values()]
241 data_pd = pd.Series(data_y, index=data_x)
243 t_data, outliers = find_outliers(data_pd)
245 results = _evaluate_results(data_pd, t_data, window=moving_win_size)
247 anomalies = pd.Series()
248 anomalies_res = list()
249 for idx, item in enumerate(in_data.items()):
250 item_pd = pd.Series([item[1], ],
253 build_info[str(item[0])][1].split("~")[-1]), ])
254 if item[0] in outliers.keys():
255 anomalies = anomalies.append(item_pd)
256 anomalies_res.append(0.0)
257 elif results[idx] in (0.33, 1.0):
258 anomalies = anomalies.append(item_pd)
259 anomalies_res.append(results[idx])
260 anomalies_res.extend([0.0, 0.33, 0.66, 1.0])
263 color_scale = [[0.00, "grey"],
272 trace_samples = plgo.Scatter(
279 name="{name}-thput".format(name=name),
286 traces = [trace_samples, ]
288 trace_anomalies = plgo.Scatter(
295 name="{name}: outliers".format(name=name),
298 "symbol": "circle-open",
299 "color": anomalies_res,
300 "colorscale": color_scale,
308 "title": "Circles Marking Data Classification",
309 "titleside": 'right',
314 "tickvals": [0.125, 0.375, 0.625, 0.875],
315 "ticktext": ["Outlier", "Regression", "Normal", "Progression"],
323 traces.append(trace_anomalies)
325 if show_moving_median:
326 data_mean_y = pd.Series(data_y).rolling(
327 window=moving_win_size, min_periods=2).median()
328 trace_median = plgo.Scatter(
337 name='{name}-trend'.format(name=name)
339 traces.append(trace_median)
341 return traces, results[-1]
344 def _generate_chart(traces, layout, file_name):
345 """Generates the whole chart using pre-generated traces.
347 :param traces: Traces for the chart.
348 :param layout: Layout of the chart.
349 :param file_name: File name for the generated chart.
356 logging.info(" Writing the file '{0}' ...".format(file_name))
357 plpl = plgo.Figure(data=traces, layout=layout)
359 ploff.plot(plpl, show_link=False, auto_open=False, filename=file_name)
360 except plerr.PlotlyEmptyDataError:
361 logging.warning(" No data for the plot. Skipped.")
364 def _generate_all_charts(spec, input_data):
365 """Generate all charts specified in the specification file.
367 :param spec: Specification.
368 :param input_data: Full data set.
369 :type spec: Specification
370 :type input_data: InputData
373 job_name = spec.cpta["data"].keys()[0]
376 for build in spec.input["builds"][job_name]:
377 status = build["status"]
378 if status != "failed" and status != "not found":
379 builds_lst.append(str(build["build"]))
381 # Get "build ID": "date" dict:
383 for build in builds_lst:
385 build_info[build] = (
386 input_data.metadata(job_name, build)["generated"][:14],
387 input_data.metadata(job_name, build)["version"]
394 header = "Build Number:," + ",".join(builds_lst) + '\n'
395 csv_table.append(header)
396 build_dates = [x[0] for x in build_info.values()]
397 header = "Build Date:," + ",".join(build_dates) + '\n'
398 csv_table.append(header)
399 vpp_versions = [x[1] for x in build_info.values()]
400 header = "VPP Version:," + ",".join(vpp_versions) + '\n'
401 csv_table.append(header)
404 for chart in spec.cpta["plots"]:
405 logging.info(" Generating the chart '{0}' ...".
406 format(chart.get("title", "")))
409 data = input_data.filter_data(chart, continue_on_error=True)
411 logging.error("No data.")
416 for idx, build in job.items():
417 for test_name, test in build.items():
418 if chart_data.get(test_name, None) is None:
419 chart_data[test_name] = OrderedDict()
421 chart_data[test_name][int(idx)] = \
422 test["result"]["throughput"]
423 except (KeyError, TypeError):
426 # Add items to the csv table:
427 for tst_name, tst_data in chart_data.items():
429 for build in builds_lst:
430 item = tst_data.get(int(build), '')
431 tst_lst.append(str(item) if item else '')
432 csv_table.append("{0},".format(tst_name) + ",".join(tst_lst) + '\n')
434 for period in chart["periods"]:
437 win_size = 10 if period == 1 else 5 if period < 20 else 3
439 for test_name, test_data in chart_data.items():
441 logging.warning("No data for the test '{0}'".
444 test_name = test_name.split('.')[-1]
445 trace, result = _generate_trending_traces(
447 build_info=build_info,
449 moving_win_size=win_size,
452 name='-'.join(test_name.split('-')[3:-1]),
455 results.append(result)
458 # Generate the chart:
459 chart["layout"]["xaxis"]["title"] = \
460 chart["layout"]["xaxis"]["title"].format(job=job_name)
461 _generate_chart(traces,
463 file_name="{0}-{1}-{2}{3}".format(
464 spec.cpta["output-file"],
465 chart["output-file-name"],
467 spec.cpta["output-file-type"]))
469 logging.info(" Done.")
472 file_name = spec.cpta["output-file"] + "-trending"
473 with open("{0}.csv".format(file_name), 'w') as file_handler:
474 file_handler.writelines(csv_table)
477 with open("{0}.csv".format(file_name), 'rb') as csv_file:
478 csv_content = csv.reader(csv_file, delimiter=',', quotechar='"')
480 for row in csv_content:
481 if txt_table is None:
482 txt_table = prettytable.PrettyTable(row)
485 for idx, item in enumerate(row):
487 row[idx] = str(round(float(item) / 1000000, 2))
490 txt_table.add_row(row)
492 txt_table.align["Build Number:"] = "l"
493 with open("{0}.txt".format(file_name), "w") as txt_file:
494 txt_file.write(str(txt_table))
502 if item == 0.66 and result == "PASS":
504 elif item == 0.33 or item == 0.0:
507 logging.info("Partial results: {0}".format(results))
508 logging.info("Result: {0}".format(result))