wmglobalqueue 2.3.10__py3-none-any.whl

WMCore/Services/LogDB/LogDBBackend.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python
+"""
+LogDBBackend
+
+Interface to LogDB persistent storage
+"""
+
+from builtins import object, bytes
+
+from Utils.PythonVersion import PY3
+from Utils.Utilities import encodeUnicodeToBytes, encodeUnicodeToBytesConditional
+
+# system modules
+import datetime
+import hashlib
+import time
+
+# WMCore modules
+from WMCore.Database.CMSCouch import CouchServer, CouchNotFoundError
+from WMCore.Services.LogDB.LogDBExceptions import LogDBError
+
+# define full list of supported LogDB types
+LOGDB_MSG_TYPES = ['info', 'error', 'warning', 'comment']
+
+def gen_hash(key):
+    "Generate hash for given key"
+    key = encodeUnicodeToBytes(key)  # if key is not unicode, then it is not changed
+    if not isinstance(key, bytes):
+        raise NotImplementedError
+    keyhash = hashlib.md5()
+    keyhash.update(encodeUnicodeToBytesConditional(key, condition=PY3))
+    return keyhash.hexdigest()
+
+def tstamp():
+    "Return timestamp with microseconds"
+    now = datetime.datetime.now()
+    base = str(time.mktime(now.timetuple())).split('.')[0]
+    ctime = '%s.%s' % (base, now.microsecond)
+    return float(ctime)
+
+def clean_entry(doc):
+    """Clean document from CouchDB attributes"""
+    for attr in ['_rev', '_id']:
+        if  attr in doc:
+            del doc[attr]
+    return doc
+
+class LogDBBackend(object):
+    """
+    Represents persistent storage for LogDB
+    """
+    def __init__(self, db_url, db_name, identifier, thread_name, **kwds):
+        self.db_url = db_url
+        self.server = CouchServer(db_url)
+        self.db_name = db_name
+        self.dbid = identifier
+        self.thread_name = thread_name
+        self.agent = kwds.get('agent', 0)
+        self.db = self.server.connectDatabase(db_name, create=False)
+        self.design = 'LogDB' # name of design document
+        self.view = 'requests' # name of view to look-up requests
+        self.tsview = 'tstamp' # name of tsview to look-up requests
+        self.threadview = 'logByRequestAndThread'
+        self.requestview = 'logByRequest'
+
+    def deleteDatabase(self):
+        """Delete back-end database"""
+        if  self.db_name in self.server.listDatabases():
+            self.server.deleteDatabase(self.db_name)
+
+    def check(self, request, mtype=None):
+        """Check that given request name is valid"""
+        # TODO: we may add some logic to check request name, etc.
+        if  not request:
+            raise LogDBError("Request name is empty")
+        if  mtype and mtype not in LOGDB_MSG_TYPES:
+            raise LogDBError("Unsupported message type: '%s', supported types %s" \
+                    % (mtype, LOGDB_MSG_TYPES))
+
+    def docid(self, request, mtype):
+        """Generate doc id, we use double dash to avoid dashes from thread names"""
+        return gen_hash('--'.join((request, self.dbid, self.thread_name, mtype)))
+
+    def prefix(self, mtype):
+        """Generate agent specific prefix for given message type"""
+        if  self.agent:
+            # we add prefix for agent messages, all others will not have this index
+            mtype = 'agent-%s' % mtype
+        return mtype
+
+    def agent_update(self, request, msg='', mtype="info"):
+        """Update agent info in LogDB for given request"""
+        self.check(request, mtype)
+        mtype = self.prefix(mtype)
+        rec = {"ts":tstamp(), "msg":msg}
+        doc = {"_id": self.docid(request, mtype), "messages": [rec],
+                "request":request, "identifier":self.dbid,
+                "thr":self.thread_name, "type":mtype}
+        try:
+            exist_doc = self.db.document(doc["_id"])
+            doc["_rev"] = exist_doc["_rev"]
+        except CouchNotFoundError:
+            # this means document is not exist so we will just insert
+            pass
+        finally:
+            res = self.db.commitOne(doc)
+        return res
+
+    def user_update(self, request, msg, mtype='comment'):
+        """Update user info in LogDB for given request"""
+        rec = {"ts":tstamp(), "msg":msg}
+        doc = {"_id": self.docid(request, mtype), "messages": [rec],
+                "request":request, "identifier":self.dbid,
+                "thr":self.thread_name, "type":mtype}
+        try:
+            exist_doc = self.db.document(doc["_id"])
+            doc["_rev"] = exist_doc["_rev"]
+            doc["messages"] += exist_doc["messages"]
+        except CouchNotFoundError:
+            # this means document is not exist so we will just insert
+            pass
+        finally:
+            res = self.db.commitOne(doc)
+        return res
+
+    def get(self, request, mtype=None, detail=True, agent=True):
+        """Retrieve all entries from LogDB for given request"""
+        self.check(request, mtype)
+        if agent and mtype:
+            mtype = self.prefix(mtype)
+        options = {'reduce':False}
+        if mtype:
+            keys = [[request, mtype]]
+        else:
+            keys=[]
+            options.update({'startkey': [request], 'endkey':[request, {}]})
+        if detail:
+            options.update({'include_docs': True})
+        docs = self.db.loadView(self.design, self.view, options, keys=keys)
+        return docs
+
+    def get_by_thread(self, request, mtype='error', detail=False, agent=True):
+        self.check(request, mtype)
+        if agent and mtype:
+            mtype = self.prefix(mtype)
+        keys = [[request, self.dbid, self.thread_name, mtype]]
+        options = {'reduce':False}
+        if detail:
+            options.update({'include_docs': True})
+        docs = self.db.loadView(self.design, self.threadview, options, keys)
+        return docs
+
+    def get_by_request(self, request):
+        keys = [request]
+        options = {'reduce':False}
+        docs = self.db.loadView(self.design, self.requestview, options, keys)
+        return docs
+
+    def get_all_requests(self):
+        """Retrieve all entries from LogDB"""
+        options = {'reduce':True, 'group_level':1}
+        docs = self.db.loadView(self.design, self.view, options)
+        return docs
+
+    def delete(self, request, mtype=None, this_thread=False, agent=True):
+        """Delete entry in LogDB for given request"""
+        if mtype:
+            self.check(request, mtype)
+        else:
+            self.check(request)
+        if this_thread:
+            docs = self.get_by_thread(request, mtype=mtype, detail=False, agent=agent)
+        else:
+            docs = self.get(request, mtype=mtype, detail=False, agent=agent)
+        ids = [r['id'] for r in docs.get('rows', [])]
+        res = self.db.bulkDeleteByIDs(ids)
+        return res
+
+    def cleanup(self, thr):
+        """
+        Clean-up docs older then given threshold (thr should be specified in seconds).
+        This is done via tstamp view end endkey, e.g.
+        curl "http://127.0.0.1:5984/logdb/_design/LogDB/_view/tstamp?endkey=1427912282"
+        """
+        cutoff = int(round(time.time()-thr))
+        #docs = self.db.allDocs() # may need another view to look-up old docs
+        spec = {'endkey':cutoff, 'reduce':False}
+        docs = self.db.loadView(self.design, self.tsview, spec)
+        ids = [d['id'] for d in docs.get('rows', [])]
+        self.db.bulkDeleteByIDs(ids)
+        return ids

WMCore/Services/LogDB/LogDBExceptions.py

@@ -0,0 +1,11 @@
+"""LogDB Exceptions"""
+
+class LogDBError(Exception):
+    """Standard error baseclass"""
+    def __init__(self, error):
+        Exception.__init__(self, error)
+        self.msg = LogDBError.__class__.__name__
+        self.error = error
+
+    def __str__(self):
+        return "%s: %s" % (self.msg, self.error)

WMCore/Services/LogDB/LogDBReport.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+#-*- coding: utf-8 -*-
+#pylint: disable=
+"""
+File       : LogDBReport.py
+Author     : Valentin Kuznetsov <vkuznet AT gmail dot com>
+Description: LogDB report class to represent LogDB messages
+"""
+from __future__ import print_function
+
+from builtins import range
+from builtins import object
+
+class LogDBReport(object):
+    """LogDBReport class to represent LogDB messages"""
+    def __init__(self, logdb):
+        self.logdb = logdb
+
+    def docs(self, request):
+        """Fetch LogDB messages for given request"""
+        if  request == 'all':
+            docs = self.logdb.get_all_requests()
+        else:
+            docs = self.logdb.get(request)
+        return docs
+
+    def orderby(self, docs, order):
+        """Order LogDB messages by given type"""
+        odict = {}
+        for item in docs:
+            odict[item['ts']] = item
+        keys = sorted(odict.keys())
+        keys.reverse()
+        out = []
+        for key in keys:
+            out.append(odict[key])
+        return out
+
+    def to_json(self, request, order='ts'):
+        """Represent given messages in JSON data-format for given set of requests"""
+        docs = self.orderby(self.docs(request), order)
+        return docs
+
+    def to_txt(self, request, order='ts', sep=' '):
+        """Represent given messages in ASCII text format for given set of requests"""
+        docs = self.orderby(self.docs(request), order)
+        keys = list(docs[0])
+        out = sep.join(keys) + '\n'
+        for doc in docs:
+            values = []
+            for key in keys:
+                values.append('%s' % doc[key])
+            out += sep.join(values) + '\n'
+        return out
+
+    def to_html(self, request, order='ts'):
+        """Represent given messages in ASCII text format for given set of requests"""
+        out = '<table id="logdb-report">\n'
+        for doc in self.to_txt(request, order, sep='</td><td>').split('\n'):
+            if  doc:
+                out += '<tr><td>'+doc+'</td></tr>\n'
+        out += '</table>'
+        return out
+
+    def to_stdout(self, request, order='ts'):
+        """Yield to stdout LogDB messages for given request/type"""
+        msg = '\nReport for %s' % request
+        print(msg, '\n', '-'*len(msg))
+        docs = self.orderby(self.docs(request), order)
+        times = []
+        messages = []
+        mtypes = []
+        for doc in docs:
+            times.append(str(doc['ts']))
+            messages.append(doc['msg'])
+            mtypes.append(doc['type'])
+        tstpad = max([len(t) for t in times])
+        msgpad = max([len(m) for m in messages])
+        mtppad = max([len(m) for m in mtypes])
+        out = []
+        for idx in range(len(times)):
+            tcol = '%s%s' % (times[idx], ' '*(tstpad-len(times[idx])))
+            mcol = '%s%s' % (messages[idx], ' '*(msgpad-len(messages[idx])))
+            ecol = '%s%s' % (mtypes[idx], ' '*(mtppad-len(mtypes[idx])))
+            print("%s %s %s" % (tcol, mcol, ecol))

