Ejemplo n.º 1
0
 def process(self, millis):
     conn = PyConnection(self.ds.getConnection())
     c = conn.cursor()
     try:
         c.execute("insert into dataservice.py_script_heartbeat(beat,demo) values (%d,'%s')" % (millis, 'nonse'))
         conn.commit()
     finally:
         if c: c.close()
         if conn: conn.close()
     #self.log.info(self.name + ': success')
     return 'success'
Ejemplo n.º 2
0
    def tick(self):
        for phrase in self.sql:
            self.startQueryCycle(phrase["id"])
            preparedStatementParams = []
            preparedStatementParamsDict = {}
            logger.info(phrase["statement"])
            numrows = 0
            conn = PyConnection(self.datasource.getConnection())
            try:
                with conn.cursor(1) as cursor:
                    #TODO: review, index out of range very possible
                    if "parameter" in phrase:
                        logger.debug("Dude, got parameters!!")
                        for parameter in phrase["parameter"]:
                            strlist = parameter.split("$cycle.")
                            if len(strlist) > 0:
                                if strlist[1] in ["qend","qstart","qlaststart","qenddt","qstartdt","qlaststartdt","qelapsed"]:
                                    value = self.getQueryParameter(phrase["id"], strlist[1])
                                    if value == None:
                                        logger.debug("Dude, couldn't fetch local parameter %s = %s, going global", parameter, value)
                                        value = self.getCycleProperty(strlist[1][1:])
                                    preparedStatementParams.append(value)
                                    preparedStatementParamsDict[parameter] = value
                                    logger.debug("Dude, got local parameter %s = %s", parameter, value)
                                else:
                                    value = self.getCycleProperty(strlist[1])
                                    if value == None:
                                        value = phrase[strlist[1]]
                                    preparedStatementParams.append(value)
                                    preparedStatementParamsDict[parameter] = value
                                    logger.debug("Dude, got global parameter %s = %s", parameter, value)
                                logger.debug(strlist[1])
                    logger.debug("Dude, preparing statement: %s", phrase["id"])
                    query = cursor.prepare(phrase["statement"])
                    logger.debug("Dude, executing statement: %s", phrase["id"])
                    cursor.execute(query, preparedStatementParams)
                    row = None
                    logger.debug("Dude, starting fetch for statement: %s", phrase["id"])
                    if cursor.description != None:
                        fields = [i[0] for i in cursor.description]
                        row = cursor.fetchone()
                    else:
                        fields = []
                        conn.commit()
                        self.processData({ '@timestamp':self.getQueryParameter(phrase["id"], "qstart"), "statement": phrase["statement"], "parameters": preparedStatementParamsDict } )
                        #TODO: process data with commit timestamp and whatnot
                    while row is not None:
                        idx = 0
                        out = {}
                        rowDict = {}
                        metrics = {}
                        terms = {}
                        for field in fields:
                            if isinstance(row[idx], str):
                                if self.getInputProperty("ignoreFieldIfEmptyString") and len(row[idx]) == 0:
                                    logger.warning("Ignoring key %s due to empty value", field)
                                else:
                                    rowDict[field] = row[idx]
                            elif isinstance(row[idx], unicode):
                                if self.getInputProperty("ignoreFieldIfEmptyString") and len(row[idx]) == 0:
                                    logger.warning("Ignoring key %s due to empty value", field)
                                else:
                                    rowDict[field] = row[idx]
                            else:
                                rowDict[field] = row[idx]
                            idx = idx + 1
                        for key in rowDict:
                            if key in self.metrics:
                                metrics[key] = rowDict[key]
                            elif key in self.terms:
                                terms[key] = rowDict[key]
                            else:
                                out[key] = rowDict[key]
                        self.processData(out)
                        for key in metrics:
                            try:
                                out["metric"] = key
                                if self.getInputProperty("decimalMark"):
                                    metrics[key] = metrics[key].replace(self.getInputProperty("decimalMark"), ".")
                                out["value"] = float(metrics[key])
                                self.processData(out)
                            except Exception, ex:
                                logger.warning("Failure to parse %s as float for metric %s", key, metrics[key])
                        #self.processData(out)
                        if 'value' in out:
                            del out['value']
                        for key in terms:
                            out["metric"] = key
                            out["term"] = str(terms[key])
                            self.processData(out)

                        row = cursor.fetchone()
                    query.close()
                    assert query.closed
            except Exception, ex:
                logger.debug("\n     _           _      _ \n  __| |_   _  __| | ___| |\n / _` | | | |/ _` |/ _ \ |\n| (_| | |_| | (_| |  __/_|\n \__,_|\__,_|\__,_|\___(_)\n")
                logger.debug(ex)
                raise
            finally: