def _serialize(self, record, write_precision, payload, **kwargs): from influxdb_client import Point if isinstance(record, bytes): payload[write_precision].append(record) elif isinstance(record, str): self._serialize(record.encode(_UTF_8_encoding), write_precision, payload, **kwargs) elif isinstance(record, Point): precision_from_point = kwargs.get('precision_from_point', True) precision = record.write_precision if precision_from_point else write_precision self._serialize(record.to_line_protocol(precision=precision), precision, payload, **kwargs) elif isinstance(record, dict): self._serialize( Point.from_dict(record, write_precision=write_precision, **kwargs), write_precision, payload, **kwargs) elif 'DataFrame' in type(record).__name__: serializer = DataframeSerializer(record, self._point_settings, write_precision, **kwargs) self._serialize(serializer.serialize(), write_precision, payload, **kwargs) elif hasattr(record, "_asdict"): # noinspection PyProtectedMember self._serialize(record._asdict(), write_precision, payload, **kwargs) elif _HAS_DATACLASS and dataclasses.is_dataclass(record): self._serialize(dataclasses.asdict(record), write_precision, payload, **kwargs) elif isinstance(record, Iterable): for item in record: self._serialize(item, write_precision, payload, **kwargs)
def send(self, payload, source_config): measurement = payload.topic[0] client = self.client() data = self.json_data( measurement, payload.fields, timestamp=payload.timestamp, tags=payload.tags) point = Point.from_dict(data) with self.client().write_api(write_options=SYNCHRONOUS) as write_api: write_api.write(source_config.influx_database, self.config.org, point)
def save(self, data): self.ensure_initialized() for row in data: point = Point.from_dict({ "measurement": "inverter", "fields": row.values, "time": row.ts }) self.api.write(bucket=self.bucket, record=point)
def test_from_dictionary_tolerant_to_missing_tags_and_fields(self): dictionary = { "name": "sensor_pt859", "location": "warehouse_125", "pressure": 125 } point = Point.from_dict(dictionary, write_precision=WritePrecision.S, record_measurement_key="name", record_tag_keys=["location", "version"], record_field_keys=["pressure", "temperature"]) self.assertEqual("sensor_pt859,location=warehouse_125 pressure=125i", point.to_line_protocol())
def test_from_dictionary_custom_measurement(self): dictionary = { "name": "test", "tags": { "tag": "a" }, "fields": { "value": 1 }, "time": 1, } point = Point.from_dict(dictionary, record_measurement_key="name") self.assertEqual("test,tag=a value=1i 1", point.to_line_protocol())
def new_event(event: Event): p = Point.from_dict({ "measurement": "testing", "tags": { "user": event.user, "event_name": event.event_name }, "fields": { "magnitude": event.magnitude }, }) influx_writer.write(bucket=bucket, record=p) return event
def test_static_measurement_name(self): dictionary = { "name": "sensor_pt859", "location": "warehouse_125", "pressure": 125 } point = Point.from_dict(dictionary, write_precision=WritePrecision.S, record_measurement_name="custom_sensor_id", record_tag_keys=["location", "version"], record_field_keys=["pressure", "temperature"]) self.assertEqual( "custom_sensor_id,location=warehouse_125 pressure=125i", point.to_line_protocol())
def test_from_dictionary_custom_tags(self): dictionary = { "name": "test", "tag_a": "a", "tag_b": "b", "fields": { "value": 1 }, "time": 1, } point = Point.from_dict(dictionary, record_measurement_key="name", record_tag_keys=["tag_a", "tag_b"]) self.assertEqual("test,tag_a=a,tag_b=b value=1i 1", point.to_line_protocol())
def test_from_dict_without_timestamp(self): json = { "measurement": "my-org", "tags": { "tag1": "tag1", "tag2": "tag2" }, "fields": { 'field1': 1, "field2": 2 } } point = Point.from_dict(json) self.assertEqual("my-org,tag1=tag1,tag2=tag2 field1=1i,field2=2i", point.to_line_protocol())
def test_from_dictionary_custom_fields(self): dictionary = { "name": "sensor_pt859", "location": "warehouse_125", "version": "2021.06.05.5874", "pressure": 125, "temperature": 10, "time": 1632208639, } point = Point.from_dict(dictionary, write_precision=WritePrecision.S, record_measurement_key="name", record_tag_keys=["location", "version"], record_field_keys=["pressure", "temperature"]) self.assertEqual( "sensor_pt859,location=warehouse_125,version=2021.06.05.5874 pressure=125i,temperature=10i 1632208639", point.to_line_protocol())
def get_telem_points(self) -> List[Point]: """Called by telemetry logger. See `TelemSource` abstract base class.""" point = Point('gamepad') # attributes of this object to be captured as fields in the telemetry measurement names = ['left_x', 'left_y', 'right_x', 'right_y', 'int_x', 'int_y', 'integrator_mode'] for name in names: point.field(name, self.__dict__[name]) point.time(datetime.utcnow()) point_raw = Point.from_dict({ 'measurement': 'gamepad_events', 'fields': self.state, 'time': datetime.utcnow(), }) return [point, point_raw]
def test_backslash(self): point = Point.from_dict( { "measurement": "test", "tags": { "tag1": "value1", "tag2": "value\2", "tag3": "value\\3", "tag4": r"value\4", "tag5": r"value\\5" }, "time": 1624989000000000000, "fields": { "value": 10 } }, write_precision=WritePrecision.NS) self.assertEqual( "test,tag1=value1,tag2=value\2,tag3=value\\3,tag4=value\\4,tag5=value\\\\5 value=10i 1624989000000000000", point.to_line_protocol())
def speedtest_run(): db_check() current_time = datetime.datetime.utcnow().isoformat() print("STATE: Loop running at", current_time) # Run Speedtest print("STATE: Speedtest running") s = speedtest.Speedtest() s.get_servers(servers) s.get_best_server() s.download(threads=threads) s.upload(threads=threads) s.results.share() results_dict = s.results.dict() # Print results to Docker logs print("NOTE: RESULTS ARE SAVED IN BPS NOT MBPS") print("STATE: Your download ", results_dict["download"], "bps") print("STATE: Your upload ", results_dict["upload"], "bps") print("STATE: Your ping latency ", results_dict["ping"], "ms") print("STATE: Your server info ", results_dict["server"]["id"], results_dict["server"]["host"], results_dict["server"]["lat"],results_dict["server"]["lon"], results_dict["server"]["country"], results_dict["server"]["host"]) print("STATE: Your URL is ", results_dict["share"], " <--- This is not saved to InfluxDB") write_api = client.write_api(write_options=SYNCHRONOUS) # convert speedtest dict to point-ready dict point_dict = { "measurement": "speedtest"} point_dict["tags"] = {"host": hostname, "server_id": results_dict["server"]["id"], "client_ip": results_dict["client"]["ip"]} point_dict["fields"] = {key: results_dict[key] for key in results_dict.keys() & {'download', 'upload', 'ping', 'bytes_sent', 'bytes_received'}} point_dict["time"] = results_dict["timestamp"] p = Point.from_dict(point_dict) write_api.write(bucket, org, p) print("STATE: Sleeping for", sleepy_time, "seconds") time.sleep(sleepy_time)
def add_points( self, data: Union[str, Iterable['str'], Point, Iterable['Point'], dict, Iterable['dict'], bytes, Iterable['bytes']] ) -> None: ''' Add points to the buffer. ''' if self._client: if isinstance(data, bytes): self._buffer.append(data) elif isinstance(data, str): self.add_points(data.encode('utf-8')) elif isinstance(data, Point): self.add_points(data.to_line_protocol().encode('utf-8')) elif isinstance(data, dict): self.add_points( Point.from_dict(data, write_precision=self._write_precision). to_line_protocol().encode('utf-8')) elif isinstance(data, Iterable): for item in data: self.add_points(item)
def __call__(self, data): self.api.write(bucket=self.bucket, org=self.org, record=Point.from_dict(data))
# pip install influxdb-client # pip install line-protocol-parser from influxdb_client import Point from line_protocol_parser import parse_line while True: try: input_line = input() # read from stdin except EOFError: # catch EOF error break else: data = parse_line(input_line) # parse input line fields = data['fields'] ips = dict() for key, value in fields.items(): ipaddress, substring = key.split('_', 1) if ipaddress not in ips: ips[ipaddress] = dict() ips[ipaddress][substring] = value for key, value in ips.items(): datapoint = dict() datapoint['measurement'] = data['measurement'] datapoint['fields'] = value datapoint['tags'] = {'ip' : key} datapoint['time'] = data['time'] point = Point.from_dict(datapoint) # new metric object print(point.to_line_protocol()) # write to stdout
def test_from_dict_without_tags(self): json = {"measurement": "my-org", "fields": {'field1': 1, "field2": 2}} point = Point.from_dict(json) self.assertEqual("my-org field1=1i,field2=2i", point.to_line_protocol())