WMCore/Services/MSUtils/MSUtils.py

@@ -0,0 +1,54 @@
+"""
+This module contains a few basic WMCore-related utilitarian functions
+"""
+
+from Utils.CertTools import ckey, cert
+
+from WMCore.Services.pycurl_manager import RequestHandler
+
+
+def makeHttpRequest(srvUrl, payload=None, method='GET', headers=None, encode=True, decode=True, payloadSizeToDump=50):
+    """
+    Perform HTTP call to provided service URL. This can be any of supported methods like
+    GET, POST, PUT, DELETE. It will return HTTP response from upstream MicroService
+    and parse it accordingly (the WMCore MS service returns results as {'result': {'data':...}}
+    HTTP response.
+
+    :param srvUrl: string with the service url
+    :param payload: payload query or document, in case of GET HTTP request it is query dictionary,
+        in case of POST/PUT HTTP requests it is JSON payload to the service
+    :param method: string, defines which HTTP method to use
+    :param headers: HTTP headers (presented as dictionarY)
+    :param encode: boolean to reflect if data should be encoded, see pycurl_manager.py
+    :param decode: boolean to reflect if data should be decoded, see pycurl_manager.py
+    :param payloadSizeToDump: amount of characters to dump in a log from payload (to make log entries readable)
+    :return: returns a list with all objects, or raises
+        an exception in case of failure
+    """
+    payload = payload or {}
+    mgr = RequestHandler()
+    headers = headers or {'Content-Type': 'application/json'}
+    data = mgr.getdata(srvUrl, payload, headers, verb=method,
+                       ckey=ckey(), cert=cert(), encode=encode, decode=decode)
+    if data and data.get("result", []):
+        if "error" in data["result"][0]:
+            # strip off part of payload to make readable log message
+            sdata = f"{payload}"
+            if len(sdata) > payloadSizeToDump:
+                sdata = sdata[:payloadSizeToDump] + "..."
+            msg = f"Failed to contact {srvUrl} via {method} request with {sdata}"
+            msg += f" and error message: {data}"
+            raise RuntimeError(msg)
+    return data["result"]
+
+def getPileupDocs(mspileupUrl, queryDict=None, method='GET'):
+    """
+    Fetch documents from MSPileup according to the query passed in using POST.
+
+    :param mspileupUrl: string with the MSPileup url
+    :param queryDict: dictionary with the MongoDB query to run
+    :param method: string, defines which HTTP method to use
+    :return: returns a list with all the pileup objects, or raises
+        an exception in case of failure
+    """
+    return makeHttpRequest(mspileupUrl, payload=queryDict, method=method)

