from datetime import datetime from influxdb_client import InfluxDBClient, Point, WritePrecision from influxdb_client.client.write_api import SYNCHRONOUS import random # You can generate a Token from the "Tokens Tab" in the UI token = "6GqhhbHug0P1ewJLlvyXwkRXwc9pgxGiRNz-T__7rkYgm4Ya771qCHdC7HhNTltLmon2U7YIQzP50yXK0wXNTQ==" org = "tpdp" bucket = "db" client = InfluxDBClient(url="http://192.168.4.23:8086", token=token) write_api = client.write_api(write_options=SYNCHRONOUS) # for n in range(300): # num = random.randint(0, 100) * 1.0 # data = "mem,host=host1 used_percent="+str(num) # write_api.write(bucket, org, data) dbs = client.get_list_database() #for better format list = [] for db in dbs: list.append(db.get('name'))
def monitoringExtenders(network_list, network_setup, polling_frequency, influxServer, dest_file, logger, system_command_lst): extender_csv_file_list = [] csv_header = [] """Monitoring Extender poll for polling_frequency all the extender part of the network_list. Then will store the results into the dest_file in csv format. A dest_file will be created per extender, to allow to have different follow up""" #Create CSV Header file csv_header.append('DATE') for command, command_type in system_command_lst: if "WIFI_CHANIM" in command_type: for chanim in chanim_info: csv_header.append(command_type + "-" + chanim) elif "VMSTAT" in command_type: for vmstat in vmstat_info: csv_header.append(command_type + "-" + vmstat) elif "LOADAVG" in command_type: for loadavg in loadavg_info: csv_header.append(command_type + "-" + loadavg) else: csv_header.append(command_type) #Create root file name by concatenating the root filename and the extender name for extender in network_list: extender_csv_name = dest_file + '-' + extender['name'].strip( " ") + ".csv" #Open the file extender_csv_file = open(extender_csv_name, 'w+') extender['CSVFile'] = extender_csv_file #Write header into csv files and define dictionary to manage and check row csv_writer = csv.DictWriter(extender['CSVFile'], fieldnames=csv_header) extender['CSVWriter'] = csv_writer extender['CSVWriter'].writeheader() logger.info("Creating file {:20} mode {:2}".format( extender['CSVFile'].name, extender['CSVFile'].mode)) logger.info("Creating Data Base {}".format(influxServer["Server_name"])) os.environ['NO_PROXY'] = influxServer["Server_name"] client = InfluxDBClient(host=influxServer["Server_name"], port=influxServer["Server_port"], ssl=False, proxies=None) client.create_database(influxServer["DB_name"]) logger.info("Creation of Data Base {} {}".format( influxServer["Server_name"], client.get_list_database())) #Start looping for monitoring extender while 1: try: #Launch the command DoExtenderMonitoring(network_list, network_setup, logger, system_command_lst, client) #Sleep for polling frequency time.sleep(int(polling_frequency)) except KeyboardInterrupt: #If Keyboard interruption then stop polling logger.info("KEYBOARD interrupt stop monitoring") break else: logger.debug("Out of polling wait launch commands") #End of monitoring close opened files for extender in network_list: logger.info("Closing file {}".format(extender['CSVFile'].name)) extender['CSVFile'].close() return
class InfluxDB(object): def __init__(self, connection): try: timerange = int(connection['data_availability_timerange']) except: timerange = 30 # defaults self.min_timerange = '{}d'.format(str(timerange)) print("Finding measurements with datapoints in last {} days".format(timerange)) try: self.client = InfluxDBClient(url=connection['url'], token=connection['token'], org=connection["org"]) self.query_api = self.client.query_api() except Exception as e: print("Failed to connect to initialize Influx Odata container") print(str(e)) raise ConnectionError() try: bucket = connection['buckets'] if isinstance(bucket, str): self.buckets = bucket.split(',') else: self.buckets = list() except: print("Bucket details not valid") raise ValueError() def fields(self, bucket, measurement): """returns a tuple of dicts where each dict has attributes (name, type, edm_type)""" fields_query = 'from (bucket: "{}") \ |> range(start: -{}, stop: now()) \ |> filter(fn: (r) => (r._measurement == "{}")) \ |> keep(columns: ["_field"]) \ |> group() \ |> distinct(column: "_field") \ |> limit(n: 200) \ |> sort()'.format(bucket, self.min_timerange, measurement) tags_query = 'from (bucket: "{}") \ |> range(start: -{}, stop: now()) \ |> filter(fn: (r) => (r._measurement == "{}")) \ |> keys() \ |> keep(columns: ["_value"]) \ |> distinct() \ |> filter(fn: (r) => r._value != "_measurement" and r._value != "_field") \ |> filter(fn: (r) => r._value != "_time" and r._value != "_start" and r._value != "_stop" and r._value != "_value") \ |> sort() \ |> limit(n: 200)'.format(bucket, self.min_timerange, measurement) fields_rs = self.query_api.query(fields_query) tags_rs = self.query_api.query(tags_query) fields = [] tags = [] try: fields = [(_f.values['_value'], 'float') for _f in fields_rs[0].records] except: pass try: tags = [(_t.values['_value'], 'string') for _t in tags_rs[0].records] except: pass fields.extend(tags) # tags_rs = self.client.query('SHOW TAG KEYS', database=db_name) # expand and deduplicate #fields = set(tuple(f.items()) for f in chain(*chain(fields_rs, tags_rs))) fields = (dict( name= mangle_field_name(f[0]), type=f[1], edm_type=get_edm_type(f[1]) ) for f in fields) return tuple(fields) @property def measurements(self): measurements = [] for each_bucket in self.buckets: q = 'import "influxdata/influxdb/v1" v1.tagValues(bucket: "{}", tag: "_measurement", predicate: (r) => true, start: -{})'\ .format(each_bucket, self.min_timerange) #'import "influxdata/influxdb/v1" v1.measurements(bucket: "{}")'.format(each_bucket) rs = self.query_api.query(q) measurements_list = [(_m.values['_value']) for _m in rs[0].records] def m_dict(m): d = dict() d['bucket'] = each_bucket d['mangled_bucket'] = mangle_bucket_name(each_bucket) d['mangled_measurement'] = mangle_measurement_name(m) d['mangled_path'] = bucket_name__measurement_name(each_bucket, m) d['fields'] = self.fields(each_bucket, m) return d measurements.extend(m_dict(m) for m in measurements_list) return measurements @property def databases(self): rs = self.client.get_list_database() return iter(rs)