csit/scripts/push_to_elk.py

   1 #!/usr/bin/python
   2 # -*- coding: utf-8 -*-
   3
   4 # @License EPL-1.0 <http://spdx.org/licenses/EPL-1.0>
   5 ##############################################################################
   6 # Copyright (c) 2017 Raghuram Vadapalli, Jaspreet Singh and others.
   7 #
   8 # All rights reserved. This program and the accompanying materials
   9 # are made available under the terms of the Eclipse Public License v1.0
  10 # which accompanies this distribution, and is available at
  11 # http://www.eclipse.org/legal/epl-v10.html
  12 ##############################################################################
  13
  14 """
  15 This script is used to parse logs, construct JSON BODY and push
  16 it to ELK DB.
  17
  18 Usage: python construct_json.py host:port
  19
  20 JSON body similar to following is constructed from robot files, jenkins environment
  21 and plot files available in workspace available post-build.
  22 {
  23     "project": "opendaylight", <- fix string for ODL project
  24     "subject": "test", <- fix string for ODL test
  25     "test-type": "performance", <- if there are csv files, otherwise "functional"
  26     "jenkins-silo": "releng" <- from Jenkins $SILO
  27     "test-name": "openflowplugin-csit-1node-periodic-bulkomatic-perf-daily-only-carbon", <- from Jenkins $JOB_NAME
  28     "test-run": 289, <- from Jenkins $BUILD_NUMBER
  29     "start-time": "20170612 16:50:04 GMT-07:00",  <- from robot log
  30     "duration": "00:01:05.942", <- from robot log
  31     "pass-tests": 9, <- from robot log
  32     "fail-tests": 0, <- from robot log
  33     "plots": {
  34         "rate": { <- csv filename
  35             "Config DS": 5816.99726601, <- from csv file
  36             "OVS Switch": 5757.05238918, <- from csv file
  37             "Operational DS": 2654.49139945 <- from csv file
  38         },
  39         "time": { <- csv filename
  40             "Config DS": 17.191, <- from csv file
  41             "OVS Switch": 17.37, <- from csv file
  42             "Operational DS": 37.672 <- from csv file
  43         }
  44     }
  45 }
  46 """
  47
  48 # stdlib
  49 from datetime import datetime
  50 import glob
  51 import json
  52 import os
  53 import requests
  54 import sys
  55 import time
  56 import xml.etree.ElementTree as ET
  57
  58 # 3rd party lib
  59 import yaml
  60
  61 # ELK DB host and port to be passed as ':' separated argument
  62
  63 if len(sys.argv) > 1:
  64     if ':' in sys.argv[1]:
  65         ELK_DB_HOST = sys.argv[1].split(':')[0]
  66         ELK_DB_PORT = sys.argv[1].split(':')[1]
  67 else:
  68     print('Usage: python push_to_elk.py host:port')
  69     print('Unable to publish data to ELK. Exiting.')
  70     sys.exit()
  71
  72 # Construct json body
  73
  74 BODY = {}
  75
  76 ts = time.time()
  77 formatted_ts = \
  78     datetime.fromtimestamp(ts).strftime('%Y-%m-%dT%H:%M:%S.%fZ')
  79 BODY['@timestamp'] = formatted_ts
  80
  81 # Plots are obtained from csv files (present in archives directory in $WORKSPACE).
  82
  83 csv_files = glob.glob('archives/*.csv')
  84 BODY['project'] = 'opendaylight'
  85 BODY['subject'] = 'test'
  86
  87 # If there are no csv files, then it is a functional test.
  88 # Parse csv files and fill perfomance parameter values
  89
  90 if len(csv_files) == 0:
  91     BODY['test-type'] = 'functional'
  92 else:
  93     BODY['test-type'] = 'performance'
  94     BODY['plots'] = {}
  95     for f in csv_files:
  96         key = (f.split('/')[-1])[:-4]
  97         BODY['plots'][key] = {}
  98         lines = open(f).readlines()
  99         props = lines[0].strip().split(',')
 100         vals = lines[1].strip().split(',')
 101         BODY['plots'][key][props[0]] = float(vals[0])
 102         BODY['plots'][key][props[1]] = float(vals[1])
 103         BODY['plots'][key][props[2]] = float(vals[2])
 104
 105 # Fill the required parameters whose values are obtained from environment.
 106
 107 BODY['jenkins-silo'] = os.environ['SILO']
 108 BODY['test-name'] = os.environ['JOB_NAME']
 109 BODY['test-run'] = os.environ['BUILD_NUMBER']
 110
 111 # Parsing robot log for statistics on no of start-time, pass/fail tests and duration.
 112
 113 robot_log = os.environ['WORKSPACE'] + '/output.xml'
 114 tree = ET.parse(robot_log)
 115 BODY['id'] = '{}-{}'.format(os.environ['JOB_NAME'],
 116                             os.environ['BUILD_NUMBER'])
 117 BODY['start-time'] = tree.getroot().attrib['generated']
 118 BODY['pass-tests'] = tree.getroot().find('statistics')[0][1].get('pass')
 119 BODY['fail-tests'] = tree.getroot().find('statistics')[0][1].get('fail')
 120 endtime = tree.getroot().find('suite').find('status').get('endtime')
 121 starttime = tree.getroot().find('suite').find('status').get('starttime')
 122 elap_time = datetime.strptime(endtime, '%Y%m%d %H:%M:%S.%f') \
 123     - datetime.strptime(starttime, '%Y%m%d %H:%M:%S.%f')
 124 BODY['duration'] = str(elap_time)
 125
 126 # Parse JSON BODY to construct PUT_URL
 127
 128 PUT_URL_INDEX = '/{}-{}'.format(BODY['project'], BODY['subject'])
 129 PUT_URL_TYPE = '/{}'.format(BODY['test-type'])
 130 PUT_URL_ID = '/{}-{}'.format(BODY['test-name'], BODY['test-run'])
 131 PUT_URL = 'https://{}:{}{}{}{}'.format(ELK_DB_HOST, ELK_DB_PORT, PUT_URL_INDEX, PUT_URL_TYPE, PUT_URL_ID)
 132 print(PUT_URL)
 133
 134 print(json.dumps(BODY, indent=4))
 135
 136 # Try to send request to ELK DB.
 137
 138 try:
 139     r = requests.put(PUT_URL, json=BODY)
 140     print(r.status_code)
 141     print(json.dumps(json.loads(r.content), indent=4))
 142 except:
 143     print('Unable to push data to ElasticSearch')
 144
 145
 146 # Function to convert JSON object to string.
 147 # Python puts 'true' as 'True' etc. which need handling.
 148
 149 def JSONToString(jobj):
 150     retval = str(jobj)
 151     retval = retval.replace('\'', '"')
 152     retval = retval.replace(': ', ':')
 153     retval = retval.replace(', ', ',')
 154     retval = retval.replace('True', 'true')
 155     retval = retval.replace('False', 'false')
 156     retval = retval.replace('None', 'null')
 157     return retval
 158
 159
 160 # This function takes
 161 # testname (string, eg: 'openflowplugin-csit-1node-periodic-bulkomatic-perf-daily-only-carbon'),
 162 # fieldlist (list of fields, eg: ['pass-tests', 'failed-tests']),
 163 # plotkey (string, eg: 'rate')
 164 # as parameters and constructs a visualization object in JSON format
 165
 166 def getVisualization(testname, fieldlist, plotkey=''):
 167     vis = {}
 168     vis['title'] = testname
 169     if plotkey != '':
 170         vis['title'] += '-' + plotkey
 171     vis['description'] = 'visualization of ' + plotkey \
 172         + ' trends for testplan ' + testname
 173     vis['version'] = 1
 174     vis['kibanaSavedObjectMeta'] = {'searchSourceJSON': ''}
 175     searchSourceJSON = {
 176         'index': 'opendaylight-test',
 177         'query': {
 178             'query_string': {
 179                 'analyze_wildcard': True,
 180                 'query': '*'
 181             }
 182         },
 183         'filter': [{
 184             'meta': {
 185                 'index': 'opendaylight-test',
 186                 'negate': False,
 187                 'disabled': False,
 188                 'alias': None,
 189                 'type': 'phrase',
 190                 'key': 'test-name',
 191                 'value': testname,
 192             },
 193             'query': {
 194                 'match': {
 195                     'test-name': {
 196                         'query': testname,
 197                         'type': 'phrase'
 198                     }
 199                 }
 200             },
 201             '$state': {
 202                 'store': 'appState'
 203             }
 204         }]
 205     }
 206
 207     vis['kibanaSavedObjectMeta']['searchSourceJSON'] = \
 208         JSONToString(searchSourceJSON)
 209     vis['uiStateJSON'] = '{"vis":{"legendOpen":true, "colors":{"pass-tests":"#7EB26D","failed-tests":"#E24D42"}}}'
 210     visState = {
 211         'title': vis['title'],
 212         'type': 'area',
 213         'params': {
 214             'addLegend': True,
 215             'addTimeMarker': False,
 216             'addTooltip': True,
 217             'times': [],
 218             'grid': {
 219                 'categoryLines': False,
 220                 'style': {
 221                     'color': '#eee'
 222                 }
 223             },
 224             'legendPosition': 'right',
 225             'seriesParams': [],
 226             'categoryAxes': [{
 227                 'id': 'CategoryAxis-1',
 228                 'labels': {'show': True, 'truncate': 100},
 229                 'position': 'bottom',
 230                 'scale': {'type': 'linear'},
 231                 'show': True,
 232                 'style': {},
 233                 'title': {'text': 'Test run number'},
 234                 'type': 'category',
 235             }],
 236             'valueAxes': [{
 237                 'id': 'ValueAxis-1',
 238                 'labels': {
 239                     'filter': False,
 240                     'rotate': 0,
 241                     'show': True,
 242                     'truncate': 100,
 243                 },
 244                 'name': 'LeftAxis-1',
 245                 'position': 'left',
 246                 'scale': {'mode': 'normal', 'type': 'linear'},
 247                 'show': True,
 248                 'style': {},
 249                 'title': {'text': ''},
 250                 'type': 'value',
 251             }],
 252         },
 253         'aggs': [{
 254             'id': '2',
 255             'enabled': True,
 256             'type': 'histogram',
 257             'schema': 'segment',
 258             'params': {
 259                 'field': 'test-run',
 260                 'interval': 1,
 261                 'extended_bounds': {},
 262                 'customLabel': 'Test run number',
 263             },
 264         }],
 265         'listeners': {},
 266     }
 267     if plotkey != '':  # Performance plot
 268         visState['type'] = 'line'
 269     for field in fieldlist:
 270         seriesParam = {
 271             'show': True,
 272             'mode': 'normal',
 273             'type': 'area',
 274             'drawLinesBetweenPoints': True,
 275             'showCircles': True,
 276             'interpolate': 'linear',
 277             'lineWidth': 2,
 278             'data': {
 279                 'id': str(len(visState['params']['seriesParams']) + 1) + '-' + vis['title'],
 280                 'label': field.split('.')[-1]
 281             },
 282             'valueAxis': 'ValueAxis-1',
 283         }
 284         if plotkey != '':  # Performance plot
 285             seriesParam['type'] = 'line'
 286         agg = {
 287             'id': str(len(visState['params']['seriesParams']) + 1) + '-' + vis['title'],
 288             'enabled': True,
 289             'type': 'sum',
 290             'schema': 'metric',
 291             'params': {
 292                 'field': field,
 293                 'customLabel': field.split('.')[-1]
 294             },
 295         }
 296
 297         visState['params']['seriesParams'].append(seriesParam)
 298         visState['aggs'].append(agg)
 299
 300     vis['visState'] = JSONToString(visState)
 301     return vis
 302
 303
 304 vis_ids = []
 305 if BODY['test-type'] == 'performance':
 306
 307     # Create visualizations for performance tests
 308     # One visualization for one plot
 309
 310     for key in BODY['plots']:
 311         fieldlist = []
 312         for subkey in BODY['plots'][key]:
 313             fieldlist.append('plots.' + key + '.' + subkey)
 314         vis = getVisualization(BODY['test-name'], fieldlist, key)
 315         vis_ids.append(BODY['test-name'] + '-' + key)
 316         PUT_URL = \
 317             'https://{}:{}/.kibana/visualization/{}-{}'.format(ELK_DB_HOST, ELK_DB_PORT, BODY['test-name'], key)
 318         print(PUT_URL)
 319         print(json.dumps(vis, indent=4))
 320         try:
 321             r = requests.put(PUT_URL, json=vis)
 322             print(r.status_code)
 323             print(json.dumps(json.loads(r.content), indent=4))
 324         except:
 325             print('Unable to push visualization to Kibana')
 326
 327 vis = getVisualization(BODY['test-name'],
 328                        ['pass-tests', 'failed-tests'])
 329 vis_ids.append(BODY['test-name'])
 330 PUT_URL = 'https://{}:{}/.kibana/visualization/{}'.format(ELK_DB_HOST, ELK_DB_PORT, BODY['test-name'])
 331 print(PUT_URL)
 332 print(json.dumps(vis, indent=4))
 333 try:
 334     r = requests.put(PUT_URL, json=vis)
 335     print(r.status_code)
 336     print(json.dumps(json.loads(r.content), indent=4))
 337 except:
 338     print('Unable to push dashboard to Kibana')
 339
 340 # Create dashboard and add above created visualizations to it
 341
 342 DASHBOARD_NAME = BODY['test-name'].split('-')[0]
 343 dashboard = {}
 344 dashboard['title'] = DASHBOARD_NAME
 345 dashboard['description'] = 'Dashboard for visualizing ' \
 346     + DASHBOARD_NAME
 347 dashboard['uiStateJSON'] = '{}'
 348 dashboard['optionsJSON'] = '{"darkTheme":false}'
 349 dashboard['version'] = 1
 350 dashboard['timeRestore'] = False
 351 dashboard['kibanaSavedObjectMeta'] = {
 352     'searchSourceJSON': '{"filter":[{"query":{"query_string":{"query":"*","analyze_wildcard":true}}}],'
 353     '"highlightAll":true,"version":true}'
 354 }
 355
 356 # Check if visualizations already present in dashboard. If present, don't add, else, add at end
 357
 358 GET_URL = 'https://{}:{}/.kibana/dashboard/{}'.format(ELK_DB_HOST, ELK_DB_PORT, DASHBOARD_NAME)
 359 r = requests.get(GET_URL)
 360 response = json.loads(r.content)
 361 dashboard_found = response['found']
 362 vis_ids_present = set()
 363 panelsJSON = []
 364
 365 print json.dumps(response, indent=4)
 366 if dashboard_found:
 367     panelsJSON = yaml.safe_load(response['_source']['panelsJSON'])
 368     for vis in panelsJSON:
 369         vis_ids_present.add(vis['id'])
 370
 371 size_x = 6
 372 size_y = 3
 373 xpos = (len(vis_ids_present) % 2) * 6 + 1
 374 ypos = (len(vis_ids_present) / 2) * 3 + 1
 375 for (i, vis_id) in enumerate(vis_ids):
 376     if (not dashboard_found or vis_id not in vis_ids_present):
 377         panelJSON = {
 378             'size_x': size_x,
 379             'size_y': size_y,
 380             'panelIndex': len(vis_ids_present) + i,
 381             'type': 'visualization',
 382             'id': vis_id,
 383             'col': xpos,
 384             'row': ypos,
 385         }
 386         xpos += size_x
 387         if xpos > 12:
 388             xpos = 1
 389             ypos += size_y
 390         panelsJSON.append(panelJSON)
 391     else:
 392         print('visualization ' + vis_id + ' already present in dashboard')
 393
 394 dashboard['panelsJSON'] = JSONToString(panelsJSON)
 395 PUT_URL = 'https://{}:{}/.kibana/dashboard/{}'.format(ELK_DB_HOST, ELK_DB_PORT, DASHBOARD_NAME)
 396 print(PUT_URL)
 397 print(json.dumps(dashboard, indent=4))
 398 r = requests.put(PUT_URL, json=dashboard)
 399 print(r.status_code)
 400 print(json.dumps(json.loads(r.content), indent=4))