WMCore/Services/McM/McM.py

@@ -0,0 +1,173 @@
+#! /bin/env python
+
+"""
+A service class for retrieving data from McM using
+an SSO cookie since it sits behind CERN SSO
+"""
+
+from builtins import str, object
+import json
+import os
+import pycurl
+import subprocess
+import logging
+from typing import List
+from io import BytesIO
+from WMCore.WMException import WMException
+
+
+class McMNoDataError(WMException):
+    """
+    _McMNoDataError_
+        McM responded but has no data for the request
+    """
+
+    def __init__(self):
+        WMException.__init__(self, 'McM responded correctly but has no data')
+
+
+class McM(object):
+    """
+    A service class for retrieving data from McM using
+    an SSO cookie since it sits behind CERN SSO
+    'key' must be unencrypted
+    """
+
+    def __init__(self, url='https://cms-pdmv.cern.ch/mcm', tmpDir='/tmp'):
+        self.url = url
+        self.tmpDir = tmpDir
+        self.logger = self._get_logger()
+        self.cookieFile = None
+
+    def __enter__(self):
+        self._krb_ticket()
+        self._get_cookie()
+        return self
+
+    def __exit__(self, exception_type, exception_value, traceback):
+        if self.cookieFile:
+            try:
+                os.remove(self.cookieFile)
+            except OSError:
+                return
+        return
+
+    def _get_logger(self) -> logging.Logger:
+        """
+        Create a logger for McM client
+        """
+        logger: logging.Logger = logging.getLogger("mcm_client")
+        date_format: str = "%Y-%m-%d %H:%M:%S %z"
+        format: str = "[%(levelname)s][%(name)s][%(asctime)s]: %(message)s"
+        formatter: logging.Formatter = logging.Formatter(fmt=format, datefmt=date_format)
+        handler: logging.StreamHandler = logging.StreamHandler()
+
+        handler.setLevel(logging.INFO)
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+        return logger
+
+    def _krb_ticket(self) -> None:
+        """
+        Check there is a valid Kerberos ticket for requesting a SSO
+        cookie. Raise a RuntimeError if there is not one.
+        """
+        process = subprocess.Popen(["klist", "-f"],
+                                   stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=False)
+        stdout: str = process.communicate()[0].decode("utf-8")
+        if process.returncode != 0:
+            msg: str = ("There is no valid Kerberos ticket for requesting a SSO cookie. "
+                        "Please make sure to provide one for your runtime environment"
+                        )
+            self.logger.error(msg)
+            raise RuntimeError("FATAL -- %s\nError msg: %s" % (msg, stdout))
+
+    def _get_cookie(self) -> None:
+        """
+        Request a SSO cookie to authenticate to McM.
+        """
+        self.cookieFile = os.path.join(self.tmpDir, 'ssoCookie.txt')
+        command: List[str] = ["auth-get-sso-cookie", "-u", self.url, "-o", self.cookieFile, "-vv"]
+        callback_not_invoked: str = "DEBUG: Not automatically redirected: trying SAML authentication"
+        cookie_stored: str = "INFO: Saving cookies"
+
+        process = subprocess.Popen(command, stdout=subprocess.PIPE,
+                                   stderr=subprocess.STDOUT, shell=False)
+        stdout: str = process.communicate()[0].decode("utf-8")
+        stdout_list: List[str] = stdout.strip().split("\n")
+        if process.returncode != 0:
+            raise RuntimeError("FATAL -- Error requesting SSO cookie\nError msg: %s" % (stdout))
+
+        if callback_not_invoked in stdout:
+            callback_idx: int = stdout_list.index(callback_not_invoked)
+            stored_after_issue: bool = cookie_stored in stdout_list[callback_idx + 1]
+            if stored_after_issue:
+                msg: str = ("Callback method was not invoked. "
+                            "Please make sure the provided Kerberos ticket is not linked to an account with 2FA"
+                            )
+                raise RuntimeError(msg)
+
+    def _getURL(self, extendURL):
+        """
+        Fetch an MCM URL with CURL using the SSO cookie.
+        Only intended to be used internally
+        """
+
+        try:
+            b = BytesIO()
+            c = pycurl.Curl()
+
+            fullUrl = '%s/%s' % (self.url, extendURL)
+
+            c.setopt(c.URL, fullUrl)
+            c.setopt(c.SSL_VERIFYPEER, False)
+            c.setopt(c.SSL_VERIFYHOST, False)
+            c.setopt(c.FOLLOWLOCATION, True)
+            c.setopt(c.COOKIEJAR, self.cookieFile)
+            c.setopt(c.COOKIEFILE, self.cookieFile)
+            c.setopt(c.WRITEFUNCTION, b.write)
+            c.perform()
+            if c.getinfo(pycurl.HTTP_CODE) != 200:
+                raise IOError
+        except:
+            c.close()
+            raise IOError('Was not able to fetch or decode URL from McM')
+
+        try:
+            body = b.getvalue()
+            res = json.loads(body)
+        except ValueError:
+            c.close()
+            raise IOError('Was not able to decode JSON from McM')
+
+        c.close()
+        return res
+
+    def getHistory(self, prepID):
+        """
+        Get the history record which has who did what to an McM request
+        """
+
+        try:
+            url = 'search?db_name=batches&contains=%s&get_raw' % prepID
+            res = self._getURL(url)
+            history = res.get("results", [])[0].get("history", [])
+            return history
+        except IndexError:
+            raise McMNoDataError
+
+    def getRequest(self, prepID):
+        """
+        Get the request record which has, among other things,
+        the number of requested events
+        """
+
+        url = 'public/restapi/requests/get/%s' % prepID
+        res = self._getURL(url)
+        return res['results']
+
+
+if __name__ == '__main__':
+    with McM() as mcm:
+        history = mcm.getHistory(prepID='BTV-Upg2023SHCAL14DR-00002')
+        request = mcm.getRequest(prepID='BTV-Upg2023SHCAL14DR-00002')

