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())