WMCore/Services/McM/__init__.py

@@ -0,0 +1,8 @@
+#!/usr/bin/env python
+"""
+_McM_
+
+API for McM
+
+"""
+__all__ = []

WMCore/Services/MonIT/Grafana.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python
+# coding=utf-8
+"""
+Wrapper class, based on the PyCuRL module, providing an interface
+to CERN MonIT Grafana APIs
+"""
+from __future__ import division, print_function, absolute_import
+from builtins import str, object
+from future import standard_library
+standard_library.install_aliases()
+
+import logging
+import json
+from copy import copy
+from pprint import pformat
+from urllib.parse import urljoin
+
+from WMCore.Services.pycurl_manager import RequestHandler
+
+class Grafana(object):
+    """
+    Service class providing functionality to CERN monitoring Grafana APIs
+    """
+
+    def __init__(self, token, configDict=None):
+        """
+        Constructs a Grafana object.
+        :param token: mandatory string with the key/token string
+        :param configDict: dictionary with extra parameters, such as:
+          logger: logger object
+          endpoint: string with the url/endpoint to be used
+          cacheduration: float with the cache duration, in hours
+          headers: dictionary with the headers to be used
+        """
+        self._token = token
+        self.configDict = configDict or {}
+        self.configDict.setdefault('endpoint', "https://monit-grafana.cern.ch")
+        self.configDict.setdefault('cacheduration', 0)  # in hours
+        if 'headers' not in self.configDict:
+            self.configDict.setdefault('headers', {})
+            self.configDict['headers'].update({"Accept": "application/json"})
+            self.configDict['headers'].update({"Content-Type": "application/json"})
+
+        self.logger = self.configDict.get("logger", logging.getLogger())
+        self.logger.info("MonIT service initialized with parameters: %s", self.configDict)
+
+    def updateToken(self, token):
+        """
+        Update token to be used in requests made through this module
+        :param token: string with the new token
+        """
+        self._token = token
+
+    def _postRequest(self, url, params, verb='POST', verbose=0):
+        "Helper function to POST request to given URL"
+        mgr = RequestHandler(logger=self.logger)
+        headers = copy(self.configDict['headers'])
+        headers.update({"Authorization": self._token})
+
+        try:
+            data = mgr.getdata(url, params, headers, verb=verb, verbose=verbose)
+            return json.loads(data)
+        except Exception as exc:
+            self.logger.error("Failed to retrieve data from MonIT. Error: %s", str(exc))
+            return None
+
+    def getAPIData(self, apiName, queryStr=''):
+        """
+        _getAPIData_
+
+        Retrieve data from a given Grafana API and index name
+        :param apiName: string with the API name/number
+        :param queryStr: string with the whole query logic
+        :return: data as retrieved from Grafana
+        """
+        uri = urljoin(self.configDict['endpoint'], "/api/datasources/proxy/%s/_msearch" % apiName)
+        return self._postRequest(uri, queryStr)
+
+    def getSSBData(self, pathName, metricName, indexName="monit_prod_cmssst_*",
+                   apiName="9475", queryStr=''):
+        """
+        _getSSBData_
+
+        Retrieve data from the SSB index in Grafana
+        :param pathName: string with the path to the correct metric, mapped from SSB as:
+            columnid=237   ProdStatus   path="sts15min"  data.prod_status
+            columnid=160   CPU bound    path="scap15min" data.core_cpu_intensive
+            columnid=161   I/O bound    path="scap15min" data.core_io_intensive
+            columnid=159   Prod Cores   path="scap15min" data.core_production
+            columnid=136   Real Cores   path="scap15min" data.core_max_used
+            columnid=107   Tape Pledge  path="scap15min" data.tape_pledge
+        :param indexName: optional string with the grafana index name
+        :param apiName: optional string with the Grafana API number
+        :param queryStr: optional string with the full query logic
+        :return: dictionary with the site names and the metric value
+        """
+        # TODO: allow flexible time range instead of the hardwired last 24h
+        # TODO: allow flexible number of rows, instead of the hardwired 500
+        results = {}
+        if metricName not in ('prod_status', 'core_cpu_intensive', 'core_io_intensive',
+                              'core_production', 'core_max_used', 'tape_pledge'):
+            self.logger.error("SSB metric name '%s' is NOT supported.", metricName)
+            return results
+
+        uri = urljoin(self.configDict['endpoint'], "/api/datasources/proxy/%s/_msearch" % apiName)
+        if not queryStr:
+            ### NOTE: these '\n' new lines are mandatory to get it working...
+            queryStr = '{"search_type":"query_then_fetch","ignore_unavailable":true,"index":["%s"]}\n' % indexName
+            queryStr += '{"size":500,"query":{"bool":{"filter":[{"range":{"metadata.timestamp":{"gte":"now-1d","lte":"now","format":"epoch_millis"}}},' \
+                        '{"query_string":{"analyze_wildcard":true,' \
+                        '"query":"metadata.type: ssbmetric AND metadata.type_prefix:raw AND metadata.monit_hdfs_path: %s"}}]}},' \
+                        '"sort":{"metadata.timestamp":{"order":"desc","unmapped_type":"boolean"}},' \
+                        '"script_fields":{},"docvalue_fields":["metadata.timestamp"]}\n' % pathName
+        self.logger.info("Calling API: %s with query: %s", uri, pformat(queryStr))
+
+        data = self._postRequest(uri, queryStr)
+        #self.logger.debug("Data retrieved: %s", pformat(data))
+        if data:
+            # now parse the ugly output
+            hits = data['responses'][0]['hits']['hits']
+            for item in hits:
+                site = item['_source']['data']['name']
+                metricValue = item['_source']['data'][metricName]
+                tStamp = int(item['sort'][0])
+
+                results.setdefault(site, {})
+                if tStamp > results[site].get("timeStamp", 0):
+                    results[site][metricName] = metricValue
+                    results[site]["timeStamp"] = tStamp
+
+            data = results
+
+        return data